Exemple #1
0
def makestock(name, output):
    if name in output.subst: return None
    objname = name + '.obj'
    if not objname in listdir('Resources'): return None

    tex = None
    vt = []
    idx = []
    obj = file(join('Resources', objname), 'rU')
    if obj.next() not in ['A\n', 'I\n']: return None
    if not obj.next().startswith('800'): return None
    if obj.next() != 'OBJ\n': return None
    for line in obj:
        tokens = line.split()
        if not tokens:
            continue
        if tokens[0] == 'TEXTURE' and len(tokens) == 2:
            if output.dds and tokens[1][-4:] == '.png':
                tex = 'Resources/' + tokens[1][:-4] + '.dds'
            else:
                tex = 'Resources/' + tokens[1]
        elif tokens[0] == 'VT' and len(tokens) == 9:
            vt.append((float(tokens[1]), float(tokens[2]), float(tokens[3]),
                       float(tokens[4]), float(tokens[5]), float(tokens[6]),
                       float(tokens[7]), float(tokens[8])))
        elif tokens[0] == 'IDX' and len(tokens) == 2:
            idx.append(int(tokens[1]))
        elif tokens[0] == 'IDX10' and len(tokens) == 11:
            idx.extend([
                int(tokens[1]),
                int(tokens[2]),
                int(tokens[3]),
                int(tokens[4]),
                int(tokens[5]),
                int(tokens[6]),
                int(tokens[7]),
                int(tokens[8]),
                int(tokens[9]),
                int(tokens[10])
            ])
    obj.close()
    obj = Object(
        name,
        "(c) Jonathan Harris 2008. http://creativecommons.org/licenses/by-sa/3.0/",
        None, None)
    obj.addgeometry(Material(output.xpver, None), vt, idx)
    return obj
Exemple #2
0
def makestock(name, output):
    if name in output.subst: return None
    objname=name+'.obj'
    if not objname in listdir('Resources'): return None

    tex=None
    vt=[]
    idx=[]
    obj=file(join('Resources', objname), 'rU')
    if obj.next() not in ['A\n', 'I\n']: return None
    if not obj.next().startswith('800'): return None
    if obj.next()!='OBJ\n': return None
    for line in obj:
        tokens=line.split()
        if not tokens:
            continue
        if tokens[0]=='TEXTURE' and len(tokens)==2:
            if output.dds and tokens[1][-4:]=='.png':
                tex='Resources/'+tokens[1][:-4]+'.dds'
            else:
                tex='Resources/'+tokens[1]
        elif tokens[0]=='VT' and len(tokens)==9:
            vt.append((float(tokens[1]), float(tokens[2]), float(tokens[3]),
                       float(tokens[4]), float(tokens[5]), float(tokens[6]),
                       float(tokens[7]), float(tokens[8])))
        elif tokens[0]=='IDX' and len(tokens)==2:
            idx.append(int(tokens[1]))
        elif tokens[0]=='IDX10' and len(tokens)==11:
            idx.extend([int(tokens[1]), int(tokens[2]), int(tokens[3]),
                        int(tokens[4]), int(tokens[5]), int(tokens[6]),
                        int(tokens[7]), int(tokens[8]), int(tokens[9]),
                        int(tokens[10])])
    obj.close()
    obj=Object(name, "(c) Jonathan Harris 2008. http://creativecommons.org/licenses/by-sa/3.0/", None, None)
    obj.addgeometry(Material(output.xpver, None), vt, idx)
    return obj
