merge_city.py

import os
import sys
import logging
import re
import shutil
import datetime

import bf2

G_OBJECTS_CORE = {
        'housingblock_1_groundfloor_v2' : 'staticobjects/pr/citybuildings/housingblock_1_groundfloor_v2',
        'housingblock_1_midfloor_v1'    : 'staticobjects/pr/citybuildings/housingblock_1_midfloor_v1',
        'housingblock_1_topfloor'       : 'staticobjects/pr/citybuildings/housingblock_1_topfloor',
    }

# placeholder func
def getStaticObjects(fname_staticobjects):
    from vec3 import Vec3

    pattern_bf2_float3 = r'[-]{0,1}\d+.\d+\/[-]{0,1}\d+.\d+\/[-]{0,1}\d+.\d+'

    pattern = r'^rem \*\*\* \S+ \*\*\*$\n'
    pattern += r'^object.create (?P<name>\S+)$\n'
    pattern += r'^object.absolutePosition (?P<position>' + pattern_bf2_float3 + ')$\n'
    pattern += r'^object.rotation (?P<rotation>' + pattern_bf2_float3 + ')$\n'
    pattern += r'^object.layer 1$\n'
    pattern += r'^\n'

    flags = re.MULTILINE | re.IGNORECASE

    staticobjects = []
    with open(fname_staticobjects) as fo:
        matches = re.findall(pattern, fo.read(), flags)
        for match in matches:
            templateName = match[0]
            position = Vec3(*match[1].split('/'))
            rotation = match[2].split('/')
            staticobjects.append(bf2.StaticObject(templateName, position, rotation))

    return staticobjects

def writeStaticObjects(fname_staticobjects, staticobjects):
    with open(fname_staticobjects, 'w') as fo:
        for staticobjects in staticobjects:
            createScript = ''
            createScript += '\nrem *** %s ***' % staticobjects.name
            createScript += '\nObject.create %s' % staticobjects.name
            createScript += '\nObject.absolutePosition %s/%s/%s' % (staticobjects.position.x, staticobjects.position.y, staticobjects.position.z)
            createScript += '\nObject.rotation %s/%s/%s' % (float(staticobjects.rotation[0]), float(staticobjects.rotation[1]), float(staticobjects.rotation[2]))
            createScript += '\nObject.layer 1'
            createScript += '\n'
            fo.write(createScript)

def rename_objects(path, templateName, suffix, filter=None):
    for dirname, dirnames, filenames in os.walk(path):
        for filename in filenames:
            fname, ext = os.path.splitext(filename)
            fname_path = os.path.join(dirname, filename)
            if ext in ['.con', '.tweak']:
                fin = open(fname_path, 'r').readlines()
                with open(fname_path, 'w') as fout:
                    for line in fin:
                        if filter:
                            line = filter(line)
                        fout.write(line.replace(templateName, templateName + suffix))
            filename_new = filename.replace(templateName, templateName + suffix)
            fname_path_new = os.path.join(dirname, filename_new)
            logging.debug('os.rename(%s, %s)' % (fname_path, fname_path_new))
            os.rename(fname_path, fname_path_new)

def remove_geom_visible(line):
    if line.lower().startswith('objecttemplate.geometry'): return ''
    if line.lower().startswith('geometrytemplate.create staticmesh'): return ''
    return line

def remove_geom_cols(line):
    if line.lower().startswith('ObjectTemplate.collisionMesh'.lower()): return ''
    if line.lower().startswith('ObjectTemplate.setCollisionMesh '.lower()): return ''
    if line.lower().startswith('ObjectTemplate.hasCollisionPhysics'.lower()): return ''
    if line.lower().startswith('CollisionManager.createTemplate'.lower()): return ''
    return line

def copy_object_as_custom(game, templateName, suffix=None, filter=None):
    logging.debug('cloning %s as custom to %s' % (templateName, game.level.name))
    src = os.path.join(game.root, game.modPath, 'objects', G_OBJECTS_CORE[templateName])
    dst = os.path.join(game.root, game.modPath, 'levels', game.level.name, 'objects', G_OBJECTS_CORE[templateName])
    if suffix: dst += suffix
    logging.debug('shutil.copytree(%s, %s)' % (src, dst))
    if os.path.exists(dst):
        shutil.rmtree(dst)
    shutil.copytree(src, dst)

    if suffix: rename_objects(dst, templateName, suffix, filter)

