home *** CD-ROM | disk | FTP | other *** search
/ Stone Design / Stone Design.iso / Stone_Friends / Wave / WavesWorld / Source / IBPalettes / WW3DKit / WW3DShader.m < prev    next >
Encoding:
Text File  |  1995-04-03  |  30.0 KB  |  1,046 lines
  1. // copyright 1993 Michael B. Johnson; some portions copyright 1994, MIT
  2. // see COPYRIGHT for reuse legalities
  3. //
  4.  
  5. #import "WW3DShader.h"
  6. #import <3Dkit/3Dkit.h>
  7.  
  8. #import "WWShaderArgPointMatrix.h"
  9. #import "WWEveParser.h"
  10.  
  11. @implementation WW3DShader
  12.  
  13. + initialize { return [WW3DShader setVersion:4], self; }
  14.  
  15. static lightHandleSeed = 0;
  16.  
  17. static BOOL
  18. validQuickShader(const char *name)
  19. {
  20.   if (!name)
  21.   {  return NO;
  22.   }
  23.   if (!strcmp("plastic", name))
  24.   {  return YES;
  25.   }
  26.   if (!strcmp("paintedplastic", name))
  27.   {  return YES;
  28.   }
  29.   if (!strcmp("constant", name))
  30.   {  return YES;
  31.   }
  32.   if (!strcmp("matte", name))
  33.   {  return YES;
  34.   }
  35.   if (!strcmp("metal", name))
  36.   {  return YES;
  37.   }
  38.   if (!strcmp("shinymetal", name))
  39.   {  return YES;
  40.   }
  41.   if (!strcmp("ambientlight", name))
  42.   {  return YES;
  43.   }
  44.   if (!strcmp("distantlight", name))
  45.   {  return YES;
  46.   }
  47.   if (!strcmp("pointlight", name))
  48.   {  return YES;
  49.   }
  50.   if (!strcmp("spotlight", name))
  51.   {  return YES;
  52.   }
  53.   if (!strcmp("depthcue", name))
  54.   {  return YES;
  55.   }
  56.   if (!strcmp("fog", name))
  57.   {  return YES;
  58.   }
  59.   if (!strcmp("bumpy", name))
  60.   {  return YES;
  61.   }
  62.   return NO;
  63. }
  64.  
  65. - init
  66. {
  67.   if (![super init])
  68.   {  return nil;
  69.   }
  70.  
  71.   // for each of the tokens, we need to see if it corresponds to a
  72.   //  valid argument of this shader.  If it does, we set the value 
  73.   // using the corresponding parm.
  74.   n = 0;
  75.   tokens = NULL;
  76.   parms = NULL;
  77.   archiveVector = NULL;
  78.   printfNVector = NULL;
  79.   printfTypeVector = NULL;
  80.   iconImage = [NXImage findImageNamed:"shader"];
  81.   [self assignQuickShader];
  82.   usingSupportedQRManShader = NO;
  83.  
  84.   lightHandle = 0;
  85.  
  86.   // dis ain't dat portable, ya know...
  87.   ribColor[0] = 1.0;
  88.   ribColor[1] = 1.0;
  89.   ribColor[2] = 1.0;
  90.  
  91.   return self;
  92. }
  93.  
  94.  
  95. - (BOOL)pushesOrPopsCTM { return NO; }
  96. - (BOOL)pushesCTM { return NO; }
  97. - (BOOL)popsCTM { return NO; }
  98.  
  99. - initWithShader:(const char *)shaderName n:(int)newN tokens:(RtToken *)newTokens parms:(RtPointer *)newParms archiveVector:(char **)newArchiveVector printfTypeVector:(int *)newPrintfTypeVector printfNVector:(int *)newPrintfNVector
  100. {
  101.   int  i;
  102.  
  103.  
  104.   if (![super initWithShader:shaderName])
  105.   {  return nil;
  106.   }
  107.  
  108.   [self setShader:shaderName];
  109.   [self setUseColor:NO];
  110.  
  111.   // for each of the tokens, we need to see if it corresponds to a
  112.   //  valid argument of this shader.  If it does, we set the value 
  113.   // using the corresponding parm.
  114.   n = newN;
  115.   tokens = newTokens;
  116.   parms = newParms;
  117.   archiveVector = newArchiveVector;
  118.   printfNVector = (int *)malloc(n * sizeof(int));
  119.   printfTypeVector = (int *)malloc(n * sizeof(int));
  120.  
  121.   for (i = 0; i < n; i++)
  122.   {  if (![self setShaderArgNamed:tokens[i] withValue:parms[i]])
  123.      {  NXLogError("in shader %s, <%s> is not a valid arg.\n", 
  124.            shaderName, tokens[i]);
  125.      }
  126.      printfNVector[i] = newPrintfNVector[i];
  127.      printfTypeVector[i] = newPrintfTypeVector[i];
  128.   }
  129.  
  130.   lightHandle = 0;
  131.  
  132.   // dis ain't dat portable, ya know...
  133.   ribColor[0] = 1.0;
  134.   ribColor[1] = 1.0;
  135.   ribColor[2] = 1.0;
  136.  
  137.   return self;
  138. }
  139.  
  140. - setShader:(const char *)name
  141. {
  142.   if (![super setShader:name])
  143.   {  return nil;
  144.   }
  145.   if (name)
  146.   {  iconImage = [NXImage findImageNamed:(char *)name];
  147.   }
  148.   else
  149.   {  iconImage = nil;
  150.   }
  151.   if (!iconImage)
  152.   {  iconImage = [NXImage findImageNamed:"shader"];
  153.   }
  154.   if (validQuickShader(name))
  155.   {  quickShader = NXCopyStringBuffer(name);
  156.      usingSupportedQRManShader = YES;
  157.   }
  158.   else
  159.   {  [self assignQuickShader];
  160.      usingSupportedQRManShader = NO;
  161.   }
  162.  
  163.   return self;
  164. }
  165.  
  166. - assignQuickShader
  167. {
  168.   if (quickShader) {  free(quickShader); }
  169.   switch ([self shaderType])
  170.   {  
  171.      case SLO_TYPE_SURFACE:
  172.        // really should be arbitrarily smart here
  173.        // you can look at the parameters of the shaders, etc. to try and figure out which it use
  174.        // for now, just just use plastic.
  175.        quickShader = NXCopyStringBuffer("plastic");
  176.        break;
  177.  
  178.      case SLO_TYPE_LIGHT:
  179.        quickShader = NXCopyStringBuffer("pointlight");
  180.        break;
  181.  
  182.      case SLO_TYPE_DISPLACEMENT:
  183.        quickShader = NXCopyStringBuffer("bumpy");
  184.        break;
  185.  
  186.      case SLO_TYPE_VOLUME:
  187.        // need to figure out what kind...
  188.        quickShader = NXCopyStringBuffer("depthcue");
  189.        break;
  190.  
  191.      case SLO_TYPE_TRANSFORMATION:
  192.        quickShader = NULL;
  193.        break;
  194.  
  195.      case SLO_TYPE_IMAGER:
  196.        quickShader = NULL;
  197.        break;
  198.  
  199.      default:
  200.        quickShader = NULL;
  201.        return nil;
  202.   }
  203.  
  204.   return self;
  205. }
  206.  
  207. - setShaderArgNamed:(const char *)argName withValue:(RtPointer)value
  208. {
  209.   SLO_TYPE   argType;
  210.  
  211.  
  212.   argType = [self shaderArgType:argName];
  213.   if (argType == SLO_TYPE_POINT)
  214.   {  return [self setShaderArg:argName pointValue:*((RtPoint *)value)];
  215.   }
  216.   if (argType == SLO_TYPE_COLOR)
  217.   {  // note that it wants an NXColor, not an RtColor...
  218.      RtFloat r = *((RtFloat *)value); 
  219.      RtFloat g = *((RtFloat *)(value+sizeof(RtFloat))); 
  220.      RtFloat b = *((RtFloat *)(value+(2*sizeof(RtFloat))));
  221.      NXColor  anNXColor = NXConvertRGBToColor((float)r, (float)g, (float)b);
  222.      
  223.      return [self setShaderArg:argName colorValue:anNXColor];
  224.   }
  225.   if (argType == SLO_TYPE_SCALAR)
  226.   {  return [self setShaderArg:argName floatValue:(*((RtFloat *)value))];
  227.   }
  228.   if (argType == SLO_TYPE_STRING)
  229.   {  return [self setShaderArg:argName stringValue:(*(char **)value)];
  230.   }
  231.  
  232.   return nil;
  233. }
  234.  
  235.  
  236. - (const char *)quickShader {  return quickShader; }
  237. - setQuickShader:(const char *)newQuickShader 
  238. {  
  239.    if (!validQuickShader(newQuickShader))
  240.    {  NXLogError("%s is not a shader supported by qrman, yabba-head!\n");
  241.       return nil;
  242.    }
  243.    if (quickShader)
  244.    {  free(quickShader);
  245.    }
  246.    quickShader = NXCopyStringBuffer(newQuickShader);
  247.    return self;
  248. }
  249.  
  250. - setColor:(NXColor)aColor
  251. {
  252.   ribColor[0] = NXRedComponent(aColor);
  253.   ribColor[1] = NXGreenComponent(aColor);
  254.   ribColor[2] = NXBlueComponent(aColor);
  255.   return [super setColor:aColor];
  256. }
  257.  
  258. - (RtToken)token { return token; }
  259.  
  260. - setToken:(RtToken)newToken
  261. {
  262.   token = newToken;
  263.   return self;
  264. }
  265.  
  266. - set
  267. {
  268.   if (NXDrawingStatus == NX_DRAWING)
  269.   {  
  270.      if ([self doesUseColor])
  271.      {  RiColor(ribColor);
  272.      }
  273.      if (quickShader)
  274.      {  switch ([self shaderType])
  275.         {  
  276.            case SLO_TYPE_SURFACE:
  277.              RiSurfaceV(quickShader, n, tokens, parms);
  278.              break;
  279.  
  280.           case SLO_TYPE_LIGHT:
  281.             if (!token)
  282.             {  RiCreateHandle(token, RI_LIGHTSOURCE);
  283.          }
  284.             if (pointOrArea)
  285.             {  lightHandle = RiAreaLightSourceV(token, quickShader, n, tokens, parms);
  286.             }
  287.             else
  288.             {  lightHandle = RiLightSourceV(token, quickShader, n, tokens, parms);
  289.             }
  290.             break;
  291.  
  292.           default:
  293.             break;
  294.         }
  295.      }
  296.   }
  297.   else
  298.   {  
  299.      [super set];
  300.   }
  301.  
  302.   return self;
  303. }
  304.  
  305. // WWRenderable
  306.  
  307. - (BOOL)hasBoundingBox  { return NO; }
  308. - calculateBoundingBoxStartingAt:(RtFloat)shutterOpenTime endingAt:(RtFloat)shutterCloseTime  { return self; }
  309.  
  310. - renderMaps:(WW3DCamera *)camera startingAt:(RtFloat)shutterOpenTime endingAt:(RtFloat)shutterCloseTime usingStream:(NXStream *)ns
  311. {
  312.   return self;
  313. }
  314. - renderMaps:(WW3DCamera *)camera usingStream:(NXStream *)ns
  315. {
  316.   return self;
  317. }
  318.  
  319. - renderMaps:(WW3DCamera *)camera startingAt:(RtFloat)shutterOpenTime endingAt:(RtFloat)shutterCloseTime 
  320. {
  321.   return self;
  322. }
  323. - renderMaps:(WW3DCamera *)camera
  324. {
  325.   return self;
  326. }
  327.  
  328. - setAtmosphere { volumeType = WW_ATMOSPHERE; return self; }
  329. - setInterior { volumeType = WW_INTERIOR; return self; }
  330. - setExterior { volumeType = WW_EXTERIOR; return self; }
  331. - setPointSource { pointOrArea = 0; return self; }
  332. - setAreaSource { pointOrArea = 1; return self; }
  333.  
  334. - renderSelfAsBox:(WW3DCamera *)camera startingAt:(RtFloat)shutterOpenTime endingAt:(RtFloat)shutterCloseTime 
  335. { return [self renderSelf:camera startingAt:shutterOpenTime endingAt:shutterCloseTime];
  336. } 
  337.  
  338. - renderSelf:(WW3DCamera *)camera startingAt:(RtFloat)shutterOpenTime endingAt:(RtFloat)shutterCloseTime 
  339. {
  340.   switch ([self shaderType])
  341.   {  
  342.      case SLO_TYPE_SURFACE:
  343.        RiSurfaceV((char *)[self shader], n, tokens, parms);
  344.        break;
  345.  
  346.      case SLO_TYPE_LIGHT:
  347.        if (!token) {  RiCreateHandle(token, RI_LIGHTSOURCE); } 
  348.        if (pointOrArea)
  349.        {  lightHandle = RiAreaLightSourceV(token, (char *)[self shader], n, tokens, parms);
  350.        }
  351.        else
  352.        {  lightHandle = RiLightSourceV(token, (char *)[self shader], n, tokens, parms);
  353.        }
  354.        break;
  355.  
  356.      case SLO_TYPE_DISPLACEMENT:
  357.        RiDisplacementV((char *)[self shader], n, tokens, parms);
  358.        break;
  359.  
  360.      case SLO_TYPE_VOLUME:
  361.        switch (volumeType)
  362.        {  case WW_ATMOSPHERE:  RiAtmosphereV((char *)[self shader], n, tokens, parms);
  363.                                break;
  364.           case WW_INTERIOR:    RiInteriorV((char *)[self shader], n, tokens, parms);
  365.                                break;
  366.           case WW_EXTERIOR:    RiExteriorV((char *)[self shader], n, tokens, parms);
  367.                                break;
  368.           default:             NXLogError("unknown volume shader %s!\n", (char *)[self shader]);
  369.        }
  370.        break;
  371.  
  372.      case SLO_TYPE_TRANSFORMATION:
  373.        NXLogError("warning: using RiDeformationV for Transformation shader %s...\n", [self shader]);
  374.        RiDeformationV((char *)[self shader], n, tokens, parms);
  375.        break;
  376.  
  377.      case SLO_TYPE_IMAGER:
  378.        RiImagerV((char *)[self shader], n, tokens, parms);
  379.        break;
  380.  
  381.      default:
  382.        return nil;
  383.   }
  384.   return self;
  385. }
  386.  
  387. - renderSelf:(WW3DCamera *)camera
  388. {
  389.   RtFloat  shutterOpenTime = [camera shutterOpenTime],
  390.            shutterCloseTime = [camera shutterCloseTime];
  391.  
  392.  
  393.   return [self renderSelf:camera startingAt:shutterOpenTime endingAt:shutterCloseTime];
  394. }
  395.  
  396. // this is a tough one; should the shader prerender itself?  For some shaders, especially ones
  397. // that make holes in objects, the answer is probably yes, but for those that are merely complicated
  398. // texturers, they shouldn't.  Probably best to keep a flag around to decide...
  399. // for now, just render
  400. - preRenderSelf:(WW3DCamera *)camera startingAt:(RtFloat)shutterOpenTime endingAt:(RtFloat)shutterCloseTime 
  401. {
  402.   return [self renderSelf:camera startingAt:shutterOpenTime endingAt:shutterCloseTime];
  403. }
  404.  
  405. - preRenderSelf:(WW3DCamera *)camera 
  406. {
  407.   return [self renderSelf:camera];
  408. }
  409.  
  410. - transformCTM:(WW3DAttributeState *)attributeState startingAt:(RtFloat)shutterOpenTime endingAt:(RtFloat)shutterCloseTime { return self; }
  411.  
  412. - setBoundingBox:(RtBound *)newBoundingBox { return nil; }
  413. - (RtBound *)boundingBoxStartingAt:(RtFloat)shutterOpenTime endingAt:(RtFloat)shutterCloseTime { return (RtBound *)NULL; };
  414.  
  415. - (void)setN:(int)newN tokens:(RtToken *)newTokens parms:(RtPointer *)newParms archiveVector:(char **)newArchiveVector printfTypeVector:(int *)newPrintfTypeVector printfNVector:(int *)newPrintfNVector
  416. {  
  417.    int  i;
  418.  
  419.  
  420.    if (n)
  421.    {  for (i = 0; i < n; i++)
  422.       {  // don't free the tokens; they're shared!
  423.          free(parms[i]);
  424.          free(archiveVector[i]);
  425.          free(printfNVector);
  426.          free(printfTypeVector);
  427.       }
  428.       if (newN > n)
  429.       {  tokens = (RtToken *)NXZoneRealloc([self zone], tokens, (newN * sizeof(RtToken)));
  430.          parms = (RtPointer *)NXZoneRealloc([self zone], parms, (newN * sizeof(RtPointer)));
  431.          archiveVector = (char **)NXZoneRealloc([self zone], archiveVector, (newN * sizeof(archiveVector)));
  432.          printfNVector = (int *)NXZoneRealloc([self zone], printfNVector, (newN * sizeof(int)));
  433.          printfTypeVector = (int *)NXZoneRealloc([self zone], printfTypeVector, (newN * sizeof(int)));
  434.       }
  435.    }
  436.    else
  437.    {  tokens = (RtToken *)NXZoneMalloc([self zone], newN * sizeof(RtToken));
  438.       parms = (RtPointer *)NXZoneMalloc([self zone], newN * sizeof(RtPointer));
  439.       archiveVector = (char **)NXZoneMalloc([self zone], newN * sizeof(archiveVector));
  440.       printfNVector = (int *)NXZoneMalloc([self zone], newN * sizeof(int));
  441.       printfTypeVector = (int *)NXZoneMalloc([self zone], newN * sizeof(int));
  442.    }
  443.    n = newN;
  444.    for (i = 0; i < n; i++)
  445.    {  tokens[i] = newTokens[i];
  446.       parms[i] = newParms[i];
  447.       archiveVector[i] = newArchiveVector[i];
  448.       printfNVector[i] = newPrintfNVector[i];
  449.       printfTypeVector[i] = newPrintfTypeVector[i];
  450.    }
  451.  
  452.    return ;
  453. }
  454.  
  455. - (int)n { return n; }
  456. - (RtToken *)tokens { return tokens; }
  457. - (RtPointer *)parms { return parms; }
  458. - (char **)archiveVector { return archiveVector; }
  459. - (int *)printfNVector { return printfNVector; }
  460. - (int *)printfTypeVector { return printfTypeVector; }
  461.  
  462. // should make this lerpable, but later...
  463. - (BOOL)isLerpable { return YES; }
  464.  
  465. // this should only be called internally
  466. // the receiving object needs to copy all the parameters using the passed in zone
  467. // the assumption is that 
  468. - _mallocPointersForN:(int)newN usingZone:(NXZone *)newZone
  469. {
  470.    n = newN;
  471.    if (n)
  472.    {  tokens = (RtToken *)NXZoneMalloc([self zone], n * sizeof(RtToken));
  473.       if (!tokens)
  474.       {  return nil;
  475.       }
  476.       parms = (RtPointer *)NXZoneMalloc([self zone], n * sizeof(RtPointer));
  477.       if (!parms)
  478.       {  NXZoneFree(newZone, tokens);
  479.          return nil;
  480.       }
  481.       archiveVector = (char **)NXZoneMalloc([self zone], n * sizeof(char *));
  482.       if (!archiveVector)
  483.       {  NXZoneFree(newZone, tokens);
  484.          NXZoneFree(newZone, parms);
  485.          return nil;
  486.       }
  487.       printfNVector = (int *)NXZoneMalloc([self zone], n * sizeof(int));
  488.       if (!printfNVector)
  489.       {  NXZoneFree(newZone, tokens);
  490.          NXZoneFree(newZone, parms);
  491.          NXZoneFree(newZone, archiveVector);
  492.          return nil;
  493.       }
  494.       printfTypeVector = (int *)NXZoneMalloc([self zone], n * sizeof(int));
  495.       if (!printfTypeVector)
  496.       {  NXZoneFree(newZone, tokens);
  497.          NXZoneFree(newZone, parms);
  498.          NXZoneFree(newZone, archiveVector);
  499.          NXZoneFree(newZone, printfNVector);
  500.          return nil;
  501.       }
  502.    }
  503.    else
  504.    {  // n == 0
  505.       tokens = (RtToken *)NULL;
  506.       parms = (RtPointer *)NULL;
  507.       archiveVector = (char **)NULL;
  508.       printfNVector = (int *)NULL;
  509.       printfTypeVector = (int *)NULL;
  510.    }
  511.    return self;
  512. }
  513.  
  514. - _setToken:(char *)newToken parm:(RtPointer)newParm i:(int)i archiveInfo:(char *)archiveInfo type:(int)parmType count:(int)howMany usingZone:(NXZone *)newZone
  515. {
  516.    int  j;
  517.  
  518.  
  519.    tokens[i] = (RtToken)NXZoneMalloc(newZone, (1 + strlen(newToken)));
  520.    if (!tokens[i])
  521.    {  return nil;
  522.    }
  523.    strcpy(tokens[i], newToken);
  524.  
  525.    archiveVector[i] = (char *)NXZoneMalloc(newZone, (1 + strlen(archiveInfo)));
  526.    if (!archiveVector[i])
  527.    {  NXZoneFree(newZone, tokens[i]);
  528.       return nil;
  529.    }
  530.    strcpy(archiveVector[i], archiveInfo);
  531.  
  532.    printfTypeVector[i] = parmType;
  533.    printfNVector[i] = howMany;
  534.  
  535.    // in a perfect world, I could just copy that chunk o memory over,
  536.    // but I'm worried about alignment problems, so I'll do it the slow way...
  537.    switch (printfTypeVector[i])
  538.    {  case WW_FLOAT:  parms[i] = (RtFloat *)NXZoneMalloc(newZone, sizeof(RtFloat) * howMany); 
  539.                       for (j = 0; j < printfNVector[i]; j++)
  540.               {  *((RtFloat *)parms[i] + j) = *((RtFloat *)(newParm) + j);
  541.               }
  542.                       break;
  543.       case WW_COLOR:  parms[i] = (RtFloat *)NXZoneMalloc(newZone, sizeof(RtFloat) * howMany); 
  544.                       for (j = 0; j < printfNVector[i]; j++)
  545.               {  *((RtFloat *)parms[i] + j) = *((RtFloat *)(newParm) + j);
  546.               }
  547.                       break;
  548.       case WW_POINT:  parms[i] = (RtFloat *)NXZoneMalloc(newZone, sizeof(RtFloat) * howMany); 
  549.                       for (j = 0; j < printfNVector[i]; j++)
  550.               {  *((RtFloat *)parms[i] + j) = *((RtFloat *)(newParm) + j);
  551.               }
  552.                       break;
  553.       case WW_INT:    parms[i] = (int *)NXZoneMalloc(newZone, sizeof(int) * howMany); 
  554.                       for (j = 0; j < printfNVector[i]; j++)
  555.               {  *((int *)parms[i] + j) = *((int *)(newParm) + j);
  556.               }
  557.                       break;
  558.       // hmm, strings are weirder.  
  559.       case WW_STRING: parms[i] = (char **)NXZoneMalloc(newZone, sizeof(char *) * howMany); 
  560.                       for (j = 0; j < printfNVector[i]; j++)
  561.               {  // need to additionally malloc up some memory here, folks
  562.                          *((char **)parms[i] + j) = (char *)NXZoneMalloc(newZone, (1 + strlen(*((char **)(newParm) + j))));
  563.                          strcpy(*((char **)parms[i] + j), *((char **)(newParm) + j));
  564.               }
  565.                       break;
  566.    }      
  567.    return self;
  568. }
  569.  
  570.  
  571.  - copyFromZone:(NXZone *)newZone
  572. {
  573.   int  i;
  574.   //id   newCopy = [super copyFromZone:newZone];
  575.   id   newCopy = [(WW3DShader *)[[WW3DShader alloc] init] setShader:[self shader]];
  576.  
  577.  
  578.   // now we need to grovel over the parameters and copy them 
  579.   // this is a pain, but boy, will it be cool...
  580.   // okay, malloc up the base list of pointers
  581.   [newCopy _mallocPointersForN:n usingZone:newZone];
  582.   [newCopy setToken:[self token]];
  583.  
  584.   for (i = 0; i < n; i++)
  585.   {  if (![newCopy _setToken:tokens[i] parm:parms[i] i:i 
  586.                        archiveInfo:archiveVector[i] type:printfTypeVector[i] count:printfNVector[i] 
  587.                        usingZone:newZone])
  588.      {  [newCopy free];
  589.         return nil;
  590.      }
  591.   }
  592.   
  593.   return newCopy;
  594. }
  595.  
  596. - _lerpParametersWith:b by:(float)u
  597. {
  598.   int        i, j;
  599.   RtToken    *tokensB;
  600.   char       **archiveVectorB;
  601.   int        *printfNVectorB;
  602.   int        *printfTypeVectorB;
  603.   RtPointer  *parmsB;
  604.  
  605.  
  606.   // okay, first thing to realize is that this instance already has its 
  607.   // parameters set to the (u ==0) case here.  Therefore, when in doubt, 
  608.   // you can leave it alone and you're fine.  We now want to grovel 
  609.   // over the two objects' parameters.  
  610.   if (n != [b n])
  611.   { // hmm.  looks like trouble.  At some point, we'll have to bail,
  612.     // since the parameter lists aren't the same length.  we could
  613.     // bail right away, since we know that "self"'s parameters are set
  614.     // to something reasonable...  Yea, let's bail.
  615.     return self;
  616.   }
  617.  
  618.   tokensB = [b tokens];
  619.   archiveVectorB = [b archiveVector];
  620.   printfNVectorB = [b printfNVector];
  621.   printfTypeVectorB = [b printfTypeVector];
  622.   parmsB = [b parms];
  623.  
  624.   // okay, at this point, we know that these two objects are the same 
  625.   // class, and the length of their parameter lists are the same. Of
  626.   // course, this might be just a lucky coincidence, and the actual 
  627.   // parameters might be different types.  
  628.  
  629.   for (i = 0; i < n; i++)
  630.   {  if ((tokens[i] == tokensB[i]) || (!strcmp(tokens[i], tokensB[i])))
  631.      {  // great! they're the same token.
  632.         // now we need to make sure they're the same type and length of data
  633.         // if not, bail to the next parameter
  634.         if ((printfNVector[i] == printfNVectorB[i]) && (printfTypeVector[i] == printfTypeVectorB[i]))
  635.     {  // okay! we're golden. Let's do a lerp...
  636.            switch (printfTypeVector[i])
  637.            {  case WW_FLOAT:   for (j = 0; j < printfNVector[i]; j++)
  638.                        {  *((RtFloat *)parms[i] + j) += ((*((RtFloat *)(parmsB[i]) + j) - *((RtFloat *)parms[i] + j)) * u);
  639.                        }
  640.                                break;
  641.               case WW_COLOR:   for (j = 0; j < printfNVector[i]; j++)
  642.                        {  *((RtFloat *)parms[i] + j) += ((*((RtFloat *)(parmsB[i]) + j) - *((RtFloat *)parms[i] + j)) * u);
  643.                        }
  644.                                break;
  645.               case WW_POINT:   for (j = 0; j < printfNVector[i]; j++)
  646.                        {  *((RtFloat *)parms[i] + j) += ((*((RtFloat *)(parmsB[i]) + j) - *((RtFloat *)parms[i] + j)) * u);
  647.                        }
  648.                                break;
  649.               case WW_INT:     for (j = 0; j < printfNVector[i]; j++)
  650.                        {  *((int *)parms[i] + j) += ((*((int *)(parmsB[i]) + j) - *((int *)parms[i] + j)) * u);
  651.                    }
  652.                                break;
  653.               case WW_STRING:  // can't lerp strings without more info...
  654.                                // maybe could encode a way to do it with enumerated values, but for now, bail...
  655.                                break;
  656.            }
  657.         }
  658.         else
  659.         {  // okay, that parameter can't be lerp'ed; on to the next
  660.         }
  661.      }
  662.      else
  663.      {  // okay, that parameter can't be lerp'ed; on to the next
  664.      }
  665.   }
  666.  
  667.   // all right, we've lerped our parameters, now we need to "install" them in the shader...
  668.   for (i = 0; i < n; i++)
  669.   {  if (![self setShaderArgNamed:tokens[i] withValue:parms[i]])
  670.      {  NXLogError("in shader %s, <%s> is not a valid arg.\n", 
  671.            [self shader], tokens[i]);
  672.      }
  673.   }
  674.  
  675.   return self;
  676. }
  677.  
  678.  
  679. // note: because we've made the WWSampleList "safe" for having
  680. // multiple samples with the same data, it's perfectly valid to return
  681. // yourself or b
  682. - lerpWith:b by:(float)uValue
  683. {
  684.    id  newMe = nil;
  685.  
  686.  
  687.    if (([self class] != [b class]) || (uValue <= 0.0) || (![self shader]) || (![b shader]) || (strcmp([self shader], [b shader]))) 
  688.    {  return self;
  689.    }
  690.  
  691.    if (uValue >= 1.0)
  692.    {  return b;
  693.    }
  694.  
  695.    newMe = [self copyFromZone:[self zone]];
  696.  
  697.    // okay, now we have to get newMe to linearly interpolate it
  698.    // parameters partway between "self" and "b"
  699.    [newMe _lerpParametersWith:b by:uValue];
  700.  
  701.    return newMe;
  702. }
  703.  
  704. - lerpSelfWith:b by:(float)uValue
  705. {
  706.    if (([self class] != [b class]) || (uValue <= 0.0) || (![self shader]) || (![b shader]) || (strcmp([self shader], [b shader])))
  707.    {  return self;
  708.    }
  709.  
  710.    if (uValue >= 1.0)
  711.    {  return b;
  712.    }
  713.  
  714.    // okay, now we have to get newMe to linearly interpolate it
  715.    // parameters partway between "self" and "b"
  716.    [self _lerpParametersWith:b by:uValue];
  717.  
  718.    return self;
  719. }
  720.  
  721.  
  722. // in 3.4, shaders aren't motion blurrable
  723. - (BOOL)isMotionBlurrable { return NO; }
  724. - (BOOL)isCompoundCommand { return NO; }
  725.  
  726. // stuff for 3DReality, as well as general UI expansion
  727.  
  728. - setIconImage:image  {  iconImage = image; return self; }
  729.  
  730. - setIconImageNamed:(const char *)name
  731. {  // It's actually a bad idea to free this image, because it might be shared...
  732.    if (name && *name)
  733.    { iconImage = [NXImage findImageNamed:name];
  734.      if (!iconImage) 
  735.      {  iconImage = [[NXImage alloc] init];
  736.         // [iconImage setDataRetained:YES];
  737.         if (![iconImage loadFromFile:name])
  738.         {  NXLogError("unable to load image from file <%s>\n", name);
  739.            return nil; 
  740.      }
  741.      }    
  742.    }
  743.    return self;
  744. }
  745.  
  746. - iconImage { return iconImage; }
  747.  
  748.  
  749. // target/action messages
  750. - takeColorArg:sender
  751. {
  752.   [self setShaderArg:[sender shaderArgName] colorValue:[sender color]];
  753.   return self;
  754. } 
  755.  
  756. - takeFloatArg:sender
  757. {
  758.   [self setShaderArg:[sender shaderArgName] floatValue:[sender floatValue]];
  759.   return self;
  760. } 
  761.  
  762. - takePointArg:sender
  763. {
  764.   RtPoint  aPoint;
  765.  
  766.   N3D_XComp(aPoint) = [[sender cellAt:0 :0] floatValue];
  767.   N3D_YComp(aPoint) = [[sender cellAt:0 :1] floatValue];
  768.   N3D_ZComp(aPoint) = [[sender cellAt:0 :2] floatValue];
  769.   [self setShaderArg:[sender shaderArgName] pointValue:aPoint];
  770.   return self;
  771. } 
  772.  
  773. - takeStringArg:sender
  774. {
  775.   [self setShaderArg:[sender shaderArgName] stringValue:[sender stringValue]];
  776.   return self;
  777. } 
  778.  
  779.  
  780. // WavesWorld archiving:
  781. // writeEve:(NXStream *)stream
  782. // writeScene:(NXStream *)stream
  783.  
  784. // this is a routine for subclasses to call when archiving themselves to an eve file or a scene...
  785. - writeParameterList:(NXStream *)stream
  786. {
  787.   int  i, j;
  788.  
  789.   
  790.    if (!n)
  791.    {  NXPrintf(stream, ";");
  792.       return nil;
  793.    }
  794.    for (i = 0; i < n; i++)
  795.    {  NXPrintf(stream, "{%s} ", tokens[i]);
  796.       NXPrintf(stream, "{ ");
  797.       switch (printfTypeVector[i])
  798.       {  case WW_FLOAT:   for (j = 0; j < printfNVector[i]; j++)
  799.                       {  NXPrintf(stream, "%f ", *((RtFloat *)(parms[i]) + j));
  800.               }
  801.                           break;
  802.          case WW_COLOR:   for (j = 0; j < printfNVector[i]; j++)
  803.                        {  NXPrintf(stream, "%f ", *((RtFloat *)(parms[i]) + j));
  804.               }
  805.                           break;
  806.          case WW_POINT:   for (j = 0; j < printfNVector[i]; j++)
  807.                        {  NXPrintf(stream, "%f ", *((RtFloat *)(parms[i]) + j));
  808.               }
  809.                           break;
  810.          case WW_INT:     for (j = 0; j < printfNVector[i]; j++)
  811.                        {  NXPrintf(stream, "%d ", *((int *)(parms[i]) + j));
  812.               }
  813.                           break;
  814.          case WW_STRING:  for (j = 0; j < printfNVector[i]; j++)
  815.                        {  NXPrintf(stream, "{%s} ", *((char **)(parms[i]) + j));
  816.               }
  817.                           break;
  818.       }      
  819.       NXPrintf(stream, "} ");
  820.    }
  821.    NXPrintf(stream, ";");
  822.    return self;
  823. }
  824.  
  825. - writeEve:(NXStream *)stream atTabLevel:(int)tab
  826. {
  827.    int  i;
  828.  
  829.  
  830.    for (i = 0; i < tab; i++)
  831.    {  NXPrintf(stream, "\t");
  832.    }
  833.  
  834.    switch ([self shaderType])
  835.    {  
  836.      case SLO_TYPE_SURFACE:
  837.        NXPrintf(stream, "Surface %s ", shader); 
  838.        break;
  839.  
  840.      case SLO_TYPE_LIGHT:
  841.        if (!lightHandle)
  842.        {  lightHandleSeed++;
  843.           lightHandle = (char *)malloc(64);
  844.           sprintf(lightHandle, "%d", lightHandleSeed);
  845.        }
  846.        if (pointOrArea)
  847.        {  NXPrintf(stream, "AreaLightSource %s %s ", shader, lightHandle); 
  848.        }
  849.        else
  850.        {  NXPrintf(stream, "LightSource %s %s ", shader, lightHandle); 
  851.        }
  852.        break;
  853.  
  854.      case SLO_TYPE_DISPLACEMENT:
  855.        NXPrintf(stream, "Displacement %s ", shader); 
  856.        break;
  857.  
  858.      case SLO_TYPE_VOLUME:
  859.        switch (volumeType)
  860.        {  case WW_ATMOSPHERE:  NXPrintf(stream, "Atmosphere %s ", shader); 
  861.                                break;
  862.           case WW_INTERIOR:    NXPrintf(stream, "Interior %s ", shader); 
  863.                                break;
  864.           case WW_EXTERIOR:    NXPrintf(stream, "Exterior %s ", shader); 
  865.                                break;
  866.           default:             NXLogError("# unknown volume shader %s ", (char *)[self shader]);
  867.        }
  868.        
  869.        break;
  870.  
  871.      case SLO_TYPE_TRANSFORMATION:
  872.        NXPrintf(stream, "Deformation %s ", shader); 
  873.        break;
  874.  
  875.      case SLO_TYPE_IMAGER:
  876.        NXPrintf(stream, "Imager %s ", shader); 
  877.        break;
  878.  
  879.      default:
  880.        NXPrintf(stream, "# unknown shader %s ", shader); 
  881.        return nil;
  882.    }
  883.   
  884.    [self writeParameterList:stream];
  885.  
  886.    return self;
  887. }
  888.  
  889. - writeScene:(NXStream *)stream atTabLevel:(int)tab
  890. {
  891.    return [self writeEve:stream atTabLevel:tab];
  892. }
  893.  
  894. - write3DTextScene:(NXStream *)stream atTabLevel:(int)tab index:(int)index time:(float)time until:(float)lastTime
  895. {
  896.    int  i;
  897.  
  898.  
  899.    for (i = 0; i < tab; i++)
  900.    {  NXPrintf(stream, "\t");
  901.    }
  902.  
  903.    NXPrintf(stream, "startShape %s; ", [[self class] name]);
  904.    // need tab
  905.    // need index (position in current list)
  906.    NXPrintf(stream, 
  907.         "EveCmd {Translate [expr { %d * $__text__(tabLength)}] [expr {$__text__(spacingFactor) * %d * $__text__(spacing) * $__text__(fontSize)}] 0 };\n", 
  908.             tab, index); 
  909.    NXPrintf(stream, "  EveCmd {WW3DText $__text__(fontName) $__text__(fontSize) {");
  910.    [self writeEve:stream atTabLevel:tab];
  911.    NXPrintf(stream, "} left;}\n");
  912.   NXPrintf(stream, "endShape;\n");
  913.  
  914.   return self;
  915. }
  916.  
  917.  
  918. - writeInventorAtTime:(float)currentTime to:(NXStream *)stream atTabLevel:(int)tab
  919. {
  920.    int  i;
  921.  
  922.  
  923.   for (i = 0; i < tab; i++)
  924.    {  NXPrintf(stream, "\t");
  925.    }
  926.    NXPrintf(stream, "# WW3DShader %s called;", [self shader]); 
  927.    return self;
  928.  
  929. }
  930.  
  931. // NeXTSTEP archiving:
  932.  
  933. #define typeVectorVersion1 "i"
  934. #define typeValuesVersion1 &n
  935.  
  936. #define typeVector "i@"
  937. #define typeValues &n, &iconImage
  938.  
  939. - read:(NXTypedStream*)stream 
  940. {
  941.   int version, i;
  942.  
  943.  
  944.   [super read:stream];
  945.  
  946.   version = NXTypedStreamClassVersion(stream,"WW3DShader");
  947.   if (version == 0) NXReadTypes(stream,"i",&version), version=1;
  948.   if (version == 1)
  949.   {  NXReadTypes(stream, typeVectorVersion1, typeValuesVersion1);
  950.      tokens = (char **)NXZoneMalloc([self zone], (sizeof(char *) * n));
  951.      archiveVector = (char **)NXZoneMalloc([self zone], (sizeof(char *) * n));
  952.      parms = (RtPointer *)NXZoneMalloc([self zone], (sizeof(char *) * n));
  953.      for (i = 0; i < n; i++)
  954.      {  NXReadTypes(stream, "**", &(tokens[i]), &(archiveVector[i]));
  955.     NXReadTypes(stream, archiveVector[i], &(parms[i]));
  956.      }
  957.   } 
  958.   if (version == 2)
  959.   {  NXReadTypes(stream, typeVector, typeValues);
  960.      tokens = (char **)NXZoneMalloc([self zone], (sizeof(char *) * n));
  961.      archiveVector = (char **)NXZoneMalloc([self zone], (sizeof(char *) * n));
  962.      parms = (RtPointer *)NXZoneMalloc([self zone], (sizeof(char *) * n));
  963.      for (i = 0; i < n; i++)
  964.      {  NXReadTypes(stream, "**", &(tokens[i]), &(archiveVector[i]));
  965.     NXReadTypes(stream, archiveVector[i], &(parms[i]));
  966.      }
  967.   } 
  968.   if (version == 3)
  969.   {  NXReadTypes(stream, typeVector, typeValues);
  970.      tokens = (char **)NXZoneMalloc([self zone], (sizeof(char *) * n));
  971.      archiveVector = (char **)NXZoneMalloc([self zone], (sizeof(char *) * n));
  972.      parms = (RtPointer *)NXZoneMalloc([self zone], (sizeof(char *) * n));
  973.      for (i = 0; i < n; i++)
  974.      {  NXReadTypes(stream, "**", &(tokens[i]), &(archiveVector[i]));
  975.     NXReadTypes(stream, archiveVector[i], &(parms[i]));
  976.      }
  977.      NXReadTypes(stream, "*ic", &quickShader, &lightHandle, &usingSupportedQRManShader);
  978.      NXReadArray(stream, "f", 3, ribColor);
  979.   } 
  980.   if (version == 4)
  981.   {  NXReadTypes(stream, typeVector, typeValues);
  982.      tokens = (char **)NXZoneMalloc([self zone], (sizeof(char *) * n));
  983.      archiveVector = (char **)NXZoneMalloc([self zone], (sizeof(char *) * n));
  984.      parms = (RtPointer *)NXZoneMalloc([self zone], (sizeof(char *) * n));
  985.      for (i = 0; i < n; i++)
  986.      {  NXReadTypes(stream, "**", &(tokens[i]), &(archiveVector[i]));
  987.     NXReadTypes(stream, archiveVector[i], &(parms[i]));
  988.      }
  989.      NXReadTypes(stream, "*ic", &quickShader, &lightHandle, &usingSupportedQRManShader);
  990.      NXReadArray(stream, "f", 3, ribColor);
  991.      NXReadTypes(stream, "ic", &volumeType, &pointOrArea);
  992.   } 
  993.  
  994.   return self; 
  995. }
  996.  
  997. - write:(NXTypedStream*)stream 
  998. {
  999.   int  i;
  1000.  
  1001.     
  1002.   [super write:stream];
  1003.  
  1004.   NXWriteTypes(stream,typeVector, typeValues);
  1005.   for (i = 0; i < n; i++)
  1006.   {  NXWriteTypes(stream, "**", &(tokens[i]), &(archiveVector[i]));
  1007.      NXWriteTypes(stream, archiveVector[i], &(parms[i]));
  1008.   }
  1009.   NXWriteTypes(stream, "*ic", &quickShader, &lightHandle, &usingSupportedQRManShader);
  1010.   NXWriteArray(stream, "f", 3, ribColor);
  1011.   NXWriteTypes(stream, "ic", &volumeType, &pointOrArea);
  1012.  
  1013.   return self;
  1014. }
  1015.  
  1016. // boy, this is dumb... This is to get around the stupid warnings from the compiler - ask wave for details
  1017. - class { return [super class]; }
  1018.  
  1019. - (float)lastSampleIsAt { return 0.0; }
  1020.  
  1021. - (BOOL)isMoot
  1022. {
  1023.   return NO;
  1024. }
  1025.  
  1026. - (BOOL)isMootStartingAt:(float)startTime endingAt:(float)endTime  {  return [self isMoot];  }
  1027.  
  1028. - (BOOL)theSameAs:otherRIBCommand
  1029. {
  1030.   return NO;
  1031. }
  1032.  
  1033. - (BOOL)similarTo:otherRIBCommand 
  1034. {
  1035.   if ([self class] != [otherRIBCommand class])
  1036.   {  return NO;
  1037.   }
  1038.   return YES;
  1039. }
  1040.  
  1041.  
  1042. //WAVE FIX ME!!!
  1043. - (unsigned long int)maxSampleBandwidth { return 100; }
  1044.  
  1045. @end
  1046.