arrowData.h

//-
// ==========================================================================
// Copyright 1995,2006,2008 Autodesk, Inc. All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk
// license agreement provided at the time of installation or download,
// or which otherwise accompanies this software in either electronic
// or hard copy form.
// ==========================================================================
//+

// 
// Description: 
//  The draw data for curvedArrowsLocator node. The vertex and face
//  lists here are used to draw the locator in curvedArrowsNode.cpp.
//  If you intend on using this file for your own locator code, you
//  should statically define the data in a cpp file and forward
//  declare the definitions.
//

#ifndef __arrowData_h 
#define __arrowData_h 

#include <maya/MTypes.h> 

double3 fsVertexList[] = { 
        {2.008225, 1.079209, 1.099684},
        {1.372727, 4.319467, 1.062919},
        {1.280773, 4.292139, 2.119867},
        {0.539631, 6.385876, 0.001970},
        {1.280571, 4.293406, -2.116594},
        {1.372622, 4.320125, -1.059360},
        {2.008054, 1.080287, -1.098606},
        {1.371678, 1.043522, -4.338864},
        {1.279918, 2.100470, -4.311536},
        {0.538348, -0.017427, -6.405273},
        {1.279295, -2.135990, -4.312802},
        {1.371354, -1.078757, -4.339522},
        {2.007523, -1.118003, -1.099684},
        {1.370871, -4.358261, -1.062919},
        {1.278961, -4.330933, -2.119867},
        {0.537693, -6.424670, -0.001970},
        {1.279162, -4.332200, 2.116594},
        {1.370975, -4.358919, 1.059360},
        {2.007695, -1.119081, 1.098606},
        {1.371921, -1.082316, 4.338864},
        {1.279816, -2.139264, 4.311536},
        {0.538976, -0.021367, 6.405273},
        {1.280439, 2.097197, 4.312802},
        {1.372244, 1.039963, 4.339522},
        {0.689836, 6.083689, -0.304354},
        {0.687872, -6.122423, -0.308345},
        {0.688532, -0.323764, -6.103074},
        {2.085568, -0.350431, -0.331356},
        {1.499430, 1.051045, -3.919533},
        {1.529212, -0.339001, -3.927586},
        {1.060962, 1.230698, -5.173299},
        {1.094450, -0.331015, -5.187352},
        {1.358106, 1.257148, -4.334800},
        {1.062640, 1.235920, -5.168137},
        {1.500284, 3.900855, -1.067099},
        {1.530372, 3.908165, -0.319592},
        {1.063729, 5.149192, -1.251617},
        {1.358988, 4.316187, -1.273126},
        {1.062019, 5.154456, -1.246286},
        {1.095755, 5.167962, -0.311606},
        {1.805411, 1.068872, -2.630027},
        {1.840273, -0.344989, -2.635986},
        {1.805912, 2.611508, -1.085823},
        {1.841150, 2.616522, -0.325579},
        {1.989196, 1.079267, -1.319875},
        {2.027111, -0.348901, -1.323331},
        {1.989278, 1.301442, -1.097376},
        {2.027605, 1.303832, -0.329491},
        {1.499065, -1.086496, -3.920275},
        {1.060692, -1.265690, -5.173846},
        {1.062416, -1.271064, -5.168539},
        {1.357708, -1.292573, -4.335583},
        {1.804689, -2.649458, -1.088268},
        {1.839898, -2.655130, -0.328084},
        {1.804946, -1.105219, -2.630971},
        {1.988671, -1.116772, -1.320941},
        {1.988629, -1.339324, -1.098664},
        {2.026941, -1.342456, -0.330810},
        {1.498628, -3.938942, -1.070441},
        {1.528676, -3.946769, -0.323016},
        {1.357257, -4.354195, -1.276643},
        {1.061859, -5.187435, -1.255416},
        {1.060152, -5.192692, -1.250098},
        {1.093819, -5.206605, -0.315548},
        {0.689167, -0.327754, 6.103014},
        {1.840678, -0.347494, 2.635666},
        {1.805806, 1.066425, 2.630939},
        {1.500402, 3.900112, 1.070442},
        {1.359117, 4.315402, 1.276595},
        {1.063801, 5.148689, 1.255368},
        {1.062106, 5.153909, 1.250088},
        {1.806063, 2.610563, 1.088270},
        {2.027326, -0.350221, 1.322957},
        {1.989405, 1.077978, 1.320891},
        {1.989447, 1.300376, 1.098664},
        {1.529760, -0.342425, 3.927349},
        {1.499966, 1.047702, 3.920264},
        {1.095076, -0.334957, 5.187215},
        {1.061565, 1.226892, 5.173850},
        {1.063244, 1.232120, 5.168687},
        {1.358666, 1.253631, 4.335587},
        {1.805341, -1.107666, 2.629994},
        {1.804840, -2.650403, 1.085822},
        {1.988881, -1.118061, 1.319826},
        {1.988799, -1.340390, 1.097375},
        {1.498746, -3.939685, 1.067098},
        {1.061931, -5.188034, 1.251568},
        {1.357386, -4.354982, 1.273078},
        {1.060238, -5.193239, 1.246297},
        {1.499600, -1.089839, 3.919521},
        {1.061296, -1.269488, 5.173302},
        {1.358268, -1.296090, 4.334797},
        {1.063021, -1.274864, 5.167988}
};
static unsigned int fsVertexListSize = sizeof(fsVertexList)/sizeof(fsVertexList[0]);

