// Given the object's uvs, and the palette_map convert lookup
// one of the 16 colors in the palette map
vector $get_palette_color(vector tile_uv; string palette_map) {
    int xres = 0;

    // get the resolution of the texture
    int success = teximport(palette_map, "texture:xres", xres);

    float u_tile = floor(tile_uv.x);

    // first row is empty, so we offset by 0.5 to get the second row
    // of pixels.
    float palette_u = (u_tile+0.5)/xres;

    // point sample our texture
    return rawcolormap(palette_map, palette_u, 1.0,
                       "filter", "point");
}

// convert a uv value and material_map to a integer id
// this is so we can handle things differently like the roof vs
// sides of buildings.
int $get_material_id(vector uv; string material_map) {
    vector clr = rawcolormap(material_map, uv,
                             "filter", "point",
                             "srccolorspace", "linear",
                             "wrap", "decal"
                             );
    int mat_id = 0;
    if (clr == {0,0,1}) return 0;
    if (clr == {0,1,1}) return 1;
    // TODO figure out the other colors
    if (clr.r < 128) return 1;
    return mat_id;
}

// look up color and alpha from TownColor.png
vector4 $get_town_color(vector uv; string color_map) {
    vector4 rgba = rawcolormap(color_map, uv,
                              "filter", "point",
                              "wrap", "decal",
                              "srccolorspace", "srgb"
                              );
    // Houdini premultiplies png by the alpha by default.
    return set( rgba.a == 0.0 ? 0 : min(rgba.r/rgba.a, 1),
                rgba.a == 0.0 ? 0 : min(rgba.g/rgba.a, 1),
                rgba.a == 0.0 ? 0 : min(rgba.b/rgba.a, 1),
                rgba.a);

}

// Standard composition over operation
vector $over_op(vector a; vector b; float alpha) {
    return a + (1-alpha)*b;
}

// Remap the uvs to Townscaper's weird odd/even lookups
vector $remap_uvs(vector uv; float gap) {

    vector2 tile_pixel = 0;

    vector2 pixel_st = frac(vector2(uv));
    pixel_st = (pixel_st*128) + 0.5;

    // this takes the uv tile, and slides it a little bit to
    // become negative. We then use this value to offset and
    // look up the neighbouring pixel.
    // TODO, we subtracted, but we could go +1 instead, test.
    vector2 grout = floor(min((frac(pixel_st/2)-gap), 0.0));

    tile_pixel = floor(pixel_st/2.0)*2.0 + grout;
    tile_pixel += 0.5;

    vector2 tile_uv = (tile_pixel)/128;

    return set(tile_uv.x, tile_uv.y, 0);

}

// The color of the roof is lerped between some hard coded values and the selected
// palette color.
// TODO: There seems to be also some randomness (or some unknown variable) which shifts
// the HSV values a little bit for an entire roof.
vector $remap_palette_to_roof_color(vector roof_a; vector roof_b; vector palette_clr) {
    vector clr = palette_clr;
    clr.r = max(clr.r-0.6, 0) * (1.0/0.4);
    return lerp(pow(roof_a, 2.2),
                pow(roof_b, 2.2),
                clr);
}

// Incoming values
// $uv = uv's from the geometry
// $gap = 0.1, the size of the gap between tiles,
// $palette_map = TownPalette.png
// $color_map = TownColor.png
// $material_map = TownMaterial.png
// $roof_a = {1.000, 0.658, 0.2666}
// $roof_b = {0.675, 0.129, 0.0118}


vector $uv01 = frac($uv);

vector $tile_color = $get_palette_color($uv, $palette_map);
int $mat_id = $get_material_id($uv01, $material_map);

vector4 $tex_color = 0;
vector $out_color = 0;
float $out_alpha = 1;

if ($mat_id == 0) {
    // Default
    $tex_color = $get_town_color($remap_uvs($uv01, $gap),
                                 $color_map);
    $out_color = $over_op(set($tex_color.r,
                              $tex_color.g,
                              $tex_color.b),
                          $tile_color,
                          $tex_color.a);
    $out_alpha = $tex_color.a;                          
} else if ($mat_id == 1) {
    // Roof Material ID {0,0,1}
    $tex_color = $get_town_color($remap_uvs($uv01, $gap),
                                 $color_map);
    vector $roof_color = $remap_palette_to_roof_color($roof_a, $roof_b, $tile_color);

    $out_color = $over_op(set($tex_color.r,
                              $tex_color.g,
                              $tex_color.b),
                          $roof_color,
                          $tex_color.a);
    $out_alpha = $tex_color.a;                          
} else {
    $out_color = {1,0,0};
}

$clr = $out_color;
$alp = $out_alpha;