csrDraw.h

   1 typedef struct csr_frag csr_frag;
   2 typedef struct csr_target csr_target;
   3 typedef struct csr_filter csr_filter;
   4
   5 struct csr_frag
   6 {
   7         v3f co;
   8         v3f nrm;
   9
  10         float depth;
  11 };
  12
  13 struct csr_target
  14 {
  15         csr_frag *fragments;
  16
  17         u32 x, y;
  18         boxf bounds;
  19         float scale;
  20
  21         v2f subsamples[ 16 ];
  22         int num_samples;
  23 };
  24
  25 struct csr_filter
  26 {
  27         const char *visgroup;           // Limit to this visgroup only
  28         const char *classname;          // Limit to this exact classname. will not draw world
  29
  30         int compute_bounds_only;
  31 };
  32
  33 void csr_create_target( csr_target *rt, u32 x, u32 y )
  34 {
  35         rt->x = x;
  36         rt->y = y;
  37         rt->num_samples = 4;
  38
  39         rt->fragments = (csr_frag *)csr_malloc( x*y*sizeof(csr_frag)*rt->num_samples );
  40
  41         v3_fill( rt->bounds[0], INFINITY );
  42         v3_fill( rt->bounds[1], -INFINITY );
  43 }
  44
  45 void csr_update_subsamples( csr_target *rt )
  46 {
  47         float range_x = (rt->bounds[1][0]-rt->bounds[0][0]);
  48         float range_y = (rt->bounds[1][1]-rt->bounds[0][1]);
  49
  50         v2f pixel_size = { range_x/(float)rt->x, range_y/(float)rt->y };
  51
  52         rt->subsamples[0][0] = pixel_size[0] * -0.25f;
  53         rt->subsamples[0][1] = 0.f;
  54         rt->subsamples[1][0] = pixel_size[0] * 0.75f;
  55         rt->subsamples[1][1] = pixel_size[1] * 0.25f;
  56         rt->subsamples[2][0] = 0.f;
  57         rt->subsamples[2][1] = pixel_size[1] * 0.5f;
  58         rt->subsamples[3][0] = pixel_size[0] * 0.5f;
  59         rt->subsamples[3][1] = pixel_size[1] * 0.75f;
  60 }
  61
  62 void csr_rt_free( csr_target *rt )
  63 {
  64         free( rt->fragments );
  65 }
  66
  67 void csr_rt_clear( csr_target *rt )
  68 {
  69         for( u32 i = 0; i < rt->x*rt->y*rt->num_samples; i ++ )
  70         {
  71                 v3_zero( rt->fragments[ i ].co );
  72                 v3_zero( rt->fragments[ i ].nrm );
  73                 rt->fragments[i].depth = 0.f;
  74         }
  75 }
  76
  77 void csr_auto_fit( csr_target *rt, float padding )
  78 {
  79         // Correct aspect ratio to be square
  80         float dx, dy, d, l, cx, cy;
  81         dx = rt->bounds[1][0] - rt->bounds[0][0];
  82         dy = rt->bounds[1][1] - rt->bounds[0][1];
  83
  84         l = fmaxf( dx, dy ) * .5f;
  85
  86         cx = (rt->bounds[1][0] + rt->bounds[0][0]) * .5f;
  87         cy = (rt->bounds[1][1] + rt->bounds[0][1]) * .5f;
  88
  89         rt->bounds[0][0] = cx - l - padding;
  90         rt->bounds[1][0] = cx + l + padding;
  91         rt->bounds[0][1] = cy - l - padding;
  92         rt->bounds[1][1] = cy + l + padding;
  93
  94         rt->scale = l + padding;
  95
  96         csr_update_subsamples( rt );
  97 }
  98
  99 void csr_write_txt( char const *path, const char *name, csr_target *rt  )
 100 {
 101         FILE *write_ptr;
 102
 103         write_ptr = fopen( path, "w" );
 104
 105         fprintf( write_ptr, "\"%s\"\n\{\n", name );
 106         fprintf( write_ptr, "\t\"material\" \"overviews/%s\"\n", name );
 107         fprintf( write_ptr, "\t\"pos_x\" \"%.8f\"\n", rt->bounds[0][0] );
 108         fprintf( write_ptr, "\t\"pos_y\" \"%.8f\"\n", rt->bounds[0][1] );
 109         fprintf( write_ptr, "\t\"scale\" \"%.8f\"\n", rt->scale / (float)rt->x );
 110         fprintf( write_ptr, "}\n" );
 111
 112         fclose( write_ptr );
 113 }
 114
 115 void simple_raster( csr_target *rt, vmf_vert tri[3] )
 116 {
 117         // Very very simplified rasterizing algorithm
 118         v2f bmin = { 0.f, 0.f };
 119         v2f bmax = { rt->x, rt->y };
 120
 121         v2_minv( tri[0].co, tri[1].co, bmin );
 122         v2_minv( tri[2].co, bmin, bmin );
 123
 124         v2_maxv( tri[0].co, tri[1].co, bmax );
 125         v2_maxv( tri[2].co, bmax, bmax );
 126
 127         float range_x = (rt->bounds[1][0]-rt->bounds[0][0])/(float)rt->x;
 128         float range_y = (rt->bounds[1][1]-rt->bounds[0][1])/(float)rt->y;
 129
 130         int start_x = csr_min( rt->x-1, csr_max( 0,       floorf( (bmin[0]-rt->bounds[0][0])/range_x)));
 131         int end_x =   csr_max( 0,       csr_min( rt->x-1,  ceilf( (bmax[0]-rt->bounds[0][0])/range_x)));
 132         int start_y = csr_min( rt->y-1, csr_max( 0,       floorf( (bmin[1]-rt->bounds[0][1])/range_y)));
 133         int end_y =   csr_max( 0,       csr_min( rt->y-1,  ceilf( (bmax[1]-rt->bounds[0][1])/range_y)));
 134
 135         v2f v0, v1, v2, vp;
 136         float d, bca = 0.f, bcb = 0.f, bcc = 0.f;
 137
 138         v2_sub( tri[1].co, tri[0].co, v0 );
 139         v2_sub( tri[2].co, tri[0].co, v1 );
 140         v2_sub( tri[1].co, tri[2].co, v2 );
 141         d = 1.f / (v0[0]*v1[1] - v1[0]*v0[1]);
 142
 143         // Backface culling
 144         if( v2_cross( v0, v1 ) > 0.f )
 145                 return;
 146
 147         v2f trace_origin;
 148
 149         for( u32 py = start_y; py <= end_y; py ++ )
 150         {
 151                 trace_origin[1] = csr_lerpf( rt->bounds[0][1], rt->bounds[1][1], (float)py/(float)rt->y );
 152
 153                 for( u32 px = start_x; px <= end_x; px ++ )
 154                 {
 155                         csr_frag *frag = &rt->fragments[ (py * rt->y + px) * rt->num_samples ];
 156
 157                         trace_origin[0] = csr_lerpf( rt->bounds[0][0], rt->bounds[1][0], (float)px/(float)rt->x );
 158
 159                         // Determine coverage
 160                         for( int i = 0; i < rt->num_samples; i ++ )
 161                         {
 162                                 v3f sample_origin;
 163
 164                                 v2_add( rt->subsamples[ i ], trace_origin, sample_origin );
 165                                 v2_sub( sample_origin, tri[0].co, vp );
 166
 167                                 if( v2_cross( v0, vp ) > 0.f )
 168                                         continue;
 169                                 if( v2_cross( vp, v1 ) > 0.f )
 170                                         continue;
 171
 172                                 v2f vp2;
 173                                 v2_sub( sample_origin, tri[2].co, vp2 );
 174
 175                                 if( v2_cross( vp2, v2 ) > 0.f )
 176                                         continue;
 177
 178                                 bcb = (vp[0]*v1[1] - v1[0]*vp[1]) * d;
 179                                 bcc = (v0[0]*vp[1] - vp[0]*v0[1]) * d;
 180                                 bca = 1.f - bcb - bcc;
 181
 182                                 float hit = (tri[0].co[2] * bca + tri[1].co[2] * bcb + tri[2].co[2] * bcc) +16385.f;
 183
 184                                 if( hit > frag[i].depth )
 185                                 {
 186                                         frag[i].depth = hit;
 187                                         v3_muls( tri[0].co, bca, frag[i].co );
 188                                         v3_muladds( frag[i].co, tri[1].co, bcb, frag[i].co );
 189                                         v3_muladds( frag[i].co, tri[2].co, bcc, frag[i].co );
 190
 191                                         // TODO: Same for normal map
 192                                 }
 193                         }
 194                 }
 195         }
 196 }
 197
 198 void csr_draw( csr_target *rt, vmf_vert *triangles, u32 triangle_count, m4x3f transform )
 199 {
 200         m3x3f normal;
 201         vmf_vert new_tri[3];
 202
 203         // Derive normal matrix
 204         m4x3_to_3x3( transform, normal );
 205         m3x3_inv_transpose( normal, normal );
 206
 207         for( u32 i = 0; i < triangle_count; i ++ )
 208         {
 209                 vmf_vert *triangle = triangles + i*3;
 210
 211                 m4x3_mulv( transform, triangle[0].co, new_tri[0].co );
 212                 m4x3_mulv( transform, triangle[1].co, new_tri[1].co );
 213                 m4x3_mulv( transform, triangle[2].co, new_tri[2].co );
 214                 m3x3_mulv( normal, triangle[0].nrm, new_tri[0].nrm );
 215                 m3x3_mulv( normal, triangle[1].nrm, new_tri[1].nrm );
 216                 m3x3_mulv( normal, triangle[2].nrm, new_tri[2].nrm );
 217
 218                 simple_raster( rt, new_tri );
 219         }
 220 }
 221
 222 void draw_vmf_group( csr_target *rt, vmf_map *map, vdf_node *root, csr_filter *filter, m4x3f prev, m4x3f inst )
 223 {
 224         m4x3f transform = M4X3_IDENTITY;
 225         vmf_solid solid;
 226         vmf_vert tri[3];
 227         boxf trf_bounds;
 228
 229         u32 group_id = 0;
 230         int filter_visgroups = 0, filter_classname = 0, compute_bounds_only = 0;
 231
 232         if( filter )
 233         {
 234                 if( filter->visgroup )
 235                 {
 236                         filter_visgroups = 1;
 237                         group_id = vmf_visgroup_id( root, filter->visgroup );
 238                 }
 239
 240                 if( filter->classname )
 241                 {
 242                         filter_classname = 1;
 243                 }
 244
 245                 compute_bounds_only = filter->compute_bounds_only;
 246         }
 247
 248         // Multiply previous transform with instance transform to create basis
 249         if( prev )
 250         {
 251                 m4x3_mul( prev, inst, transform );
 252         }
 253
 254         // Gather world brushes
 255         solidgen_ctx_init( &solid );
 256
 257         if( !filter_classname )
 258         {
 259                 vdf_node *world = vdf_next( root, "world", NULL );
 260
 261                 vdf_foreach( world, "solid", brush )
 262                 {
 263                         if( filter_visgroups && !vmf_visgroup_match( brush, group_id ) )
 264                                 continue;
 265
 266                         solidgen_push( &solid, brush );
 267                 }
 268         }
 269
 270         // Actual entity loop
 271         m4x3f model;
 272
 273         vdf_foreach( root, "entity", ent )
 274         {
 275                 if( filter_visgroups && !vmf_visgroup_match( ent, group_id ) )
 276                         continue;
 277
 278                 if( filter_classname )
 279                         if( strcmp( kv_get( ent, "classname", "" ), filter->classname ) )
 280                                 continue;
 281
 282                 if( ent->user & VMF_FLAG_IS_PROP )
 283                 {
 284                         // Create model transform
 285                         m4x3_identity( model );
 286
 287                         vmf_entity_transform( ent, model );
 288                         m4x3_mul( transform, model, model );
 289
 290                         // Draw model
 291                         mdl_mesh_t *mdl = &map->models[ ent->user1 ].mdl;
 292
 293                         if( compute_bounds_only )
 294                         {
 295                                 box_copy( mdl->bounds, trf_bounds );
 296                                 m4x3_transform_aabb( model, trf_bounds );
 297
 298                                 // Join
 299                                 box_concat( rt->bounds, trf_bounds );
 300                         }
 301                         else
 302                         {
 303                                 for( int i = 0; i < mdl->num_indices/3; i ++ )
 304                                 {
 305                                         for( int j = 0; j < 3; j ++ )
 306                                         {
 307                                                 v3_copy( &mdl->vertices[ mdl->indices[ i*3+j ] *8 ],   tri[j].co );
 308                                                 v3_copy( &mdl->vertices[ mdl->indices[ i*3+j ] *8+3 ], tri[j].nrm );
 309                                                 tri[j].xy[0] = 0.f;
 310                                                 tri[j].xy[1] = 0.f;
 311                                         }
 312
 313                                         csr_draw( rt, tri, 1, model );
 314                                 }
 315                         }
 316                 }
 317                 else if( ent->user & VMF_FLAG_IS_INSTANCE )
 318                 {
 319                         m4x3_identity( model );
 320                         vmf_entity_transform( ent, model );
 321
 322                         draw_vmf_group( rt, map, map->cache[ ent->user1 ].root, filter, transform, model );
 323                 }
 324                 else
 325                 {
 326                         // Brush entity
 327                         vdf_foreach( ent, "solid", ent_solid )
 328                         {
 329                                 solidgen_push( &solid, ent_solid );
 330                         }
 331                 }
 332         }
 333
 334         if( compute_bounds_only )
 335         {
 336                 solidgen_bounds( &solid, trf_bounds );
 337                 m4x3_transform_aabb( transform, trf_bounds );
 338                 box_concat( rt->bounds, trf_bounds );
 339         }
 340         else
 341         {
 342                 // Draw brushes
 343                 for( int i = 0; i < csr_sb_count( solid.indices )/3; i ++ )
 344                 {
 345                         u32 * base = solid.indices + i*3;
 346
 347                         tri[0] = solid.verts[ base[0] ];
 348                         tri[1] = solid.verts[ base[1] ];
 349                         tri[2] = solid.verts[ base[2] ];
 350
 351                         csr_draw( rt, tri, 1, transform );
 352                 }
 353         }
 354
 355         solidgen_ctx_reset( &solid );
 356         solidgen_ctx_free( &solid );
 357 }
 358
 359 void csr_rt_save_buffers( csr_target *rt, const char *basename, const char *subname )
 360 {
 361         char output[ 512 ];
 362
 363         float *image = (float *)csr_malloc( 1024*1024*sizeof(float)*3 );
 364
 365         for( int l = 0; l < rt->x; l ++ )
 366         {
 367                 for( int x = 0; x < rt->y; x ++ )
 368                 {
 369                         float *dst = &image[ (l*1024+x)*3 ];
 370                         csr_frag *src = &rt->fragments[ ((1023-l)*1024+x)*rt->num_samples ];
 371
 372                         v3_zero( dst );
 373                         v3_muls( src[0].co, 1.f/(float)rt->num_samples, dst );
 374                         v3_muladds( dst, src[1].co, 1.f/(float)rt->num_samples, dst );
 375                         v3_muladds( dst, src[2].co, 1.f/(float)rt->num_samples, dst );
 376                         v3_muladds( dst, src[3].co, 1.f/(float)rt->num_samples, dst );
 377                 }
 378         }
 379
 380         // Save position buffer
 381         strcpy( output, basename );
 382         strcat( output, "." );
 383         strcat( output, subname );
 384         strcat( output, "_position.pfm" );
 385         csr_32f_write( output, rt->x, rt->y, image );
 386
 387         free( image );
 388 }