Exemple #3
0
    def __init__(self, bgl, enda, scale, libname, srcfile, texdir, output):

        self.old = False  # Old style scenery found and skipped
        self.rrt = False  # Old style runways/roads found and skipped
        self.anim = False  # Animations found and skipped

        assert (scale == 1)  # new-style objects are scaled when placed

        comment = "object %s in file %s" % (libname,
                                            asciify(basename(srcfile), False))

        tex = []
        mattex = []
        vt = []
        idx = []
        matrix = []
        amap = []
        scen = []
        data = {}

        if bgl.read(4) != 'RIFF': raise IOError
        (mdlsize, ) = unpack('<I', bgl.read(4))
        endmdl = bgl.tell() + mdlsize
        if bgl.read(4) != 'MDLX': raise IOError
        while bgl.tell() < endmdl:
            c = bgl.read(4)
            (size, ) = unpack('<I', bgl.read(4))
            if c == 'MDLD':
                end = size + bgl.tell()
                while bgl.tell() < end:
                    c = bgl.read(4)
                    (size, ) = unpack('<I', bgl.read(4))
                    if c == 'TEXT':
                        tex.extend([
                            bgl.read(64).strip('\0').strip()
                            for i in range(0, size, 64)
                        ])
                    elif c == 'MATE':
                        # http://www.fsdeveloper.com/wiki/index.php?title=MDL_file_format_(FSX)#MATE
                        for i in range(0, size, 120):
                            (flags1, flags2, diffuse, detail, normal, specular,
                             emissive, reflection, fresnel, dr, dg, db, da, sr,
                             sg, sb, sa, sp, ds, normalscale, recflectionscale,
                             po, power, bloomfloor, ambientscale, srcblend,
                             dstblend, alphafunc, alphathreshhold,
                             zwritealpha) = unpack('<9I16f3I2f', bgl.read(120))
                            # Get texture names
                            diffuse = (flags1 & Material.FSX_MAT_HAS_DIFFUSE
                                       ) and tex[diffuse] or None
                            emissive = (flags1 & Material.FSX_MAT_HAS_EMISSIVE
                                        ) and tex[emissive] or None
                            if output.xpver <= 10:
                                normal = specular = reflection = None  # Not supported in<=10, so no point doing lookup
                            else:
                                specular = (flags1
                                            & Material.FSX_MAT_HAS_SPECULAR
                                            ) and tex[specular] or None
                                normal = (flags1 & Material.FSX_MAT_HAS_NORMAL
                                          ) and tex[normal] or None
                                reflection = (flags1
                                              & Material.FSX_MAT_HAS_REFLECTION
                                              ) and tex[reflection] or None
                            # Get texture filenames
                            if diffuse:
                                diffuse = findtex(diffuse, texdir,
                                                  output.addtexdir)
                            if emissive:
                                emissive = findtex(emissive, texdir,
                                                   output.addtexdir)
                            if specular:
                                specular = findtex(specular, texdir,
                                                   output.addtexdir)
                            if normal:
                                normal = findtex(normal, texdir,
                                                 output.addtexdir)
                            if reflection:
                                reflection = findtex(reflection, texdir,
                                                     output.addtexdir)

                            t = (diffuse or emissive) and Texture(
                                output.xpver, diffuse, emissive, specular,
                                normal, reflection) or None
                            m = Material(
                                output.xpver,
                                (dr, dg, db),
                                (flags1 & Material.FSX_MAT_SPECULAR)
                                and not specular and
                                ((sr != sg or sr != sb or sr < 0.9) and
                                 (sr, sg, sb) !=
                                 (0, 0, 0)) and [sr, sg, sb] or None,
                                False,  # Poly
                                flags2 & Material.FSX_MAT_DOUBLE_SIDED != 0,
                                flags1 & Material.FSX_MAT_ZTEST_ALPHA
                                and alphafunc in [
                                    Material.FSX_MAT_ALPHA_TEST_GREATER,
                                    Material.FSX_MAT_ALPHA_TEST_GREATER_EQUAL
                                ] and alphathreshhold / 255 or None,
                                not diffuse
                                and ((flags1 & Material.FSX_MAT_SPECULAR) and
                                     (sr, sg, sb) != (0, 0, 0)) and True,
                                flags1 & Material.FSX_MAT_NO_SHADOW != 0)
                            mattex.append((m, t))
                        if __debug__:
                            if output.debug:
                                output.debug.write("Materials %d\n" %
                                                   len(mattex))
                                for i in range(len(mattex)):
                                    output.debug.write(
                                        "%3d:\t%s\t%s\n" %
                                        (i, mattex[i][0], mattex[i][1]))
                    elif c == 'INDE':
                        idx = unpack('<%dH' % (size / 2), bgl.read(size))
                    elif c == 'VERB':
                        endv = size + bgl.tell()
                        while bgl.tell() < endv:
                            c = bgl.read(4)
                            (size, ) = unpack('<I', bgl.read(4))
                            if c == 'VERT':
                                vt.append([
                                    unpack('<8f', bgl.read(32))
                                    for i in range(0, size, 32)
                                ])
                            else:
                                bgl.seek(size, 1)
                    elif c == 'TRAN':
                        for i in range(0, size, 64):
                            matrix.append(
                                Matrix([
                                    unpack('<4f', bgl.read(16))
                                    for j in range(4)
                                ]))
                        if __debug__:
                            if output.debug:
                                output.debug.write("Matrices %d\n" %
                                                   len(matrix))
                                for i in range(len(matrix)):
                                    output.debug.write("%s = %d\n" %
                                                       (matrix[i], i))
                    elif c == 'AMAP':
                        for i in range(0, size, 8):
                            (a, b) = unpack('<2I', bgl.read(8))
                            amap.append(b)
                        if __debug__:
                            if output.debug:
                                output.debug.write("Animation map %d\n" %
                                                   len(amap))
                                for i in range(len(amap)):
                                    output.debug.write("%2d: %2d\n" %
                                                       (i, amap[i]))
                    elif c == 'SCEN':
                        # Assumed to be after TRAN and AMAP sections
                        count = size / 8
                        for i in range(count):
                            (child, peer, offset,
                             unk) = unpack('<4h', bgl.read(8))
                            scen.append((child, peer, offset, -1))
                        # Invert Child/Peer pointers to get parents
                        for i in range(count):
                            (child, peer, thisoff, parent) = scen[i]
                            if child != -1:  # child's parent is me
                                (xchild, xpeer, xoff, xparent) = scen[child]
                                scen[child] = (xchild, xpeer, xoff, i)
                            if peer != -1:  # peer's parent is my parent
                                (xchild, xpeer, xoff, xparent) = scen[peer]
                                scen[peer] = (xchild, xpeer, xoff, parent)
                        # Replace AMAP offsets with matrix
                        if __debug__:
                            if output.debug:
                                output.debug.write("Scene Graph %d\n" %
                                                   len(scen))
                        for i in range(count):
                            (child, peer, offset, parent) = scen[i]
                            scen[i] = (child, peer, matrix[amap[offset / 8]],
                                       parent)
                            if __debug__:
                                if output.debug:
                                    output.debug.write(
                                        "%2d: %2d %2d %2d %2d\n" %
                                        (i, child, peer, parent, offset / 8))
                    elif c == 'LODT':
                        endt = size + bgl.tell()
                        partno = 0
                        maxlod = 0
                        while bgl.tell() < endt:
                            c = bgl.read(4)
                            (size, ) = unpack('<I', bgl.read(4))
                            if c == 'LODE':
                                ende = size + bgl.tell()
                                (lod, ) = unpack('<I', bgl.read(4))
                                while bgl.tell() < ende:
                                    c = bgl.read(4)
                                    (size, ) = unpack('<I', bgl.read(4))
                                    if c == 'PART':
                                        (typ, scene, material, verb, voff,
                                         vcount, ioff, icount,
                                         unk) = unpack('<9I', bgl.read(36))
                                        assert (typ == 1)
                                        maxlod = max(lod, maxlod)
                                        (child, peer, finalmatrix,
                                         parent) = scen[scene]
                                        if __debug__:
                                            if output.debug:
                                                output.debug.write(
                                                    "LOD %4d: scene %d verb %d material %d tris %d voff %d vcount %d ioff %d icount %d\n"
                                                    % (lod, scene, verb,
                                                       material, icount / 3,
                                                       voff, vcount, ioff,
                                                       icount))

                                        while parent != -1:
                                            (child, peer, thismatrix,
                                             parent) = scen[parent]
                                            finalmatrix = finalmatrix * thismatrix
                                        if not lod in data: data[lod] = []
                                        data[lod].append(
                                            (mattex[material][0],
                                             mattex[material][1],
                                             vt[verb][voff:voff + vcount],
                                             idx[ioff:ioff + icount],
                                             finalmatrix))
                                        partno += 1
                                    else:
                                        bgl.seek(size, 1)
                            else:
                                bgl.seek(size, 1)
                    else:
                        bgl.seek(size, 1)
            else:
                bgl.seek(size, 1)

        # Only interested in highest LOD
        objs = {}  # objs by texture
        for (m, t, vt, idx, matrix) in data[maxlod]:
            if __debug__:
                if output.debug: output.debug.write("%s\n%s\n" % (t, matrix))
            objvt = []
            nrmmatrix = matrix.adjoint()
            if t:
                assert not t.s and not t.n and not t.r  # Bunching scheme will need re-work
                for (x, y, z, nx, ny, nz, tu, tv) in vt:
                    (x, y, z) = matrix.transform(x, y, z)
                    (nx, ny, nz) = nrmmatrix.rotateAndNormalize(nx, ny, nz)
                    objvt.append((x, y, -z, nx, ny, -nz, tu, tv))
            else:
                # replace material with palette texture
                (pu, pv) = rgb2uv(m.d)
                for (x, y, z, nx, ny, nz, tu, tv) in vt:
                    (x, y, z) = matrix.transform(x, y, z)
                    (nx, ny, nz) = nrmmatrix.rotateAndNormalize(nx, ny, nz)
                    objvt.append((x, y, -z, nx, ny, -nz, pu, pv))
            if t in objs:
                obj = objs[t]
                if t and t.e:
                    obj.tex.e = t.e  # Because we don't compare on emissive
            else:
                objs[t] = obj = Object(libname, comment, t, None)
            obj.addgeometry(m, objvt, idx)

        # Add objs to library with one name
        if objs: output.objdat[libname] = objs.values()
