Guest User

Untitled

a guest
May 16th, 2018
195
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 7.53 KB | None | 0 0
  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. }
Add Comment
Please, Sign In to add comment