NET Client Crash



  • THE POST BELOW IS MORE THAN 5 YEARS OLD. RELATED SUPPORT INFORMATION MIGHT BE OUTDATED OR DEPRECATED

    On 28/11/2010 at 17:23, xxxxxxxx wrote:

    User Information:
    Cinema 4D Version:   R10-R12 
    Platform:   Windows  ;   Mac OSX  ; 
    Language(s) :     C++  ;

    ---------
    Now that I've internalized all my stock object, I am getting a NET Client crash when attempting to do a job using my plugin (Access Violation).  I was assured that multiprocessor threading and NET Render would be compatible.  There are no problems rendering (editor, external renderer) in Cinema 4D R10-12.  So this is strictly an issue between my plugin and NET Client.

    Could someone at Maxon please advise?  My last query has been five days unanswered and I resorted to spending two days internalizing 36 polygon objects.  You don't know anything about interactions between C++ SDK plugins and NET Render or what?  I'll thank you when I get a response.



  • THE POST BELOW IS MORE THAN 5 YEARS OLD. RELATED SUPPORT INFORMATION MIGHT BE OUTDATED OR DEPRECATED

    On 29/11/2010 at 06:13, xxxxxxxx wrote:

    I am sorry for the late reply. Please send a simplified plugin project to sdk_support@maxon.net showing the problem otherwise it's not possible for me to find a solution.

    cheers,
    Matthias



  • THE POST BELOW IS MORE THAN 5 YEARS OLD. RELATED SUPPORT INFORMATION MIGHT BE OUTDATED OR DEPRECATED

    On 29/11/2010 at 12:12, xxxxxxxx wrote:

    Not much I can do to simply the project.  It is ready-for-release and everything is very much interdependent (except for maybe the plugin tag which isn't where the problem resides).  It is still in Greebler.LoadStockLibrary() and the method that it calls for each shape object.  The code is supplied below.  Note that every single solitary memory allocation is checked and there are no error messages (I'm now also opening a MessageDialog() - still silent crash!).  Also note that there are no problems, issues, or crashes whatsoever in Cinema 4D using this code.

    // Greebler.LoadStockLibrary  
    //*---------------------------------------------------------------------------*  
    Bool Greebler::LoadStockLibrary()  
    //*---------------------------------------------------------------------------*  
    {  
      // Create Stock Shape Objects programmatically (because of C4D NET Client)  
      if (!CreateStockObject("Cube", Cube_Extrude, Cube_ExtrudeCap, Cube_Bevel, Cube_BevelCap))                    return FALSE;  
      if (!CreateStockObject("T", T_Extrude, T_ExtrudeCap, T_Bevel, T_BevelCap))                                    return FALSE;  
      if (!CreateStockObject("L", L_Extrude, L_ExtrudeCap, L_Bevel, L_BevelCap))                                    return FALSE;  
      if (!CreateStockObject("C", C_Extrude, C_ExtrudeCap, C_Bevel, C_BevelCap))                                    return FALSE;  
      if (!CreateStockObject("H", H_Extrude, H_ExtrudeCap, H_Bevel, H_BevelCap))                                    return FALSE;  
      if (!CreateStockObject("D", D_Extrude, D_ExtrudeCap, D_Bevel, D_BevelCap))                                    return FALSE;  
      if (!CreateStockObject("Box", Box_Extrude, Box_ExtrudeCap, Box_Bevel, Box_BevelCap))                        return FALSE;  
      if (!CreateStockObject("CubeCC", CubeCC_Extrude, CubeCC_ExtrudeCap, CubeCC_Bevel, CubeCC_BevelCap))            return FALSE;  
      if (!CreateStockObject("OblongOctagon", OblOct_Extrude, OblOct_ExtrudeCap, OblOct_Bevel, OblOct_BevelCap))    return FALSE;  
      return TRUE;  
    }  
    // Greebler.CreateStockObject  
    //*---------------------------------------------------------------------------*  
    Bool Greebler::CreateStockObject(const String& name, StockShapeDefs ssd_extrude, StockShapeDefs ssd_extcap, StockShapeDefs ssd_bevel, StockShapeDefs ssd_bevcap)  
    //*---------------------------------------------------------------------------*  
    {  
      // Create All Shape objects and tags  
      AutoAlloc<PolygonObject>    extrude(ssd_extrude.numPoints, ssd_extrude.numPolygons);  
      if (!extrude)                return ErrPrt("Greebler.Greebler.CreateStockObject.extrude");  
      extrude->SetName("Extrude");  
      AutoAlloc<PolygonObject>    extcap(ssd_extcap.numPoints, ssd_extcap.numPolygons);  
      if (!extcap)                return ErrPrt("Greebler.Greebler.CreateStockObject.extcap");  
      extcap->SetName("ExtrudeCap");  
      AutoAlloc<PolygonObject>    bevel(ssd_bevel.numPoints, ssd_bevel.numPolygons);  
      if (!bevel)                    return ErrPrt("Greebler.Greebler.CreateStockObject.bevel");  
      bevel->SetName("Bevel");  
      AutoAlloc<PolygonObject>    bevcap(ssd_bevcap.numPoints, ssd_bevcap.numPolygons);  
      if (!bevcap)                return ErrPrt("Greebler.Greebler.CreateStockObject.bevcap");  
      bevcap->SetName("BevelCap");  
      AutoAlloc<BaseObject>        nop(Onull);  
      if (!nop)                    return ErrPrt("Greebler.Greebler.CreateStockObject.nop");  
      nop->SetName(name);  
      // - PolygonSelection and PointSelection tags  
      // -- Extrude  
      AutoAlloc<SelectionTag>        ext_po_top(Tpolygonselection);  
      if (!ext_po_top)            return ErrPrt("Greebler.Greebler.CreateStockObject.ext_po_top");  
      ext_po_top->SetName("Top");  
      AutoAlloc<SelectionTag>        ext_po_sides(Tpolygonselection);  
      if (!ext_po_sides)            return ErrPrt("Greebler.Greebler.CreateStockObject.ext_po_sides");  
      ext_po_sides->SetName("Sides");  
      AutoAlloc<SelectionTag>        ext_pt_top(Tpointselection);  
      if (!ext_pt_top)            return ErrPrt("Greebler.Greebler.CreateStockObject.ext_pt_top");  
      ext_pt_top->SetName("Top");  
      // -- ExtrudeCap  
      AutoAlloc<SelectionTag>        extc_po_top(Tpolygonselection);  
      if (!extc_po_top)            return ErrPrt("Greebler.Greebler.CreateStockObject.extc_po_top");  
      extc_po_top->SetName("Top");  
      AutoAlloc<SelectionTag>        extc_po_sides(Tpolygonselection);  
      if (!extc_po_sides)            return ErrPrt("Greebler.Greebler.CreateStockObject.extc_po_sides");  
      extc_po_sides->SetName("Sides");  
      AutoAlloc<SelectionTag>        extc_po_cap(Tpolygonselection);  
      if (!extc_po_cap)            return ErrPrt("Greebler.Greebler.CreateStockObject.extc_po_cap");  
      extc_po_cap->SetName("Cap");  
      AutoAlloc<SelectionTag>        extc_pt_top(Tpointselection);  
      if (!extc_pt_top)            return ErrPrt("Greebler.Greebler.CreateStockObject.extc_pt_top");  
      extc_pt_top->SetName("Top");  
      // -- Bevel  
      AutoAlloc<SelectionTag>        bev_po_top(Tpolygonselection);  
      if (!bev_po_top)            return ErrPrt("Greebler.Greebler.CreateStockObject.bev_po_top");  
      bev_po_top->SetName("Top");  
      AutoAlloc<SelectionTag>        bev_po_sides(Tpolygonselection);  
      if (!bev_po_sides)            return ErrPrt("Greebler.Greebler.CreateStockObject.bev_po_sides");  
      bev_po_sides->SetName("Sides");  
      AutoAlloc<SelectionTag>        bev_po_bevel(Tpolygonselection);  
      if (!bev_po_bevel)            return ErrPrt("Greebler.Greebler.CreateStockObject.bev_po_bevel");  
      bev_po_bevel->SetName("Bevel");  
      AutoAlloc<SelectionTag>        bev_pt_top(Tpointselection);  
      if (!bev_pt_top)            return ErrPrt("Greebler.Greebler.CreateStockObject.bev_pt_top");  
      bev_pt_top->SetName("Top");  
      AutoAlloc<SelectionTag>        bev_pt_sides(Tpointselection);  
      if (!bev_pt_sides)            return ErrPrt("Greebler.Greebler.CreateStockObject.bev_pt_sides");  
      bev_pt_sides->SetName("Sides");  
      // -- BevelCap  
      AutoAlloc<SelectionTag>        bevc_po_top(Tpolygonselection);  
      if (!bevc_po_top)            return ErrPrt("Greebler.Greebler.CreateStockObject.bevc_po_top");  
      bevc_po_top->SetName("Top");  
      AutoAlloc<SelectionTag>        bevc_po_sides(Tpolygonselection);  
      if (!bevc_po_sides)            return ErrPrt("Greebler.Greebler.CreateStockObject.bevc_po_sides");  
      bevc_po_sides->SetName("Sides");  
      AutoAlloc<SelectionTag>        bevc_po_cap(Tpolygonselection);  
      if (!bevc_po_cap)            return ErrPrt("Greebler.Greebler.CreateStockObject.bevc_po_cap");  
      bevc_po_cap->SetName("Cap");  
      AutoAlloc<SelectionTag>        bevc_po_bevel(Tpolygonselection);  
      if (!bevc_po_bevel)            return ErrPrt("Greebler.Greebler.CreateStockObject.bevc_po_bevel");  
      bevc_po_bevel->SetName("Bevel");  
      AutoAlloc<SelectionTag>        bevc_pt_top(Tpointselection);  
      if (!bevc_pt_top)            return ErrPrt("Greebler.Greebler.CreateStockObject.bevc_pt_top");  
      bevc_pt_top->SetName("Top");  
      AutoAlloc<SelectionTag>        bevc_pt_sides(Tpointselection);  
      if (!bevc_pt_sides)            return ErrPrt("Greebler.Greebler.CreateStockObject.bevc_pt_sides");  
      bevc_pt_sides->SetName("Sides");  
      // Set up Points and Polygons  
      // - Extrude  
      LONG        i;  
      Vector*        points =        extrude->GetPointW();  
      if (!points)                return ErrPrt("Greebler.Greebler.CreateStockObject.extrude->GetPointW");  
      CPolygon*    polys =            extrude->GetPolygonW();  
      if (!polys)                    return ErrPrt("Greebler.Greebler.CreateStockObject.extrude->GetPolygonW");  
      CopyMem(ssd_extrude.points, points, sizeof(Vector)*ssd_extrude.numPoints);  
      for (i = 0L; i != ssd_extrude.numPolygons; ++i)  
      {  
          polys[i].a =    ssd_extrude.polygons[i][0];  
          polys[i].b =    ssd_extrude.polygons[i][1];  
          polys[i].c =    ssd_extrude.polygons[i][2];  
          polys[i].d =    ssd_extrude.polygons[i][3];  
      }  
      // - Create UVWTag and set it up.  
      if (!CreateUVs(extrude, polys, points, NULL, ssd_extrude.numPolygons, ssd_extrude.numPoints))    return ErrPrt("Greebler.Greebler.CreateStockObject.CreateUVs(extrude)");  
      // - Extrude Cap  
      points =                    extcap->GetPointW();  
      if (!points)                return ErrPrt("Greebler.Greebler.CreateStockObject.extcap->GetPointW");  
      polys =                        extcap->GetPolygonW();  
      if (!polys)                    return ErrPrt("Greebler.Greebler.CreateStockObject.extcap->GetPolygonW");  
      CopyMem(ssd_extcap.points, points, sizeof(Vector)*ssd_extcap.numPoints);  
      for (i = 0L; i != ssd_extcap.numPolygons; ++i)  
      {  
          polys[i].a =    ssd_extcap.polygons[i][0];  
          polys[i].b =    ssd_extcap.polygons[i][1];  
          polys[i].c =    ssd_extcap.polygons[i][2];  
          polys[i].d =    ssd_extcap.polygons[i][3];  
      }  
      // - Create UVWTag and set it up.  
      if (!CreateUVs(extcap, polys, points, NULL, ssd_extcap.numPolygons, ssd_extcap.numPoints))    return ErrPrt("Greebler.Greebler.CreateStockObject.CreateUVs(extcap)");  
      // - Bevel  
      points =                    bevel->GetPointW();  
      if (!points)                return ErrPrt("Greebler.Greebler.CreateStockObject.bevel->GetPointW");  
      polys =                        bevel->GetPolygonW();  
      if (!polys)                    return ErrPrt("Greebler.Greebler.CreateStockObject.bevel->GetPolygonW");  
      CopyMem(ssd_bevel.points, points, sizeof(Vector)*ssd_bevel.numPoints);  
      for (i = 0L; i != ssd_bevel.numPolygons; ++i)  
      {  
          polys[i].a =    ssd_bevel.polygons[i][0];  
          polys[i].b =    ssd_bevel.polygons[i][1];  
          polys[i].c =    ssd_bevel.polygons[i][2];  
          polys[i].d =    ssd_bevel.polygons[i][3];  
      }  
      // - Create UVWTag and set it up.  
      if (!CreateUVs(bevel, polys, points, NULL, ssd_bevel.numPolygons, ssd_bevel.numPoints))    return ErrPrt("Greebler.Greebler.CreateStockObject.CreateUVs(bevel)");  
      // - Bevel Cap  
      points =                    bevcap->GetPointW();  
      if (!points)                return ErrPrt("Greebler.Greebler.CreateStockObject.bevcap->GetPointW");  
      polys =                        bevcap->GetPolygonW();  
      if (!polys)                    return ErrPrt("Greebler.Greebler.CreateStockObject.bevcap->GetPolygonW");  
      CopyMem(ssd_bevcap.points, points, sizeof(Vector)*ssd_bevcap.numPoints);  
      for (i = 0L; i != ssd_bevcap.numPolygons; ++i)  
      {  
          polys[i].a =    ssd_bevcap.polygons[i][0];  
          polys[i].b =    ssd_bevcap.polygons[i][1];  
          polys[i].c =    ssd_bevcap.polygons[i][2];  
          polys[i].d =    ssd_bevcap.polygons[i][3];  
      }  
      // - Create UVWTag and set it up.  
      if (!CreateUVs(bevcap, polys, points, NULL, ssd_bevcap.numPolygons, ssd_bevcap.numPoints))    return ErrPrt("Greebler.Greebler.CreateStockObject.CreateUVs(bevcap)");  
      // Set up PolygonSelections and PointSelections  
      // - Extrude  
      BaseSelect*    bs =            ext_po_top->GetBaseSelect();  
      if (!bs)                    return ErrPrt("Greebler.Greebler.CreateStockObject.ext_po_top->GetBaseSelect");  
      bs->FromArray(&(ssd_extrude.posel_top)[0], ssd_extrude.numPolygons);  
      bs =                        ext_po_sides->GetBaseSelect();  
      if (!bs)                    return ErrPrt("Greebler.Greebler.CreateStockObject.ext_po_sides->GetBaseSelect");  
      bs->FromArray(&(ssd_extrude.posel_sides)[0], ssd_extrude.numPolygons);  
      bs =                        ext_pt_top->GetBaseSelect();  
      if (!bs)                    return ErrPrt("Greebler.Greebler.CreateStockObject.ext_pt_top->GetBaseSelect");  
      bs->FromArray(&(ssd_extrude.ptsel_top)[0], ssd_extrude.numPoints);  
      // - Extrude Cap  
      bs =                        extc_po_top->GetBaseSelect();  
      if (!bs)                    return ErrPrt("Greebler.Greebler.CreateStockObject.extc_po_top->GetBaseSelect");  
      bs->FromArray(&(ssd_extcap.posel_top)[0], ssd_extcap.numPolygons);  
      bs =                        extc_po_sides->GetBaseSelect();  
      if (!bs)                    return ErrPrt("Greebler.Greebler.CreateStockObject.extc_po_sides->GetBaseSelect");  
      bs->FromArray(&(ssd_extcap.posel_sides)[0], ssd_extcap.numPolygons);  
      bs =                        extc_po_cap->GetBaseSelect();  
      if (!bs)                    return ErrPrt("Greebler.Greebler.CreateStockObject.extc_po_cap->GetBaseSelect");  
      bs->FromArray(&(ssd_extcap.posel_cap)[0], ssd_extcap.numPolygons);  
      bs =                        extc_pt_top->GetBaseSelect();  
      if (!bs)                    return ErrPrt("Greebler.Greebler.CreateStockObject.extc_pt_top->GetBaseSelect");  
      bs->FromArray(&(ssd_extcap.ptsel_top)[0], ssd_extcap.numPoints);  
      // - Bevel  
      bs =                        bev_po_top->GetBaseSelect();  
      if (!bs)                    return ErrPrt("Greebler.Greebler.CreateStockObject.bev_po_top->GetBaseSelect");  
      bs->FromArray(&(ssd_bevel.posel_top)[0], ssd_bevel.numPolygons);  
      bs =                        bev_po_sides->GetBaseSelect();  
      if (!bs)                    return ErrPrt("Greebler.Greebler.CreateStockObject.bev_po_sides->GetBaseSelect");  
      bs->FromArray(&(ssd_bevel.posel_sides)[0], ssd_bevel.numPolygons);  
      bs =                        bev_po_bevel->GetBaseSelect();  
      if (!bs)                    return ErrPrt("Greebler.Greebler.CreateStockObject.bev_po_bevel->GetBaseSelect");  
      bs->FromArray(&(ssd_bevel.posel_bevel)[0], ssd_bevel.numPolygons);  
      bs =                        bev_pt_top->GetBaseSelect();  
      if (!bs)                    return ErrPrt("Greebler.Greebler.CreateStockObject.bev_pt_top->GetBaseSelect");  
      bs->FromArray(&(ssd_bevel.ptsel_top)[0], ssd_bevel.numPoints);  
      bs =                        bev_pt_sides->GetBaseSelect();  
      if (!bs)                    return ErrPrt("Greebler.Greebler.CreateStockObject.bev_pt_sides->GetBaseSelect");  
      bs->FromArray(&(ssd_bevel.ptsel_sides)[0], ssd_bevel.numPoints);  
      // - Bevel Cap  
      bs =                        bevc_po_top->GetBaseSelect();  
      if (!bs)                    return ErrPrt("Greebler.Greebler.CreateStockObject.bevc_po_top->GetBaseSelect");  
      bs->FromArray(&(ssd_bevcap.posel_top)[0], ssd_bevcap.numPolygons);  
      bs =                        bevc_po_sides->GetBaseSelect();  
      if (!bs)                    return ErrPrt("Greebler.Greebler.CreateStockObject.bevc_po_sides->GetBaseSelect");  
      bs->FromArray(&(ssd_bevcap.posel_sides)[0], ssd_bevcap.numPolygons);  
      bs =                        bevc_po_bevel->GetBaseSelect();  
      if (!bs)                    return ErrPrt("Greebler.Greebler.CreateStockObject.bevc_po_bevel->GetBaseSelect");  
      bs->FromArray(&(ssd_bevcap.posel_bevel)[0], ssd_bevcap.numPolygons);  
      bs =                        bevc_po_cap->GetBaseSelect();  
      if (!bs)                    return ErrPrt("Greebler.Greebler.CreateStockObject.bevc_po_cap->GetBaseSelect");  
      bs->FromArray(&(ssd_bevcap.posel_cap)[0], ssd_bevcap.numPolygons);  
      bs =                        bevc_pt_top->GetBaseSelect();  
      if (!bs)                    return ErrPrt("Greebler.Greebler.CreateStockObject.bevc_pt_top->GetBaseSelect");  
      bs->FromArray(&(ssd_bevcap.ptsel_top)[0], ssd_bevcap.numPoints);  
      bs =                        bevc_pt_sides->GetBaseSelect();  
      if (!bs)                    return ErrPrt("Greebler.Greebler.CreateStockObject.bevc_pt_sides->GetBaseSelect");  
      bs->FromArray(&(ssd_bevcap.ptsel_sides)[0], ssd_bevcap.numPoints);  
      // Release all from AutoAlloc  
      // - put tags on objects  
      extrude->InsertTag(ext_pt_top.Release());  
      extrude->InsertTag(ext_po_sides.Release());  
      extrude->InsertTag(ext_po_top.Release());  
      extcap->InsertTag(extc_pt_top.Release());  
      extcap->InsertTag(extc_po_cap.Release());  
      extcap->InsertTag(extc_po_sides.Release());  
      extcap->InsertTag(extc_po_top.Release());  
      bevel->InsertTag(bev_pt_sides.Release());  
      bevel->InsertTag(bev_pt_top.Release());  
      bevel->InsertTag(bev_po_bevel.Release());  
      bevel->InsertTag(bev_po_sides.Release());  
      bevel->InsertTag(bev_po_top.Release());  
      bevcap->InsertTag(bevc_pt_sides.Release());  
      bevcap->InsertTag(bevc_pt_top.Release());  
      bevcap->InsertTag(bevc_po_bevel.Release());  
      bevcap->InsertTag(bevc_po_cap.Release());  
      bevcap->InsertTag(bevc_po_sides.Release());  
      bevcap->InsertTag(bevc_po_top.Release());  
      // - put objects under Null object  
      bevcap->InsertUnderLast(nop);  
      bevel->InsertUnderLast(nop);  
      extcap->InsertUnderLast(nop);  
      extrude->InsertUnderLast(nop);  
      bevcap.Release();  
      bevel.Release();  
      extcap.Release();  
      extrude.Release();  
      // - and Append Null to AtomArray  
      if (!array_stock->Append(nop.Release()))    return ErrPrt("Greebler.Greebler.CreateStockObject.array_stock.Append()");  
      return TRUE;  
    }
    

    And the header with the static shape object definitions (partial) :

    ////////////////////////////////////////////////////////////////  
    // StockShapeDefs.h  
    ////////////////////////////////////////////////////////////////  
    // Greebler Stock Shape Geometry definitions  
    ////////////////////////////////////////////////////////////////  
    // V1.0.0 2010.11.26 Robert Templeton  
    ////////////////////////////////////////////////////////////////  
    #ifndef _STOCKSHAPEDEFS_H_  
    #define _STOCKSHAPEDEFS_H_  
      
    // Somewhere to internally define stock shape object information  
    struct StockShapeDefs  
    {  
      LONG        numPoints;  
      LONG        numPolygons;  
      Vector        points[40];  
      LONG        polygons[40][4];  
      // Polygon Selections  
      UCHAR        posel_top[40];  
      UCHAR        posel_sides[40];  
      UCHAR        posel_cap[40];  
      UCHAR        posel_bevel[40];  
      // Point Selections  
      UCHAR        ptsel_top[40];  
      UCHAR        ptsel_sides[40];  
    };  
      
    // =============================================================  
    // Cube  
    static StockShapeDefs    Cube_Extrude =  
    {  
      8L, 5L,  
      {  
          Vector(-0.5,    0.0,    -0.5),  
          Vector(-0.5,    0.0,    0.5),  
          Vector(0.5,        0.0,    0.5),  
          Vector(0.5,        0.0,    -0.5),  
          Vector(-0.5,    0.0,    -0.5),  
          Vector(-0.5,    0.0,    0.5),  
          Vector(0.5,        0.0,    0.5),  
          Vector(0.5,        0.0,    -0.5),  
          0L  
      },  
      {  
          {7,        4,    5,    6},  
          {3,        7,    6,    2},  
          {2,        6,    5,    1},  
          {1,        5,    4,    0},  
          {0,        4,    7,    3},  
          0L  
      },  
      // Polygon  
      // - Top  
      {1,0,0,0,0},  
      // - Sides  
      {0,1,1,1,1},  
      // - Cap  
      {0L},  
      // - Bevel  
      {0L},  
      // Point  
      // - Top  
      {0,0,0,0,1,1,1,1},  
      // - Sides  
      {0L}  
    };  
    static StockShapeDefs    Cube_ExtrudeCap =  
    {  
      8L, 6L,  
      {  
          Vector(-0.5,    0.0,    -0.5),  
          Vector(-0.5,    0.0,    0.5),  
          Vector(0.5,        0.0,    0.5),  
          Vector(0.5,        0.0,    -0.5),  
          Vector(-0.5,    0.0,    -0.5),  
          Vector(-0.5,    0.0,    0.5),  
          Vector(0.5,        0.0,    0.5),  
          Vector(0.5,        0.0,    -0.5),  
          0L  
      },  
      {  
          {7,        4,    5,    6},  
          {2,        1,    0,    3},  
          {3,        7,    6,    2},  
          {2,        6,    5,    1},  
          {1,        5,    4,    0},  
          {0,        4,    7,    3},  
          0L  
      },  
      // Polygon  
      // - Top  
      {1,0,0,0,0,0},  
      // - Sides  
      {0,0,1,1,1,1},  
      // - Cap  
      {0,1,0,0,0,0},  
      // - Bevel  
      {0L},  
      // Point  
      // - Top  
      {0,0,0,0,1,1,1,1},  
      // - Sides  
      {0L}  
    };  
    static StockShapeDefs    Cube_Bevel =  
    {  
      12L, 9L,  
      {  
          Vector(-0.5,    0.0,    -0.5),  
          Vector(-0.5,    0.0,    0.5),  
          Vector(0.5,        0.0,    0.5),  
          Vector(0.5,        0.0,    -0.5),  
          Vector(-0.5,    0.0,    -0.5),  
          Vector(-0.5,    0.0,    0.5),  
          Vector(0.5,        0.0,    0.5),  
          Vector(0.5,        0.0,    -0.5),  
          Vector(0.0,        0.0,    0.0),  
          Vector(0.0,        0.0,    0.0),  
          Vector(0.0,        0.0,    0.0),  
          Vector(0.0,        0.0,    0.0),  
          0L  
      },  
      {  
          {11,    8,    9,    10},  
          {3,        7,    6,    2},  
          {2,        6,    5,    1},  
          {1,        5,    4,    0},  
          {0,        4,    7,    3},  
          {7,        11,    10,    6},  
          {6,        10,    9,    5},  
          {5,        9,    8,    4},  
          {4,        8,    11,    7},  
          0L  
      },  
      // Polygon  
      // - Top  
      {1,0,0,0,0,0,0,0,0},  
      // - Sides  
      {0,1,1,1,1,0,0,0,0},  
      // - Cap  
      {0L},  
      // - Bevel  
      {0,0,0,0,0,1,1,1,1},  
      // Point  
      // - Top  
      {0,0,0,0,0,0,0,0,1,1,1,1},  
      // - Sides  
      {0,0,0,0,1,1,1,1,0,0,0,0}  
    };  
    static StockShapeDefs    Cube_BevelCap =  
    {  
      12L, 10L,  
      {  
          Vector(-0.5,    0.0,    -0.5),  
          Vector(-0.5,    0.0,    0.5),  
          Vector(0.5,        0.0,    0.5),  
          Vector(0.5,        0.0,    -0.5),  
          Vector(-0.5,    0.0,    -0.5),  
          Vector(-0.5,    0.0,    0.5),  
          Vector(0.5,        0.0,    0.5),  
          Vector(0.5,        0.0,    -0.5),  
          Vector(0.0,        0.0,    0.0),  
          Vector(0.0,        0.0,    0.0),  
          Vector(0.0,        0.0,    0.0),  
          Vector(0.0,        0.0,    0.0),  
          0L  
      },  
      {  
          {11,    8,    9,    10},  
          {2,        1,    0,    3},  
          {3,        7,    6,    2},  
          {2,        6,    5,    1},  
          {1,        5,    4,    0},  
          {0,        4,    7,    3},  
          {7,        11,    10,    6},  
          {6,        10,    9,    5},  
          {5,        9,    8,    4},  
          {4,        8,    11,    7},  
          0L  
      },  
      // Polygon  
      // - Top  
      {1,0,0,0,0,0,0,0,0,0},  
      // - Sides  
      {0,0,1,1,1,1,0,0,0,0},  
      // - Cap  
      {0,1,0,0,0,0,0,0,0,0},  
      // - Bevel  
      {0,0,0,0,0,0,1,1,1,1},  
      // Point  
      // - Top  
      {0,0,0,0,0,0,0,0,1,1,1,1},  
      // - Sides  
      {0,0,0,0,1,1,1,1,0,0,0,0}  
    };  
    ...  
    


  • THE POST BELOW IS MORE THAN 5 YEARS OLD. RELATED SUPPORT INFORMATION MIGHT BE OUTDATED OR DEPRECATED

    On 29/11/2010 at 12:23, xxxxxxxx wrote:

    I will send you the entire project after some more tests.  I am looking at C4DPL_STARTACTIVITY for doing the plugin Init() instead of after Registering the plugin in PluginStart().  At a complete loss on reason why this fails.

    Thanks!


Log in to reply