home *** CD-ROM | disk | FTP | other *** search
/ Stone Design / Stone Design.iso / Stone_Friends / Wave / WavesWorld / Source / IBPalettes / WW3DKit / WW3DVideoHack.m < prev    next >
Encoding:
Text File  |  1995-03-22  |  7.0 KB  |  288 lines
  1. // This compound command was inspired by the cool hack Steve Drucker
  2. // used in his PhD system to take some small (usually 8 or 16) views of a
  3. // "real" object and map it into a 3D virtual environment.  This
  4. // technique probably originates in flight simulators and/or video games,
  5. // but I'm stealing it from Steve, so that's who I'm crediting with the
  6. // idea...
  7.  
  8. // The 
  9.  
  10.  
  11. // WW3DVideoHack {list of texture files} width height
  12.  
  13. // The difficulty here is that I need to determine at renderSelf: time
  14. // where I am in relation to the camera's view point.  If I can do that,
  15. // I'm golden.
  16.  
  17. // what I need to do is transform the vector (0, 0, 1) 
  18.  
  19.  
  20.  
  21. #import "WW3DVideoHack.h"
  22. #import "RIBTransformBegin.h"
  23. #import "RIBScale.h"
  24. #import "RIBSphere.h"
  25. #import "RIBTransformEnd.h"
  26. #import "WWSample.h"
  27. #import "WWEveParser.h"
  28.  
  29. @implementation WW3DVideoHack
  30.  
  31. + initialize { return [WW3DVideoHack setVersion:1], self; }
  32.  
  33. - init
  34. {
  35.   [super init];
  36.  
  37.   radius = 1.0;
  38.   zMin = -1.0;
  39.   zMax =  1.0;
  40.   xScale = yScale = zScale = 1.0;
  41.   ribCommandList  = [[RIBCommandList alloc] init];
  42.   dirtyBoundingBox = YES;
  43.   
  44.   return self;
  45. }
  46.  
  47.  
  48. - awake
  49. {
  50.     [super awake];
  51.     dirtyBoundingBox = YES;
  52.     return self;
  53. }
  54.  
  55.  
  56. - setYScale:(RtFloat)newYScale
  57. {
  58.    yScale = newYScale;
  59.    xScale = zScale = 1./sqrt((double)yScale);
  60.    return self;
  61. }
  62.  
  63. - setRadius:(RtFloat)newRadius 
  64.      zMin:(RtFloat)newZMin zMax:(RtFloat)newZMax 
  65.      thetaMax:(RtFloat)newThetaMax yScale:(RtFloat)newYScale
  66.      n:(int)newN tokens:(RtToken *)newTokens parms:(RtPointer *)newParms archiveVector:(char **)newArchiveVector
  67.      printfTypeVector:(int *)newPrintfTypeVector printfNVector:(int *)newPrintfNVector
  68. {  
  69.    id  sphereObj;
  70.  
  71.  
  72.    radius = newRadius;
  73.    zMin = newZMin;
  74.    zMax = newZMax;
  75.    thetaMax = newThetaMax;
  76.    [self setYScale:newYScale];
  77.  
  78.    // I should make sure there is some non-whitespace text before I waste my time...
  79.    [ribCommandList empty];
  80.  
  81.    sphereObj = [[RIBSphere alloc] init]; 
  82.    [sphereObj setRadius:radius zMin:zMin zMax:zMax thetaMax:thetaMax
  83.                     n:newN tokens:newTokens parms:newParms archiveVector:newArchiveVector printfTypeVector:newPrintfTypeVector printfNVector:newPrintfNVector];
  84.    [sphereObj setMyShape:myShape];
  85.  
  86.    [ribCommandList insertObject:sphereObj at:0];
  87.    [ribCommandList insertObject:[[[[RIBScale alloc] init] setSX:xScale sy:yScale sz:zScale] setMyShape:myShape] at:0];
  88.    [ribCommandList insertObject:[[[RIBTransformBegin alloc] init] setMyShape:myShape] at:0];
  89.    [ribCommandList addObject:[[[RIBTransformEnd alloc] init] setMyShape:myShape]];
  90.  
  91.    dirtyBoundingBox = TRUE;
  92.   
  93.    return self;
  94. }
  95.  
  96. - setRadius:(RtFloat)newRadius { radius = newRadius; dirtyBoundingBox = TRUE; return self; }
  97. - setZMin:(RtFloat)newZMin { zMin = newZMin; dirtyBoundingBox = TRUE; return self; }
  98. - setZMax:(RtFloat)newZMax { zMax = newZMax; dirtyBoundingBox = TRUE; return self; }
  99.  
  100. - (RtFloat)radius { return radius; } 
  101. - (RtFloat)zMin { return zMin; }
  102. - (RtFloat)zMax { return zMax; }
  103.  
  104. - free
  105. {
  106.     [ribCommandList free];
  107.     return [super free];
  108. }
  109.  
  110. - (BOOL)hasBoundingBox        { return YES; }
  111. - (BOOL)isMotionBlurrable    { return YES; }
  112. - (BOOL)isCompoundCommand    { return YES; }
  113.  
  114. - setBoundingBox:(RtBound *)newBoundingBox
  115. {
  116.     N3D_CopyBound(*newBoundingBox, boundingBox);
  117.     return self;
  118. }
  119.  
  120. - calculateBoundingBoxStartingAt:(RtFloat)shutterOpenTime endingAt:(RtFloat)shutterCloseTime  
  121. {  
  122.     dirtyBoundingBox = NO;
  123.     [ribCommandList calculateBoundingBoxStartingAt:shutterOpenTime
  124.                     endingAt:shutterCloseTime];
  125.     return [self setBoundingBox:[ribCommandList boundingBox]];
  126. }
  127.  
  128. - (RtBound *)boundingBox 
  129. { 
  130.     if (dirtyBoundingBox) { 
  131.     [self calculateBoundingBoxStartingAt:[[myShape sceneClock] timestamp]
  132.               endingAt:[[myShape sceneClock] timestamp]];
  133.     }
  134.     return &boundingBox; 
  135. }
  136.  
  137. - (float)lastSampleIsAt { return 0.0; }
  138.  
  139. - (unsigned long int)maxSampleBandwidth { return [ribCommandList maxSampleBandwidth]; }
  140.  
  141. - setMyShape:shape
  142. {
  143.     myShape = shape;
  144.     return self;
  145. }
  146.  
  147. - shape
  148. {
  149.     return myShape;
  150. }
  151.  
  152. - renderMaps:(WW3DCamera *)camera
  153.     startingAt:(RtFloat)shutterOpenTime
  154.     endingAt:(RtFloat)shutterCloseTime usingStream:(NXStream *)ns
  155. {
  156.     return self;
  157. }
  158.  
  159. - renderMaps:(WW3DCamera *)camera usingStream:(NXStream *)ns
  160. {
  161.     return self;
  162. }
  163.  
  164. - renderMaps:(WW3DCamera *)camera
  165.     startingAt:(RtFloat)shutterOpenTime
  166.     endingAt:(RtFloat)shutterCloseTime
  167. {
  168.     return self;
  169. }
  170.  
  171. - renderMaps:(WW3DCamera *)camera
  172. {
  173.     return self;
  174. }
  175.  
  176. - renderSelf:(WW3DCamera *)camera
  177.     startingAt:(RtFloat)shutterOpenTime
  178.     endingAt:(RtFloat)shutterCloseTime
  179. {
  180.     return [ribCommandList renderSelf:camera
  181.                startingAt:shutterOpenTime
  182.                endingAt:shutterCloseTime];
  183. }
  184.  
  185. - renderSelf:(WW3DCamera *)camera
  186. {
  187.     return [ribCommandList renderSelf:camera];
  188. }
  189.  
  190. - preRenderSelf:(WW3DCamera *)camera
  191.     startingAt:(RtFloat)shutterOpenTime
  192.     endingAt:(RtFloat)shutterCloseTime
  193. {
  194.     return [ribCommandList preRenderSelf:camera
  195.                startingAt:shutterOpenTime
  196.                endingAt:shutterCloseTime];
  197. }
  198.  
  199. - preRenderSelf:(WW3DCamera *)camera
  200. {
  201.     return [ribCommandList preRenderSelf:camera];
  202. }
  203.  
  204. - transformCTM:(RtMatrix)aMatrix 
  205.     startingAt:(RtFloat)shutterOpenTime
  206.     endingAt:(RtFloat)shutterCloseTime 
  207. {
  208.     return [ribCommandList transformCTM:aMatrix
  209.                            startingAt:shutterOpenTime
  210.                endingAt:shutterCloseTime]; 
  211. }
  212.  
  213. // methods to make me look like a compound command:
  214. - (int)count {  return [ribCommandList count]; }
  215. - objectAt:(int)i {  return [ribCommandList objectAt:i]; }
  216.  
  217.  
  218. // WavesWorld archiving:
  219. // writeEve:(NXStream *)stream
  220. // writeScene:(NXStream *)stream
  221.  
  222. - writeEve:(NXStream *)stream atTabLevel:(int)tab
  223. {
  224.     int  i;
  225.     
  226.     for (i = 0; i < tab; i++) {
  227.     NXPrintf(stream, "\t");
  228.     }
  229.     NXPrintf(stream, "WW3DVideoHack %f %f %f %f", radius, zMin, zMax, thetaMax, yScale);
  230.     return self;
  231. }
  232.  
  233. - writeScene:(NXStream *)stream atTabLevel:(int)tab
  234. {
  235.     int  i;
  236.     
  237.     for (i = 0; i < tab; i++) {
  238.     NXPrintf(stream, "\t");
  239.     }
  240.     NXPrintf(stream, "WW3DVideoHack %f %f %f %f", radius, zMin, zMax, thetaMax, yScale);
  241.     return self;
  242. }
  243.  
  244. #define typeVector "ffff"
  245. #define typeValues &radius, &zMin, &zMax, &yScale
  246.  
  247. - read:(NXTypedStream *)stream 
  248. {
  249.     int version;
  250.     
  251.     [super read:stream];
  252.     version = NXTypedStreamClassVersion(stream,"WW3DVideoHack");
  253.     if (version == 0) NXReadTypes(stream, "i", &version), version = 1;
  254.     if (version == 1)
  255.     {  NXReadTypes(stream, typeVector, typeValues);
  256.        NXReadArray(stream, "f", 6, boundingBox);
  257.        myShape = NXReadObject(stream);
  258.        xScale = zScale = 1./sqrt((double)yScale);
  259.     }
  260.  
  261.     return self;
  262. }
  263.  
  264. - write:(NXTypedStream *)stream 
  265. {
  266.     [super write:stream];
  267.     NXWriteTypes(stream, typeVector, typeValues);
  268.     NXWriteArray(stream, "f", 6, boundingBox);
  269.     NXWriteObjectReference(stream, myShape);
  270.     return self;
  271. }
  272.  
  273. - (BOOL)theSameAs:otherRIBCommand
  274. {
  275.   // WAVE: really should try and return YES, but for now...
  276.   return NO;
  277. }
  278.  
  279. - (BOOL)isMoot
  280. {
  281.   return NO;
  282. }
  283.  
  284. // boy, this is dumb... This is to get around the stupid warnings from the compiler - ask wave for details
  285. - class { return [super class]; }
  286.  
  287. @end
  288.