SHARE
TWEET

Untitled

a guest Jan 10th, 2013 1,277 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <cstdio>
  2. #include <vector>
  3.  
  4. struct vector3
  5. {
  6.   vector3(float x_, float y_, float z_) :
  7.     x(x_), y(y_), z(z_) {}
  8.  
  9.   float x, y, z;
  10. };
  11.  
  12. struct vector5
  13. {
  14.   vector5(float x_, float y_, float z_, float w_, float q_) :
  15.     x(x_), y(y_), z(z_), w(w_), q(q_) {}
  16.  
  17.   float x, y, z, w, q;
  18. };
  19.  
  20. int dims[3] = {4, 4, 4};
  21. int volume[4 * 4 * 4];
  22.  
  23. int f(int i, int j, int k)
  24. {
  25.   return volume[i + dims[0] * (j + dims[1] * k)];
  26. }
  27.  
  28. void
  29. greedy(const int *volume, const int *dims, std::vector<vector3> &vertices, std::vector<vector5> &faces)
  30. {
  31.   for (std::size_t axis = 0; axis < 3; ++axis)
  32.   {
  33.     // printf("axis: %ld\n", axis);
  34.    
  35.     const std::size_t u = (axis + 1) % 3;
  36.     const std::size_t v = (axis + 2) % 3;
  37.  
  38.     // printf("u: %ld, v: %ld\n", u, v);
  39.  
  40.     int x[3] = {0}, q[3] = {0}, mask[dims[u] * dims[v]];
  41.     // printf("dims[u]: %d, dims[v]: %d\n", dims[u], dims[v]);
  42.  
  43.     // printf("x: %d, %d, %d\n", x[0], x[1], x[2]);
  44.     // printf("q: %d, %d, %d\n", q[0], q[1], q[2]);
  45.  
  46.     // Compute mask
  47.     q[axis] = 1;
  48.     for (x[axis] = -1; x[axis] < dims[axis];)
  49.     {
  50.       // printf("x: %d, %d, %d\n", x[0], x[1], x[2]);
  51.       // printf("q: %d, %d, %d\n", q[0], q[1], q[2]);
  52.      
  53.       std::size_t counter = 0;
  54.       for (x[v] = 0; x[v] < dims[v]; ++x[v])
  55.         for (x[u] = 0; x[u] < dims[u]; ++x[u], ++counter)
  56.         {
  57.           const int a = 0 <= x[axis] ? f(x[0], x[1], x[2]) : 0;
  58.           const int b = x[axis] < dims[axis] - 1 ? f(x[0] + q[0],
  59.                                                      x[1] + q[1],
  60.                                                      x[2] + q[2]) : 0;
  61.           const bool ba = static_cast<bool>(a);
  62.           if (ba == static_cast<bool>(b))
  63.             mask[counter] = 0;
  64.           else if (ba)
  65.             mask[counter] = a;
  66.           else
  67.             mask[counter] = -b;
  68.         }
  69.  
  70.       ++x[axis];
  71.  
  72.       // for (size_t a = 0; a < dims[u] * dims[v]; ++a)
  73.       //   printf("%d, ", mask[a]);
  74.       // printf("\n");
  75.  
  76.       // Generate mesh for mask using lexicographic ordering
  77.       std::size_t width = 0, height = 0;
  78.      
  79.       counter = 0;
  80.       for (std::size_t j = 0; j < dims[v]; ++j)
  81.         for (std::size_t i = 0; i < dims[u];)
  82.         {
  83.           int c = mask[counter];
  84.           if (c)
  85.           {
  86.             // Compute width
  87.             for (width = 1; c == mask[counter + width] &&
  88.                    i + width < dims[u]; ++width)
  89.             {}
  90.  
  91.             // Compute height
  92.             bool done = false;
  93.             for (height = 1; j + height < dims[v]; ++height)
  94.             {
  95.               for (std::size_t k = 0; k < width; ++k)
  96.                 if (c != mask[counter + k + height * dims[u]])
  97.                 {
  98.                   done = true;
  99.                   break;
  100.                 }
  101.  
  102.               if (done)
  103.                 break;
  104.             }
  105.  
  106.             // Add quad
  107.             x[u] = i;
  108.             x[v] = j;
  109.  
  110.             int du[3] = {0}, dv[3] = {0};
  111.  
  112.             if (c > 0)
  113.             {
  114.               dv[v] = height;
  115.               du[u] = width;
  116.             }
  117.             else
  118.             {
  119.               c = -c;
  120.               du[v] = height;
  121.               dv[u] = width;
  122.             }
  123.  
  124.             const std::size_t vertexSize = vertices.size();
  125.             vertices.push_back(vector3(x[0], x[1], x[2]));
  126.             vertices.push_back(vector3(x[0] + du[0], x[1] + du[1], x[2] + du[2]));
  127.             vertices.push_back(vector3(x[0] + du[0] + dv[0], x[1] + du[1] + dv[1], x[2] + du[2] + dv[2]));
  128.             vertices.push_back(vector3(x[0] + dv[0], x[1] + dv[1], x[2] + dv[2]));
  129.  
  130.             faces.push_back(vector5(vertexSize, vertexSize + 1, vertexSize + 2, vertexSize + 3, c));
  131.  
  132.             for (std::size_t b = 0; b < width; ++b)
  133.               for (std::size_t a = 0; a < height; ++a)
  134.                 mask[counter + b + a * dims[u]] = 0;
  135.  
  136.             // Increment counters
  137.             i += width; counter += width;
  138.           }
  139.           else
  140.           {
  141.             ++i;
  142.             ++counter;
  143.           }
  144.         }
  145.     }
  146.  
  147.     // printf("x: %d, %d, %d\n", x[0], x[1], x[2]);
  148.     // printf("q: %d, %d, %d\n", q[0], q[1], q[2]);
  149.  
  150.  
  151.     // printf("\n");
  152.  
  153.   }  
  154. }
  155.  
  156. int
  157. main(void)
  158. {
  159.   std::vector<vector3> vertices;
  160.   std::vector<vector5> faces;
  161.  
  162.   for (size_t a = 0; a < dims[0] * dims[1] * dims[2]; ++a)
  163.     volume[a] = 255;
  164.  
  165.   greedy(volume, dims, vertices, faces);
  166.  
  167.   for (size_t a = 0; a < vertices.size(); ++a)
  168.     printf("%ld: %f, %f, %f\n", a, vertices[a].x, vertices[a].y, vertices[a].z);
  169.   printf("\n");
  170.  
  171.   for (size_t a = 0; a < faces.size(); ++a)
  172.     printf("%ld: %f, %f, %f, %f, %f\n", a, faces[a].x, faces[a].y, faces[a].z, faces[a].w, faces[a].q);
  173.  
  174.  
  175.   return 0;
  176. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top