fishladder_resources.h

   1 // TEXTURES
   2 // ===========================================================================================================
   3
   4 vg_tex2d tex_tile_data =        { .path = "textures/tileset.qoi" };
   5 vg_tex2d tex_tile_detail = { .path = "textures/tile_overlays.qoi" };
   6 vg_tex2d tex_wood =                     { .path = "textures/wood.qoi" };
   7 vg_tex2d tex_ball =                     { .path = "textures/ball.qoi", .flags = VG_TEXTURE_CLAMP };
   8 vg_tex2d tex_background =       { .path = "textures/background.qoi" };
   9 vg_tex2d tex_ball_noise =  { .path = "textures/bnoise.qoi" };
  10
  11 vg_tex2d *texture_list[] = { &tex_tile_detail, &tex_tile_data, &tex_wood, &tex_ball, &tex_background, &tex_ball_noise };
  12
  13 // AUDIO
  14 // ===========================================================================================================
  15
  16 sfx_vol_control audio_volume_sfx =              { .val = 1.0f, .name = "Sound effects" };
  17 sfx_vol_control audio_volume_music =    { .val = 1.0f, .name = "Music" };
  18
  19 sfx_system audio_system_sfx =
  20 {
  21  .vol = 1.f,
  22  .ch = 1,
  23  .vol_src = &audio_volume_sfx,
  24  .name = "sfx"
  25 };
  26
  27 sfx_set audio_tile_mod =
  28 {
  29  .sources = "\
  30 sound/mod_01.ogg\0\
  31 sound/mod_02.ogg\0\
  32 sound/mod_03.ogg\0\
  33 sound/mod_04.ogg\0\
  34 sound/mod_05.ogg\0\
  35 sound/mod_06.ogg\0",
  36  .flags = 0
  37 };
  38
  39 sfx_set audio_splitter =
  40 {
  41  .sources = "\
  42 sound/splitter_01.ogg\0"
  43 };
  44
  45 sfx_set audio_rolls =
  46 {
  47  .sources = "\
  48 sound/rolling_01.ogg\0\
  49 sound/rolling_02.ogg\0"
  50 };
  51
  52 sfx_set audio_random =
  53 {
  54  .sources = "\
  55 sound/random_01.ogg\0\
  56 sound/random_02.ogg\0\
  57 sound/random_03.ogg\0\
  58 sound/random_04.ogg\0\
  59 sound/random_05.ogg\0\
  60 sound/random_06.ogg\0\
  61 sound/random_07.ogg\0\
  62 sound/random_08.ogg\0"
  63 };
  64
  65 // One two or three layers of rolling noise
  66 sfx_system audio_system_balls_rolling =
  67 {
  68         .vol = 1.f, .ch = 1, .vol_src = &audio_volume_sfx,
  69         .name = "Balls Rolling", .flags = SFX_FLAG_REPEAT
  70 };
  71
  72 // Various oneshots
  73 sfx_system audio_system_balls_switching =
  74 {
  75         .vol = 1.f, .ch = 1, .vol_src = &audio_volume_sfx,
  76         .name = "Balls Switching"
  77 };
  78
  79 // Gameplay critical sounds eg. splitter sound rocking
  80 sfx_system audio_system_balls_important =
  81 {
  82         .vol = 1.f, .ch = 1, .vol_src = &audio_volume_sfx,
  83         .name = "Balls Gameplay"
  84 };
  85
  86 // Suplemental sounds
  87 sfx_system audio_system_balls_extra =
  88 {
  89         .vol = 1.f, .ch = 1, .vol_src = &audio_volume_sfx,
  90         .name = "Balls Extra"
  91 };
  92
  93 static void resource_load_main(void)
  94 {
  95         // Textures
  96         vg_tex2d_init( texture_list, vg_list_size( texture_list ) );
  97
  98         // Audio
  99         sfx_set_init( &audio_tile_mod, NULL );
 100         sfx_set_init( &audio_splitter, NULL );
 101         sfx_set_init( &audio_rolls, NULL );
 102         sfx_set_init( &audio_random, NULL );
 103 }
 104
 105 static void resource_free_main(void)
 106 {
 107         vg_tex2d_free( texture_list, vg_list_size( texture_list ) );
 108
 109         sfx_set_free( &audio_tile_mod );
 110         sfx_set_free( &audio_splitter );
 111         sfx_set_free( &audio_rolls );
 112         sfx_set_free( &audio_random );
 113 }
 114
 115 // SHADERS
 116 // ===========================================================================================================
 117
 118 SHADER_DEFINE( shader_tile_colour,
 119
 120         // VERTEX
 121         "layout (location=0) in vec2 a_co;"
 122         "uniform mat3 uPv;"
 123         "uniform vec3 uOffset;"
 124         ""
 125         "void main()"
 126         "{"
 127                 "gl_Position = vec4( uPv * vec3( a_co * uOffset.z + uOffset.xy, 1.0 ), 1.0 );"
 128         "}",
 129
 130         // FRAGMENT
 131         "out vec4 FragColor;"
 132         "uniform vec4 uColour;"
 133         ""
 134         "void main()"
 135         "{"
 136                 "FragColor = uColour;"
 137         "}"
 138         ,
 139         UNIFORMS({ "uPv", "uOffset", "uColour" })
 140 )
 141
 142 /*
 143 SHADER_DEFINE( shader_ball,
 144         // VERTEX
 145         "layout (location=0) in vec2 a_co;"
 146         "uniform vec2 uOffset;"
 147         "uniform mat3 uPv;"
 148         ""
 149         "out vec2 aTexCoords;"
 150         ""
 151         "void main()"
 152         "{"
 153                 // Create texture coords
 154                 "aTexCoords = a_co;"
 155
 156                 // Vertex transform
 157                 "vec3 worldpos = vec3( a_co * 0.5 - 0.25 + uOffset, 1.0 );"
 158                 "gl_Position = vec4( uPv * worldpos, 1.0 );"
 159         "}",
 160
 161         // FRAGMENT
 162         "out vec4 FragColor;"
 163         ""
 164         "uniform sampler2D uTexMain;"
 165         "uniform vec3 uColour;"
 166         ""
 167         "in vec2 aTexCoords;"
 168         ""
 169         "void main()"
 170         "{"
 171                 "vec4 glyph = texture( uTexMain, aTexCoords );"
 172                 "FragColor = vec4( uColour + glyph.rgb * 0.2, glyph.a );"
 173         "}"
 174         ,
 175         UNIFORMS({ "uTexMain", "uColour", "uOffset", "uPv" })
 176 )
 177 */
 178
 179 SHADER_DEFINE( shader_ball,
 180         // VERTEX
 181         "layout (location=0) in vec2 a_co;"
 182         "uniform vec2 uOffset;"
 183         "uniform mat3 uPv;"
 184         ""
 185         "out vec4 aTexCoords;"
 186         ""
 187         "void main()"
 188         "{"
 189                 // Vertex transform
 190                 "vec3 worldpos = vec3( a_co * 0.5 - 0.25 + uOffset, 1.0 );"
 191                 "gl_Position = vec4( uPv * worldpos, 1.0 );"
 192
 193                 // Create texture coords
 194                 "aTexCoords = vec4( a_co, worldpos.xy );"
 195         "}",
 196
 197         // FRAGMENT
 198         "out vec4 FragColor;"
 199         ""
 200         "uniform sampler2D uTexMain;"
 201         "uniform vec3 uColour;"
 202         "uniform vec2 uTexOffset;"
 203         ""
 204         "in vec4 aTexCoords;"
 205         ""
 206         "void main()"
 207         "{"
 208                 "vec2 center_coords = aTexCoords.xy - 0.5;"
 209                 "vec2 center_coords_sqr = center_coords*center_coords;"
 210                 "float circle_factor = smoothstep( 0.07, 0.0625, center_coords_sqr.x+center_coords_sqr.y );"
 211
 212                 "float bulge_amt = center_coords_sqr.x+center_coords_sqr.y;"
 213                 "vec2 warped_coords = aTexCoords.zw+uTexOffset - center_coords;"
 214                 "vec4 noise_sample = texture( uTexMain, warped_coords );"
 215
 216                 "float rim_light = (center_coords_sqr.x+center_coords_sqr.y)*15.0;"
 217
 218                 "vec2 shadow_coords = center_coords + vec2(0.02,0.07);"
 219                 "vec2 shadow_coords_sqr = shadow_coords*shadow_coords;"
 220                 //"float shadow = exp(-abs(shadow_coords_sqr.x+shadow_coords_sqr.y)*20.0);"
 221                 "float shadow = exp(-((shadow_coords_sqr.x+shadow_coords_sqr.y)-0.0125)*15.0);"
 222
 223                 "vec3 marble_comp = uColour*0.9 + (noise_sample.x*0.7+pow(rim_light,3.0)*2.0) * 0.1;"
 224                 "vec4 colour_comp = mix( vec4(0.74,0.53,0.34,shadow), vec4(marble_comp,1.0), circle_factor );"
 225
 226                 "FragColor = colour_comp;"
 227         "}"
 228         ,
 229         UNIFORMS({ "uTexMain", "uColour", "uOffset", "uPv", "uTexOffset" })
 230 )
 231
 232 SHADER_DEFINE( shader_tile_main,
 233         // VERTEX
 234         "layout (location=0) in vec2 a_co;"
 235         "uniform vec4 uOffset;" // Tile x/y, uv x/y
 236         "uniform mat3 uPv;"
 237         "uniform mat2 uSubTransform;"
 238         ""
 239         "out vec4 aTexCoords;"
 240         "out vec2 aWorldCoords;"
 241         ""
 242         "vec2 hash22(vec2 p)"
 243         "{"
 244                 "vec3 p3 = fract(vec3(p.xyx) * vec3(.1031, .1030, .0973));"
 245                 "p3 += dot(p3, p3.yzx+33.33);"
 246                 "return fract((p3.xx+p3.yz)*p3.zy);"
 247         "}"
 248         ""
 249         "void main()"
 250         "{"
 251                 // Vertex transform
 252                 "vec2 subtransform = uSubTransform * (a_co-0.5) + 0.5;"
 253                 "vec3 worldpos = vec3( subtransform + uOffset.xy, 1.0 );"
 254                 "gl_Position = vec4( uPv * worldpos, 1.0 );"
 255
 256                 // Create texture coords
 257                 "vec2 random_offset = floor(hash22(uOffset.xy) * 4.0) * 0.25;"
 258                 "vec2 edge_safe_coords = a_co * 0.98 + 0.01;"
 259                 "aTexCoords = vec4((edge_safe_coords + uOffset.zw) * 0.25, edge_safe_coords * 0.25 + random_offset );"
 260                 "aWorldCoords = worldpos.xy;"
 261         "}",
 262
 263         // FRAGMENT
 264         "out vec4 FragColor;"
 265         ""
 266         "uniform sampler2D uTexGlyphs;"
 267         "uniform sampler2D uTexWood;"
 268         "uniform float uGhost;"
 269         "uniform float uForeground;"
 270         "uniform vec2 uMousePos;"
 271         "uniform vec4 uColour;"
 272         ""
 273         "in vec4 aTexCoords;"
 274         "in vec2 aWorldCoords;"
 275         ""
 276         "void main()"
 277         "{"
 278                 "vec3 shadowing_colour = vec3( 0.93, 0.88536, 0.8184 );"
 279                 "vec4 glyph = texture( uTexGlyphs, aTexCoords.xy );"
 280                 "vec4 wood = texture( uTexWood, aTexCoords.zw );"
 281                 "vec4 wood_secondary = texture( uTexWood, aTexCoords.zw + 0.25 );"
 282                 "vec3 wood_comp = mix( wood_secondary.rgb * shadowing_colour, wood.rgb, clamp( glyph.b * 2.0 - 1.0, 0.0, 1.0 ) );"
 283
 284                 "vec3 shadows = mix( vec3( 0.85, 0.7344, 0.561 ), vec3(1.0,1.0,1.0), glyph.r );"
 285
 286                 "vec4 output_regular = vec4( wood_comp * shadows, mix( glyph.a, glyph.b, uForeground ) );"
 287
 288                 "float ghost_dist = clamp( 1.5 - distance(uMousePos, aWorldCoords), 0.0, 1.0 );"
 289                 "vec4 output_ghost = vec4( 1.0, 1.0, 1.0, glyph.g * ghost_dist );"
 290
 291                 "FragColor = mix( output_regular, output_ghost, uGhost ) * uColour;"
 292         "}"
 293         ,
 294         UNIFORMS({ "uPv", "uOffset", "uTexGlyphs", "uTexWood", "uSubTransform", "uGhost", "uMousePos", "uColour", "uForeground" })
 295 )
 296
 297 SHADER_DEFINE( shader_background,
 298         // VERTEX
 299         "layout (location=0) in vec2 a_co;"
 300         "uniform mat3 uPv;"
 301         "uniform vec3 uOffset;"
 302         ""
 303         "out vec2 aTexCoords;"
 304         ""
 305         "void main()"
 306         "{"
 307                 "vec2 world_pos = a_co * uOffset.z + uOffset.xy;"
 308                 "gl_Position = vec4( uPv * vec3( world_pos, 1.0 ), 1.0 );"
 309                 "aTexCoords = a_co;"
 310         "}",
 311
 312         // FRAGMENT
 313         "out vec4 FragColor;"
 314         ""
 315         "uniform sampler2D uTexMain;"
 316         "uniform sampler2D uSamplerNoise;"
 317         "uniform float uVariance;"
 318         ""
 319         "in vec2 aTexCoords;"
 320         ""
 321         "void main()"
 322         "{"
 323                 "float ao_accum = 0.0;"
 324                 "for( int i=0; i<10; ++i )"
 325                 "{"
 326                         "vec2 random_noise = (texture( uSamplerNoise, aTexCoords * 20.0 + float(i) * 0.2 ).xy - vec2( 0.5, 0.5 )) * uVariance;"
 327                         "vec4 background = texture( uTexMain, aTexCoords + random_noise );"
 328                         "ao_accum += background.r * clamp((1.0 - length( random_noise )), 0.0, 1.0);"
 329                 "}"
 330                 "ao_accum *= 0.15;"
 331
 332                 "vec4 data_this_tile = texture( uTexMain, aTexCoords );"
 333
 334                 "ao_accum -= data_this_tile.r;"
 335
 336                 "vec3 colour_main = vec3( 0.369768, 0.3654, 0.42 );"
 337
 338                 "vec2 square_coords = fract( aTexCoords * 64.0 );"
 339                 "vec2 grid_coords = abs( square_coords - 0.5 );"
 340                 "float edge_contrast = (1.0-ao_accum*0.2);"
 341
 342                 "float gridline = step( 0.49, max(grid_coords.x,grid_coords.y) );"
 343                 "float gridline_fadeout = min(max(edge_contrast-1.0, 0.0)*40.0 + data_this_tile.g,10.0);"
 344
 345                 "FragColor = vec4( colour_main * edge_contrast + gridline * 0.02 * gridline_fadeout, 1.0 );"
 346         "}"
 347         ,
 348         UNIFORMS({ "uPv", "uOffset", "uTexMain", "uVariance", "uSamplerNoise" })
 349 )
 350
 351 SHADER_DEFINE( shader_wire,
 352         // VERTEX
 353         "layout (location=0) in vec2 a_co;"
 354         "uniform vec3 uStart;"
 355         "uniform vec3 uEnd;"
 356         "uniform mat3 uPv;"
 357         "uniform float uCurve;"
 358         ""
 359         "out vec2 aTexCoords;"
 360         ""
 361         "vec3 sample_curve_time( float t )"
 362         "{"
 363                 "vec3 line_coord = mix( uStart, uEnd, t );"
 364
 365                 "float curve_amt = 1.0-(pow((t*2.0-1.0),2.0));"
 366                 "return vec3( line_coord.x, line_coord.y - curve_amt*uCurve, line_coord.z );"
 367         "}"
 368         ""
 369         "void main()"
 370         "{"
 371                 // Vertex transform
 372                 "vec3 p0 = sample_curve_time( a_co.x );"
 373                 "vec3 p1 = sample_curve_time( a_co.x + 0.025 );"
 374
 375                 "vec2 line_tangent = normalize(p1.xy-p0.xy);"
 376                 "vec2 line_normal = vec2( -line_tangent.y, line_tangent.x );"
 377
 378                 "vec2 worldfinal = p0.xy + line_normal*a_co.y*p0.z;"
 379
 380                 "gl_Position = vec4( uPv * vec3(worldfinal, 1.0), 1.0 );"
 381
 382                 // Create texture coords (todo: include stretch adjusted coords?)
 383                 "aTexCoords = vec2( a_co.x, a_co.y + 0.5 );"
 384         "}",
 385
 386         // FRAGMENT
 387         "out vec4 FragColor;"
 388         ""
 389         "uniform sampler2D uTexMain;"
 390         "uniform vec4 uColour;"
 391         ""
 392         "in vec2 aTexCoords;"
 393         ""
 394         "void main()"
 395         "{"
 396                 "FragColor = uColour;"
 397         "}"
 398         ,
 399         UNIFORMS({ "uPv", "uColour", "uTexMain", "uStart", "uEnd", "uCurve" })
 400 )
 401
 402
 403 void vg_register(void)
 404 {
 405         SHADER_INIT( shader_tile_colour );
 406         SHADER_INIT( shader_tile_main );
 407         SHADER_INIT( shader_ball );
 408         SHADER_INIT( shader_background );
 409         SHADER_INIT( shader_wire );
 410 }
 411
 412 /*
 413         0000 0   | 0001 1   | 0010 2   | 0011 3
 414                            |          |    |     |    |
 415                 X     |           X=    |    X     |    X=
 416                            |          |          |
 417         0100 4   | 0101 5   | 0110 6   | 0111 7
 418                            |          |    |     |    |
 419           =X     |   =X=    |   =X     |   =X=
 420                            |          |          |
 421         1000 8   | 1001 9   | 1010 10  | 1011 11
 422                       |          |    |     |    |
 423                 X     |    X=    |    X     |    X=
 424                 |               |    |     |    |     |    |
 425         1100 12  | 1101 13  | 1110 14  | 1111 15
 426                       |          |    |     |    |
 427           =X     |   =X=    |   =X     |   =X=
 428                 |          |    |     |    |     |    |
 429 */
 430
 431 float const MESH_NUMBER_0[] = {
 432         #include "fonts/numbers/n0.h"
 433 };
 434
 435 float const MESH_NUMBER_1[] = {
 436         #include "fonts/numbers/n1.h"
 437 };
 438
 439 float const MESH_NUMBER_2[] = {
 440         #include "fonts/numbers/n2.h"
 441 };
 442
 443 float const MESH_NUMBER_3[] = {
 444         #include "fonts/numbers/n3.h"
 445 };
 446
 447 float const MESH_NUMBER_4[] = {
 448         #include "fonts/numbers/n4.h"
 449 };
 450
 451 float const MESH_NUMBER_5[] = {
 452         #include "fonts/numbers/n5.h"
 453 };
 454
 455 float const MESH_NUMBER_6[] = {
 456         #include "fonts/numbers/n6.h"
 457 };
 458
 459 float const MESH_NUMBER_7[] = {
 460         #include "fonts/numbers/n7.h"
 461 };
 462
 463 float const MESH_NUMBER_8[] = {
 464         #include "fonts/numbers/n8.h"
 465 };
 466
 467 float const MESH_NUMBER_9[] = {
 468         #include "fonts/numbers/n9.h"
 469 };
 470
 471 float const MESH_NUMBERS_BUFFER[] =
 472 {
 473         #include "fonts/numbers/n0.h"
 474         #include "fonts/numbers/n1.h"
 475         #include "fonts/numbers/n2.h"
 476         #include "fonts/numbers/n3.h"
 477         #include "fonts/numbers/n4.h"
 478         #include "fonts/numbers/n5.h"
 479         #include "fonts/numbers/n6.h"
 480         #include "fonts/numbers/n7.h"
 481         #include "fonts/numbers/n8.h"
 482         #include "fonts/numbers/n9.h"
 483 };
 484
 485 #define MESH_NUMBER_DIVISOR 6
 486
 487 u32 const MESH_NUMBERS_OFFSETS[][2] =
 488 {
 489         {
 490                 0,
 491                 vg_list_size( MESH_NUMBER_0 ) / MESH_NUMBER_DIVISOR
 492         },
 493         {
 494                 vg_list_size( MESH_NUMBER_0 ) / MESH_NUMBER_DIVISOR,
 495                 vg_list_size( MESH_NUMBER_1 ) / MESH_NUMBER_DIVISOR
 496         },
 497         {
 498                 (
 499                         vg_list_size( MESH_NUMBER_0 ) +
 500                         vg_list_size( MESH_NUMBER_1 )
 501                 ) / MESH_NUMBER_DIVISOR,
 502                 vg_list_size( MESH_NUMBER_2 ) / MESH_NUMBER_DIVISOR
 503         },
 504         {
 505                 (
 506                         vg_list_size( MESH_NUMBER_0 ) +
 507                         vg_list_size( MESH_NUMBER_1 ) +
 508                         vg_list_size( MESH_NUMBER_2 )
 509                 ) / MESH_NUMBER_DIVISOR,
 510                 vg_list_size( MESH_NUMBER_3 ) / MESH_NUMBER_DIVISOR
 511         },
 512         {
 513                 (
 514                         vg_list_size( MESH_NUMBER_0 ) +
 515                         vg_list_size( MESH_NUMBER_1 ) +
 516                         vg_list_size( MESH_NUMBER_2 ) +
 517                         vg_list_size( MESH_NUMBER_3 )
 518                 ) / MESH_NUMBER_DIVISOR,
 519                 vg_list_size( MESH_NUMBER_4 ) / MESH_NUMBER_DIVISOR
 520         },
 521         {
 522                 (
 523                         vg_list_size( MESH_NUMBER_0 ) +
 524                         vg_list_size( MESH_NUMBER_1 ) +
 525                         vg_list_size( MESH_NUMBER_2 ) +
 526                         vg_list_size( MESH_NUMBER_3 ) +
 527                         vg_list_size( MESH_NUMBER_4 )
 528                 ) / MESH_NUMBER_DIVISOR,
 529                 vg_list_size( MESH_NUMBER_5 ) / MESH_NUMBER_DIVISOR
 530         },
 531         {
 532                 (
 533                         vg_list_size( MESH_NUMBER_0 ) +
 534                         vg_list_size( MESH_NUMBER_1 ) +
 535                         vg_list_size( MESH_NUMBER_2 ) +
 536                         vg_list_size( MESH_NUMBER_3 ) +
 537                         vg_list_size( MESH_NUMBER_4 ) +
 538                         vg_list_size( MESH_NUMBER_5 )
 539                 ) / MESH_NUMBER_DIVISOR,
 540                 vg_list_size( MESH_NUMBER_6 ) / MESH_NUMBER_DIVISOR
 541         },
 542         {
 543                 (
 544                         vg_list_size( MESH_NUMBER_0 ) +
 545                         vg_list_size( MESH_NUMBER_1 ) +
 546                         vg_list_size( MESH_NUMBER_2 ) +
 547                         vg_list_size( MESH_NUMBER_3 ) +
 548                         vg_list_size( MESH_NUMBER_4 ) +
 549                         vg_list_size( MESH_NUMBER_5 ) +
 550                         vg_list_size( MESH_NUMBER_6 )
 551                 ) / MESH_NUMBER_DIVISOR,
 552                 vg_list_size( MESH_NUMBER_7 ) / MESH_NUMBER_DIVISOR
 553         },
 554         {
 555                 (
 556                         vg_list_size( MESH_NUMBER_0 ) +
 557                         vg_list_size( MESH_NUMBER_1 ) +
 558                         vg_list_size( MESH_NUMBER_2 ) +
 559                         vg_list_size( MESH_NUMBER_3 ) +
 560                         vg_list_size( MESH_NUMBER_4 ) +
 561                         vg_list_size( MESH_NUMBER_5 ) +
 562                         vg_list_size( MESH_NUMBER_6 ) +
 563                         vg_list_size( MESH_NUMBER_7 )
 564                 ) / MESH_NUMBER_DIVISOR,
 565                 vg_list_size( MESH_NUMBER_8 ) / MESH_NUMBER_DIVISOR
 566         },
 567         {
 568                 (
 569                         vg_list_size( MESH_NUMBER_0 ) +
 570                         vg_list_size( MESH_NUMBER_1 ) +
 571                         vg_list_size( MESH_NUMBER_2 ) +
 572                         vg_list_size( MESH_NUMBER_3 ) +
 573                         vg_list_size( MESH_NUMBER_4 ) +
 574                         vg_list_size( MESH_NUMBER_5 ) +
 575                         vg_list_size( MESH_NUMBER_6 ) +
 576                         vg_list_size( MESH_NUMBER_7 ) +
 577                         vg_list_size( MESH_NUMBER_8 )
 578                 ) / MESH_NUMBER_DIVISOR,
 579                 vg_list_size( MESH_NUMBER_9 ) / MESH_NUMBER_DIVISOR
 580         }
 581 };