Exemple #4
0
def makegenquad(name, output, x, z, incx, incz, heights, texs, roof):
    # roof types: 0=flat, 1=pointy, 2=gabled, 3=slanty
    cumheight = 0
    vt = []
    idx = []
    rgbs = []
    for i in range(len(texs)):
        rgbs.append(genrgb(i, texs[i]))
    sign = [(1, 1), (1, -1), (-1, -1), (-1, 1), (1, 1)]
    n = [(cos(incx), sin(incx), 0), (0, sin(incz), -cos(incz)),
         (-cos(incx), sin(incx), 0), (0, sin(incz), cos(incz))]
    for story in range(3):
        if not heights[story]:
            continue
        (u, v) = rgb2uv(rgbs[story])
        x0 = x / 2 - sin(incx) * cumheight
        z0 = z / 2 - sin(incz) * cumheight
        x1 = x / 2 - sin(incx) * (cumheight + heights[story])
        z1 = z / 2 - sin(incz) * (cumheight + heights[story])
        for side in range(4):
            (nx, ny, nz) = n[side]
            base = len(vt)
            for corner in [side, side + 1]:
                (sx, sz) = sign[corner]
                vt.extend([(sx * x0, cumheight, sz * z0, nx, ny, nz, u, v),
                           (sx * x1, cumheight + heights[story], sz * z1, nx,
                            ny, nz, u, v)])
            idx.extend(
                [base, base + 1, base + 2, base + 3, base + 2, base + 1])
        cumheight += heights[story]

    # roof
    x0 = x / 2 - sin(incx) * cumheight
    z0 = z / 2 - sin(incz) * cumheight
    (u, v) = rgb2uv(rgbs[3])
    base = len(vt)
    if roof == 0 or heights[3] == 0:  # simplify if actually flat
        vt.extend([(x0, cumheight, z0, 0, 1, 0, u, v),
                   (x0, cumheight, -z0, 0, 1, 0, u, v),
                   (-x0, cumheight, -z0, 0, 1, 0, u, v),
                   (-x0, cumheight, z0, 0, 1, 0, u, v)])
        idx.extend([base + 2, base + 1, base, base, base + 3, base + 2])

    elif roof == 1:
        # pointy
        topheight = cumheight + heights[3]
        incx = atan(x / (2 * heights[3]))
        incz = atan(z / (2 * heights[3]))
        vt.extend([(x0, cumheight, z0, cos(incx), sin(incx), 0, u, v),
                   (0, topheight, 0, cos(incx), sin(incx), 0, u, v),
                   (x0, cumheight, -z0, cos(incx), sin(incx), 0, u, v),
                   (-x0, cumheight, z0, -cos(incx), sin(incx), 0, u, v),
                   (0, topheight, 0, -cos(incx), sin(incx), 0, u, v),
                   (-x0, cumheight, -z0, -cos(incx), sin(incx), 0, u, v),
                   (x0, cumheight, z0, 0, sin(incz), cos(incz), u, v),
                   (0, topheight, 0, 0, sin(incz), cos(incz), u, v),
                   (-x0, cumheight, z0, 0, sin(incz), cos(incz), u, v),
                   (x0, cumheight, -z0, 0, sin(incz), -cos(incz), u, v),
                   (0, topheight, 0, 0, sin(incz), -cos(incz), u, v),
                   (-x0, cumheight, -z0, 0, sin(incz), -cos(incz), u, v)])
        idx.extend([
            base, base + 1, base + 2, base + 5, base + 4, base + 3, base + 8,
            base + 7, base + 6, base + 9, base + 10, base + 11
        ])

    elif roof == 2:
        # gabled
        topheight = cumheight + heights[3]
        incz = atan(z / (2 * heights[3]))
        ny = sin(incz)
        nz = cos(incz)
        #roof
        vt.extend([(x0, cumheight, z0, 0, ny, nz, u, v),
                   (x0, topheight, 0, 0, ny, nz, u, v),
                   (-x0, topheight, 0, 0, ny, nz, u, v),
                   (-x0, cumheight, z0, 0, ny, nz, u, v),
                   (x0, cumheight, -z0, 0, ny, -nz, u, v),
                   (x0, topheight, 0, 0, ny, -nz, u, v),
                   (-x0, topheight, 0, 0, ny, -nz, u, v),
                   (-x0, cumheight, -z0, 0, ny, -nz, u, v)])
        idx.extend([
            base + 2, base + 1, base, base, base + 3, base + 2, base + 4,
            base + 5, base + 6, base + 6, base + 7, base + 4
        ])
        #gables
        (u, v) = rgb2uv(rgbs[4])
        base = len(vt)
        vt.extend([(x0, cumheight, z0, 1, 0, 0, u, v),
                   (x0, topheight, 0, 1, 0, 0, u, v),
                   (x0, cumheight, -z0, 1, 0, 0, u, v),
                   (-x0, cumheight, z0, -1, 0, 0, u, v),
                   (-x0, topheight, 0, -1, 0, 0, u, v),
                   (-x0, cumheight, -z0, -1, 0, 0, u, v)])
        idx.extend([base, base + 1, base + 2, base + 5, base + 4, base + 3])

    elif roof == 3:
        # slanty
        topheight = cumheight + heights[3]
        incz = atan(z / heights[3])
        ny = sin(incz)
        nz = cos(incz)
        #roof
        vt.extend([(x0, cumheight, z0, 0, ny, nz, u, v),
                   (x0, topheight, -z0, 0, ny, nz, u, v),
                   (-x0, topheight, -z0, 0, ny, nz, u, v),
                   (-x0, cumheight, z0, 0, ny, nz, u, v)])
        idx.extend([base + 2, base + 1, base, base, base + 3, base + 2])
        #gables
        (u, v) = rgb2uv(rgbs[4])
        base = len(vt)
        vt.extend([(x0, topheight, -z0, 1, 0, 0, u, v),
                   (x0, cumheight, -z0, 1, 0, 0, u, v),
                   (x0, cumheight, z0, 1, 0, 0, u, v),
                   (-x0, topheight, -z0, -1, 0, 0, u, v),
                   (-x0, cumheight, -z0, -1, 0, 0, u, v),
                   (-x0, cumheight, z0, -1, 0, 0, u, v)])
        idx.extend([base, base + 1, base + 2, base + 5, base + 4, base + 3])
        #face
        (u, v) = rgb2uv(rgbs[5])
        base = len(vt)
        vt.extend([(x0, topheight, -z0, 0, 0, -1, u, v),
                   (x0, cumheight, -z0, 0, 0, -1, u, v),
                   (-x0, cumheight, -z0, 0, 0, -1, u, v),
                   (-x0, topheight, -z0, 0, 0, -1, u, v)])
        idx.extend([base + 2, base + 1, base, base, base + 3, base + 2])

    obj = Object(name, "Generic building", None, None)
    obj.addgeometry(Material(output.xpver, None), vt, idx)
    return obj
