CAD system - CFD Grid Generation

Simple Scenario to Kick Off This Conversion 2011-March-24

     Scenario
     (1) Start Application
          MainWindow::constructor
          pDoc = new CDoc(this);
          // Create a default view - same as New Window
          miNewWindow_Click(null, null);

     (2) Enter FM-command: CreateBox
          MainWindow::miFMbox_Click
          pDoc.OnFMCreateBox()
          ===>     GDoc::OnFMCreateBox()
                       m_pFM = new CFM_createBox (m_pData)
                       InitializeFM()

     (3) In FM_createBox, click Viewport --> This "creates" a new box
          GView::UserControl_PrevMouseLeftButtonDown
          CFM_base pFM = m_pdoc.GetActiveFM()
          pFM.EventForDEFPT (1, null) ------------------- CREATE BOX
          (A)==> GFM_createBox::EventForDEFPT ()
                      CElemBase pE = new CElemBox()
                      m_pData.m_elemList.Add (pE)
                      InvalidateAllVpts()??
          m_pDoc.OnDraw_WPF (this.myViewport, allVpts) ------> (C) ON DRAW

     (4) In FM_createBox, click model --> This "modifies" the box
          GView::Model_PrevMouseLeftButtonDown
          CFM_base pFM = m_pdoc.GetActiveFM()
          pFM.EventForSEL (1, null) -------------------- MODIFY BOX
          (B)==> GFM_createBox::EventForSEL ()
                      ///////////// - test of MODIFY box
                      CElemBox pE = m_pData.m_elemList[0] as CElemBox;
                      // Modify some elem attributes...
                      pE.m_width *= 2;
          m_pDoc.OnDraw_WPF (this.myViewport, allVpts) ------> (C) ON DRAW

     (C) GDoc::OnDraw_WPF (vpt, allVpts)
          foreach (CView pV in m_viewList)
          foreach (CElem pE in m_pData.m_elemList)
               pE.DrawElemOneVpt (out n3, out vec3) ------> (D) DRAW ELEM ONE VPT
             (D)==> GElem::DrawElemOneVpt (out n3, out vec3, ...)
                           // Elem's own ViewMatrix...
                           CreateVertices() // -- no change needed
                           CreateGLcalls_WPF (out n3, out vec3)
               MesgGeometry3D mesh = new...
                    mesh.TriangleINDEX
               pV.MyViewport.Children.Add (model)

     (5) R-click the viewport --> Real-time View rotation
          GView::UserControl_PrevMouseRightButtonDown
          myCamera.Position
          myCamera.LookDirection
          myCamera.FieldOfView

     (6) R-click the model --> Just a Test to add geometry
          GView::Model_PrevMouseRightButtonDown
          m_pDoc.OnDraw_WPF_TEST (this.myViewport, allVpts)

