Maxon Developers Maxon Developers
    • Documentation
      • Cinema 4D Python API
      • Cinema 4D C++ API
      • Cineware API
      • ZBrush Python API
      • ZBrush GoZ API
      • Code Examples on Github
    • Forum
    • Downloads
    • Support
      • Support Procedures
      • Registered Developer Program
      • Plugin IDs
      • Contact Us
    • Categories
      • Overview
      • News & Information
      • Cinema 4D SDK Support
      • Cineware SDK Support
      • ZBrush 4D SDK Support
      • Bugs
      • General Talk
    • Recent
    • Tags
    • Users
    • Login

    NET Client Crash

    Scheduled Pinned Locked Moved SDK Help
    4 Posts 0 Posters 332 Views
    Loading More Posts
    • Oldest to Newest
    • Newest to Oldest
    • Most Votes
    Reply
    • Reply as topic
    Log in to reply
    This topic has been deleted. Only users with topic management privileges can see it.
    • H Offline
      Helper
      last edited by

      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.

      1 Reply Last reply Reply Quote 0
      • H Offline
        Helper
        last edited by

        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 [email protected] showing the problem otherwise it's not possible for me to find a solution.

        cheers,
        Matthias

        1 Reply Last reply Reply Quote 0
        • H Offline
          Helper
          last edited by

          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}  
          };  
          ...  
          
          1 Reply Last reply Reply Quote 0
          • H Offline
            Helper
            last edited by

            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!

            1 Reply Last reply Reply Quote 0
            • First post
              Last post