X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=world_routes.h;h=b0151b4eecda1f288f0853b8219e437fea71de13;hb=63b5ac44f74599b21c4b9b18398c29b797337bea;hp=62fe06913bb1e8da83347c9b00dd325c5c0e3e67;hpb=0310bab3c018e23f5516c3e3c3653b844a8106ed;p=carveJwlIkooP6JGAAIwe30JlM.git

diff --git a/world_routes.h b/world_routes.h
index 62fe069..b0151b4 100644
--- a/world_routes.h
+++ b/world_routes.h
@@ -230,10 +230,48 @@ VG_STATIC void world_routes_debug( world_instance *world )
 }
 
 VG_STATIC 
-void world_routes_place_curve( world_instance *world,
+void world_routes_pointcloud_spot( world_instance *world, 
+                                   pointcloud_buffer *pcbuf, 
+                                   v3f co, f32 radius, u32 samples, v4f colour )
+{
+   v3f inv_ext;
+   v3_sub( pcbuf->boundary[1], pcbuf->boundary[0], inv_ext );
+   v3_div( (v3f){1.0f,1.0f,1.0f}, inv_ext, inv_ext );
+
+   for( u32 j=0; j<samples; j++ ){
+      if( pcbuf->count >= pcbuf->max )
+         return;
+
+      pointcloud_vert *vert = &pcbuf->buf[ pcbuf->count ++ ];
+
+      v3f sample, jitter, point;
+      vg_rand_sphere( jitter );
+      v3_muladds( co, jitter, radius, sample );
+
+      if( bh_closest_point( world->geo_bh, sample, point, radius*1.5f ) == -1 ){
+         v3_copy( sample, point );
+      }
+
+      v3f pos;
+      v3_sub( point, pcbuf->boundary[0], pos );
+      v3_mul( pos, inv_ext, pos );
+
+      for( u32 i=0; i<3; i++ ){
+         vert->pos[i] = (pos[i]-0.5f) * 32767.0f;
+      }
+
+      float dist = 1.0f-(v3_length(jitter));
+
+      for( u32 i=0; i<4; i++ ){
+         vert->colour[i] = colour[i] * 255.0f * dist*dist;
+      }
+   }
+}
+
+VG_STATIC 
+void world_routes_place_curve( world_instance *world, ent_route *route,
                                v4f h[3], v3f n0, v3f n2, scene_context *scene,
-                               struct pointcloud_vert *points, 
-                               u32 *point_count, v4f colour )
+                               pointcloud_buffer *pcbuf )
 {
    float t;
    v3f p, pd;
@@ -294,35 +332,9 @@ void world_routes_place_curve( world_instance *world,
       int resa = ray_world( world, sa, down, &ha ),
           resb = ray_world( world, sb, down, &hb );
       
-      for( u32 j=0; j<10; j++ ){
-      if( *point_count < POINTCLOUD_POINTS ){
-         struct pointcloud_vert *vert = &points[*point_count];
-         *point_count = (*point_count) + 1;
-
-         v3f sample, jitter, pcpoint;
-         vg_rand_sphere( jitter );
-         v3_muladds( ha.pos, jitter, 8.0f, sample );
-
-         if( bh_closest_point( world->geo_bh, sample, pcpoint, 10.0f ) == -1 ){
-            v3_copy( sample, pcpoint );
-         }
-
-         v3f pos, vol;
-         v3_sub( world->scene_geo.bbx[1], world->scene_geo.bbx[0], vol );
-         v3_sub( pcpoint, world->scene_geo.bbx[0], pos );
-         v3_div( pos, vol, pos );
-
-         for( u32 i=0; i<3; i++ ){
-            vert->pos[i] = vg_clampf(pos[i], 0.0f,1.0f) * 65535.0f;
-            vert->norm[i] = ha.normal[i] * 127.0f;
-         }
-
-         float dist = 1.0f-(v3_length(jitter));
-
-         for( u32 i=0; i<4; i++ ){
-            vert->colour[i] = colour[i] * 255.0f * dist*dist;
-         }
-      }
+      if( resa ){
+         world_routes_pointcloud_spot( world, pcbuf, ha.pos, 
+                                       12.0f, 10, route->colour );
       }
 
       if( resa && resb ){
@@ -378,11 +390,9 @@ void world_routes_place_curve( world_instance *world,
    }
 }
 
-VG_STATIC 
-void world_routes_create_mesh( world_instance *world, u32 route_id, 
-                               scene_context *sc,
-                               struct pointcloud_vert *points, 
-                               u32 *point_count )
+VG_STATIC void world_routes_gen_meshes( world_instance *world, u32 route_id, 
+                                        scene_context *sc,
+                                        pointcloud_buffer *pcbuf )
 {
    ent_route *route = mdl_arritm( &world->ent_route, route_id );
    u8 colour[4];
@@ -493,8 +503,7 @@ void world_routes_create_mesh( world_instance *world, u32 route_id,
          v3_normalize( n0 );
          v3_normalize( n2 );
 
-         world_routes_place_curve( world, p, n0, n2, sc, points, point_count,
-                                   route->colour );
+         world_routes_place_curve( world, route, p, n0, n2, sc, pcbuf );
 
          /* --- */
          v4_copy( p[2], p[0] );
@@ -507,6 +516,212 @@ void world_routes_create_mesh( world_instance *world, u32 route_id,
 VG_STATIC 
 struct world_surface *world_tri_index_surface( world_instance *world, 
                                                  u32 index );
+
+VG_STATIC f64 world_routes_scatter_surface_points( world_instance *world,
+                                                   pointcloud_buffer *pcbuf,
+                                                   f32 rate )
+{
+   static f32 densities[] = {
+      [k_surface_prop_concrete] = 2.0f,
+      [k_surface_prop_grass]    = 0.8f,
+      [k_surface_prop_metal]    = 1.0f,
+      [k_surface_prop_wood]     = 2.5f,
+      [k_surface_prop_tiles]    = 4.0f
+   };
+
+   /* calculate total area */
+   f64 total_area = 0.0f;
+   for( u32 i=0; i<world->scene_geo.indice_count/3; i++ ){
+      u32 *tri = &world->scene_geo.arrindices[i*3];
+      struct world_surface *surf = world_tri_index_surface( world, tri[0] );
+
+      if( surf->info.shader == k_shader_boundary ||
+          surf->info.shader == k_shader_invisible ) continue;
+
+      if( !(surf->info.flags & k_material_flag_preview_visibile) ) continue;
+
+      scene_vert *va = &world->scene_geo.arrvertices[tri[0]],
+                 *vb = &world->scene_geo.arrvertices[tri[1]],
+                 *vc = &world->scene_geo.arrvertices[tri[2]];
+
+      v3f v0, v1, vn;
+      v3_sub( vb->co, va->co, v0 );
+      v3_sub( vc->co, va->co, v1 );
+      v3_cross( v0, v1, vn );
+      if( vn[1] < 0.0f ) continue;
+
+      f32 density = 1.0f;
+      if( surf->info.surface_prop < vg_list_size(densities) )
+         density = densities[surf->info.surface_prop];
+      total_area += v3_length(vn)*0.5f*density;
+   }
+   
+   f32 accum = 0.0f;
+
+   u8 colour[] = { 80,80,80,255 };
+   v3f light_dir = {0.3f,0.8f,0.1f};
+   v3_normalize( light_dir );
+
+   v3f inv_ext;
+   v3_sub( pcbuf->boundary[1], pcbuf->boundary[0], inv_ext );
+   v3_div( (v3f){1.0f,1.0f,1.0f}, inv_ext, inv_ext );
+
+   for( u32 i=0; i<world->scene_geo.indice_count/3; i++ ){
+      u32 *tri = &world->scene_geo.arrindices[i*3];
+      struct world_surface *surf = world_tri_index_surface( world, tri[0] );
+
+      if( surf->info.shader == k_shader_boundary ||
+          surf->info.shader == k_shader_invisible ) continue;
+
+      if( !(surf->info.flags & k_material_flag_preview_visibile) ) continue;
+
+      scene_vert *va = &world->scene_geo.arrvertices[tri[0]],
+                 *vb = &world->scene_geo.arrvertices[tri[1]],
+                 *vc = &world->scene_geo.arrvertices[tri[2]];
+
+      v3f v0, v1, vn;
+      v3_sub( vb->co, va->co, v0 );
+      v3_sub( vc->co, va->co, v1 );
+      v3_cross( v0, v1, vn );
+      if( vn[1] < 0.0f ) continue;
+
+      f32 density = 1.0f;
+      if( surf->info.surface_prop < vg_list_size(densities) )
+         density = densities[surf->info.surface_prop];
+
+      f32 area = v3_length(vn)*0.5f*density;
+      accum += area;
+
+      v3_normalize( vn );
+
+      while( accum > rate ){
+         accum -= rate;
+
+         if( pcbuf->count >= pcbuf->max ) return total_area;
+
+         v2f co = { vg_randf64(), vg_randf64() };
+         if( v2_length2(co) > 0.5f ){
+            co[0] = 1.0f-co[0];
+            co[1] = 1.0f-co[1];
+         }
+
+         v3f pt;
+         v3_muls( v0, co[0], pt );
+         v3_muladds( pt, v1, co[1], pt );
+         v3_add( va->co, pt, pt );
+
+         if( pt[1] < world->water.height ) continue;
+         pointcloud_vert *vert = &pcbuf->buf[ pcbuf->count ++ ];
+
+         v3f pos;
+         v3_sub( pt, pcbuf->boundary[0], pos );
+         v3_mul( pos, inv_ext, pos );
+
+         for( u32 i=0; i<3; i++ ){
+            vert->pos[i] = (pos[i]-0.5f) * 32767.0f;
+         }
+
+         static v4f colours[] = {
+            [k_surface_prop_concrete] = { 0.13, 0.15, 0.17, 1.0 },
+            [k_surface_prop_grass]    = { 0.07, 0.1, 0.14, 1.0 },
+            [k_surface_prop_metal]    = { 0.15, 0.19, 0.22, 1.0 },
+            [k_surface_prop_wood]     = { 0.1, 0.13, 0.17, 1.0 },
+            [k_surface_prop_tiles]    = { 0.05, 0.06, 0.07, 1.0 },
+         };
+
+         v4f col = {0.0f,0.0f,0.0f,0.0f};
+         if( surf->info.surface_prop < vg_list_size(colours) ){
+            v4_copy( colours[surf->info.surface_prop], col );
+         }
+
+         f32 brightness = v3_dot(vn,light_dir)*0.5f+0.5f;
+         v3_muls( col, brightness, col );
+
+         for( u32 j=0; j<4; j++ ){
+            vert->colour[j] = col[j] * 255.0f;
+         }
+      }
+   }
+
+   return total_area;
+}
+
+VG_STATIC void world_routes_surface_grid( world_instance *world,
+                                          pointcloud_buffer *pcbuf )
+{
+   i32 const k_gridlines = 32,
+             k_gridres   = 255;
+
+   v3f inv_ext;
+   v3_sub( pcbuf->boundary[1], pcbuf->boundary[0], inv_ext );
+   v3_div( (v3f){1.0f,1.0f,1.0f}, inv_ext, inv_ext );
+   v4f colour = {0.2f,0.2f,0.2f,1.0f};
+   v3f dir = {0.0f,-1.0f,0.0f};
+
+   for( u32 k=0; k<2; k++ ){
+      u32 a = k*2,
+          b = (k^0x1)*2;
+
+      for( i32 x=0; x<=k_gridlines; x++ ){
+         f32 t = (float)x / (float)k_gridlines,
+             px = vg_lerpf( pcbuf->boundary[0][a], pcbuf->boundary[1][a], t );
+
+         for( i32 z=0; z<=k_gridres; z++ ){
+            f32 tz = (float)z / (float)k_gridres,
+                pz = vg_lerpf(pcbuf->boundary[0][b],pcbuf->boundary[1][b], tz);
+
+            v3f ro, hit;
+            ro[a] = px;
+            ro[1] = 1000.0f;
+            ro[b] = pz;
+
+            bh_iter it;
+            bh_iter_init_ray( 0, &it, ro, dir, INFINITY );
+            i32 idx;
+
+            while( bh_next( world->geo_bh, &it, &idx ) ){
+               u32 *tri = &world->scene_geo.arrindices[ idx*3 ];
+               v3f vs[3];
+
+               for( u32 i=0; i<3; i++ ){
+                  v3_copy( world->scene_geo.arrvertices[tri[i]].co, vs[i] );
+               }
+               
+               f32 t;
+               if( ray_tri( vs, ro, dir, &t ) ){
+                  v3_muladds( ro, dir, t, hit );
+                  struct world_surface *m1 = 
+                     world_tri_index_surface( world, tri[0] );
+
+                  if( !(m1->info.flags & k_material_flag_preview_visibile) )
+                     continue;
+
+                  if( world->water.enabled )
+                     if( hit[1] < world->water.height )
+                        continue;
+
+                  if( pcbuf->count >= pcbuf->max ) return;
+
+                  pointcloud_vert *vert = &pcbuf->buf[ pcbuf->count ++ ];
+
+                  v3f co;
+                  v3_sub( hit, pcbuf->boundary[0], co );
+                  v3_mul( co, inv_ext, co );
+
+                  for( u32 i=0; i<3; i++ ){
+                     vert->pos[i] = (co[i]-0.5f) * 32767.0f;
+                  }
+
+                  for( u32 i=0; i<4; i++ ){
+                     vert->colour[i] = colour[i] * 255.0f;
+                  }
+               }
+            }
+         }
+      }
+   }
+}
+
 /* 
  * Create the strips of colour that run through the world along course paths
  */
@@ -516,13 +731,24 @@ VG_STATIC void world_routes_generate( world_instance *world )
    vg_async_stall();
 
    vg_rand_seed( 2000 );
-   vg_async_item *call = scene_alloc_async( &world->scene_lines, 
-                                            &world->mesh_route_lines,
-                                            200000, 300000 );
-   vg_async_item *call1 = 
-      vg_async_alloc( sizeof(struct pointcloud_vert)*POINTCLOUD_POINTS );
-   u32 generated_points = 0;
-   struct pointcloud_vert *cloud_data = call1->payload;
+   vg_async_item *call_scene = scene_alloc_async( &world->scene_lines, 
+                                                  &world->mesh_route_lines,
+                                                  200000, 300000 );
+   vg_async_item *call_pointcloud = vg_async_alloc( 
+         sizeof(pointcloud_buffer) + 
+         sizeof(pointcloud_vert)*POINTCLOUD_POINTS );
+   pointcloud_buffer *pcbuf = call_pointcloud->payload;
+   pcbuf->count = 0;
+   pcbuf->max = POINTCLOUD_POINTS;
+   pcbuf->op = k_pointcloud_op_clear;
+
+   v3f ext, mid, v0;
+   v3_sub( world->scene_geo.bbx[1], world->scene_geo.bbx[0], ext );
+   f32 maxe = v3_maxf( ext );
+   v3_fill( v0, maxe * 0.5f );
+   v3_muladds( world->scene_geo.bbx[0], ext, 0.5f, mid );
+   v3_add( mid, v0, pcbuf->boundary[1] );
+   v3_sub( mid, v0, pcbuf->boundary[0] );
 
    for( u32 i=0; i<mdl_arrcount(&world->ent_gate); i++ ){
       ent_gate *gate = mdl_arritm( &world->ent_gate, i );
@@ -564,116 +790,16 @@ VG_STATIC void world_routes_generate( world_instance *world )
    }
 
    for( u32 i=0; i<mdl_arrcount(&world->ent_route); i++ ){
-      world_routes_create_mesh( world, i, &world->scene_lines,
-                                cloud_data, &generated_points );
-   }
-
-
-   {
-   vg_info( "Executing awesome algorithm!\n" );
-
-   f32 accum = 0.0f;
-   
-   v3f vol;
-   v3_sub( world->scene_geo.bbx[1], world->scene_geo.bbx[0], vol );
-   v3_div( (v3f){1.0f,1.0f,1.0f}, vol, vol );
-
-   u8 colour[] = { 80,80,80,255 };
-   v3f light_dir = {0.3f,0.8f,0.1f};
-   v3_normalize( light_dir );
-
-   for( u32 k=1; k<=10; k++ ){
-      f32 rate = 50.0f * (1.0f/(float)k);
-
-      for( u32 i=0; i<world->scene_geo.indice_count/3; i++ ){
-         u32 *tri = &world->scene_geo.arrindices[i*3];
-         struct world_surface *surf = world_tri_index_surface( world, tri[0] );
-
-         if( surf->info.shader == k_shader_boundary ||
-             surf->info.shader == k_shader_invisible ) continue;
-
-         if( !(surf->info.flags & k_material_flag_preview_visibile) ) continue;
-
-         scene_vert *va = &world->scene_geo.arrvertices[tri[0]],
-                    *vb = &world->scene_geo.arrvertices[tri[1]],
-                    *vc = &world->scene_geo.arrvertices[tri[2]];
-
-         v3f v0, v1, vn;
-         v3_sub( vb->co, va->co, v0 );
-         v3_sub( vc->co, va->co, v1 );
-         v3_cross( v0, v1, vn );
-         if( vn[1] < 0.0f ) continue;
-
-         accum += v3_length(vn)*0.5f;
-
-         v3_normalize( vn );
-
-         while( accum > rate ){
-            accum -= rate;
-
-            if( generated_points >= POINTCLOUD_POINTS ){
-               goto too_many_points;
-            }
-
-            v2f co = { vg_randf64(), vg_randf64() };
-            if( v2_length2(co) > 0.5f ){
-               co[0] = 1.0f-co[0];
-               co[1] = 1.0f-co[1];
-            }
-
-            v3f pt;
-            v3_muls( v0, co[0], pt );
-            v3_muladds( pt, v1, co[1], pt );
-            v3_add( va->co, pt, pt );
-
-            if( pt[1] < world->water.height ) continue;
-            struct pointcloud_vert *vert = &cloud_data[generated_points ++];
-
-            v3f pos;
-            v3_sub( pt, world->scene_geo.bbx[0], pos );
-            v3_mul( pos, vol, pos );
-
-            for( u32 j=0; j<3; j++ ){
-               vert->pos[j] = vg_clampf(pos[j],0.0f,1.0f) * 65535.0f;
-               vert->norm[j] = vg_clampf(vn[j],-1.0f,1.0f) * 127.0f;
-            }
-
-            f32 brightness = vg_clampf( v3_dot( vn, light_dir ), 0.0f, 1.0f );
-
-            v4f col = {0.0f,0.0f,0.0f,0.0f};
-            if( surf->info.surface_prop == k_surface_prop_wood ){
-               v4_copy( (v4f){0.66f,0.6f,0.5f}, col );
-            }
-            else if( surf->info.surface_prop == k_surface_prop_grass ){
-               v4_copy( (v4f){0.42f,0.5f,0.33f}, col );
-            }
-            else if( surf->info.surface_prop == k_surface_prop_concrete ){
-               v4_copy( (v4f){0.57f,0.57f,0.55f}, col );
-            }
-            else if( surf->info.surface_prop == k_surface_prop_metal ){
-               v4_copy( (v4f){0.76f,0.76f,0.75f}, col );
-            }
-            else{
-               v4_copy( (v4f){0.2f,0.2f,0.2f}, col );
-            }
-
-            v4_copy( (v4f){0.2f,0.2f,0.26f}, col );
-            v3_muls( col, brightness*0.25f, col );
-
-            for( u32 j=0; j<4; j++ ){
-               vert->colour[j] = col[j] * 255.0f;
-            }
-         }
-      }
+      world_routes_gen_meshes( world, i, &world->scene_lines, pcbuf );
    }
 
-too_many_points:
-   vg_info( "finished awesome algorithm! yipee (%u)!\n", generated_points );
-   }
+   f64 area = 0.0;
+   area = world_routes_scatter_surface_points( world, pcbuf, 16.0f );
+   world_routes_surface_grid( world, pcbuf );
+   vg_info( "Distrubuted %u points over %fkm^2!\n", pcbuf->count, area/1e6f );
 
-   call1->size = generated_points;
-   vg_async_dispatch( call, async_scene_upload );
-   vg_async_dispatch( call1, async_pointcloud_sub );
+   vg_async_dispatch( call_scene, async_scene_upload );
+   vg_async_dispatch( call_pointcloud, async_pointcloud_sub );
 
    world_routes_clear( world );
 }