double3 fsNormalList[] = { 
        {-0.931122, 0.038131, -0.362710},
        {-0.912231, -0.005503, -0.409640},
        {-0.933578, 0.006943, -0.358306},
        {-0.931095, 0.362789, 0.038019},
        {-0.912227, 0.409648, -0.005557},
        {-0.933550, 0.358383, 0.006858},
        {-0.997459, -0.042270, 0.057351},
        {-0.993341, -0.026643, 0.112084},
        {-0.994834, 0.005967, 0.101338},
        {-0.944191, -0.031638, 0.327875},
        {-0.925551, -0.028775, 0.377527},
        {-0.933560, 0.006761, 0.358358},
        {-0.907808, -0.032590, 0.418117},
        {-0.912226, -0.005666, 0.409648},
        {-0.938752, -0.081124, 0.334909},
        {-0.937371, -0.096144, 0.334802},
        {-0.939100, -0.066084, 0.337231},
        {-0.944104, -0.327156, 0.040453},
        {-0.966679, -0.252334, 0.043109},
        {-0.960969, -0.276637, 0.003159},
        {-0.939124, -0.337153, 0.066138},
        {-0.937387, -0.334742, 0.096190},
        {-0.938771, -0.334845, 0.081163},
        {-0.912227, -0.409644, -0.005734},
        {-0.931111, -0.362760, 0.037919},
        {-0.933585, -0.358294, 0.006690},
        {-0.967351, -0.023114, 0.252386},
        {-0.960826, 0.013512, 0.276822},
        {-0.982288, 0.011914, 0.187001},
        {-0.984228, -0.170339, 0.047757},
        {-0.982359, -0.186756, 0.009630},
        {-0.985027, -0.025548, 0.170498},
        {-0.992471, -0.111860, 0.049884},
        {-0.995415, -0.094359, 0.015656},
        {-0.939102, 0.066141, 0.337213},
        {-0.937369, 0.096190, 0.334792},
        {-0.938752, 0.081181, 0.334895},
        {-0.931093, 0.037925, 0.362805},
        {-0.944074, 0.040491, 0.327237},
        {-0.964270, 0.041449, 0.261658},
        {-0.991342, 0.121848, 0.048936},
        {-0.978396, 0.201767, 0.045070},
        {-0.982265, 0.187120, 0.011932},
        {-0.978414, 0.045051, 0.201683},
        {-0.991353, 0.048984, 0.121739},
        {-0.996495, 0.059201, 0.059092},
        {-0.994819, 0.101489, 0.005905},
        {-0.964254, 0.261709, 0.041505},
        {-0.960805, 0.276893, 0.013589},
        {-0.938752, 0.334874, 0.081267},
        {-0.937370, 0.334766, 0.096273},
        {-0.939103, 0.337190, 0.066241},
        {-0.944069, 0.327242, 0.040582},
        {-0.907792, -0.032472, -0.418163},
        {-0.925549, -0.028624, -0.377545},
        {-0.995398, 0.015903, -0.094495},
        {-0.982336, 0.009926, -0.186865},
        {-0.992245, -0.025986, -0.121548},
        {-0.938785, -0.334775, -0.081291},
        {-0.937401, -0.334667, -0.096321},
        {-0.939136, -0.337099, -0.066236},
        {-0.944233, -0.327743, -0.031761},
        {-0.925574, -0.377464, -0.028876},
        {-0.907810, -0.418108, -0.032678},
        {-0.979223, -0.201333, -0.024215},
        {-0.998284, -0.041303, -0.041510},
        {-0.992261, -0.121362, -0.026260},
        {-0.960946, 0.003462, -0.276715},
        {-0.979198, -0.023910, -0.201495},
        {-0.944194, -0.031458, -0.327883},
        {-0.939094, -0.065903, -0.337282},
        {-0.937364, -0.095970, -0.334872},
        {-0.938744, -0.080943, -0.334974},
        {-0.939071, 0.337339, -0.065948},
        {-0.937345, 0.334923, -0.095971},
        {-0.938725, 0.335024, -0.080962},
        {-0.992448, 0.050148, -0.111948},
        {-0.984202, 0.048049, -0.170403},
        {-0.985000, 0.170655, -0.025537},
        {-0.993321, 0.112257, -0.026691},
        {-0.997443, 0.057550, -0.042372},
        {-0.967321, 0.252508, -0.023037},
        {-0.907802, 0.418140, -0.032480},
        {-0.925535, 0.377575, -0.028671},
        {-0.944163, 0.327965, -0.031530},
        {-0.966661, 0.043405, -0.252353},
        {-0.938785, 0.081433, -0.334740},
        {-0.937400, 0.096451, -0.334631},
        {-0.939136, 0.066388, -0.337069},
        {-0.944108, 0.040709, -0.327112},
        {-0.999889, 0.010615, 0.010460},
        {-0.964989, -0.261340, -0.022320},
        {-0.964949, -0.022014, -0.261513}
};
// static unsigned int fsNormalListSize = sizeof(fsNormalList)/sizeof(fsNormalList[0]);

