home *** CD-ROM | disk | FTP | other *** search
/ Stone Design / Stone Design.iso / Stone_Friends / Wave / WavesWorld / Source / IBPalettes / WW3DKit / WWSampleComponentList.m < prev    next >
Encoding:
Text File  |  1995-03-25  |  9.7 KB  |  314 lines
  1.  
  2. #import "WWSampleComponentList.h"
  3. #import "Protocol_WWRenderable.h"
  4.  
  5. @implementation WWSampleComponentList
  6.  
  7. - init
  8. {
  9.   [super init];
  10.  
  11.   timestamp = -1.;
  12.   cachedSample = [[WWSample alloc] init];
  13.   // this isn't too smart, but to avoid surprises, you could...
  14.   //[cachedSample setFreeData:NO];
  15.  
  16.   cacheIsDirty = YES;
  17.  
  18.   return self;
  19.  
  20. }
  21.  
  22. - initCount:(unsigned)numSlots
  23. {
  24.   [super initCount:numSlots];
  25.  
  26.   timestamp = -1.;
  27.   cachedSample = [[WWSample alloc] init];
  28.   // this isn't too smart, but to avoid surprises, you could...
  29.   [cachedSample setFreeData:NO];
  30.   cacheIsDirty = YES;
  31.  
  32.   return self;
  33.  
  34. }
  35.  
  36. - awake
  37. {
  38.   [super awake];
  39.  
  40.   timestamp = -1.;
  41.   cachedSample = [[WWSample alloc] init];
  42.   cacheIsDirty = YES;
  43.  
  44.   return self;
  45.  
  46. }
  47.  
  48.  
  49. - free 
  50. { 
  51.    //NXLogError("WWSampleComponentList %p at time %f being free'ed\n", self, timestamp);
  52.    //NXLogError("WWSample freeing cachedSample %p\n", cachedSample);
  53.    [cachedSample free];
  54.    return [super free]; 
  55. }
  56.  
  57.  
  58. - addObject_:anObject { cacheIsDirty = TRUE; return [super addObject:anObject]; }
  59.  
  60. - setData:newData timestamp:(float)floatTime generator:(const char *)genName weight:(float)floatWeight
  61. {
  62.    WWSample    *newSample, *oldSample;
  63.    BOOL        notFound;
  64.    int         i, howMany;
  65.    const char  *previousGenerator;
  66.  
  67.  
  68.    // okay, so here's the deal.  Whenever we get sent this msg, we
  69.    // first check and see if we have any data, i.e. ([self count]).  If we
  70.    // don't, we malloc up a new WWSample using this info, stick it in our
  71.    // list, set our timestamp to be this, then set the contents of our cache 
  72.    // to new sample, mark the cache clean, and return.  Actually, we should be
  73.    // lazy about it and only compute the cache as necessary...
  74.  
  75.    if (![self count])
  76.    {  timestamp = floatTime;
  77.       newSample = [[[WWSample alloc] init] setData:newData timestamp:floatTime generator:genName weight:floatWeight];
  78.       [self addObject_:newSample];
  79.    }
  80.    else
  81.    {  // need to see if we already have a sample from this source
  82.       notFound = YES;
  83.       i = 0;
  84.       howMany = [self count];
  85.  
  86.       while (notFound && (i < howMany))
  87.       {  oldSample = [self objectAt:i];
  88.          previousGenerator = [oldSample generatorName];
  89.          if (!genName)
  90.          {  if (!previousGenerator) // they're both NULL; that's it; reuse the old sample
  91.             {  [oldSample setData:newData timestamp:floatTime generator:genName weight:floatWeight];
  92.                notFound = FALSE;
  93.         }
  94.             else  // genName is NULL but this sample's not; it's not it
  95.         {}
  96.      }
  97.          else // genName isn't NULL... 
  98.          {  if (previousGenerator) // they're both not NULL; check the strings
  99.             {  if (!strcmp(genName, previousGenerator))  // same generators; that's it
  100.                {  [oldSample setData:newData timestamp:floatTime generator:genName weight:floatWeight];
  101.                   notFound = FALSE;
  102.             }
  103.                else // nope, they're not the same...
  104.                {}
  105.         }
  106.             else  // genName is NULL but this sample's not; it's not it
  107.         {}
  108.      }
  109.          i++;
  110.       }
  111.       if (notFound)
  112.       {  newSample = [[[WWSample alloc] init] setData:newData timestamp:floatTime generator:genName weight:floatWeight];
  113.          [self addObject_:newSample];
  114.       }
  115.    }
  116.    cacheIsDirty = YES; 
  117.    return self;
  118. }
  119.  
  120.  
  121. - setFreeData:(BOOL)flag
  122. {
  123.    return self;
  124. }
  125.  
  126.  
  127. - (BOOL)freeData
  128. {
  129.    return YES;
  130. }
  131.  
  132.  
  133. - (const char *)generatorName { return (const char *)NULL; }
  134.  
  135.  
  136. - addObject:(id <WWSample>)anObject 
  137. { 
  138.   if ([anObject conformsTo:@protocol(WWSample)])
  139.   {  cacheIsDirty = TRUE; 
  140.      return [self setData:[anObject data] timestamp:[anObject timestamp] generator:[anObject generatorName] weight:[anObject weight]];
  141.   }
  142.   NXLogError("object %s doesn't conform to the WWSample protocol: can't add it to the WWSampleComponentList", [[anObject class] name]);
  143.   return nil;
  144. }
  145.  
  146.  
  147. - insertObject:anObject at:(unsigned)index { cacheIsDirty = TRUE; return [super insertObject:anObject at:(unsigned)index]; }
  148. - removeObjectAt:(unsigned)index { cacheIsDirty = TRUE; return [super removeObjectAt:(unsigned)index]; }
  149. - removeLastObject { cacheIsDirty = TRUE; return [super removeLastObject]; }
  150. - replaceObjectAt:(unsigned)index with:newObject { cacheIsDirty = TRUE; return [super replaceObjectAt:(unsigned)index with:newObject]; }
  151. - appendList: (List *)otherList { cacheIsDirty = TRUE; return [super appendList: (List *)otherList]; }
  152. - addObjectIfAbsent:anObject { cacheIsDirty = TRUE; return [super addObjectIfAbsent:anObject]; }
  153. - removeObject:anObject  { cacheIsDirty = TRUE; return [super removeObject:anObject]; }
  154. - replaceObject:anObject with:newObject  { cacheIsDirty = TRUE; return [super replaceObject:anObject with:newObject]; }
  155. - empty  { cacheIsDirty = TRUE; timestamp = -1; return [super empty]; }
  156.  
  157. - fillCache
  158. {
  159.    int            i = 1, 
  160.                   howMany = [self count];
  161.    float          u, weightThusFar;
  162.    id <WWSample>  b = nil, 
  163.                   newData = nil;
  164.  
  165.  
  166.    if (cacheIsDirty)
  167.    {  // yow.  time to fill dat der cache...
  168.       
  169.       if (timestamp == -1)
  170.       {  // yow.  never set my timestamp
  171.          timestamp = [[self objectAt:0] timestamp];
  172.       }
  173.  
  174.       // okay, let's say we have 3 samples, the first two with weights
  175.       // of 1, and the third has a weight of 2
  176.       // a == .2, b == 3; c == 1
  177.       // so we want d = ((.2 * 1) + (3 * 1) + (1 * 2))/(1 + 1 + 2) == (.2 + 3 + 2)/4 == 5.2/4
  178.  
  179.       // can we recreate this incrementally 
  180.       // d1 = lerp between a and b
  181.       // hmm... let's take a simpler example: 1 4 4; 9/3; 3
  182.       // lerp the first two; .5 between
  183.       // lerp the result and the next; .333 
  184.  
  185.       // hmm... let's take a simpler example: 1 4 4 7; 16/4; 4
  186.       // lerp the first two; .5 between (2.5)
  187.       // lerp the result and the next; .333 ((2.5 + (1.5/3)) == 3)
  188.       // lerp the result and the next; .25 ((3 + (4/4)) == 4)
  189.  
  190.  
  191.       // copy the first element to the cache
  192.       newData = [[(WWSample *)[self objectAt:0] data] copy];
  193.       [cachedSample setData:newData timestamp:timestamp generator:"cache" weight:1.0];
  194.       weightThusFar = [[self objectAt:0] weight];
  195.       while (i < howMany)
  196.       {  b = [self objectAt:i];
  197.          //u = (1./(float)(i+1)) * ([b weight]/(weightThusFar/i));
  198.  
  199.          u = 1./((float)(i+1));  // this version of calculating u ignores weights
  200.          [[cachedSample data] lerpSelfWith:[b data] by:u];
  201.          weightThusFar += [b weight];
  202.          i++;
  203.       }
  204.    }
  205.    cacheIsDirty = NO;
  206.  
  207.    return self;
  208. }
  209.  
  210.  
  211. - (float)timestamp {  [self fillCache];  return timestamp; }
  212.  
  213. - sample  {  [self fillCache];  return cachedSample; }
  214.  
  215.  
  216. - data  {  [self fillCache];  return [cachedSample data]; }
  217.  
  218.  
  219. - setWeight:(float)newWeight  {  return self;  }
  220.  
  221.  
  222. - (float)weight  { return 1.0;  }
  223.  
  224. - (int)generatorCount { return [self count]; }
  225.  
  226. - writeEve:(NXStream *)stream atTabLevel:(int)tab
  227. {
  228.    int   howMany = [self count], 
  229.          i, j = 0;
  230.  
  231.  
  232.    //for (i = 0; i < tab; i++)
  233.    //{  NXPrintf(stream, "\t");
  234.    //}
  235.  
  236.    if (howMany)
  237.    {  if (howMany > 1)
  238.       {  [(id <WWRenderable>)[self objectAt:0] writeEve:stream atTabLevel:0];
  239.          NXPrintf(stream, " \\\n");
  240.          for (j = 1; j < (howMany-1); j++)
  241.          {  for (i = 0; i < tab; i++)
  242.             {  NXPrintf(stream, "\t");
  243.             }
  244.             for (i = 0; i < 33; i++) // magic numbers are evil, wave!!
  245.             {  NXPrintf(stream, " ");
  246.             }
  247.             [(id <WWRenderable>)[self objectAt:j] writeEve:stream atTabLevel:0];
  248.             NXPrintf(stream, " \\\n");
  249.          }
  250.          for (i = 0; i < tab; i++)
  251.          {  NXPrintf(stream, "\t");
  252.          }
  253.          for (i = 0; i < 33; i++) // magic numbers are evil, wave!!
  254.          {  NXPrintf(stream, " ");
  255.          }
  256.       }
  257.       [(id <WWRenderable>)[self objectAt:j] writeEve:stream atTabLevel:0];
  258.    }
  259.  
  260.    return self;
  261. }
  262.  
  263. - write3DTextScene:(NXStream *)stream atTabLevel:(int)tab index:(int)index time:(float)time until:(float)lastTime
  264. {
  265.    int   howMany = [self count], 
  266.          i;
  267.  
  268.  
  269.    for (i = 0; i < tab; i++)
  270.    {  NXPrintf(stream, "\t");
  271.    }
  272.  
  273.    // should look like this:
  274.    // {$owner1 {$compiledSample1}} {$owner2 {$compiledSample1}} {$owner3 {$compiledSample3}}
  275.    // so we want to actually get our samples to give us this info directly, and so I shouldn't
  276.    // recurse down calling the same routine as this.  We need a new routine... actuallly, why
  277.    // not just get the sample to write its eve code into the stream...
  278.  
  279.  
  280.    NXPrintf(stream, "startShape %s; ", [[[self objectAt:i] class] name]);
  281.    // need tab
  282.    // need index (position in current list)
  283.    NXPrintf(stream, "set __text__(colorTime%f) {1 1 1};", time);
  284.    NXPrintf(stream, "set __text__(colorSurface%f) plastic;", time);
  285.    NXPrintf(stream, "animatable: {Color $__text__(colorTime%f) }; ", time); // to make animation easy
  286.    NXPrintf(stream, "animatable: {Surface $__text__(colorSurface%f)}; ", time); // to make animation easy
  287.  
  288.    NXPrintf(stream, 
  289.         "animatable: {Translate [expr { %d * $__text__(tabLength)}] ", tab);
  290.    NXPrintf(stream, 
  291.             "[expr {$__text__(spacingFactor) * %d * $__text__(spacing) * $__text__(fontSize)}] ", index);
  292.    NXPrintf(stream, 
  293.             "[expr {$__text__(sampleOffset) + ($__text__(timeFactor) * %f)}]};\n", time); 
  294.    NXPrintf(stream, "  animatable: {WW3DText $__text__(fontName) $__text__(fontSize) {");
  295.  
  296.  
  297.      for (i = 0; i < howMany; i++)
  298.      {  [(id <WWRenderable>)[self objectAt:i] writeEve:stream atTabLevel:tab];
  299.         // need to be moving stuff to the left here - no, since it's one string, it will be fine......
  300.      }
  301.    NXPrintf(stream, "} left;}\n");
  302.   NXPrintf(stream, "endShape;\n");
  303.  
  304.   return self;
  305. }
  306.  
  307.  
  308.  
  309. // boy, this is dumb... This is to get around the stupid warnings from the compiler - ask wave for details
  310. - class { return [super class]; }
  311. - (BOOL) conformsTo: (Protocol *)aProtocolObject { return [super conformsTo:aProtocolObject]; }
  312.  
  313. @end
  314.