def merge_objects(game, staticobjects, templateName, suffix):
    # stop
    # you violated the law
    from bf2mesh.visiblemesh import VisibleMesh

    staticobject_main = staticobjects[0]
    mergedNum = 0
    with VisibleMesh(os.path.join(game.root, game.modPath, 'objects', G_OBJECTS_CORE[templateName], 'meshes', templateName + '.staticMesh')) as staticobject_main_mesh:
        for staticobject_secondary in staticobjects[1:]:
            offset = staticobject_secondary.position - staticobject_main.position
            with VisibleMesh(os.path.join(game.root, game.modPath, 'objects', G_OBJECTS_CORE[templateName], 'meshes', templateName + '.staticMesh')) as staticobject_secondary_mesh:
                logging.info('translating(%s) %s' % (offset, staticobject_secondary_mesh.filename))
                staticobject_secondary_mesh.translate(offset, False)
                try:
                    logging.info('merging #%d %s to %s' % (mergedNum, templateName, staticobject_main_mesh.filename))
                    staticobject_main_mesh.merge(staticobject_secondary_mesh, False)
                except OverflowError as err:
                    logging.error(err.__repr__)
                    raise err
                mergedNum += 1
        export_path = os.path.join(game.root,
                                    game.mod.modPath,
                                    'levels',
                                    game.level.name,
                                    'objects',
                                    G_OBJECTS_CORE[templateName] + suffix,
                                    'Meshes',
                                    '%s.staticmesh' % (templateName + suffix))
        logging.info('updating bounds %s' % (staticobject_main_mesh.filename))
        staticobject_main_mesh.update_boundaries()
        staticobject_main_mesh.export(export_path)
        logging.info('exported %d merged %s to %s' % (mergedNum, templateName, export_path))

        staticobject_main.name += suffix
        return staticobject_main

def main2():
    logging.debug('logging level is DEBUG')

    root = 'D:\\Games\\Project Reality'
    modPath = 'mods/pr_repo'
    levelName = 'test_airfield'
    game = bf2.Game(root)
    game.loadMod(modPath)
    game.loadLevel(levelName)

    fname_for_merge = 'staticobjects_testing.con'
    fname_visible = 'staticobjects_visible.con'
    fname_cols = 'staticobjects_cols.con'

    staticobjects_city = getStaticObjects(os.path.join(root, modPath, 'levels', levelName, fname_for_merge))
    #staticobjects_city = game.level.getStaticObjects(os.path.join(game.level.path, fname_for_merge))

    objects2merge = {}
    for staticobject in staticobjects_city:
        if staticobject.name not in objects2merge: objects2merge[staticobject.name] = []
        objects2merge[staticobject.name].append(staticobject)

    # cleanup first
    shutil.rmtree(os.path.join(game.root, game.modPath, 'levels', game.level.name, 'objects', 'staticobjects'), ignore_errors=True)

    # clone first&remove geometry
    suffix_cols = '_cols'
    for templateName in objects2merge:
        copy_object_as_custom(game, templateName, suffix_cols, remove_geom_visible)
    staticobjects_city_cols = []
    for staticobject in staticobjects_city:
        staticobject_cols = bf2.StaticObject(
                                staticobject.name+suffix_cols,
                                staticobject.position,
                                staticobject.rotation)
        staticobjects_city_cols.append(staticobject_cols)
    writeStaticObjects(os.path.join(root, modPath, 'levels', levelName, fname_cols), staticobjects_city_cols)

    # clone visible meshes now
    # then merge
    staticobjects_city_visible_merged = []
    # 1. merge groundfloor
    templateName = 'housingblock_1_groundfloor_v2'
    suffix_merged = '_merged'
    copy_object_as_custom(game, templateName, suffix_merged, remove_geom_cols)
    staticobjects_groundfloors = [staticobject for staticobject in staticobjects_city if staticobject.name == templateName]
    staticobject_merged = merge_objects(game, staticobjects_groundfloors, templateName, suffix_merged)
    staticobjects_city_visible_merged.append(staticobject_merged)

    # 2. merge middle floors, grouped
    templateName = 'housingblock_1_midfloor_v1'
    suffix_merged = '_merged'
    copy_object_as_custom(game, templateName, suffix_merged, remove_geom_cols)
    staticobjects_middlefloors = {}
    for staticobject in staticobjects_city:
        if staticobject.name != templateName: continue
        positionXZ = '%s%s' % (staticobject.position.x, staticobject.position.z)
        if positionXZ not in staticobjects_middlefloors.keys(): staticobjects_middlefloors[positionXZ] = []
        staticobjects_middlefloors[positionXZ].append(staticobject)
    midfloors_merged = False
    for positionXZ in staticobjects_middlefloors:
        staticobject = staticobjects_middlefloors[positionXZ][0]
        staticobject_middlefloors_base = bf2.StaticObject(
                                staticobject.name+suffix_merged,
                                staticobject.position,
                                staticobject.rotation)
        staticobjects_city_visible_merged.append(staticobject_middlefloors_base)
        if not midfloors_merged: merge_objects(game, staticobjects_middlefloors[positionXZ], templateName, suffix_merged)
        midfloors_merged = True

    # 3. merge topfloor
    templateName = 'housingblock_1_topfloor'
    suffix_merged = '_merged'
    copy_object_as_custom(game, templateName, suffix_merged, remove_geom_cols)
    staticobjects_topfloors = [staticobject for staticobject in staticobjects_city if staticobject.name == templateName]
    staticobject_merged = merge_objects(game, staticobjects_topfloors, templateName, suffix_merged)
    staticobjects_city_visible_merged.append(staticobject_merged)

    # MERGED ALL
    writeStaticObjects(os.path.join(root, modPath, 'levels', levelName, fname_visible), staticobjects_city_visible_merged)

