home *** CD-ROM | disk | FTP | other *** search
/ Chip Special: HTML & Java / Chip-Special_1997-01_HTML-a-Java.bin / javasdk / sdk-java.exe / SDKJava.cab / Samples / directX / d3drm / Viewer / SelectionDude.java < prev    next >
Encoding:
Java Source  |  1996-10-10  |  14.0 KB  |  588 lines
  1. import com.ms.com.*;
  2. import com.ms.com.*;
  3. import com.ms.awt.*;
  4. import com.ms.awt.peer.*;
  5. import com.ms.directX.*;
  6.  
  7. class SelectionDude
  8. {
  9.     private d3dvector zero;
  10.     private d3dvector dir;
  11.  
  12.     private int            showBoxes = 0;
  13.     d3drmFrame            sFrame = null;
  14.     d3drmMeshBuilder    sVisual = null;
  15.     d3drmLight            sLight = null;
  16.     d3drmMesh            selectionBox = null;
  17.  
  18.     d3drmFrame            clipboardFrame = null;
  19.     d3drmMeshBuilder    clipboardVisual = null;
  20.  
  21.     d3drm                lpd3drm;
  22.  
  23.     int rod_faces[] = {
  24.         8, 7, 7, 6, 6, 5, 5, 4, 4, 3, 3, 2, 2, 1, 1, 0, 0, /* end 1 */
  25.         4, 0, 0, 1, 1, 9, 1, 8, 0,  /* side 0 */
  26.         4, 1, 1, 2, 2, 10, 2, 9, 1, /* side 1 */
  27.         4, 2, 2, 3, 3, 11, 3, 10, 2, /* side 2 */
  28.         4, 3, 3, 4, 4, 12, 4, 11, 3, /* side 3 */
  29.         4, 4, 4, 5, 5, 13, 5, 12, 4, /* side 4 */
  30.         4, 5, 5, 6, 6, 14, 6, 13, 5, /* side 5 */
  31.         4, 6, 6, 7, 7, 15, 7, 14, 6, /* side 6 */
  32.         4, 7, 7, 0, 0, 8, 0, 15, 7,         /* side 7 */
  33.         8, 8, 0, 9, 1, 10, 2, 11, 3, 12, 4, 13, 5, 14, 6, 15, 7, /* end 2 */
  34.         0,0
  35.         };
  36.  
  37.     int cone_faces[] = {   
  38.         8, 7, 7, 6, 6, 5, 5, 4, 4, 3, 3, 2, 2, 1, 1, 0, 0, /* end 1 */
  39.         3, 0, 0, 1, 1, 8, 1,        /* side 0 */
  40.         3, 1, 1, 2, 2, 8, 1,        /* side 1 */
  41.         3, 2, 2, 3, 3, 8, 1, /* side 2 */
  42.         3, 3, 3, 4, 4, 8, 1, /* side 3 */
  43.         3, 4, 4, 5, 5, 8, 1, /* side 4 */
  44.         3, 5, 5, 6, 6, 8, 1, /* side 5 */
  45.         3, 6, 6, 7, 7, 8, 1, /* side 6 */
  46.         3, 7, 7, 0, 0, 8, 1,                /* side 7 */
  47.         0, 0
  48.         };
  49.  
  50.     //////////////////////////////////////////////////////////////////////////
  51.  
  52.     d3dvector CreateVector()
  53.     {
  54.         d3dvector v;
  55.  
  56.         v = new d3dvector();
  57.         v.x = 0.0F;
  58.         v.y = 0.0F;
  59.         v.z = 0.0F;
  60.  
  61.         return v;
  62.     }
  63.  
  64.     //////////////////////////////////////////////////////////////////////////
  65.  
  66.     SelectionDude(d3drm i)
  67.     {
  68.         lpd3drm = i;
  69.  
  70.         zero = CreateVector();
  71.         dir = CreateVector();
  72.     }
  73.  
  74.     //////////////////////////////////////////////////////////////////////////
  75.  
  76.     void ShowBoxes(int show)
  77.     {
  78.         showBoxes = show;
  79.         SelectVisual(sVisual, sFrame);
  80.     }
  81.  
  82.     //////////////////////////////////////////////////////////////////////////
  83.  
  84.     int ToggleBoxes()
  85.     {
  86.         if(showBoxes == 0)
  87.             ShowBoxes(1);
  88.         else
  89.             ShowBoxes(0);
  90.  
  91.         return showBoxes;
  92.     }
  93.  
  94.     //////////////////////////////////////////////////////////////////////////
  95.  
  96.     d3drmFrame SelectedFrame()
  97.     {
  98.         return sFrame;
  99.     }
  100.  
  101.     //////////////////////////////////////////////////////////////////////////
  102.  
  103.     d3drmMeshBuilder SelectedVisual()
  104.     {
  105.         return sVisual;
  106.     }
  107.  
  108.     //////////////////////////////////////////////////////////////////////////
  109.  
  110.     d3drmLight SelectedLight()
  111.     {
  112.         return sLight;
  113.     }
  114.  
  115.     //////////////////////////////////////////////////////////////////////////
  116.  
  117.     void DeselectVisual()
  118.     {
  119.         if ((sFrame != null) && (selectionBox != null))
  120.             sFrame.DeleteVisualMesh(selectionBox);
  121.  
  122.         sFrame    = null;
  123.         sVisual = null;
  124.         selectionBox = null;
  125.     }
  126.  
  127.     //////////////////////////////////////////////////////////////////////////
  128.  
  129.     void SelectVisual(d3drmMeshBuilder visual, d3drmFrame frame)
  130.     {
  131.         DeselectVisual();
  132.         sVisual = visual;
  133.         sFrame = frame;
  134.  
  135.         if (sVisual != null)
  136.         {   
  137.             d3drmLightArray lights;
  138.  
  139.             sLight = null;
  140.             lights = sFrame.GetLights();
  141.             if ( lights != null )
  142.             {   
  143.                 if (lights.GetSize() != 0)
  144.                     sLight = lights.GetElement(0);
  145.             }
  146.  
  147.             if ((showBoxes != 0) && (visual != null))
  148.             {   
  149.                 d3drmBox box = new d3drmBox();
  150.                 d3drmMeshBuilder builder;
  151.  
  152.                 sVisual.GetBox(box);
  153.                 builder = makeBox(box);
  154.                 selectionBox = builder.CreateMesh();
  155.                 sFrame.AddVisualMesh(selectionBox);
  156.             }
  157.         }
  158.     }
  159.  
  160.     //////////////////////////////////////////////////////////////////////////
  161.  
  162.     void FindAndSelectVisual(d3drmViewport view, int x, int y)
  163.     {
  164.         d3drmFrame frame;
  165.         d3drmPickedArray picked;
  166.         d3drmMeshBuilder mesh;
  167.  
  168.         /*
  169.          * Make sure we don't try to select the selection box of the current
  170.          * selection.
  171.          */
  172.         DeselectVisual();
  173.  
  174.         picked = view.Pick(x, y);
  175.         if (picked != null)
  176.         {   
  177.             if (picked.GetSize() != 0)
  178.             {
  179.                 d3drmFrameArray fa = picked.GetPickFrame(0, null);
  180.                 d3drmVisual     v  = picked.GetPickVisual(0, null);
  181.  
  182.                 frame = fa.GetElement(fa.GetSize()-1);
  183.                 mesh  = v.Getd3drmMeshBuilder();
  184.                 
  185.                 if( mesh != null )
  186.                     SelectVisual(mesh, frame);
  187.             }
  188.         }
  189.     }
  190.  
  191.     //////////////////////////////////////////////////////////////////////////
  192.  
  193.     void CutVisual()
  194.     {
  195.         d3drmFrame frame;
  196.  
  197.         if (sFrame != null) 
  198.         {
  199.             clipboardFrame = sFrame;
  200.             clipboardVisual = sVisual;
  201.                         
  202.             DeselectVisual();
  203.  
  204.             frame = clipboardFrame.GetParent();
  205.             if (frame != null) 
  206.                 frame.DeleteChild(clipboardFrame);
  207.         }
  208.     }
  209.  
  210.     //////////////////////////////////////////////////////////////////////////
  211.  
  212.     void CopyVisual()
  213.     {
  214.         d3drmFrame frame;
  215.  
  216.         if (sFrame != null) 
  217.         {
  218.             clipboardFrame = sFrame.Clone();
  219.             clipboardVisual = sVisual.Clone();
  220.  
  221.             clipboardFrame.AddVisualMeshBuilder(clipboardVisual);
  222.  
  223.             frame = clipboardFrame.GetParent();
  224.             if (frame != null) 
  225.                 frame.DeleteChild(clipboardFrame);
  226.         }
  227.     }
  228.  
  229.     //////////////////////////////////////////////////////////////////////////
  230.  
  231.     void PasteVisual(d3drmFrame scene)
  232.     {
  233.         if (clipboardFrame != null)
  234.         {
  235.             d3drmFrame frame;
  236.             d3drmMeshBuilder visual;
  237.  
  238.             frame = clipboardFrame.Clone();
  239.             visual = clipboardVisual.Clone();
  240.  
  241.             frame.AddVisualMeshBuilder(visual);
  242.             scene.AddChild(frame);
  243.         }    
  244.     }
  245.  
  246.     //////////////////////////////////////////////////////////////////////////
  247.  
  248.     void DeleteVisual()
  249.     {
  250.         if (sFrame != null)
  251.         {
  252.             d3drmFrame parent;
  253.             d3drmFrame frame = sFrame;
  254.  
  255.             DeselectVisual();
  256.             parent = frame.GetParent();
  257.             parent.DeleteChild(frame);
  258.         }
  259.     }
  260.  
  261.     //////////////////////////////////////////////////////////////////////////
  262.  
  263.     void ClearClipboard()
  264.     {
  265.     }
  266.  
  267.     //////////////////////////////////////////////////////////////////////////
  268.  
  269.     private d3drmMeshBuilder makeBox(d3drmBox box)
  270.     {
  271.         d3drmMeshBuilder mesh;
  272.         d3dvector a, b;
  273.  
  274.         mesh = lpd3drm.CreateMeshBuilder();
  275.  
  276.         dir.z = box.maxz + 1.0F;
  277.         AddRod(mesh, 0.05F, zero, dir);
  278.  
  279.         a = dir;
  280.         a.z += 0.6F;
  281.         AddCone(mesh, 0.2F, dir, a);
  282.  
  283.         a.x = box.minx; a.y = box.miny; a.z = box.minz;
  284.         b = a;
  285.         b.y = box.maxy;
  286.         AddRod(mesh, 0.05F, a, b);
  287.  
  288.         a = b; b.x = box.maxx;
  289.         AddRod(mesh, 0.05F, a, b);
  290.  
  291.         a = b; b.y = box.miny;
  292.         AddRod(mesh, 0.05F, a, b);
  293.  
  294.         a = b; b.x = box.minx;
  295.         AddRod(mesh, 0.05F, a, b);
  296.  
  297.         a = b; b.z = box.maxz;
  298.         AddRod(mesh, 0.05F, a, b);
  299.  
  300.         a = b; b.x = box.maxx;
  301.         AddRod(mesh, 0.05F, a, b);
  302.  
  303.         a = b; b.y = box.maxy;
  304.         AddRod(mesh, 0.05F, a, b);
  305.  
  306.         a = b; b.x = box.minx;
  307.         AddRod(mesh, 0.05F, a, b);
  308.  
  309.         a = b; b.y = box.miny;
  310.         AddRod(mesh, 0.05F, a, b);
  311.  
  312.         b.y = box.maxy; a = b; b.z = box.minz;
  313.         AddRod(mesh, 0.05F, a, b);
  314.  
  315.         a.x = b.x = box.maxx;
  316.         a.y = b.y = box.maxy;
  317.         a.z = box.maxz;
  318.         b.z = box.minz;
  319.  
  320.         AddRod(mesh, 0.05F, a, b);
  321.  
  322.         a.y = box.miny; b = a; b.z = box.minz;
  323.         AddRod(mesh, 0.05F, a, b);
  324.  
  325.         mesh.SetColor(lpd3drm.d3drmCreateColorRGB(1.0F, 1.0F, 1.0F));
  326.         return mesh;
  327.     }
  328.  
  329.     //////////////////////////////////////////////////////////////////////////
  330.  
  331.     float D3DDivide( float a, float b)
  332.     {
  333.         return (float)((double) (a) / (double) (b));
  334.     }
  335.  
  336.     float D3DMultiply( float a, float b)
  337.     {
  338.         return ((a) * (b));
  339.     }
  340.  
  341.     //////////////////////////////////////////////////////////////////////////
  342.     
  343.     void AddRod(d3drmMeshBuilder mesh, float radius, d3dvector a, d3dvector b)
  344.     {
  345.         float f;
  346.         int i;
  347.  
  348.         d3dvector d = new d3dvector();
  349.         d3dvector u = new d3dvector();
  350.         d3dvector r = new d3dvector();
  351.         d3dvector[] v = new d3dvector[16];
  352.  
  353.         for(i=0; i<16; i++)
  354.             v[i] = new d3dvector();
  355.             
  356.         d3dvector[] n = new d3dvector[8];
  357.         for(i=0; i<8; i++)
  358.             n[i] = new d3dvector();
  359.             
  360.         /*
  361.          * Find the unit vector along the rod.
  362.          */
  363.         d.x = b.x - a.x;
  364.         d.y = b.y - a.y;
  365.         d.z = b.z - a.z;
  366.         lpd3drm.d3drmVectorNormalise(d);
  367.  
  368.         /*
  369.          * Pick a vector normal to d
  370.          */
  371.         if (d.y != 0.0 || d.z != 0.0) 
  372.         {   
  373.             u.x = 0.0F;
  374.             if (d.y == 0.0F)
  375.             {   
  376.                 u.y = 1.0F;
  377.                 u.z = 0.0F;
  378.             } 
  379.             else
  380.             {   
  381.                 float n_fix = 1.0F + D3DDivide(D3DMultiply(d.z, d.z), D3DMultiply(d.y, d.y));
  382.                 u.z = (float)Math.sqrt(D3DDivide(1.0F, n_fix));
  383.                 u.y = -D3DMultiply(u.z, D3DDivide(d.z, d.y));
  384.             }
  385.         } 
  386.         else
  387.         {   
  388.             u.x = 0.0F;
  389.             u.y = 0.0F;
  390.             u.z = 1.0F;
  391.         }
  392.  
  393.         /*
  394.          * Now find a vector normal to them both, to give us a coordinate
  395.          * system in the plane normal to the rod.
  396.          */
  397.         lpd3drm.d3drmVectorCrossProduct(r, d, u);
  398.  
  399.         /*
  400.          * Scale down the coordinates to the radius of the rod.
  401.          */
  402.         u.x = D3DMultiply(u.x, radius);
  403.         u.y = D3DMultiply(u.y, radius);
  404.         u.z = D3DMultiply(u.z, radius);
  405.         r.x = D3DMultiply(r.x, radius);
  406.         r.y = D3DMultiply(r.y, radius);
  407.         r.z = D3DMultiply(r.z, radius);
  408.  
  409.         /*
  410.          * Calculate the corners of an octagon.
  411.          */
  412.         f = (float)Math.sqrt(2) / (2 * (1 + (float)Math.sqrt(2) / 2));
  413.         v[0].x = 1;  // huh!! null pointer exception here
  414.         
  415.         v[0].x = u.x + D3DMultiply(r.x, f);
  416.         v[0].y = u.y + D3DMultiply(r.y, f);
  417.         v[0].z = u.z + D3DMultiply(r.z, f);
  418.  
  419.         v[1].x = D3DMultiply(u.x, f) + r.x;
  420.         v[1].y = D3DMultiply(u.y, f) + r.y;
  421.         v[1].z = D3DMultiply(u.z, f) + r.z;
  422.  
  423.         v[2].x = D3DMultiply(-u.x, f) + r.x;
  424.         v[2].y = D3DMultiply(-u.y, f) + r.y;
  425.         v[2].z = D3DMultiply(-u.z, f) + r.z;
  426.  
  427.         v[3].x = -u.x + D3DMultiply(r.x, f);
  428.         v[3].y = -u.y + D3DMultiply(r.y, f);
  429.         v[3].z = -u.z + D3DMultiply(r.z, f);
  430.  
  431.         v[4].x = -u.x - D3DMultiply(r.x, f);
  432.         v[4].y = -u.y - D3DMultiply(r.y, f);
  433.         v[4].z = -u.z - D3DMultiply(r.z, f);
  434.  
  435.         v[5].x = D3DMultiply(-u.x, f) - r.x;
  436.         v[5].y = D3DMultiply(-u.y, f) - r.y;
  437.         v[5].z = D3DMultiply(-u.z, f) - r.z;
  438.  
  439.         v[6].x = D3DMultiply(u.x, f) - r.x;
  440.         v[6].y = D3DMultiply(u.y, f) - r.y;
  441.         v[6].z = D3DMultiply(u.z, f) - r.z;
  442.  
  443.         v[7].x = u.x - D3DMultiply(r.x, f);
  444.         v[7].y = u.y - D3DMultiply(r.y, f);
  445.         v[7].z = u.z - D3DMultiply(r.z, f);
  446.  
  447.         /*
  448.             * Add the rod endpoints and calculate the vertex normals.
  449.          */
  450.         for (i = 0; i < 8; i++)
  451.            {   
  452.                n[i] = v[i];
  453.            
  454.             lpd3drm.d3drmVectorNormalise(n[i]);
  455.         
  456.                v[i + 8].x = v[i].x + b.x;
  457.                v[i + 8].y = v[i].y + b.y;
  458.             v[i + 8].z = v[i].z + b.z;
  459.                v[i].x += a.x;
  460.                v[i].y += a.y;
  461.             v[i].z += a.z;
  462.            }
  463.            mesh.AddFacesToMesh(16, v, 8, n, rod_faces);
  464.     }
  465.  
  466.     //////////////////////////////////////////////////////////////////////////
  467.  
  468.     void AddCone(d3drmMeshBuilder mesh, float radius, d3dvector a, d3dvector b)
  469.     {
  470.         d3dvector d = new d3dvector();
  471.         d3dvector u = new d3dvector();
  472.         d3dvector r = new d3dvector();
  473.         d3dvector[] v = new d3dvector[16];
  474.         d3dvector[] n = new d3dvector[8];
  475.         float f;
  476.         int i;
  477.  
  478.         for(i=0; i<8; i++)
  479.         {
  480.             v[i] = new d3dvector();
  481.             n[i] = new d3dvector();
  482.         }
  483.         for(i=8; i<16; i++)
  484.             v[i] = new d3dvector();
  485.         
  486.         /*
  487.          * Find the unit vector along the rod.
  488.          */
  489.         d.x = b.x - a.x;
  490.         d.y = b.y - a.y;
  491.         d.z = b.z - a.z;
  492.         lpd3drm.d3drmVectorNormalise(d);
  493.  
  494.         /*
  495.          * Pick a vector normal to d
  496.          */
  497.         if (d.y != 0.0F || d.z != 0.0F)
  498.         {   
  499.             u.x = 0.0F;
  500.             if (d.y == 0.0F)
  501.             {   
  502.                 u.y = 1.0F;
  503.                 u.z = 0.0F;
  504.             } 
  505.             else
  506.             {   
  507.                 float n_fix = 1.0F + D3DDivide(D3DMultiply(d.z, d.z), D3DMultiply(d.y, d.y));
  508.                 u.z = (float)Math.sqrt(1.0F / n_fix);
  509.                 u.y = - D3DDivide(D3DMultiply(u.z, d.z), d.y);
  510.             }
  511.         } 
  512.         else
  513.         {   
  514.             u.x = 0.0F;
  515.             u.y = 0.0F;
  516.             u.z = 1.0F;
  517.         }
  518.  
  519.         /*
  520.          * Now find a vector normal to them both, to give us a coordinate
  521.          * system in the plane normal to the rod.
  522.          */
  523.         lpd3drm.d3drmVectorCrossProduct(r, d, u);
  524.  
  525.         /*
  526.          * Scale down the coordinates to the radius of the rod.
  527.          */
  528.         u.x = D3DMultiply(u.x, radius);
  529.         u.y = D3DMultiply(u.y, radius);
  530.         u.z = D3DMultiply(u.z, radius);
  531.         r.x = D3DMultiply(r.x, radius);
  532.         r.y = D3DMultiply(r.y, radius);
  533.         r.z = D3DMultiply(r.z, radius);
  534.  
  535.         /*
  536.          * Calculate the corners of an octagon.
  537.          */
  538.         f = (float)Math.sqrt(2) / (2 * (1 + (float)Math.sqrt(2) / 2));
  539.         v[0].x = u.x + D3DMultiply(r.x, f);
  540.         v[0].y = u.y + D3DMultiply(r.y, f);
  541.         v[0].z = u.z + D3DMultiply(r.z, f);
  542.  
  543.         v[1].x = D3DMultiply(u.x, f) + r.x;
  544.         v[1].y = D3DMultiply(u.y, f) + r.y;
  545.         v[1].z = D3DMultiply(u.z, f) + r.z;
  546.  
  547.         v[2].x = D3DMultiply(-u.x, f) + r.x;
  548.         v[2].y = D3DMultiply(-u.y, f) + r.y;
  549.         v[2].z = D3DMultiply(-u.z, f) + r.z;
  550.  
  551.         v[3].x = -u.x + D3DMultiply(r.x, f);
  552.         v[3].y = -u.y + D3DMultiply(r.y, f);
  553.         v[3].z = -u.z + D3DMultiply(r.z, f);
  554.  
  555.         v[4].x = -u.x - D3DMultiply(r.x, f);
  556.         v[4].y = -u.y - D3DMultiply(r.y, f);
  557.         v[4].z = -u.z - D3DMultiply(r.z, f);
  558.  
  559.         v[5].x = D3DMultiply(-u.x, f) - r.x;
  560.         v[5].y = D3DMultiply(-u.y, f) - r.y;
  561.         v[5].z = D3DMultiply(-u.z, f) - r.z;
  562.  
  563.         v[6].x = D3DMultiply(u.x, f) - r.x;
  564.         v[6].y = D3DMultiply(u.y, f) - r.y;
  565.         v[6].z = D3DMultiply(u.z, f) - r.z;
  566.  
  567.         v[7].x = u.x - D3DMultiply(r.x, f);
  568.         v[7].y = u.y - D3DMultiply(r.y, f);
  569.         v[7].z = u.z - D3DMultiply(r.z, f);
  570.  
  571.         v[8] = b;
  572.  
  573.         // Calculate the vertex normals and add the faces to the mesh
  574.         for (i = 0; i < 8; i++)
  575.         {   
  576.             n[i] = v[i];
  577.             
  578.             lpd3drm.d3drmVectorNormalise(n[0]);
  579.             v[i].x += a.x;
  580.             v[i].y += a.y;
  581.             v[i].z += a.z;
  582.         }
  583.         mesh.AddFacesToMesh(9, v, 8, n, cone_faces);
  584.     }
  585.     
  586.     //////////////////////////////////////////////////////////////////////////
  587. }
  588.