daily pastebin goal
2%
SHARE
TWEET

Untitled

a guest May 16th, 2018 102 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*
  2.  *
  3.  *  This example demonstrates how to manually implement a tool operation
  4.  *  item.
  5.  *
  6.  */
  7. #include <lxsdk/lx_mesh.hpp>
  8. #include <lxsdk/lx_tool.hpp>
  9. #include <lxsdk/lx_toolui.hpp>
  10. #include <lxsdk/lx_vector.hpp>
  11. #include <lxsdk/lxu_attributes.hpp>
  12. #include <lxsdk/lxu_math.hpp>
  13. #include <lxsdk/lxu_modifier.hpp>
  14. #include <lxsdk/lxu_package.hpp>
  15. #include <lxsdk/lx_layer.hpp>
  16.  
  17. #include <cmath>
  18.  
  19. static const char *sPackageName = "plane.tool.item";
  20. static const char *sToolOpName = "plane.tool.operation";
  21. static const char *sToolName = "plane.tool";
  22. static const char *sModifierName = "plane.tool.modifier";
  23. static const char *sAttrSize = "size";
  24.  
  25. static LXtTextValueHint sHintMinZero[] =
  26. {
  27.     0,  "%min",
  28.     -1, NULL
  29. };
  30.  
  31. class Package :
  32.     public CLxDefaultPackage
  33. {
  34.     public:
  35.             static void
  36.         initialize()
  37.         {
  38.             CLxGenericPolymorph *srv = new CLxPolymorph<Package>;
  39.             srv->AddInterface(new CLxIfc_Package<Package>);
  40.             srv->AddInterface(new CLxIfc_StaticDesc<Package>);
  41.             lx::AddServer(sPackageName, srv);
  42.         }
  43.    
  44.         LXxO_Package_SetupChannels  // LxResult (ILxUnknownID addChan)
  45.         {
  46.             CLxUser_AddChannel channel(addChan);
  47.             if(LXx_OK(channel.NewChannel(sAttrSize, LXsTYPE_DISTANCE)))
  48.             {
  49.                 channel.SetDefault(0.5, 0);
  50.                 channel.SetHint(sHintMinZero);
  51.             }
  52.             if(LXx_OK(channel.NewChannel(LXsICHAN_TOOL_OBJ, LXsTYPE_OBJREF)))
  53.             {
  54.                 channel.SetInternal();
  55.             }
  56.             return LXe_OK;
  57.         }
  58.    
  59.         static LXtTagInfoDesc descInfo[];
  60. };
  61.  
  62. LXtTagInfoDesc Package::descInfo[] =
  63. {
  64.     { LXsPKG_SUPERTYPE, LXsITYPE_TOOLOP },
  65.     { LXsPKG_TOOL_TASK, LXs_TASK_ACTR },
  66.     { LXsPKG_TOOL_ORDER, LXs_ORD_ACTR },
  67.     { LXsPKG_TOOL_CHANNEL, LXsICHAN_TOOL_OBJ },
  68.     { 0 }
  69. };
  70.  
  71. enum ePacketOffset
  72. {
  73.     ePacketOffset_Subject2,
  74.     ePacketOffset_MAX
  75. };
  76.  
  77. class ToolOperation :
  78.     public CLxImpl_ToolOperation
  79. {
  80.     public:
  81.             static void
  82.         initialize()
  83.         {
  84.             CLxGenericPolymorph *srv = new CLxPolymorph<ToolOperation>;
  85.             srv->AddInterface(new CLxIfc_ToolOperation<ToolOperation>);
  86.             lx::AddSpawner(sToolOpName, srv);
  87.         }
  88.    
  89.             static ToolOperation*
  90.         Spawn(
  91.             void **ppvObj)
  92.         {
  93.             static CLxSpawner<ToolOperation> spawner(sToolOpName);
  94.             return spawner.Alloc(ppvObj);
  95.         }
  96.    
  97.         ToolOperation()
  98.         {
  99.             for(unsigned int i = 0; i < ePacketOffset_MAX; i++)
  100.             {
  101.                 mPacketOffsets[i] = 0;
  102.             }
  103.         }
  104.    
  105.         LXxO_ToolOperation_Evaluate  // LxResult (ILxUnknownID vts)
  106.         {
  107.             CLxUser_VectorStack vector(vts);
  108.             if(true == vector.test())
  109.             {
  110.                 CLxUser_Subject2Packet subjectPacket;
  111.                 if(true == vector.ReadObject(mPacketOffsets[ePacketOffset_Subject2], subjectPacket))
  112.                 {
  113.                     CLxUser_LayerScan layerScan;
  114.                     if(true == subjectPacket.BeginScan(LXf_LAYERSCAN_EDIT, layerScan))
  115.                     {
  116.                         unsigned int count = layerScan.NumLayers();
  117.                         for(unsigned int i = 0; i < count; i++)
  118.                         {
  119.                             CLxUser_Mesh mesh;
  120.                             if(true == layerScan.EditMeshByIndex(i, mesh))
  121.                                 createPlane(mesh, mSize);
  122.                         }
  123.                        
  124.                         return LXe_OK;
  125.                     }
  126.                 }
  127.             }
  128.        
  129.             return LXe_FAILED;
  130.         }
  131.    
  132.             void
  133.         createPlane(
  134.             CLxUser_Mesh &mesh,
  135.             double size)
  136.         {
  137.             if(false == mesh.test() || lx::Compare(size, 0.0) == LXi_EQUAL_TO)
  138.                 return;
  139.            
  140.             static double positions[4][3] = {{-1.0, 0.0, -1.0},
  141.                              { 1.0, 0.0, -1.0},
  142.                              { 1.0, 0.0,  1.0},
  143.                              {-1.0, 0.0,  1.0}};
  144.            
  145.             CLxUser_Point point(mesh);
  146.             LXtPointID pointIDs[4];
  147.             for(unsigned int i = 0; i < 4; i++)
  148.             {
  149.                 LXtVector temp;
  150.                 LXx_VSCL3(temp, positions[i], mSize);
  151.                 point.New(temp, &pointIDs[i]);
  152.             }
  153.            
  154.             CLxUser_Polygon polygon(mesh);
  155.             LXtPolygonID polygonID = NULL;
  156.             polygon.New(LXiPTYP_FACE, pointIDs, 4, 1, &polygonID);
  157.            
  158.             mesh.SetMeshEdits(LXf_MESHEDIT_GEOMETRY);
  159.         }
  160.    
  161.             void
  162.         setSize(
  163.             double size)
  164.         {
  165.             mSize = std::fabs(size);
  166.         }
  167.    
  168.             bool
  169.         setPacketOffset(
  170.             unsigned int index,
  171.             unsigned int offset)
  172.         {
  173.             if(index >= ePacketOffset_MAX)
  174.                 return false;
  175.            
  176.             mPacketOffsets[index] = offset;
  177.             return true;
  178.         }
  179.    
  180.     private:
  181.         unsigned int mPacketOffsets[ePacketOffset_MAX];
  182.         double mSize;
  183. };
  184.  
  185. class Tool :
  186.     public CLxImpl_Tool,
  187.     public CLxImpl_ToolModel,
  188.     public CLxDynamicAttributes
  189. {
  190.     public:
  191.             static void
  192.         initialize ()
  193.         {
  194.             CLxGenericPolymorph *srv = new CLxPolymorph<Tool>;
  195.             srv->AddInterface(new CLxIfc_Tool<Tool>);
  196.             srv->AddInterface(new CLxIfc_ToolModel<Tool>);
  197.             srv->AddInterface(new CLxIfc_Attributes<Tool>);
  198.             srv->AddInterface(new CLxIfc_AttributesUI<Tool>);
  199.             srv->AddInterface(new CLxIfc_StaticDesc<Tool>);
  200.             lx::AddSpawner(sToolName, srv);
  201.         }
  202.    
  203.             static Tool*
  204.         Spawn(
  205.             void **ppvObj)
  206.         {
  207.             static CLxSpawner<Tool> spawner(sToolName);
  208.             return spawner.Alloc(ppvObj);
  209.         }
  210.    
  211.         Tool()
  212.         {
  213.             dyna_Add(sAttrSize, LXsTYPE_DISTANCE);
  214.             attr_SetFlt(0, 0.5);
  215.        
  216.             for(unsigned int i = 0; i < ePacketOffset_MAX; i++)
  217.             {
  218.                 mPacketOffsets[i] = 0;
  219.             }
  220.        
  221.             CLxUser_PacketService pktSvc;
  222.             if(true == pktSvc.NewVectorType(LXsCATEGORY_TOOL, mVecType))
  223.             {
  224.                 if(LXx_OK(pktSvc.AddPacket(mVecType, LXsP_TOOL_SUBJECT2, LXfVT_GET)))
  225.                     mPacketOffsets[ePacketOffset_Subject2] = pktSvc.GetOffset(LXsCATEGORY_TOOL, LXsP_TOOL_SUBJECT2);
  226.             }
  227.         }
  228.    
  229.         LXxO_Tool_VectorType  // LXtObjectID (void)
  230.         {
  231.             return mVecType.m_loc;
  232.         }
  233.    
  234.         LXxO_Tool_Order  // const char * (void)
  235.         {
  236.             return LXs_ORD_ACTR;
  237.         }
  238.    
  239.         LXxO_Tool_Task  // LXtID4 (void)
  240.         {
  241.             return LXi_TASK_ACTR;
  242.         }
  243.    
  244.         LXxO_Tool_GetOp  // LxResult (void **ppvObj, unsigned flags)
  245.         {
  246.             *ppvObj = NULL;
  247.        
  248.             ToolOperation *toolOp = ToolOperation::Spawn(ppvObj);
  249.             if(NULL != toolOp)
  250.             {
  251.                 toolOp->setSize(dyna_Float(0, 0.5));
  252.                 for(unsigned int i = 0; i < ePacketOffset_MAX; i++)
  253.                 {
  254.                     toolOp->setPacketOffset(i, mPacketOffsets[i]);
  255.                 }
  256.             }
  257.            
  258.             return ((NULL != *ppvObj) ? LXe_OK : LXe_FAILED);
  259.         }
  260.    
  261.         static LXtTagInfoDesc descInfo[];
  262.    
  263.     private:
  264.         CLxUser_VectorType mVecType;
  265.         unsigned int mPacketOffsets[ePacketOffset_MAX];
  266. };
  267.  
  268. LXtTagInfoDesc Tool::descInfo[] =
  269. {
  270.     { LXsTOOL_USETOOLOP, "." },
  271.     { 0 }
  272. };
  273.  
  274. class ModifierElement :
  275.     public CLxItemModifierElement
  276. {
  277.     public:
  278.         ModifierElement(
  279.             CLxUser_Evaluation &eval,
  280.             ILxUnknownID item)
  281.         {
  282.             mSizeChannel = -1;
  283.             mToolChannel = -1;
  284.  
  285.             CLxUser_Item modifierItem(item);
  286.             if(true == eval.test() && true == modifierItem.test())
  287.             {
  288.                 mSizeChannel = eval.AddChan(item, sAttrSize, LXfECHAN_READ);
  289.                 mToolChannel = eval.AddChan(item, LXsICHAN_TOOL_OBJ, LXfECHAN_WRITE);
  290.             }
  291.         }
  292.  
  293.             void
  294.         Eval(
  295.             CLxUser_Evaluation &eval,
  296.             CLxUser_Attributes &attr) LXx_OVERRIDE
  297.         {
  298.             if(false == eval.test() || false == attr.test() || mSizeChannel < 0 || mToolChannel < 0)
  299.                 return;
  300.  
  301.             ILxUnknownID object = NULL;
  302.             Tool *tool = Tool::Spawn((void**)&object);
  303.             if(NULL != tool)
  304.             {
  305.                 CLxUser_ValueReference valueReference;
  306.                 if (true == attr.ObjectRW ((unsigned int) mToolChannel, valueReference))
  307.                 {
  308.                     valueReference.SetObject(object);
  309.                    
  310.                     CLxUser_Attributes toolAttr(object);
  311.                     if(true == toolAttr.test())
  312.                         toolAttr.Set(0, attr.Float((unsigned int) mSizeChannel));
  313.                 }
  314.                 lx::UnkRelease(object);
  315.             }
  316.         }
  317.  
  318.     private:
  319.         int mSizeChannel, mToolChannel;
  320. };
  321.  
  322. class ModifierServer :
  323.     public CLxItemModifierServer
  324. {
  325.     public:
  326.             static void
  327.         initialize()
  328.         {
  329.             CLxGenericPolymorph *srv = new CLxPolymorph<ModifierServer>;
  330.             srv->AddInterface(new CLxIfc_EvalModifier<ModifierServer>);
  331.             srv->AddInterface(new CLxIfc_TagDescription<ModifierServer>);
  332.             lx::AddServer(sModifierName, srv);
  333.         }
  334.  
  335.             const char*
  336.         ItemType() LXx_OVERRIDE
  337.         {
  338.             return sPackageName;
  339.         }
  340.    
  341.             CLxItemModifierElement*
  342.         Alloc(
  343.             CLxUser_Evaluation &eval,
  344.             ILxUnknownID item) LXx_OVERRIDE
  345.         {
  346.             return new ModifierElement(eval, item);
  347.         }
  348. };
  349.  
  350.     void
  351. initialize()
  352. {
  353.     Package::initialize();
  354.     ToolOperation::initialize();
  355.     Tool::initialize();
  356.     ModifierServer::initialize();
  357. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top