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