Exemple #5
0
def makegenmulti(name, output, sides, x, z, heights, texs):
    # building fits inside an oval inscribed in a x*z box
    slice = 2 * pi / sides
    halfslice = pi / sides
    sides2 = sides * 2
    cumheight = 0
    vt = []
    idx = []
    rgbs = []
    for i in range(len(texs)):
        rgbs.append(genrgb(i, texs[i]))
    for story in range(3):
        (u, v) = rgb2uv(rgbs[story])
        base = len(vt)
        for corner in range(sides):
            angle = corner * slice - halfslice
            nx = sin(angle)
            nz = cos(angle)
            x0 = x * nx / 2
            z0 = z * nz / 2
            vt.append((x0, cumheight, z0, nx, 0, nz, u, v))
            vt.append((x0, cumheight + heights[story], z0, nx, 0, nz, u, v))
            idx.extend([
                base + corner * 2, base + (corner * 2 + 1) % sides2,
                base + (corner * 2 + 2) % sides2,
                base + (corner * 2 + 3) % sides2,
                base + (corner * 2 + 2) % sides2,
                base + (corner * 2 + 1) % sides2
            ])
        cumheight += heights[story]

    # roof
    (u, v) = rgb2uv(rgbs[3])
    base = len(vt)

    if heights[3] == 0:  # simplify if actually flat
        for corner in range(sides):
            angle = corner * slice - halfslice
            x0 = sin(angle) * x / 2
            z0 = cos(angle) * z / 2
            vt.append((x0, cumheight, z0, 0, 1, 0, u, v))
            vt.append((0, cumheight, 0, 0, 1, 0, u, v))
            idx.extend([
                base + corner * 2, base + (corner * 2 + 1) % sides2,
                base + (corner * 2 + 2) % sides2
            ])
    else:
        incx = atan(x / (2 * heights[3]))
        incz = atan(z / (2 * heights[3]))
        for corner in range(sides):
            # FIXME: normal calculation is incorrect
            angle = corner * slice - halfslice
            nx = cos(incx) * sin(angle)
            ny = sin(incx) * sin(angle) + sin(incz) * cos(angle)
            nz = cos(incz) * cos(angle)
            x0 = sin(angle) * x / 2
            z0 = cos(angle) * z / 2
            vt.append((x0, cumheight, z0, nx, ny, nz, u, v))
            angle = corner * slice
            nx = cos(incx) * sin(angle)
            ny = sin(incx) * sin(angle) + sin(incz) * cos(angle)
            nz = cos(incz) * cos(angle)
            vt.append((0, cumheight + heights[3], 0, nx, ny, nz, u, v))
            idx.extend([
                base + corner * 2, base + (corner * 2 + 1) % sides2,
                base + (corner * 2 + 2) % sides2
            ])

    obj = Object(name, "Generic building", None, None)
    obj.addgeometry(Material(output.xpver, None), vt, idx)
    return obj