How to create a new element 2011-March-27

   CElemBox:: example
   /////////////////////////////////////////////////////////////////////////////
   public CElemBox(G.COLORREF color, int layer, CPoint3D pt, CPoint3D dir,
   CPoint3D ori, double height, double width) : base(color, layer, 1, pt, dir, ori, height, width)
   {
        m_elemType = G.ELEM_TYPE.ET_BOX;
        m_totalVertex = 4;
   }
   /////////////////////////////////////////////////////////////////////////////
   public override int GenerateVertices() // public virtual???????
   {
        double w = m_width / 2.0f;
        double h = m_height / 2.0f;

        m_pVertex2D = new CPoint2D [m_totalVertex ];
        CPoint2D pt0 = new CPoint2D(w, h); m_pVertex2D[0] = pt0;
        CPoint2D pt1 = new CPoint2D(w, -h); m_pVertex2D[1] = pt1;
        CPoint2D pt2 = new CPoint2D(-w, -h); m_pVertex2D[2] = pt2;
        CPoint2D pt3 = new CPoint2D(-w, h); m_pVertex2D[3] = pt3;
        return 4; // ?
   }
   /////////////////////////////////////////////////////////////////////////////
   public override void CreateGLcalls_WPF(out int n3, out CPoint3D[,] vec3)
   {
        // Create calls to OpenGL using vertices in m_generatedPts[i] qaz
        n3 = 2; // 2 triangles
        vec3 = new CPoint3D[3, 100];

        vec3[0, 0] = new CPoint3D(m_pVertex2D[0].x, m_pVertex2D[0].y, 0.0f);
        vec3[0, 1] = new CPoint3D(m_pVertex2D[1].x, m_pVertex2D[1].y, 0.0f);
        vec3[0, 2] = new CPoint3D(m_pVertex2D[2].x, m_pVertex2D[2].y, 0.0f);

        vec3[1, 0] = new CPoint3D(m_pVertex2D[2].x, m_pVertex2D[2].y, 0.0f);
        vec3[1, 1] = new CPoint3D(m_pVertex2D[3].x, m_pVertex2D[3].y, 0.0f);
        vec3[1, 2] = new CPoint3D(m_pVertex2D[0].x, m_pVertex2D[0].y, 0.0f);

       ApplyMatrixToVec(n3, ref vec3);

        //2011-3-14 was CreatePolygonWithNormal (4, vertex, 3,2,1,0);
   }

   CElemBase2D::
   /////////////////////////////////////////////////////////////////////////////
   public void ApplyMatrixToVec(int n3, ref CPoint3D[,] vec3)
   {
        // Apply elem's matrix to each vertex... m_matrix
        for (int i = 0; i < n3; i++)
        {
             vec3[0, i] = m_matrix.TransformPoint(vec3[0, i]);
             vec3[1, i] = m_matrix.TransformPoint(vec3[1, i]);
             vec3[2, i] = m_matrix.TransformPoint(vec3[2, i]);
        }
   }

   CElemBase::
   /////////////////////////////////////////////////////////////////////////////
   public void DrawElemOneVpt_WPF(out int n3, out CPoint3D[,] vec3)
   {
        GenerateVertices();
        CreateGLcalls_WPF(out n3, out vec3); // Apply Elem's own matrix, etc.....
   }

   CDoc::
   /////////////////////////////////////////////////////////////////////////////
   public void OnDraw_WPF(Viewport3D vpt, bool bOneVptOnly = false) // 2011-3-22
   {
        // In the VC++ G system, CView::OnDraw drew everything:
        // - DrawAllElems
        // - DrawCurPlane
        // - DrawAllTempElems
        // - DrawRubberband3D
        // - DrawZoomBox
        // - DrawRubberband2D
        // So, we have to do the same here....
        ///////////////////////////////////////////////////////
        //---------- DrawAllElems -------------------
        ///////////////////////////////////////////////////////
        // Most cases require all viewports to be updated
        foreach (CView pV in m_viewList)
        {
             foreach (CElemBase1D pE in m_pData.m_elemList)
             {
                  Colors color;
                  int n3 = 0;
                  CPoint3D[,] vec3 = new CPoint3D[3, 100];
                  pE.DrawElemOneVpt_WPF(out n3, out vec3);
                  ///////////////////////////////////////// Create model
                   MeshGeometry3D mesh = new MeshGeometry3D();
                  ///////////////////////////////////////// Create model
                  for (int i = 0; i < n3; i++)
                  {
                       int ii = i * 3;
                       Point3D pp0 = new Point3D(vec3[0, i].x, vec3[0, i].y, vec3[0, i].z);
                       Point3D pp1 = new Point3D(vec3[1, i].x, vec3[1, i].y, vec3[1, i].z);
                       Point3D pp2 = new Point3D(vec3[2, i].x, vec3[2, i].y, vec3[2, i].z);
                       mesh.Positions.Add(pp0);
                       mesh.Positions.Add(pp1);
                       mesh.Positions.Add(pp2);
                       mesh.TriangleIndices.Add(ii);
                       mesh.TriangleIndices.Add(ii + 2);
                       mesh.TriangleIndices.Add(ii + 1);
                       Vector3D norml = CalculateNormal(pp2, pp1, pp0); // bad - (pp0, pp1, pp2);
                       mesh.Normals.Add(norml);
                       mesh.Normals.Add(norml);
                       mesh.Normals.Add(norml);
                  }
                  Material matl = new DiffuseMaterial(new SolidColorBrush(Colors.Yellow));
                  GeometryModel3D geo = new GeometryModel3D(mesh, matl);
                  ModelVisual3D model = new ModelVisual3D();
                  model.Content = geo;
                  ///////////////////////////////// Add model to viewport
                  if (bOneVptOnly)
                  {
                       vpt.Children.Add(model); // This vpt only
                       //-------------------------------------------------- Lihgt
                       // vpt.Children.Add(model4light); // add light
                       break;
                  }
                  pV.myViewport.Children.Add(model);
                  ///////////////////////////////// Add model to viewport
             }
             //--------------------------------------------------------------- Lihgt
             ModelVisual3D model4light = new ModelVisual3D();
             DirectionalLight light = new DirectionalLight();
             light.Color = Colors.White; // Green; // White;
             light.Direction = new Vector3D(11, -21, -111);//(-1, 1, -5);
             model4light.Content = light;
             pV.myViewport.Children.Add(model4light); // add light
             //--------------------------------------------------------------- Lihgt
        }

VIew Creation / Initialization / OnSize() 2011-May-26

   /////////////////////////////////////////////////////////////////////////////
   Main :: miNewWindow_Click (object sender, RoutedEventArgs e)
   {
        //------------------------------------------------- A NEW VIEWPORT
        CView pV = new CView(pDoc, pDoc.m_pData);
        pDoc.m_viewList.Add(pV);

        //------------------------------------------------- MDI Creation
        MdiCild mdiView = new MdiChild()

        //------------------------------------------------- OnInitialUpdate
        pV.OnInitialUpdate ();
      // In MFC's Doc/View architecture, OnInitialUpdate is called immediately after the view is attached
        // to the document. This is where the view's initialization should be done.


   /////////////////////////////////////////////////////////////////////////////
   CView :: constructor
   {
        //-------------- mainly member data initialization

   /////////////////////////////////////////////////////////////////////////////
   CView :: OnInitialUpdate ()
   {
       //-------------- initialization
       OnSize (mdi.Width, mdi.Height)
       Setup2Projection ()
       Setup2UpVector ()
       Setup3Light ()


   /////////////////////////////////////////////////////////////////////////////
   CView :: OnSize (x, y)
   {
        //------------------------------------------------- A NEW VIEWPORT
        m_pixSizeX, Y
        UpdateOrthoSizeGivenNewPerspectiveSetting ()
        --->   Setup1ViewAspectRatio ()

Menu: Window --> New Window (viewport) 2011-March-29

   New Viewport Creation - MainWindow::
   /////////////////////////////////////////////////////////////////////////////
   private void miNewWindow_Click(object sender, RoutedEventArgs e)
   {
        //------------------------------------------------- CREATE A NEW VIEWPORT
        // (1) Create a CView instance...
        CView pV = new CView(pDoc, pDoc.m_pData);
        pDoc.m_viewList.Add(pV);

        // (2) Create an Mdi instance...
        MdiCild mdiView = new MdiChild()
        { Title = "WPF 3D - CView",
          Content = pV,
          Width = 600, MinWidth = 150,
          Height = 400, MinHeight = 150,
          MinimizeBox = true, MaximizeBox = true,
        };
        Canvas.SetLeft(mdiView, 600);
        Canvas.SetTop(mdiView, 150);
        // Save in 2 places: (1) Mdi Container (2) data member
        Container.Children.Add(mdiView);
        pDoc.m_mdiViewList.Add(mdiView);
        pDoc.m_viewList.Add(pV);

        // (3) Initialize view attributes...
        pV.OnInitialUpdate(600, 400);
      // In MFC's Doc/View architecture, OnInitialUpdate is called immediately after the view is attached
        // to the document. This is where the view's initialization should be done.

        // (4) Camera setup...
        pV.Setup2Projection();
        pV.Setup2UpVector();
        -- pV.myCamera.Position = new Point3D(-20, 0, 0);
        -- pV.myCamera.LookDirection = new System.Windows.Media.Media3D.Vector3D(1, 0, 0);
        -- pV.myCamera.UpDirection = new System.Windows.Media.Media3D.Vector3D(0, 0, 1);
        -- pV.myCamera.FieldOfView = 30;
        -- pV.myCamera.NearPlaneDistance = 0.1;
        -- pV.myCamera.FarPlaneDistance = 200;

        // (5) Lighting...
        ModelVisual3D model4light = new ModelVisual3D();
        DirectionalLight light = new DirectionalLight();
        light.Color = Colors.White; // Green;
        light.Direction = new Vector3D(1, -21, -111);
        model4light.Content = light;
        pV.myViewport.Children.Add(model4light); // add light to vpt
        //------------------------------------------------- CREATE A NEW VIEWPORT
}

WPF Rendering Flow : OnDraw_WPF 2011-May-26

   (A) Create a New Element
   /////////////////////////////////////////////////////////////////////////////
   CView::UserControl_PreviewMouseLeftButtonDown (object sender, MouseButtonEventArgs e)
   {
        CFM_base pFM = m_pDoc.GetActiveFM ();

        pFM.EventForIND ();

        m_pDoc.OnDraw_WPF (m_pData.m_OnDrawFlag, this);
   }
   /////////////////////////////////////////////////////////////////////////////
   CFM_createBox3d::EventForIND ()
   {
        //------------------------------------------------- CREATE A NEW ELEMENT
        // Clear this list every time
        m_pData.m_elemNewlyCreatedList.Clear ();

        CElemBase pE1 = new CElemBox3d(G.COLORREF.A, layer, m_ptIND, new CPoint3D(1, 0, 0), new CPoint3D(1, 0, 1), 0.1, 0.1, 0.5);
        m_pData.m_elemList.Add (pE1);
        m_pData.m_elemNewlyCreatedList.Add (pE1);
        CElemBase pE2 = new CElemBox3d(G.COLORREF.A, layer, m_ptIND, new CPoint3D(-1, 0, 0), new CPoint3D(1, 0, 1), 0.1, 0.1, 0.5);
        m_pData.m_elemList.Add (pE2);
        m_pData.m_elemNewlyCreatedList.Add (pE2);

        m_pData.m_OnDraw_flag = 1; // Draw only newly created elements on all vpts
   }
   /////////////////////////////////////////////////////////////////////////////
   CDoc::OnDraw_WPF (int flag, CView pVOnlyOne = null)
   {
        ------------------------------------------------------------
        // flag = 1: Draw only newly created elems in all vpts
       {
             foreach (CView pV in m_viewList)
             {
                  DrawNewlyCreatedElems (pV);
                  //------------------ Draw Axis axes
                  //------------------ Draw Current plane
             }
        ------------------------------------------------------------
        // flag = 2: Undraw an elem in all vpts
       {
             foreach (CView pV in m_viewList)
             {
                  UndrawThisElem (pV, m_pData.m_pElemUndraw);
             }
        ------------------------------------------------------------
        // flag = 3: Draw all elems in only one vpt
       {
             DrawAllElems (pVOnlyOne);
             //------------------ Draw Axis axes
             //------------------ Draw Current plane
   }
   /////////////////////////////////////////////////////////////////////////////
   CDoc::DrawAllElems (CView pV)
   {
        foreach (CElemBase1D pE in m_pData.m_elemList)
        {
             DrawElemOneVpt (pE, pV);
        }
}
   /////////////////////////////////////////////////////////////////////////////
   CDoc::DrawNewlyCreatedElems (CView pV)
   {
        foreach (CElemBase1D pE in m_pData.m_elemNewlyCreatedList)
        {
             DrawElemOneVpt (pE, pV);
        }
}
   /////////////////////////////////////////////////////////////////////////////
   CDoc::UndrawThisElem (CView pV, CElemBase pElemToDelete)
   {
        int index = 0;
        foreach (CElemBase pE in pV.m_elemList)
        {
             if (pE == pElemToDelete)
             {
                  index = 1;
                  ModelVisual3D model = pV.m_modelVisual3DList (index);
                  pV.myViewport.Children.Remove (model);
                  break;
              }
         }
   }
   /////////////////////////////////////////////////////////////////////////////
   CDoc::DrawElemOneVpt (CElemBase pE, CView pV)
   {
        Colors color;
        int n3 = 0;
        CPoint3D[,] vec3 = new CPoint3D[3, 100];
        pE.GenerateVerticesAndCreateWPFcalls (out n3, out vec3);

        MeshGeometry3D mesh = new MeshGeometry3D();
        for (int i = 0; i < n3; i++)
        {
             Point3D pp0 = new Point3D(vec3[0, i].x, vec3[0, i].y, vec3[0, i].z);
             mesh.Positions.Add (pp0,,,,);
             mesh.TriangleIndices.Add (ii,,,,);
             Vector3D norml = CalculateNormal(pp0, pp1, pp2);
             mesh.Normals.Add (norml,,,,);
        }
        Material mat = new DiffuseMaterial(new SolidColorBrush(Colors.LightBlue));
        GeometryModel3D geo = new GeometryModel3D(mesh, mat);
        ModelVisual3D model = new ModelVisual3D ();
        model.Content = geo;
        pV.myViewport.Children.Add (model); // Add model to viewport

        // Save for future delete...
        pV.m_modelVisual3DList.Add (model);
        pV.m_elemList.Add (pE);
   }

   (B) Delete an Element
   /////////////////////////////////////////////////////////////////////////////
   CView::UserControl_PreviewMouseLeftButtonDown (object sender, MouseButtonEventArgs e)
   {
        //------------------------------------------------- GET CURRENT FM
        CFM_base pFM = m_pDoc.GetActiveFM ();

        pFM.EventForIND ();

        m_pDoc.OnDraw_WPF (m_pData.m_OnDrawFlag, this);
   }
   /////////////////////////////////////////////////////////////////////////////
   CFM_createBox3d::EventForIND ()
   {
        // ---- Identify the element to be deleted

        //------------------------------------------------- REMOVE THIS ELEM FROM ELEM LIST
        m_pData.m_elemList.Remove (pElemToDelete);

        m_pData.m_OnDraw_flag = 2; // Undraw an element on all vpts

        m_pData.m_pElemUndraw = pElemToDelete;
   }
   /////////////////////////////////////////////////////////////////////////////
   CDoc::OnDraw_WPF (int flag, CView pVOnlyOne = null)
   {
        // flag = 1: Draw only newly created elems in all vpts
       {
             foreach (CView pV in m_viewList)
             {
                  DrawNewlyCreatedElems (pV);
                  //------------------ Draw Axis axes
                  //------------------ Draw Current plane
             }
        }
        // flag = 2: Undraw an elem in all vpts
       {
             foreach (CView pV in m_viewList)
             {
                  UndrawThisElem (pV, m_pData.m_pElemUndraw);
             }
        }
        // flag = 3: Draw all elems in only one vpt
       {
             DrawAllElems (pVOnlyOne);
             //------------------ Draw Axis axes
             //------------------ Draw Current plane
        }
   }
   /////////////////////////////////////////////////////////////////////////////
   CDoc::UndrawThisElem (CView pV, CElemBase pElemToDelete)
   {
        int index = 0;
        foreach (CElemBase pE in pV.m_elemList)
        {
             if (pE == pElemToDelete)
             {
                  index = 1;
                  ModelVisual3D model = pV.m_modelVisual3DList (index);
                  pV.myViewport.Children.Remove (model);
                  break;
              }
         }
   }

   (C) When a New Viewport Popped
   /////////////////////////////////////////////////////////////////////////////
   MainWindow::miNewViewport_Click(object sender, RoutedEventArgs e)
   {
        //------------------------------------------------- GET CURRENT FM
        // (1) Create a CView instance ---------------------- CREATE NEW VIEWPORT
        CView pV = new CView (pDoc, pDoc.m_pData);
        pDoc.m_viewList.Add (pV);

        // (2) Create an Mdi instance ------------------------ CREATE MDI INSTANCE
        MdiChild mdiChd = new MdiChild()
        Canvas.SetLeft(mdiChd, 600);
        Canvas.SetTop(mdiChd, 150);

        // Save in 2 places: (1) Mdi Container (2) data member
        Container.Children.Add(mdiChd);
        pDoc.m_mdiViewList.Add(mdiChd);
        pV.m_mdiChild = mdiChd;

        // (3) Initialize view attributes...
        pV.OnInitialUpdate(); // ((int)mdiWidth, (int)mdiHeight);

        // (4) Camera setup ------------------------------------ CAMERA
        pV.Setup2Projection();
        pV.Setup2UpVector();

        // (5) Lighting ----------------------------------------- LIGHT
        ModelVisual3D model = new ModelVisual3D();
        DirectionalLight lightDir = new DirectionalLight();
        AmbientLight lightAmb = new AmbientLight();
        PointLight lightPnt = new PointLight();
        pV.myViewport.Children.Add(model); // add light to vpt

        // (6) Draw all elements -------------------------- DRAW ELEMENTS
        pDoc.OnDraw_WPF (3, pV); // Draw all elemes in one vpt
   }
   /////////////////////////////////////////////////////////////////////////////
   CDoc::OnDraw_WPF (int flag, CView pVOnlyOne = null)
   {
        // flag = 1: Draw only newly created elems in all vpts
       {
             foreach (CView pV in m_viewList)
             {
                  DrawNewlyCreatedElems (pV);
                  //------------------ Draw Axis axes
                  //------------------ Draw Current plane
             }
        }
        // flag = 2: Undraw an elem in all vpts
       {
             foreach (CView pV in m_viewList)
             {
                  UndrawThisElem (pV, m_pData.m_pElemUndraw);
             }
        }
        // flag = 3: Draw all elems in only one vpt
       {
             DrawAllElems (pVOnlyOne);
             //------------------ Draw Axis axes
             //------------------ Draw Current plane
        }
   }
   /////////////////////////////////////////////////////////////////////////////
   CDoc::DrawAllElems (CView pV)
   {
        foreach (CElemBase1D pE in m_pData.m_elemList)
        {
             DrawElemOneVpt (pE, pV);
        }
}
   /////////////////////////////////////////////////////////////////////////////
   CDoc::DrawElemOneVpt (CElemBase pE, CView pV)
   {
        Colors color;
        int n3 = 0;
        CPoint3D[,] vec3 = new CPoint3D[3, 100];
        pE.GenerateVerticesAndCreateWPFcalls (out n3, out vec3);

        MeshGeometry3D mesh = new MeshGeometry3D();
        for (int i = 0; i < n3; i++)
        {
             Point3D pp0 = new Point3D(vec3[0, i].x, vec3[0, i].y, vec3[0, i].z);
             mesh.Positions.Add (pp0,,,,);
             mesh.TriangleIndices.Add (ii,,,,);
             Vector3D norml = CalculateNormal(pp0, pp1, pp2);
             mesh.Normals.Add (norml,,,,);
        }
        Material mat = new DiffuseMaterial(new SolidColorBrush(Colors.LightBlue));
        GeometryModel3D geo = new GeometryModel3D(mesh, mat);
        ModelVisual3D model = new ModelVisual3D ();
        model.Content = geo;
        pV.myViewport.Children.Add (model); // Add model to viewport

        // Save for future delete...
        pV.m_modelVisual3DList.Add (model);
        pV.m_elemList.Add (pE);
   }

Function Mode (FM) Messages Printing Mechanism 2011-June-04

I decided to use a delegate to pass FMPrintMessages() down to Class FM_command
to handle FM prompt message display on the G-System desktop.

   ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   MainWindow::
   ------------------------------------------------------------------------------------
   public void FMPrintMessages ()   // to be sent as Delegate to -> Doc -> FM base
   {
        if (pDoc != null)
        {
             lblFMcommand.Content = pDoc.m_pData.FM_command;
             lblFMprompt.Content = pDoc.m_pData.FM_prompt;
             lblSystemFeedback.Content = pDoc.m_pData.FM_systemFeedback;
             lblKeyinEcho.Content = pDoc.m_pData.FM_keyinEcho;
             // clear each time
             pDoc.m_pData.FM_prompt = "";
             pDoc.m_pData.FM_systemFeedback = "";
             pDoc.m_pData.FM_keyinEcho = "";
        }
   }
   ------------------------------------------------------------------------------------
   pDoc = new CDoc (this, FMPrintMessages);