typedef unsigned int uint3[3]; 

uint3 fsFaceList[] = {
        {91, 65, 78},
        {63, 26, 64},
        {7, 45, 46},
        {8, 31, 32},
        {31, 10, 27},
        {33, 9, 34},
        {6, 35, 36},
        {37, 5, 38},
        {25, 39, 40},
        {29, 30, 42},
        {35, 43, 44},
        {41, 42, 46},
        {43, 47, 48},
        {51, 11, 52},
        {27, 50, 32},
        {12, 49, 30},
        {57, 53, 54},
        {49, 55, 30},
        {55, 56, 42},
        {13, 57, 58},
        {53, 59, 60},
        {61, 15, 62},
        {14, 63, 64},
        {65, 22, 79},
        {73, 66, 74},
        {69, 3, 70},
        {2, 71, 40},
        {71, 4, 25},
        {36, 44, 72},
        {1, 75, 48},
        {44, 48, 75},
        {66, 76, 67},
        {78, 79, 24},
        {80, 23, 81},
        {87, 17, 88},
        {84, 82, 73},
        {58, 54, 83},
        {58, 85, 19},
        {54, 60, 86},
        {26, 16, 89},
        {64, 89, 18},
        {82, 90, 66},
        {92, 21, 93},
        {20, 91, 78},
        {48, 47, 7},
        {46, 28, 7},
        {7, 28, 48},
        {8, 33, 34},
        {30, 29, 8},
        {8, 32, 30},
        {34, 31, 8},
        {27, 32, 31},
        {37, 38, 6},
        {40, 39, 6},
        {36, 40, 6},
        {6, 39, 37},
        {42, 41, 29},
        {44, 36, 35},
        {46, 45, 41},
        {48, 44, 43},
        {51, 52, 12},
        {32, 50, 12},
        {30, 32, 12},
        {12, 50, 51},
        {54, 58, 57},
        {55, 42, 30},
        {56, 46, 42},
        {46, 56, 13},
        {58, 28, 13},
        {13, 28, 46},
        {60, 54, 53},
        {14, 61, 62},
        {60, 59, 14},
        {14, 64, 60},
        {62, 63, 14},
        {79, 78, 65},
        {66, 67, 74},
        {2, 69, 70},
        {36, 68, 2},
        {2, 40, 36},
        {70, 71, 2},
        {25, 40, 71},
        {72, 68, 36},
        {73, 74, 1},
        {48, 28, 1},
        {1, 28, 73},
        {75, 72, 44},
        {76, 77, 67},
        {80, 81, 24},
        {24, 77, 76},
        {76, 78, 24},
        {24, 79, 80},
        {82, 66, 73},
        {83, 85, 58},
        {19, 84, 73},
        {19, 28, 58},
        {73, 28, 19},
        {86, 83, 54},
        {89, 64, 26},
        {87, 88, 18},
        {18, 86, 60},
        {60, 64, 18},
        {18, 89, 87},
        {90, 76, 66},
        {20, 92, 93},
        {76, 90, 20},
        {20, 78, 76},
        {93, 91, 20}
};

