home *** CD-ROM | disk | FTP | other *** search
/ Stone Design / Stone Design.iso / Stone_Friends / Wave / WavesWorld / Source / IBPalettes / WW3DKit / WWLightInspectorCamera.m < prev    next >
Encoding:
Text File  |  1995-03-22  |  13.3 KB  |  419 lines
  1. // copyright 1993 Michael B. Johnson; some portions copyright 1994, MIT
  2. // see COPYRIGHT for reuse legalities
  3. //
  4.  
  5.  
  6. /* this camera is intended to be used in conjunction with some other
  7. camera "sourceCamera" for controlling that camera's lights.  This
  8. camera has a notion of the "sceneShape", which is the world shape from
  9. the other camera.  It interrogates this shape for it's bounding box
  10. and uses it to draw a box where the shape is.  It draws this box (in
  11. wireframe) and then it draws a plane twice the size of the box in each
  12. of the three orthogonal axes.
  13. */
  14.  
  15. #import "WW3DLight.h"
  16. #import "WW3DShader.h"
  17. #import "WWLightInspectorCamera.h"
  18. #import "WWLightInspectorShape.h"
  19. #import "WWDADLightView.h"
  20.  
  21. @implementation WWLightInspectorCamera
  22.  
  23. + initialize { return [WWLightInspectorCamera setVersion:1], self; }
  24.  
  25. - initFrame:(const NXRect *)r 
  26. {
  27.    RtPoint  fromP = {5, 5, -10.0}, toP = {0, 0, 0};
  28.    id       aShape, secondLevelShape, thirdLevelShape;
  29.    const char  *WDRAG_PBTYPE[] = { NXAsciiPboardType, NULL};
  30.  
  31.  
  32.    [super initFrame:r];
  33.    [self registerForDraggedTypes:WDRAG_PBTYPE count:1];
  34.  
  35.    renderStyle = N3D_SmoothSolids;
  36.    movingRenderStyle = N3D_WireFrame;
  37.  
  38.    scaleUpFactor = 1.05;
  39.    scaleDownFactor = 0.95;
  40.    translateXFactor = 0.025;
  41.    translateYFactor = 0.025;
  42.    translateZFactor = 0.05;
  43.    epsilon = 4.0;
  44.    selectionWidthEpsilon = 8.0;
  45.    selectionHeightEpsilon = 8.0;
  46.    showSelectedShape = NO;
  47.    drawOriginForSelectedShape = NO;
  48.    
  49.    // setup 3D camera stuff
  50.    [self setEyeAt:fromP toward:toP roll:0.0];
  51.  
  52.   //[self setupDefaultLights];
  53.   // !!! need to get lights from sourceCamera
  54.   // here in init, though, we probably don't have any...
  55.  
  56.   // setup some initial global rendering state
  57.   // note that this fucks up the 3DWell - yikes!
  58.   //[self setSurfaceTypeForAll:renderStyle chooseHider:YES];    
  59.   lowRezTesselationVector[0] = lowRezTesselationVector[1] = 4.0;
  60.   tesselationVector[0] = tesselationVector[1] = 8.0;
  61.   //RiGeometricApproximation(RI_TESSELATION, RI_PARAMETRIC, tesselationVector, RI_NULL);
  62.  
  63.   // stick in a reasonable shader
  64.   theShader=[[WW3DShader alloc] init];
  65.   [theShader setUseColor:YES];
  66.   [theShader setColor:ribColor];
  67.   [(N3DShader *)theShader setShader:"plastic"];
  68.  
  69.   // stick in a reasonable reference shape
  70.   aShape = [[N3DShape alloc] init];
  71.   [aShape setShapeName:NXCopyStringBuffer("lightWorld")];
  72.   [[self setWorldShape:aShape] free]; // free the default world shape
  73.  
  74.   secondLevelShape = [[N3DShape alloc] init];
  75.   [[self worldShape] linkDescendant:secondLevelShape];
  76.   thirdLevelShape = [[WWLightInspectorShape alloc] init];
  77.   [aShape setShapeName:NXCopyStringBuffer("boundingBoxOfWellWorld")];
  78.   //[aShape calculateBoundingBox];
  79.   [secondLevelShape linkDescendant:thirdLevelShape];
  80.  
  81.   // now when we add lights as descendants of the worldShape, they
  82.   // will illuminate the bounding box of the well world...
  83.  
  84.   [self setSurfaceTypeForAll:N3D_SmoothSolids chooseHider:YES];
  85.  
  86.   theRotator = [[N3DRotator alloc] initWithCamera:self];
  87.   [theRotator setRotationAxis:N3D_AllAxes];
  88.   trackballAffects = WW_TRACKBALL_CAMERA;
  89.  
  90.   return self;
  91. }
  92.  
  93. // the receptor gets sent this message when the object is dragged into
  94. // the File window, and when it is unarchived from the nib file.
  95. - awake
  96. {
  97.   const char  *WDRAG_PBTYPE[] = { NXAsciiPboardType, NULL};
  98.  
  99.  
  100.   [super awake];
  101.   [self registerForDraggedTypes:WDRAG_PBTYPE count:1];
  102.  
  103.   // everything else has just been unarchived...
  104.  
  105.   theRotator = [[N3DRotator alloc] initWithCamera:self];
  106.   [theRotator setRotationAxis:N3D_AllAxes];
  107.   trackballAffects = WW_TRACKBALL_CAMERA;
  108.  
  109.   return self;
  110. }
  111.  
  112. - free
  113.  
  114. {
  115.   [self unregisterDraggedTypes];
  116.   return [super free];
  117. }
  118.  
  119.  
  120. /////////////////////// 
  121. // 3D stuff
  122. /////////////////////// 
  123. #define ACTIVEBUTTONMASK (NX_MOUSEUPMASK|NX_MOUSEDRAGGEDMASK|NX_ALTERNATEMASK|NX_CONTROLMASK|NX_COMMANDMASK)
  124. - mouseDown:(NXEvent *)theEvent
  125. {
  126.   int        oldMask;
  127.   //NXPoint    p, last, start;
  128.   //NXRect     visibleRect, oldRegion;
  129.   NXPoint    start;
  130.   RtPoint    myEyePoint, 
  131.              previousEyePoint, previousViewPoint;
  132.   float      previousRoll;
  133.  
  134.  
  135.   dMouse.x = 0.0;
  136.   dMouse.y = 0.0;
  137.  
  138.   // track the mouse until a mouseUp event occurs, updating the display
  139.   // as tracking happens.
  140.   [self lockFocus];
  141.   oldMask = [window addToEventMask:ACTIVEBUTTONMASK];
  142.   
  143.   // switch to the N3D_WireFrame surface type
  144.   [self setSurfaceTypeForAll:movingRenderStyle chooseHider:YES];    
  145.   RiGeometricApproximation(RI_TESSELATION, RI_PARAMETRIC, lowRezTesselationVector, RI_NULL);
  146.   
  147.   oldMouse = theEvent->location;
  148.   [self convertPoint:&oldMouse fromView:nil];
  149.   start = oldMouse;
  150.  
  151.   // when the alt key is depressed, we scale the worldShape up or down, depending on mouse movement.
  152.   // otherwise, we rotate the worldShape using the virtual trackball
  153.  
  154.   while (1)
  155.   { newMouse = theEvent->location;
  156.     [self convertPoint:&newMouse fromView:nil];
  157.     dMouse.x = newMouse.x - oldMouse.x;
  158.     dMouse.y = newMouse.y - oldMouse.y;
  159.     if (dMouse.x != 0.0 || dMouse.y != 0.0) 
  160.     {  if (theEvent->flags & NX_ALTERNATEMASK)
  161.        {  switch (trackballAffects)
  162.       {  case WW_TRACKBALL_WORLD_SHAPE:
  163.          [worldShape translate:0.0 :0.0 :(translateZFactor * dMouse.y)];
  164.          break;
  165.          case WW_TRACKBALL_CAMERA:
  166.          // need to change Eye point
  167.          [self moveEyeBy:0.0 :0.0 :(-1. * (translateZFactor * dMouse.y))];
  168.          break;
  169.       }
  170.        }
  171.        else
  172.        {  
  173.          if (theEvent->flags & NX_COMMANDMASK)
  174.              {  switch (trackballAffects)
  175.           {  case WW_TRACKBALL_WORLD_SHAPE:
  176.             [worldShape translate:(translateXFactor * dMouse.x) 
  177.                                          :(translateYFactor * dMouse.y) :0.0];
  178.             break;
  179.               case WW_TRACKBALL_CAMERA:
  180.                     [self moveEyeBy:(-1. * (translateXFactor * dMouse.x)) 
  181.                              :(-1. * (translateYFactor * dMouse.y)) :0.0];
  182.             break;
  183.             }
  184.          }
  185.              else
  186.              {  [theRotator trackMouseFrom:&oldMouse to:&newMouse rotationMatrix:rmat andInverse:irmat];
  187.                 switch (trackballAffects)
  188.         {  case WW_TRACKBALL_WORLD_SHAPE:
  189.                [worldShape concatTransformMatrix:rmat premultiply:YES];
  190.                        break;
  191.            case WW_TRACKBALL_CAMERA:
  192.                [self getEyeAt:&previousEyePoint toward:&previousViewPoint roll:&previousRoll];   
  193.                        myEyePoint[0] = previousEyePoint[0] + (-1. * (translateXFactor * dMouse.x)); 
  194.                        myEyePoint[1] = previousEyePoint[1] + (-1. * (translateYFactor * dMouse.y)); 
  195.                        myEyePoint[2] = previousEyePoint[2];
  196.                [self setEyeAt:myEyePoint toward:previousViewPoint roll:previousRoll];   
  197.  
  198.                        break;
  199.         }
  200.          } 
  201.        }
  202.        [self display];
  203.        NXPing();
  204.     }
  205.     theEvent = [NXApp getNextEvent:ACTIVEBUTTONMASK];
  206.     if (theEvent->type == NX_MOUSEUP)
  207.     {  break;
  208.     }
  209.     else
  210.     {  oldMouse = newMouse;
  211.     }
  212.   }
  213.  
  214.   // check to see if we should go off and render (need a minimum image size, like 16x16)...
  215.  
  216.   [self setSurfaceTypeForAll:renderStyle chooseHider:YES];    
  217.   RiGeometricApproximation(RI_TESSELATION, RI_PARAMETRIC, tesselationVector, RI_NULL);
  218.  
  219.   [self display];
  220.   [self unlockFocus];
  221.   [window setEventMask:oldMask];
  222.   [window flushWindow];
  223.  
  224.   return self;
  225. }
  226.  
  227. - (BOOL)acceptsFirstResponder { return YES; }
  228.  
  229. - (BOOL)acceptsFirstMouse { return YES; }
  230.  
  231. - (int)trackballAffects { return trackballAffects; }
  232. - takeTrackballAffectsFromMatrix:sender
  233. {
  234.   int  newVal = [[sender selectedCell] tag];
  235.  
  236.  
  237.   switch (newVal)
  238.   {  case WW_TRACKBALL_WORLD_SHAPE:
  239.      trackballAffects = newVal;
  240.          [self setUsePreTransformMatrix:NO];
  241.      break;
  242.      case WW_TRACKBALL_CAMERA:
  243.      // we assume that [self usesPreTransformMatrix] returns YES...
  244.      trackballAffects = newVal;
  245.          [self setUsePreTransformMatrix:YES];
  246.       break;
  247.      default:
  248.      NXLogError("%d is an invalid value for trackballAffects.\n", newVal);
  249.      } 
  250.  
  251.  
  252.   return self;
  253. }
  254.  
  255. - (int)trackballXYZ 
  256. { 
  257.   N3DAxis  theAxis  = [theRotator rotationAxis];
  258.   int      theAxisInt = -1;
  259.  
  260.  
  261.   if (theAxis == N3D_AllAxes) { theAxisInt = 0; }
  262.  
  263.   if (theAxis == N3D_XAxis) { theAxisInt = 1; }
  264.   if (theAxis == N3D_YAxis) { theAxisInt = 2; }
  265.   if (theAxis == N3D_ZAxis) { theAxisInt = 3; }
  266.  
  267.   if (theAxis == N3D_XYAxes) { theAxisInt = 4; }
  268.   if (theAxis == N3D_XZAxes) { theAxisInt = 5; }
  269.   if (theAxis == N3D_YZAxes) { theAxisInt = 6; }
  270.  
  271.   return theAxisInt;
  272. }
  273.  
  274. - takeTrackballXYZFromMatrix:sender
  275. {
  276.   int  newVal = [[sender selectedCell] tag];
  277.  
  278.   switch (newVal)
  279.   {  case 0:
  280.      [theRotator setRotationAxis:N3D_AllAxes];
  281.      break;
  282.      case 1:
  283.      [theRotator setRotationAxis:N3D_XAxis];
  284.      break;
  285.      case 2:
  286.      [theRotator setRotationAxis:N3D_YAxis];
  287.      break;
  288.      case 3:
  289.      [theRotator setRotationAxis:N3D_ZAxis];
  290.      break;
  291.      case 4:
  292.      [theRotator setRotationAxis:N3D_XYAxes];
  293.      break;
  294.      case 5:
  295.      [theRotator setRotationAxis:N3D_XZAxes];
  296.      break;
  297.      case 6:
  298.      [theRotator setRotationAxis:N3D_YZAxes];
  299.      break;
  300.      default:
  301.      NXLogError("%d is an invalid value for trackballXYZ.\n", newVal);
  302.      } 
  303.   return self;
  304. }
  305.  
  306.  
  307. - (NXColor) backgroundColor     { return backgroundColor; }
  308. - setBackgroundColor:(NXColor)c { backgroundColor = c; [self display]; return self; }
  309.  
  310. ////////////////////////////////////////////////////////////////////
  311. //            Dragging stuff
  312. ///////////////////////////////////////////////////////////////////
  313.  
  314.  
  315. - (NXDragOperation)draggingEntered:(id <NXDraggingInfo>)sender
  316. {
  317.     if ([[sender draggingSource] respondsTo:@selector(lightType)])
  318.     {  return NX_DragOperationCopy;
  319.     }
  320.     return NX_DragOperationNone;
  321. }
  322.  
  323. - (NXDragOperation)draggingUpdated:(id <NXDraggingInfo>)sender
  324. {
  325.     if ([[sender draggingSource] respondsTo:@selector(lightType)])
  326.     {  return NX_DragOperationCopy;
  327.     }
  328.     return NX_DragOperationNone;
  329. }
  330.  
  331. - draggingExited:sender { return self; }
  332. - (BOOL)prepareForDragOperation:sender  { return YES; }
  333.  
  334. - (BOOL)performDragOperation:sender
  335. {
  336.     RtPoint fromPoint = {1, 1, -1};
  337.     RtPoint toPoint = {0, 0, 0};
  338.     RtFloat  coneAngle = 30.0, 
  339.              coneDelta = 5.0, 
  340.              beamDistribution = 2.0, 
  341.              intensity = 0.7;
  342.     id       newLight;
  343.     NXEvent  *event = [NXApp currentEvent];
  344.     NXPoint  locationInWindow;
  345.     NXRect   myFrame;
  346.  
  347.  
  348.     locationInWindow.x = event->location.x;
  349.     locationInWindow.y = event->location.y;
  350.     NXLogError("locationInWindow == (%f %f)\n", locationInWindow.x, locationInWindow.y);
  351.     [self convertPoint:&locationInWindow fromView:[[self window] contentView]];
  352.     NXLogError("location in this view == (%f %f)\n", locationInWindow.x, locationInWindow.y);
  353.     [self getFrame:&myFrame];
  354.     NXLogError("my frame is (%f %f) and starts at (%f %f)\n", 
  355.                myFrame.size.width, myFrame.size.height, myFrame.origin.x, myFrame.origin.y);
  356.     NXLogError("normalized, the drop happened at (%f %f)\n", 
  357.                (locationInWindow.x/myFrame.size.width), (locationInWindow.y/myFrame.size.height)); 
  358.  
  359.     if ([[sender draggingSource] respondsTo:@selector(lightType)])
  360.     {  // send lightType, malloc up a new one, figure out where the mouse is and drop the light there
  361.        switch ((int)[[sender draggingSource] lightType])
  362.        {  case ((int)N3D_PointLight):    newLight = [[WW3DLight alloc] init];
  363.                                      [newLight makePointFrom:fromPoint intensity:intensity];
  364.                                      [newLight translate:N3D_XComp(fromPoint) :N3D_YComp(fromPoint) :N3D_ZComp(fromPoint)];
  365.                                      [[self worldShape] linkDescendant:newLight];
  366.                                       break;
  367.           case ((int)N3D_DistantLight):  newLight = [[WW3DLight alloc] init];
  368.                                      [newLight makeDistantFrom:fromPoint to:toPoint intensity:intensity];
  369.                                      [newLight translate:N3D_XComp(fromPoint) :N3D_YComp(fromPoint) :N3D_ZComp(fromPoint)];
  370.                                      [[self worldShape] linkDescendant:newLight];
  371.                                      break;
  372.           case ((int)N3D_SpotLight):     newLight = [[WW3DLight alloc] init];
  373.                                      [newLight makeSpotFrom:fromPoint to:toPoint 
  374.                                                    coneAngle:coneAngle coneDelta:coneDelta 
  375.                                                    beamDistribution:beamDistribution 
  376.                                                    intensity:intensity];
  377.                                      [newLight translate:N3D_XComp(fromPoint) :N3D_YComp(fromPoint) :N3D_ZComp(fromPoint)];
  378.                                         [[self worldShape] linkDescendant:newLight];
  379.                                      break;
  380.           default:                       newLight = [[WW3DLight alloc] init];
  381.                                      [[self worldShape] linkDescendant:newLight];
  382.                                      break;
  383.         }
  384.         return YES;
  385.     }
  386.     return NO;
  387. }
  388.  
  389.  
  390. - concludeDragOperation:sender {  return self; }
  391.  
  392. #define typeVector "fff[2f][2f]"
  393. #define typeValues &translateXFactor, &translateYFactor, &translateZFactor, &lowRezTesselationVector, &tesselationVector
  394.  
  395.  
  396. - read:(NXTypedStream *)stream {
  397.     int version;
  398.     [super read:stream];
  399.  
  400.     version = NXTypedStreamClassVersion(stream,"WWLightCamera");
  401.     if (version == 0) NXReadTypes(stream,"i",&version), version=1;
  402.     if (version == 1)
  403.     {  NXReadTypes(stream, typeVector, typeValues);
  404.        backgroundColor = NXReadColor(stream);
  405.     }
  406.     return self;
  407. }
  408.  
  409. - write:(NXTypedStream *)stream 
  410. {
  411.     [super write:stream];
  412.     NXWriteTypes(stream, typeVector, typeValues);
  413.     NXWriteColor(stream, backgroundColor);
  414.     return self;
  415. }
  416.  
  417.  
  418. @end
  419.