import bpy

def render_vec3(v):
    return f"{{{v.x:.6f}, {v.y:.6f}, {v.z:.6f}}}"

def render_vec2(v):
    return f"{{{v.x:.6f}, {v.y:.6f}}}"

def render_mesh_vertices(f, name, vertices):
    f.write(f"const vec3 {name}_position[] = {{\n")
    for vertex in vertices:
        f.write(f"  {render_vec3(vertex.co)},\n")
    f.write("};\n\n")

def render_vertex_normals(f, name, vertices):
    f.write(f"const vec3 {name}_normal[] = {{\n")
    for vertex in vertices:
        f.write(f"  {render_vec3(vertex.normal)},\n")
    f.write("};\n\n")

def render_polygon_normals(f, name, polygon_normals):
    f.write(f"const vec3 {name}_polygon_normal[] = {{\n")
    for normal in polygon_normals:
        f.write(f"  {render_vec3(normal.vector)},\n")
    f.write("};\n\n")

def render_polygons(f, name, polygons):
    f.write(f"const polygon {name}_polygons[] = {{\n")
    for i, polygon in enumerate(polygons):
        s = ", ".join(map(str, polygon.vertices))
        c = "// " if len(polygon.vertices) != 4 else ""

        f.write(f"  {c}{{{s}}},\n")
    f.write("};\n\n")

def render_uv_map(f, name, name2, uvm):
    f.write(f"const vec2 {name}_{name2}_uvmap[] = {{\n")
    print(uvm)
    for uv in uvm:
        s = render_vec2(uv.vector)
        f.write(f"  {s},\n")
    f.write("};\n\n")

def render_location(f, location):
    s = render_vec3(location)
    f.write(f"  .location = {s},\n")

def render_scale(f, scale):
    s = render_vec3(scale)
    f.write(f"  .scale = {s},\n")

def render_rotation_axis_angle(f, r):
    r = f"{{{r[1]:.6f}, {r[2]:.6f}, {r[3]:.6f}, {r[0]:.6f}}}"
    f.write(f"  .rotation = {r}, // rotation_axis_angle (XYZ T)\n")

def render_rotation_quaternion(f, r):
    r = f"{{{r[1]:.6f}, {r[2]:.6f}, {r[3]:.6f}, {r[0]:.6f}}}"
    f.write(f"  .rotation = {r}, // quaternion (XYZW)\n")

def render_mesh(f, name, mesh):
    f.write(f"const vec2 * {name}_uv_layers[] = {{\n")
    for layer_name in mesh.uv_layers.keys():
        f.write(f"  {name}_{layer_name}_uvmap,\n");
    f.write( "};\n\n")

    f.write(f"const mesh {name} = {{\n")
    f.write(f"  .position = {name}_position,\n")
    f.write(f"  .position_length = (sizeof ({name}_position)) / (sizeof ({name}_position[0])),\n")
    f.write(f"  .normal = {name}_normal,\n")
    f.write(f"  .normal_length = (sizeof ({name}_normal)) / (sizeof ({name}_normal[0])),\n")
    f.write(f"  .polygon_normal = {name}_polygon_normal,\n")
    f.write(f"  .polygon_normal_length = (sizeof ({name}_polygon_normal)) / (sizeof ({name}_polygon_normal[0])),\n")
    f.write(f"  .polygons = {name}_polygons,\n")
    f.write(f"  .polygons_length = (sizeof ({name}_polygons)) / (sizeof ({name}_polygons[0])),\n")
    f.write(f"  .uv_layers = {name}_uv_layers,\n")
    f.write(f"  .uv_layers_length = (sizeof ({name}_uv_layers)) / (sizeof ({name}_uv_layers[0])),\n")
    f.write( "};\n\n")

def translate_name(name):
    return name.replace(".", "_").replace("-", "_")

def mesh_objects(objects):
    for object in objects:
        if object.type == "MESH":
            yield object

def mesh_meshes(objects):
    mesh_names = set()
    for object in mesh_objects(objects):
        mesh = object.data
        if mesh.name in mesh_names:
            continue
        mesh_names.add(mesh.name)
        yield mesh

def export_meshes(f):
    for mesh in mesh_meshes(bpy.context.scene.objects):
        #mesh.vertex_normals
        #mesh.vertex_colors
        #mesh.vertices
        #mesh.uv_layers
        #mesh.polygons
        #mesh.polygon_normals
        #mesh.name

        mesh_name = "mesh_" + translate_name(mesh.name)

        render_mesh_vertices(f, mesh_name, mesh.vertices)
        for layer_name, layer in mesh.uv_layers.items():
            render_uv_map(f, mesh_name, layer_name, layer.uv)
        render_vertex_normals(f, mesh_name, mesh.vertices)
        render_polygon_normals(f, mesh_name, mesh.polygon_normals)
        render_polygons(f, mesh_name, mesh.polygons)


        render_mesh(f, mesh_name, mesh);

        #mesh.polygons[0].vertices
        # [0, 1, 3, 2]

        # v = mesh.vertices[0]
        # v.normal
        # v.index

def mesh_objects_sorted(objects):
    def key(o):
        return (o.data.name, o.name)
    return sorted(mesh_objects(objects), key=key)

def export_objects(f):
    f.write("const struct object objects[] = {\n")
    for object in mesh_objects_sorted(bpy.context.scene.objects):
        #object.rotation_mode = 'AXIS_ANGLE'
        #object.name
        #object.rotation_axis_angle
        #object.rotation_euler
        #object.location

        obj_name = "object_" + translate_name(object.name)

        f.write(f"  {{ // {obj_name}\n")

        obj_mesh_name = "mesh_" + translate_name(object.to_mesh().name)

        f.write("  ")
        f.write(f"  .mesh = &{obj_mesh_name},\n")

        location, rotation, scale = object.matrix_world.decompose()
        f.write("  ")
        render_scale(f, scale)
        f.write("  ")
        render_rotation_quaternion(f, rotation)
        f.write("  ")
        render_location(f, location)

        f.write("  },\n")
    f.write("};\n\n")

def export_scene(f):
    export_meshes(f)
    export_objects(f)

with open("/home/bilbo/output.h", "w") as f:
    export_scene(f)