static unsigned int fsFaceListSize = sizeof(fsFaceList)/sizeof(fsFaceList[0]);

uint3 fsFaceVertexNormalList[] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9},
        {10, 11, 12},
        {11, 13, 14},
        {15, 16, 17},
        {18, 19, 20},
        {21, 22, 23},
        {24, 25, 26},
        {27, 28, 29},
        {19, 30, 31},
        {32, 29, 9},
        {30, 33, 34},
        {35, 36, 37},
        {14, 38, 12},
        {39, 40, 28},
        {41, 42, 43},
        {40, 44, 28},
        {44, 45, 29},
        {46, 41, 47},
        {42, 48, 49},
        {50, 51, 52},
        {53, 4, 6},
        {2, 54, 55},
        {56, 57, 58},
        {59, 60, 61},
        {62, 63, 26},
        {63, 64, 24},
        {20, 31, 65},
        {66, 67, 34},
        {31, 34, 67},
        {57, 68, 69},
        {3, 55, 70},
        {71, 72, 73},
        {74, 75, 76},
        {77, 78, 56},
        {47, 43, 79},
        {47, 80, 81},
        {43, 49, 82},
        {5, 83, 84},
        {6, 84, 85},
        {78, 86, 57},
        {87, 88, 89},
        {90, 1, 3},
        {34, 33, 7},
        {9, 91, 7},
        {7, 91, 34},
        {10, 15, 17},
        {28, 27, 10},
        {10, 12, 28},
        {17, 11, 10},
        {14, 12, 11},
        {21, 23, 18},
        {26, 25, 18},
        {20, 26, 18},
        {18, 25, 21},
        {29, 32, 27},
        {31, 20, 19},
        {9, 8, 32},
        {34, 31, 30},
        {35, 37, 39},
        {12, 38, 39},
        {28, 12, 39},
        {39, 38, 35},
        {43, 47, 41},
        {44, 29, 28},
        {45, 9, 29},
        {9, 45, 46},
        {47, 91, 46},
        {46, 91, 9},
        {49, 43, 42},
        {53, 50, 52},
        {49, 48, 53},
        {53, 6, 49},
        {52, 4, 53},
        {55, 3, 2},
        {57, 69, 58},
        {62, 59, 61},
        {20, 92, 62},
        {62, 26, 20},
        {61, 63, 62},
        {24, 26, 63},
        {65, 92, 20},
        {56, 58, 66},
        {34, 91, 66},
        {66, 91, 56},
        {67, 65, 31},
        {68, 93, 69},
        {71, 73, 70},
        {70, 93, 68},
        {68, 3, 70},
        {70, 55, 71},
        {78, 57, 56},
        {79, 80, 47},
        {81, 77, 56},
        {81, 91, 47},
        {56, 91, 81},
        {82, 79, 43},
        {84, 6, 5},
        {74, 76, 85},
        {85, 82, 49},
        {49, 6, 85},
        {85, 84, 74},
        {86, 68, 57},
        {90, 87, 89},
        {68, 86, 90},
        {90, 3, 68},
        {89, 1, 90}
};

// static unsigned int fsFaceVertexNormalListSize = sizeof(fsFaceVertexNormalList)/sizeof(fsFaceVertexNormalList[0]);

unsigned int fsEdgeLoop[] = { 0, 74, 71, 67, 1, 
                                                          68, 2, 69, 70, 3,
                                                          24, 38, 36, 4, 37, 
                                                          5, 34, 42, 46, 6, 
                                                          44, 40, 28, 7, 
                                                          32, 8, 33, 30, 9,
                                                          26, 49, 50, 10, 51, 11, 
                                                          48, 54, 55, 12, 56, 52, 
                                                          58, 13, 60, 14, 61, 62,
                                                          25, 15, 88, 86, 16, 87, 17, 
                                                          85, 82, 84, 18, 83, 81, 89, 19, 
                                                          91, 20, 92, 90, 64, 21, 78, 79, 
                                                          22, 80, 23, 76, 66, 73 };

static unsigned int fsEdgeLoopSize = sizeof(fsEdgeLoop)/sizeof(fsEdgeLoop[0]);

#endif