def main():
    logging.debug('logging level is DEBUG')

    root = 'D:\\Games\\Project Reality'
    modPath = 'mods/pr_repo'
    levelName = 'test_airfield'
    game = bf2.Game(root)
    game.loadMod(modPath)
    game.loadLevel(levelName)

    fname_for_merge = 'staticobjects_testing.con'
    fname_visible = 'staticobjects_visible.con'
    fname_cols = 'staticobjects_cols.con'

    #staticobjects_city = getStaticObjects(os.path.join(root, modPath, 'levels', levelName, fname_for_merge))
    staticobjects_city = game.level.getStaticObjects(os.path.join(game.level.path, fname_for_merge))

    objects2merge = {}
    for staticobject in staticobjects_city:
        if staticobject.name not in objects2merge: objects2merge[staticobject.name] = []
        objects2merge[staticobject.name].append(staticobject)

    staticobjects_merged = []
    for templateName in objects2merge:
        staticobject_main = objects2merge[templateName][0]
        for staticobject_secondary in objects2merge[templateName][1:]:
            offset = staticobject_secondary.position - staticobject_main.position
            staticobject_secondary.objectTemplate(game).geometry.mesh.translate(offset)
            staticobject_main.objectTemplate(game).geometry.mesh.merge(staticobject_secondary.objectTemplate(game).geometry.mesh)
        templateName_merged = '%s_merged' % templateName
        export_path = os.path.join(game.root, game.mod.modPath, 'levels', game.level, 'objects', 'staticobjects', 'merged', templateName_merged, 'Meshes', '%s.staticmesh' % templateName_merged)
        logging.info('exporting merged %s to %s' % (templateName, export_path))
        #vmesh_main.export()
        raise NotImplementedError
        staticobject_main.name = templateName_merged
        staticobjects_merged.append(staticobject_main)

if __name__ == '__main__':
    loglevel=logging.INFO
    FORMAT = '%(levelname)s:%(module)s:%(funcName)s:%(message)s'
    logging.basicConfig(filename='merge.log',filemode='a',level=loglevel, format=FORMAT)
    logging.getLogger().addHandler(logging.StreamHandler(sys.stdout))
    #logging.basicConfig(level=loglevel, format=FORMAT)
    #main()
    main2()