home *** CD-ROM | disk | FTP | other *** search
/ Stone Design / Stone Design.iso / Stone_Friends / Wave / WavesWorld / Source / IBPalettes / WW3DKit / RIBTrimCurve.m < prev    next >
Encoding:
Text File  |  1995-03-22  |  8.1 KB  |  296 lines
  1. // copyright 1993 Michael B. Johnson; some portions copyright 1994, MIT
  2. // see COPYRIGHT for reuse legalities
  3. //
  4.  
  5. #import "RIBTrimCurve.h"
  6.  
  7. @implementation RIBTrimCurve
  8.  
  9. + initialize { return [RIBTrimCurve setVersion:1], self; }
  10.  
  11.  
  12. - init
  13. {
  14.   [super init];
  15.  
  16.   return self;
  17. }
  18.  
  19. - copyFromZone:(NXZone *)zone
  20. {
  21.    id   newCopy = [super copyFromZone:zone];
  22.  
  23.   NXLogError("WARNING: copyFromZone: incompletely implemented for %s : I'm leaking memory in -free", [[self class] name]);
  24.  
  25.   return newCopy;
  26. }
  27.  
  28. - setNLoops:(RtInt)newNLoops nCurves:(RtInt *)newNCurves 
  29.      order:(RtInt *)newOrder len:(int)newOrderLength 
  30.      knot:(RtFloat *)newKnot len:(int)newKnotLength
  31.      min:(RtFloat *)newMin len:(int)newMinLength  max:(RtFloat *)newMax len:(int)newMaxLength
  32.      n2:(RtInt *)newN2 len:(int)newN2Length
  33.      u:(RtFloat *)newU len:(int)newULength  v:(RtFloat *)newV len:(int)newVLength  w:(RtFloat *)newW len:(int)newWLength
  34. {  
  35.    nLoops = newNLoops;
  36.    nCurves = newNCurves;
  37.    order = newOrder;
  38.    orderLength = newOrderLength;
  39.    knot = newKnot;
  40.    knotLength = newKnotLength;
  41.    min = newMin;
  42.    minLength = newMinLength;
  43.    max = newMax;
  44.    maxLength = newMaxLength;
  45.    n2 = newN2;
  46.    n2Length = newN2Length;
  47.    u = newU;
  48.    uLength = newULength;
  49.    v = newV;
  50.    vLength = newVLength;
  51.    w = newW;
  52.    wLength = newWLength;
  53.  
  54.    dirtyBoundingBox = TRUE;
  55.   
  56.    return self;
  57. }
  58.  
  59. - renderSelf:(WW3DCamera *)camera startingAt:(RtFloat)shutterOpenTime endingAt:(RtFloat)shutterCloseTime
  60. {
  61.   RiTrimCurve(nLoops, nCurves, order, knot, min, max, n2, u, v, w);
  62.   return self;
  63. }
  64.  
  65. - writeEve:(NXStream *)stream atTabLevel:(int)tab
  66. {
  67.    int  i;
  68.  
  69.  
  70.    for (i = 0; i < tab; i++)
  71.    {  NXPrintf(stream, "\t");
  72.    }
  73.    NXPrintf(stream, "TrimCurve "); 
  74.  
  75.    NXPrintf(stream, "{ ");
  76.    for (i = 0; i < nLoops; i++)
  77.    {  NXPrintf(stream, "%ld ", nCurves[i]);
  78.    }
  79.    NXPrintf(stream, " } ");
  80.  
  81.    NXPrintf(stream, "{ ");
  82.    for (i = 0; i < orderLength; i++)
  83.    {  NXPrintf(stream, "%ld ", order[i]);
  84.    }
  85.    NXPrintf(stream, " } ");
  86.  
  87.    NXPrintf(stream, "{ ");
  88.    for (i = 0; i < knotLength; i++)
  89.    {  NXPrintf(stream, "%f ", knot[i]);
  90.    }
  91.    NXPrintf(stream, " } ");
  92.  
  93.    NXPrintf(stream, "{ ");
  94.    for (i = 0; i < minLength; i++)
  95.    {  NXPrintf(stream, "%f ", min[i]);
  96.    }
  97.    NXPrintf(stream, " } ");
  98.  
  99.    NXPrintf(stream, "{ ");
  100.    for (i = 0; i < maxLength; i++)
  101.    {  NXPrintf(stream, "%f ", max[i]);
  102.    }
  103.    NXPrintf(stream, " } ");
  104.  
  105.    NXPrintf(stream, "{ ");
  106.    for (i = 0; i < n2Length; i++)
  107.    {  NXPrintf(stream, "%ld ", n2[i]);
  108.    }
  109.    NXPrintf(stream, " } ");
  110.  
  111.    NXPrintf(stream, "{ ");
  112.    for (i = 0; i < uLength; i++)
  113.    {  NXPrintf(stream, "%f ", u[i]);
  114.    }
  115.    NXPrintf(stream, " } ");
  116.  
  117.    NXPrintf(stream, "{ ");
  118.    for (i = 0; i < vLength; i++)
  119.    {  NXPrintf(stream, "%f ", v[i]);
  120.    }
  121.    NXPrintf(stream, " } ");
  122.  
  123.    NXPrintf(stream, "{ ");
  124.    for (i = 0; i < wLength; i++)
  125.    {  NXPrintf(stream, "%f ", w[i]);
  126.    }
  127.    NXPrintf(stream, " }; ");
  128.  
  129.    return self;
  130. }
  131.  
  132.  
  133. - writeInventorAtTime:(float)currentTime to:(NXStream *)stream atTabLevel:(int)tab
  134. {
  135.    int  i, j, k, curveIndex, indexIndex, knotIndex,
  136.         loopMax,
  137.         pointCount = 0,
  138.         howManyCurves = 0;
  139.    
  140.  
  141.    for (i = 0; i < nLoops; i++)
  142.    {  howManyCurves += nCurves[i];
  143.    }
  144.    for (i = 0; i < howManyCurves; i++)
  145.    {  pointCount += n2[i];
  146.    }
  147.  
  148.    for (i = 0; i < tab; i++) {  NXPrintf(stream, "\t"); }
  149.    NXPrintf(stream, "ProfileCoordinate3 {\n");
  150.   
  151.    j = 0;
  152.    for (i = 0; i < (tab+1); i++) {  NXPrintf(stream, "\t"); }
  153.    NXPrintf(stream, "point [%f %f %f,\n", u[j], v[j], w[j]); j++;
  154.  
  155.    while (j < (pointCount-1))
  156.    {  for (i = 0; i < (tab+1); i++) {  NXPrintf(stream, "\t"); }
  157.       NXPrintf(stream, "       %f %f %f,\n", u[j], v[j], w[j]); j++;
  158.    }
  159.  
  160.    for (i = 0; i < (tab+1); i++) {  NXPrintf(stream, "\t"); }
  161.    NXPrintf(stream, "       %f %f %f]\n", u[j], v[j], w[j]);
  162.    for (i = 0; i < tab; i++) {  NXPrintf(stream, "\t"); }
  163.    NXPrintf(stream, "}\n");
  164.  
  165.    // okay, now let's define the profiles
  166.    curveIndex = 0;
  167.  
  168.    // the first one is special, as we need to blow away any others in the state
  169.    for (i = 0; i < tab; i++) {  NXPrintf(stream, "\t"); }
  170.    NXPrintf(stream, "NurbsProfile {\n");
  171.  
  172.    for (i = 0; i < (tab+1); i++) {  NXPrintf(stream, "\t"); }
  173.    NXPrintf(stream, "linkage START_FIRST\n");
  174.  
  175.    indexIndex = 0;
  176.    knotIndex = 0;
  177.    // spit out the first knotVector
  178.    for (i = 0; i < (tab+1); i++) {  NXPrintf(stream, "\t"); }
  179.    NXPrintf(stream, "knotVector [");
  180.    for (k = knotIndex; k < ((n2[curveIndex] + order[curveIndex]) - 1); k++)
  181.    {  NXPrintf(stream, "%f, ", knot[k]);
  182.    }
  183.    NXPrintf(stream, "%f]\n", knot[k]);
  184.    knotIndex = k + 1;
  185.  
  186.    // spit out the first set of indices into the points
  187.    for (i = 0; i < (tab+1); i++) {  NXPrintf(stream, "\t"); }
  188.    NXPrintf(stream, "index [");
  189.    for (k = indexIndex; k < (n2[curveIndex]  - 1); k++)
  190.    {  NXPrintf(stream, "%d, ", k);
  191.    }
  192.    NXPrintf(stream, "%d]\n", k);
  193.    indexIndex = k + 1;
  194.  
  195.    for (i = 0; i < tab; i++) {  NXPrintf(stream, "\t"); }
  196.    NXPrintf(stream, "}\n");
  197.  
  198.    curveIndex++;
  199.  
  200.    // okay, add the rest of the curves
  201.    while (curveIndex < howManyCurves)
  202.    {  for (i = 0; i < tab; i++) {  NXPrintf(stream, "\t"); }
  203.       NXPrintf(stream, "NurbsProfile {\n");
  204.  
  205.       for (i = 0; i < (tab+1); i++) {  NXPrintf(stream, "\t"); }
  206.       NXPrintf(stream, "linkage START_NEW\n");
  207.  
  208.       // spit out the first knotVector
  209.       for (i = 0; i < (tab+1); i++) {  NXPrintf(stream, "\t"); }
  210.       NXPrintf(stream, "knotVector [");
  211.       loopMax = knotIndex + (n2[curveIndex] + order[curveIndex]) - 1;
  212.       for (k = knotIndex; k < loopMax; k++)
  213.       {  NXPrintf(stream, "%f, ", knot[k]);
  214.       }
  215.       NXPrintf(stream, "%f]\n", knot[k]);
  216.       knotIndex = k + 1;
  217.  
  218.       // spit out the first set of indices into the points
  219.       for (i = 0; i < (tab+1); i++) {  NXPrintf(stream, "\t"); }
  220.       NXPrintf(stream, "index [");
  221.       loopMax = indexIndex + n2[curveIndex]  - 1;
  222.       for (k = indexIndex; k < loopMax; k++)
  223.       {  NXPrintf(stream, "%d, ", k);
  224.       }
  225.       NXPrintf(stream, "%d]\n", k);
  226.       indexIndex = k + 1;
  227.  
  228.       for (i = 0; i < tab; i++) {  NXPrintf(stream, "\t"); }
  229.       NXPrintf(stream, "}\n");
  230.  
  231.       curveIndex++;
  232.    }
  233.  
  234.    return self;
  235. }
  236.  
  237. #define typeVector "liiiiiiii"
  238. #define typeValues &nLoops, &orderLength, &n2Length, &knotLength, &minLength, &maxLength, &uLength, &vLength, &wLength
  239.  
  240. - read:(NXTypedStream *)stream 
  241. {
  242.     int   version;
  243.  
  244.     
  245.     [super read:stream];
  246.     version = NXTypedStreamClassVersion(stream,"RIBTrimCurve");
  247.     if (version == 0) NXReadTypes(stream,"i",&version), version=1;
  248.     if (version == 1) {
  249.     NXReadTypes(stream,typeVector,typeValues);
  250.     
  251.     nCurves = (long *)NXZoneMalloc([self zone], nLoops*sizeof(long));
  252.     NXReadArray(stream, "i", nLoops, nCurves);
  253.     order = (long *)NXZoneMalloc([self zone], orderLength*sizeof(long));
  254.     NXReadArray(stream, "i", orderLength, order);
  255.     n2 = (long *)NXZoneMalloc([self zone], n2Length*sizeof(long));
  256.     NXReadArray(stream, "i", n2Length, n2);
  257.     
  258.     knot = (float *)NXZoneMalloc([self zone], knotLength*sizeof(float));
  259.     NXReadArray(stream, "f", knotLength, knot);
  260.     min = (float *)NXZoneMalloc([self zone], minLength*sizeof(float));
  261.     NXReadArray(stream, "f", minLength, min);
  262.     max = (float *)NXZoneMalloc([self zone], maxLength*sizeof(float));
  263.     NXReadArray(stream, "f", maxLength, max);
  264.     u = (float *)NXZoneMalloc([self zone], uLength*sizeof(float));
  265.     NXReadArray(stream, "f", uLength, u);
  266.     v = (float *)NXZoneMalloc([self zone], vLength*sizeof(float));
  267.     NXReadArray(stream, "f", vLength, v);
  268.     w = (float *)NXZoneMalloc([self zone], wLength*sizeof(float));
  269.     NXReadArray(stream, "f", wLength, w);
  270.     } else {
  271.     }
  272.     return self;
  273. }
  274.  
  275. - write:(NXTypedStream *)stream 
  276. {
  277.     [super write:stream];
  278.     
  279.     NXWriteTypes(stream,typeVector, typeValues);
  280.     
  281.     NXWriteArray(stream, "l", nLoops, nCurves);
  282.     NXWriteArray(stream, "l", orderLength, order);
  283.     NXWriteArray(stream, "l", n2Length, n2);
  284.     
  285.     NXWriteArray(stream, "f", knotLength, knot);
  286.     NXWriteArray(stream, "f", minLength, min);
  287.     NXWriteArray(stream, "f", maxLength, max);
  288.     NXWriteArray(stream, "f", uLength, u);
  289.     NXWriteArray(stream, "f", vLength, v);
  290.     NXWriteArray(stream, "f", wLength, w);
  291.     
  292.     return self;
  293. }
  294.  
  295. @end
  296.