Exemple #6
0
def makegenquad(name, output, x, z, incx, incz, heights, texs, roof):
    # roof types: 0=flat, 1=pointy, 2=gabled, 3=slanty
    cumheight=0
    vt=[]
    idx=[]
    rgbs=[]
    for i in range(len(texs)):
        rgbs.append(genrgb(i, texs[i]))
    sign=[(1,1), (1,-1), (-1,-1), (-1,1), (1,1)]
    n=[( cos(incx),sin(incx),0), (0,sin(incz),-cos(incz)),
       (-cos(incx),sin(incx),0), (0,sin(incz), cos(incz))]
    for story in range(3):
        if not heights[story]:
            continue
        (u,v)=rgb2uv(rgbs[story])
        x0=x/2-sin(incx)*cumheight
        z0=z/2-sin(incz)*cumheight
        x1=x/2-sin(incx)*(cumheight+heights[story])
        z1=z/2-sin(incz)*(cumheight+heights[story])
        for side in range(4):
            (nx,ny,nz)=n[side]
            base=len(vt)
            for corner in [side, side+1]:
                (sx,sz)=sign[corner]
                vt.extend([(sx*x0, cumheight, sz*z0, nx,ny,nz, u,v),
                           (sx*x1, cumheight+heights[story], sz*z1,
                            nx,ny,nz, u,v)])
            idx.extend([base,base+1,base+2, base+3,base+2,base+1])
        cumheight += heights[story]

    # roof
    x0=x/2-sin(incx)*cumheight
    z0=z/2-sin(incz)*cumheight
    (u,v)=rgb2uv(rgbs[3])
    base=len(vt)
    if roof==0 or heights[3]==0:        # simplify if actually flat
        vt.extend([( x0, cumheight,  z0, 0,1,0, u,v),
                   ( x0, cumheight, -z0, 0,1,0, u,v),
                   (-x0, cumheight, -z0, 0,1,0, u,v),
                   (-x0, cumheight,  z0, 0,1,0, u,v)])
        idx.extend([base+2,base+1,base, base,base+3,base+2])

    elif roof==1:
        # pointy
        topheight=cumheight+heights[3]
        incx=atan(x/(2*heights[3]))
        incz=atan(z/(2*heights[3]))
        vt.extend([( x0, cumheight,  z0,  cos(incx),sin(incx),0, u,v),
                   (  0, topheight,   0,  cos(incx),sin(incx),0, u,v),
                   ( x0, cumheight, -z0,  cos(incx),sin(incx),0, u,v),
                   (-x0, cumheight,  z0, -cos(incx),sin(incx),0, u,v),
                   (  0, topheight,   0, -cos(incx),sin(incx),0, u,v),
                   (-x0, cumheight, -z0, -cos(incx),sin(incx),0, u,v),
                   ( x0, cumheight,  z0, 0,sin(incz), cos(incz), u,v),
                   (  0, topheight,   0, 0,sin(incz), cos(incz), u,v),
                   (-x0, cumheight,  z0, 0,sin(incz), cos(incz), u,v),
                   ( x0, cumheight, -z0, 0,sin(incz),-cos(incz), u,v),
                   (  0, topheight,   0, 0,sin(incz),-cos(incz), u,v),
                   (-x0, cumheight, -z0, 0,sin(incz),-cos(incz), u,v)])
        idx.extend([  base,base+1,base+2, base+5,base+4,base+3,
                    base+8,base+7,base+6, base+9,base+10,base+11])

    elif roof==2:
        # gabled
        topheight=cumheight+heights[3]
        incz=atan(z/(2*heights[3]))
        ny=sin(incz)
        nz=cos(incz)
        #roof
        vt.extend([( x0, cumheight,  z0, 0,ny,nz, u,v),
                   ( x0, topheight,   0, 0,ny,nz, u,v),
                   (-x0, topheight,   0, 0,ny,nz, u,v),
                   (-x0, cumheight,  z0, 0,ny,nz, u,v),
                   ( x0, cumheight, -z0, 0,ny,-nz, u,v),
                   ( x0, topheight,   0, 0,ny,-nz, u,v),
                   (-x0, topheight,   0, 0,ny,-nz, u,v),
                   (-x0, cumheight, -z0, 0,ny,-nz, u,v)])
        idx.extend([base+2,base+1,base,     base,base+3,base+2,
                    base+4,base+5,base+6, base+6,base+7,base+4])
        #gables
        (u,v)=rgb2uv(rgbs[4])
        base=len(vt)
        vt.extend([( x0, cumheight,  z0, 1,0,0, u,v),
                   ( x0, topheight,   0, 1,0,0, u,v),
                   ( x0, cumheight, -z0, 1,0,0, u,v),
                   (-x0, cumheight,  z0, -1,0,0, u,v),
                   (-x0, topheight,   0, -1,0,0, u,v),
                   (-x0, cumheight, -z0, -1,0,0, u,v)])
        idx.extend([base,base+1,base+2, base+5,base+4,base+3])

    elif roof==3:
        # slanty
        topheight=cumheight+heights[3]
        incz=atan(z/heights[3])
        ny=sin(incz)
        nz=cos(incz)
        #roof
        vt.extend([( x0, cumheight,  z0, 0,ny,nz, u,v),
                   ( x0, topheight, -z0, 0,ny,nz, u,v),
                   (-x0, topheight, -z0, 0,ny,nz, u,v),
                   (-x0, cumheight,  z0, 0,ny,nz, u,v)])
        idx.extend([base+2,base+1,base, base,base+3,base+2])
        #gables
        (u,v)=rgb2uv(rgbs[4])
        base=len(vt)
        vt.extend([( x0, topheight, -z0,  1,0,0, u,v),
                   ( x0, cumheight, -z0,  1,0,0, u,v),
                   ( x0, cumheight,  z0,  1,0,0, u,v),
                   (-x0, topheight, -z0, -1,0,0, u,v),
                   (-x0, cumheight, -z0, -1,0,0, u,v),
                   (-x0, cumheight,  z0, -1,0,0, u,v)])
        idx.extend([base,base+1,base+2, base+5,base+4,base+3])
        #face
        (u,v)=rgb2uv(rgbs[5])
        base=len(vt)
        vt.extend([( x0, topheight, -z0, 0,0,-1, u,v),
                   ( x0, cumheight, -z0, 0,0,-1, u,v),
                   (-x0, cumheight, -z0, 0,0,-1, u,v),
                   (-x0, topheight, -z0, 0,0,-1, u,v)])
        idx.extend([base+2,base+1,base, base,base+3,base+2])
        
    obj=Object(name, "Generic building", None, None)
    obj.addgeometry(Material(output.xpver, None), vt, idx)
    return obj
Exemple #7
0
def makegenmulti(name, output, sides, x, z, heights, texs):
    # building fits inside an oval inscribed in a x*z box
    slice=2*pi/sides
    halfslice=pi/sides
    sides2=sides*2
    cumheight=0
    vt=[]
    idx=[]
    rgbs=[]
    for i in range(len(texs)):
        rgbs.append(genrgb(i, texs[i]))
    for story in range(3):
        (u,v)=rgb2uv(rgbs[story])
        base=len(vt)
        for corner in range(sides):
            angle=corner*slice-halfslice
            nx=sin(angle)
            nz=cos(angle)
            x0=x*nx/2
            z0=z*nz/2
            vt.append((x0, cumheight, z0, nx,0,nz, u,v))
            vt.append((x0, cumheight+heights[story], z0, nx,0,nz, u,v))
            idx.extend([base + corner*2,
                        base +(corner*2+1)%sides2,
                        base +(corner*2+2)%sides2,
                        base +(corner*2+3)%sides2,
                        base +(corner*2+2)%sides2,
                        base +(corner*2+1)%sides2])
        cumheight += heights[story]

    # roof
    (u,v)=rgb2uv(rgbs[3])
    base=len(vt)

    if heights[3]==0:        # simplify if actually flat
        for corner in range(sides):
            angle=corner*slice-halfslice
            x0=sin(angle)*x/2
            z0=cos(angle)*z/2
            vt.append((x0, cumheight, z0, 0,1,0, u,v))
            vt.append((0,  cumheight, 0, 0,1,0, u,v))
            idx.extend([base +corner*2,
                        base+(corner*2+1)%sides2,
                        base+(corner*2+2)%sides2])
    else:
        incx=atan(x/(2*heights[3]))
        incz=atan(z/(2*heights[3]))
        for corner in range(sides):
            # FIXME: normal calculation is incorrect
            angle=corner*slice-halfslice
            nx=cos(incx)*sin(angle)
            ny=sin(incx)*sin(angle)+sin(incz)*cos(angle)
            nz=cos(incz)*cos(angle)
            x0=sin(angle)*x/2
            z0=cos(angle)*z/2
            vt.append((x0, cumheight, z0, nx,ny,nz, u,v))
            angle=corner*slice
            nx=cos(incx)*sin(angle)
            ny=sin(incx)*sin(angle)+sin(incz)*cos(angle)
            nz=cos(incz)*cos(angle)
            vt.append((0, cumheight+heights[3], 0, nx,ny,nz, u,v))
            idx.extend([base +corner*2,
                        base+(corner*2+1)%sides2,
                        base+(corner*2+2)%sides2])

    obj=Object(name, "Generic building", None, None)
    obj.addgeometry(Material(output.xpver, None), vt, idx)
    return obj