PageRenderTime 44ms CodeModel.GetById 14ms RepoModel.GetById 0ms app.codeStats 0ms

/Externals/MayaDataModel/include/MayaDMSkinCluster.h

https://bitbucket.org/ZhangJingGuo/opencollada
C Header | 479 lines | 457 code | 13 blank | 9 comment | 47 complexity | a713230e23142ad331435e9356fc994b MD5 | raw file
    

  1. /*

    2. 

  2.     Copyright (c) 2008-2009 NetAllied Systems GmbH

    3. 

  3. 

    4. 

  4.     This file is part of MayaDataModel.

    5. 

  5. 

    6. 

  6.     Licensed under the MIT Open Source License,

    7. 

  7.     for details please see LICENSE file or the website

    8. 

  8.     http://www.opensource.org/licenses/mit-license.php

    9. 

  9. */

    10. 

  10. #ifndef __MayaDM_SKINCLUSTER_H__

    11. 

  11. #define __MayaDM_SKINCLUSTER_H__

    12. 

  12. #include "MayaDMTypes.h"

    13. 

  13. #include "MayaDMConnectables.h"

    14. 

  14. #include "MayaDMGeometryFilter.h"

    15. 

  15. namespace MayaDM

    16. 

  16. {

    17. 

  17. class SkinCluster : public GeometryFilter

    18. 

  18. {

    19. 

  19. public:

    20. 

  20. 	struct WeightList{

    21. 

  21. 		double* weights;

    22. 

  22. 		void write(FILE* file) const

    23. 

  23. 		{

    24. 

  24. 			size_t size = sizeof(weights)/sizeof(double);

    25. 

  25. 			for(size_t i=0; i<size; ++i)

    26. 

  26. 			{

    27. 

  27. 				fprintf(file,"%f", weights[i]);

    28. 

  28. 				if(i+1<size) fprintf(file," ");

    29. 

  29. 			}

    30. 

  30. 		}

    31. 

  31. 	};

    32. 

  32. public:

    33. 

  33. 

    34. 

  34. 	SkinCluster():GeometryFilter(){}

    35. 

  35. 	SkinCluster(FILE* file,const std::string& name,const std::string& parent="",bool shared=false,bool create=true)

    36. 

  36. 		:GeometryFilter(file, name, parent, "skinCluster", shared, create){}

    37. 

  37. 	virtual ~SkinCluster(){}

    38. 

  38. 

    39. 

  39. 	void setWeightList(size_t wl_i,const WeightList& wl)

    40. 

  40. 	{

    41. 

  41. 		fprintf(mFile,"\tsetAttr \".wl[%i]\" ",wl_i);

    42. 

  42. 		wl.write(mFile);

    43. 

  43. 		fprintf(mFile,";\n");

    44. 

  44. 	}

    45. 

  45. 	void setWeightList(size_t wl_start,size_t wl_end,WeightList* wl)

    46. 

  46. 	{

    47. 

  47. 		fprintf(mFile,"\tsetAttr \".wl[%i:%i]\" ", wl_start,wl_end);

    48. 

  48. 		size_t size = (wl_end-wl_start)*1+1;

    49. 

  49. 		for(size_t i=0;i<size;++i)

    50. 

  50. 		{

    51. 

  51. 			wl[i].write(mFile);

    52. 

  52. 			fprintf(mFile,"\n");

    53. 

  53. 		}

    54. 

  54. 		fprintf(mFile,";\n");

    55. 

  55. 	}

    56. 

  56. 	void startWeightList(size_t wl_start,size_t wl_end)const

    57. 

  57. 	{

    58. 

  58. 		fprintf(mFile,"\tsetAttr \".wl[%i:%i]\"",wl_start,wl_end);

    59. 

  59. 		fprintf(mFile," -type \"WeightList\" ");

    60. 

  60. 	}

    61. 

  61. 	void appendWeightList(const WeightList& wl)const

    62. 

  62. 	{

    63. 

  63. 		fprintf(mFile," ");

    64. 

  64. 		wl.write(mFile);

    65. 

  65. 	}

    66. 

  66. 	void endWeightList()const

    67. 

  67. 	{

    68. 

  68. 		fprintf(mFile,";\n");

    69. 

  69. 	}

    70. 

  70. 	void setWeights(size_t wl_i,size_t w_i,double w)

    71. 

  71. 	{

    72. 

  72. 		if(w == 0.0) return;

    73. 

  73. 		fprintf(mFile,"\tsetAttr \".wl[%i].w[%i]\" %f;\n", wl_i,w_i,w);

    74. 

  74. 	}

    75. 

  75. 	void setWeights(size_t wl_i,size_t w_start,size_t w_end,double* w)

    76. 

  76. 	{

    77. 

  77. 		fprintf(mFile,"\tsetAttr \".wl[%i].w[%i:%i]\" ", wl_i,w_start,w_end);

    78. 

  78. 		size_t size = (w_end-w_start)*1+1;

    79. 

  79. 		for(size_t i=0;i<size;++i)

    80. 

  80. 		{

    81. 

  81. 			fprintf(mFile,"%f",w[i]);

    82. 

  82. 			if(i+1<size) fprintf(mFile," ");

    83. 

  83. 		}

    84. 

  84. 		fprintf(mFile,";\n");

    85. 

  85. 	}

    86. 

  86. 	void startWeights(size_t wl_i,size_t w_start,size_t w_end)const

    87. 

  87. 	{

    88. 

  88. 		fprintf(mFile,"\tsetAttr \".wl[%i].w[%i:%i]\"",wl_i,w_start,w_end);

    89. 

  89. 	}

    90. 

  90. 	void appendWeights(double w)const

    91. 

  91. 	{

    92. 

  92. 		fprintf(mFile," %f",w);

    93. 

  93. 	}

    94. 

  94. 	void endWeights()const

    95. 

  95. 	{

    96. 

  96. 		fprintf(mFile,";\n");

    97. 

  97. 	}

    98. 

  98. 	void setBindPreMatrix(size_t pm_i,const matrix& pm)

    99. 

  99. 	{

    100. 

  100. 		if(pm == identity) return;

    101. 

  101. 		fprintf(mFile,"\tsetAttr \".pm[%i]\" -type \"matrix\" ",pm_i);

    102. 

  102. 		pm.write(mFile);

    103. 

  103. 		fprintf(mFile,";\n");

    104. 

  104. 	}

    105. 

  105. 	void setBindPreMatrix(size_t pm_start,size_t pm_end,matrix* pm)

    106. 

  106. 	{

    107. 

  107. 		fprintf(mFile,"\tsetAttr \".pm[%i:%i]\" ", pm_start,pm_end);

    108. 

  108. 		size_t size = (pm_end-pm_start)*1+1;

    109. 

  109. 		for(size_t i=0;i<size;++i)

    110. 

  110. 		{

    111. 

  111. 			pm[i].write(mFile);

    112. 

  112. 			fprintf(mFile,"\n");

    113. 

  113. 		}

    114. 

  114. 		fprintf(mFile,";\n");

    115. 

  115. 	}

    116. 

  116. 	void startBindPreMatrix(size_t pm_start,size_t pm_end)const

    117. 

  117. 	{

    118. 

  118. 		fprintf(mFile,"\tsetAttr \".pm[%i:%i]\"",pm_start,pm_end);

    119. 

  119. 		fprintf(mFile," -type \"matrix\" ");

    120. 

  120. 	}

    121. 

  121. 	void appendBindPreMatrix(const matrix& pm)const

    122. 

  122. 	{

    123. 

  123. 		fprintf(mFile," ");

    124. 

  124. 		pm.write(mFile);

    125. 

  125. 	}

    126. 

  126. 	void endBindPreMatrix()const

    127. 

  127. 	{

    128. 

  128. 		fprintf(mFile,";\n");

    129. 

  129. 	}

    130. 

  130. 	void setGeomMatrix(const matrix& gm)

    131. 

  131. 	{

    132. 

  132. 		if(gm == identity) return;

    133. 

  133. 		fprintf(mFile,"\tsetAttr \".gm\" -type \"matrix\" ");

    134. 

  134. 		gm.write(mFile);

    135. 

  135. 		fprintf(mFile,";\n");

    136. 

  136. 	}

    137. 

  137. 	void setMatrix(size_t ma_i,const matrix& ma)

    138. 

  138. 	{

    139. 

  139. 		if(ma == identity) return;

    140. 

  140. 		fprintf(mFile,"\tsetAttr \".ma[%i]\" -type \"matrix\" ",ma_i);

    141. 

  141. 		ma.write(mFile);

    142. 

  142. 		fprintf(mFile,";\n");

    143. 

  143. 	}

    144. 

  144. 	void setMatrix(size_t ma_start,size_t ma_end,matrix* ma)

    145. 

  145. 	{

    146. 

  146. 		fprintf(mFile,"\tsetAttr \".ma[%i:%i]\" ", ma_start,ma_end);

    147. 

  147. 		size_t size = (ma_end-ma_start)*1+1;

    148. 

  148. 		for(size_t i=0;i<size;++i)

    149. 

  149. 		{

    150. 

  150. 			ma[i].write(mFile);

    151. 

  151. 			fprintf(mFile,"\n");

    152. 

  152. 		}

    153. 

  153. 		fprintf(mFile,";\n");

    154. 

  154. 	}

    155. 

  155. 	void startMatrix(size_t ma_start,size_t ma_end)const

    156. 

  156. 	{

    157. 

  157. 		fprintf(mFile,"\tsetAttr \".ma[%i:%i]\"",ma_start,ma_end);

    158. 

  158. 		fprintf(mFile," -type \"matrix\" ");

    159. 

  159. 	}

    160. 

  160. 	void appendMatrix(const matrix& ma)const

    161. 

  161. 	{

    162. 

  162. 		fprintf(mFile," ");

    163. 

  163. 		ma.write(mFile);

    164. 

  164. 	}

    165. 

  165. 	void endMatrix()const

    166. 

  166. 	{

    167. 

  167. 		fprintf(mFile,";\n");

    168. 

  168. 	}

    169. 

  169. 	void setDropoff(size_t dpf_i,double dpf)

    170. 

  170. 	{

    171. 

  171. 		if(dpf == 4.0) return;

    172. 

  172. 		fprintf(mFile,"\tsetAttr \".dpf[%i]\" %f;\n", dpf_i,dpf);

    173. 

  173. 	}

    174. 

  174. 	void setDropoff(size_t dpf_start,size_t dpf_end,double* dpf)

    175. 

  175. 	{

    176. 

  176. 		fprintf(mFile,"\tsetAttr \".dpf[%i:%i]\" ", dpf_start,dpf_end);

    177. 

  177. 		size_t size = (dpf_end-dpf_start)*1+1;

    178. 

  178. 		for(size_t i=0;i<size;++i)

    179. 

  179. 		{

    180. 

  180. 			fprintf(mFile,"%f",dpf[i]);

    181. 

  181. 			if(i+1<size) fprintf(mFile," ");

    182. 

  182. 		}

    183. 

  183. 		fprintf(mFile,";\n");

    184. 

  184. 	}

    185. 

  185. 	void startDropoff(size_t dpf_start,size_t dpf_end)const

    186. 

  186. 	{

    187. 

  187. 		fprintf(mFile,"\tsetAttr \".dpf[%i:%i]\"",dpf_start,dpf_end);

    188. 

  188. 	}

    189. 

  189. 	void appendDropoff(double dpf)const

    190. 

  190. 	{

    191. 

  191. 		fprintf(mFile," %f",dpf);

    192. 

  192. 	}

    193. 

  193. 	void endDropoff()const

    194. 

  194. 	{

    195. 

  195. 		fprintf(mFile,";\n");

    196. 

  196. 	}

    197. 

  197. 	void setSmoothness(size_t smt_i,double smt)

    198. 

  198. 	{

    199. 

  199. 		if(smt == 0.0) return;

    200. 

  200. 		fprintf(mFile,"\tsetAttr \".smt[%i]\" %f;\n", smt_i,smt);

    201. 

  201. 	}

    202. 

  202. 	void setSmoothness(size_t smt_start,size_t smt_end,double* smt)

    203. 

  203. 	{

    204. 

  204. 		fprintf(mFile,"\tsetAttr \".smt[%i:%i]\" ", smt_start,smt_end);

    205. 

  205. 		size_t size = (smt_end-smt_start)*1+1;

    206. 

  206. 		for(size_t i=0;i<size;++i)

    207. 

  207. 		{

    208. 

  208. 			fprintf(mFile,"%f",smt[i]);

    209. 

  209. 			if(i+1<size) fprintf(mFile," ");

    210. 

  210. 		}

    211. 

  211. 		fprintf(mFile,";\n");

    212. 

  212. 	}

    213. 

  213. 	void startSmoothness(size_t smt_start,size_t smt_end)const

    214. 

  214. 	{

    215. 

  215. 		fprintf(mFile,"\tsetAttr \".smt[%i:%i]\"",smt_start,smt_end);

    216. 

  216. 	}

    217. 

  217. 	void appendSmoothness(double smt)const

    218. 

  218. 	{

    219. 

  219. 		fprintf(mFile," %f",smt);

    220. 

  220. 	}

    221. 

  221. 	void endSmoothness()const

    222. 

  222. 	{

    223. 

  223. 		fprintf(mFile,";\n");

    224. 

  224. 	}

    225. 

  225. 	void setLockWeights(size_t lw_i,bool lw)

    226. 

  226. 	{

    227. 

  227. 		if(lw == false) return;

    228. 

  228. 		fprintf(mFile,"\tsetAttr \".lw[%i]\" %i;\n", lw_i,lw);

    229. 

  229. 	}

    230. 

  230. 	void setLockWeights(size_t lw_start,size_t lw_end,bool* lw)

    231. 

  231. 	{

    232. 

  232. 		fprintf(mFile,"\tsetAttr \".lw[%i:%i]\" ", lw_start,lw_end);

    233. 

  233. 		size_t size = (lw_end-lw_start)*1+1;

    234. 

  234. 		for(size_t i=0;i<size;++i)

    235. 

  235. 		{

    236. 

  236. 			fprintf(mFile,"%i",lw[i]);

    237. 

  237. 			if(i+1<size) fprintf(mFile," ");

    238. 

  238. 		}

    239. 

  239. 		fprintf(mFile,";\n");

    240. 

  240. 	}

    241. 

  241. 	void startLockWeights(size_t lw_start,size_t lw_end)const

    242. 

  242. 	{

    243. 

  243. 		fprintf(mFile,"\tsetAttr \".lw[%i:%i]\"",lw_start,lw_end);

    244. 

  244. 	}

    245. 

  245. 	void appendLockWeights(bool lw)const

    246. 

  246. 	{

    247. 

  247. 		fprintf(mFile," %i",lw);

    248. 

  248. 	}

    249. 

  249. 	void endLockWeights()const

    250. 

  250. 	{

    251. 

  251. 		fprintf(mFile,";\n");

    252. 

  252. 	}

    253. 

  253. 	void setMaintainMaxInfluences(bool mmi)

    254. 

  254. 	{

    255. 

  255. 		if(mmi == false) return;

    256. 

  256. 		fprintf(mFile,"\tsetAttr \".mmi\" %i;\n", mmi);

    257. 

  257. 	}

    258. 

  258. 	void setMaxInfluences(int mi)

    259. 

  259. 	{

    260. 

  260. 		if(mi == 2) return;

    261. 

  261. 		fprintf(mFile,"\tsetAttr \".mi\" %i;\n", mi);

    262. 

  262. 	}

    263. 

  263. 	void setBindMethod(int bm)

    264. 

  264. 	{

    265. 

  265. 		if(bm == 1) return;

    266. 

  266. 		fprintf(mFile,"\tsetAttr \".bm\" %i;\n", bm);

    267. 

  267. 	}

    268. 

  268. 	void setPaintWeights(const doubleArray& ptw)

    269. 

  269. 	{

    270. 

  270. 		if(ptw.size == 0) return;

    271. 

  271. 		fprintf(mFile,"\tsetAttr \".ptw\" -type \"doubleArray\" ");

    272. 

  272. 		ptw.write(mFile);

    273. 

  273. 		fprintf(mFile,";\n");

    274. 

  274. 	}

    275. 

  275. 	void setUseComponents(bool uc)

    276. 

  276. 	{

    277. 

  277. 		if(uc == 0) return;

    278. 

  278. 		fprintf(mFile,"\tsetAttr \".uc\" %i;\n", uc);

    279. 

  279. 	}

    280. 

  280. 	void setNurbsSamples(size_t ns_i,int ns)

    281. 

  281. 	{

    282. 

  282. 		if(ns == 10) return;

    283. 

  283. 		fprintf(mFile,"\tsetAttr \".ns[%i]\" %i;\n", ns_i,ns);

    284. 

  284. 	}

    285. 

  285. 	void setNurbsSamples(size_t ns_start,size_t ns_end,int* ns)

    286. 

  286. 	{

    287. 

  287. 		fprintf(mFile,"\tsetAttr \".ns[%i:%i]\" ", ns_start,ns_end);

    288. 

  288. 		size_t size = (ns_end-ns_start)*1+1;

    289. 

  289. 		for(size_t i=0;i<size;++i)

    290. 

  290. 		{

    291. 

  291. 			fprintf(mFile,"%i",ns[i]);

    292. 

  292. 			if(i+1<size) fprintf(mFile," ");

    293. 

  293. 		}

    294. 

  294. 		fprintf(mFile,";\n");

    295. 

  295. 	}

    296. 

  296. 	void startNurbsSamples(size_t ns_start,size_t ns_end)const

    297. 

  297. 	{

    298. 

  298. 		fprintf(mFile,"\tsetAttr \".ns[%i:%i]\"",ns_start,ns_end);

    299. 

  299. 	}

    300. 

  300. 	void appendNurbsSamples(int ns)const

    301. 

  301. 	{

    302. 

  302. 		fprintf(mFile," %i",ns);

    303. 

  303. 	}

    304. 

  304. 	void endNurbsSamples()const

    305. 

  305. 	{

    306. 

  306. 		fprintf(mFile,";\n");

    307. 

  307. 	}

    308. 

  308. 	void setUseComponentsMatrix(bool ucm)

    309. 

  309. 	{

    310. 

  310. 		if(ucm == false) return;

    311. 

  311. 		fprintf(mFile,"\tsetAttr \".ucm\" %i;\n", ucm);

    312. 

  312. 	}

    313. 

  313. 	void setNormalizeWeights(bool nw)

    314. 

  314. 	{

    315. 

  315. 		if(nw == true) return;

    316. 

  316. 		fprintf(mFile,"\tsetAttr \".nw\" %i;\n", nw);

    317. 

  317. 	}

    318. 

  318. 	void setDeformUserNormals(bool dun)

    319. 

  319. 	{

    320. 

  320. 		if(dun == true) return;

    321. 

  321. 		fprintf(mFile,"\tsetAttr \".dun\" %i;\n", dun);

    322. 

  322. 	}

    323. 

  323. 	void getWeightList(size_t wl_i)const

    324. 

  324. 	{

    325. 

  325. 		fprintf(mFile,"\"%s.wl[%i]\"",mName.c_str(),wl_i);

    326. 

  326. 	}

    327. 

  327. 	void getWeightList()const

    328. 

  328. 	{

    329. 

  329. 

  330. 		fprintf(mFile,"\"%s.wl\"",mName.c_str());

    331. 

  331. 	}

    332. 

  332. 	void getWeights(size_t wl_i,size_t w_i)const

    333. 

  333. 	{

    334. 

  334. 		fprintf(mFile,"\"%s.wl[%i].w[%i]\"",mName.c_str(),wl_i,w_i);

    335. 

  335. 	}

    336. 

  336. 	void getWeights(size_t w_i)const

    337. 

  337. 	{

    338. 

  338. 

  339. 		fprintf(mFile,"\"%s.wl.w[%i]\"",mName.c_str(),w_i);

    340. 

  340. 	}

    341. 

  341. 	void getBindPreMatrix(size_t pm_i)const

    342. 

  342. 	{

    343. 

  343. 		fprintf(mFile,"\"%s.pm[%i]\"",mName.c_str(),pm_i);

    344. 

  344. 	}

    345. 

  345. 	void getBindPreMatrix()const

    346. 

  346. 	{

    347. 

  347. 

  348. 		fprintf(mFile,"\"%s.pm\"",mName.c_str());

    349. 

  349. 	}

    350. 

  350. 	void getGeomMatrix()const

    351. 

  351. 	{

    352. 

  352. 		fprintf(mFile,"\"%s.gm\"",mName.c_str());

    353. 

  353. 	}

    354. 

  354. 	void getMatrix(size_t ma_i)const

    355. 

  355. 	{

    356. 

  356. 		fprintf(mFile,"\"%s.ma[%i]\"",mName.c_str(),ma_i);

    357. 

  357. 	}

    358. 

  358. 	void getMatrix()const

    359. 

  359. 	{

    360. 

  360. 

  361. 		fprintf(mFile,"\"%s.ma\"",mName.c_str());

    362. 

  362. 	}

    363. 

  363. 	void getDropoffRate()const

    364. 

  364. 	{

    365. 

  365. 		fprintf(mFile,"\"%s.dr\"",mName.c_str());

    366. 

  366. 	}

    367. 

  367. 	void getDropoff(size_t dpf_i)const

    368. 

  368. 	{

    369. 

  369. 		fprintf(mFile,"\"%s.dpf[%i]\"",mName.c_str(),dpf_i);

    370. 

  370. 	}

    371. 

  371. 	void getDropoff()const

    372. 

  372. 	{

    373. 

  373. 

  374. 		fprintf(mFile,"\"%s.dpf\"",mName.c_str());

    375. 

  375. 	}

    376. 

  376. 	void getSmoothness(size_t smt_i)const

    377. 

  377. 	{

    378. 

  378. 		fprintf(mFile,"\"%s.smt[%i]\"",mName.c_str(),smt_i);

    379. 

  379. 	}

    380. 

  380. 	void getSmoothness()const

    381. 

  381. 	{

    382. 

  382. 

  383. 		fprintf(mFile,"\"%s.smt\"",mName.c_str());

    384. 

  384. 	}

    385. 

  385. 	void getLockWeights(size_t lw_i)const

    386. 

  386. 	{

    387. 

  387. 		fprintf(mFile,"\"%s.lw[%i]\"",mName.c_str(),lw_i);

    388. 

  388. 	}

    389. 

  389. 	void getLockWeights()const

    390. 

  390. 	{

    391. 

  391. 

  392. 		fprintf(mFile,"\"%s.lw\"",mName.c_str());

    393. 

  393. 	}

    394. 

  394. 	void getMaintainMaxInfluences()const

    395. 

  395. 	{

    396. 

  396. 		fprintf(mFile,"\"%s.mmi\"",mName.c_str());

    397. 

  397. 	}

    398. 

  398. 	void getMaxInfluences()const

    399. 

  399. 	{

    400. 

  400. 		fprintf(mFile,"\"%s.mi\"",mName.c_str());

    401. 

  401. 	}

    402. 

  402. 	void getBindMethod()const

    403. 

  403. 	{

    404. 

  404. 		fprintf(mFile,"\"%s.bm\"",mName.c_str());

    405. 

  405. 	}

    406. 

  406. 	void getDriverPoints(size_t drp_i)const

    407. 

  407. 	{

    408. 

  408. 		fprintf(mFile,"\"%s.drp[%i]\"",mName.c_str(),drp_i);

    409. 

  409. 	}

    410. 

  410. 	void getDriverPoints()const

    411. 

  411. 	{

    412. 

  412. 

  413. 		fprintf(mFile,"\"%s.drp\"",mName.c_str());

    414. 

  414. 	}

    415. 

  415. 	void getBasePoints(size_t bsp_i)const

    416. 

  416. 	{

    417. 

  417. 		fprintf(mFile,"\"%s.bsp[%i]\"",mName.c_str(),bsp_i);

    418. 

  418. 	}

    419. 

  419. 	void getBasePoints()const

    420. 

  420. 	{

    421. 

  421. 

  422. 		fprintf(mFile,"\"%s.bsp\"",mName.c_str());

    423. 

  423. 	}

    424. 

  424. 	void getBaseDirty()const

    425. 

  425. 	{

    426. 

  426. 		fprintf(mFile,"\"%s.bsd\"",mName.c_str());

    427. 

  427. 	}

    428. 

  428. 	void getPaintWeights()const

    429. 

  429. 	{

    430. 

  430. 		fprintf(mFile,"\"%s.ptw\"",mName.c_str());

    431. 

  431. 	}

    432. 

  432. 	void getPaintTrans()const

    433. 

  433. 	{

    434. 

  434. 		fprintf(mFile,"\"%s.ptt\"",mName.c_str());

    435. 

  435. 	}

    436. 

  436. 	void getPaintArrDirty()const

    437. 

  437. 	{

    438. 

  438. 		fprintf(mFile,"\"%s.pad\"",mName.c_str());

    439. 

  439. 	}

    440. 

  440. 	void getUseComponents()const

    441. 

  441. 	{

    442. 

  442. 		fprintf(mFile,"\"%s.uc\"",mName.c_str());

    443. 

  443. 	}

    444. 

  444. 	void getNurbsSamples(size_t ns_i)const

    445. 

  445. 	{

    446. 

  446. 		fprintf(mFile,"\"%s.ns[%i]\"",mName.c_str(),ns_i);

    447. 

  447. 	}

    448. 

  448. 	void getNurbsSamples()const

    449. 

  449. 	{

    450. 

  450. 

  451. 		fprintf(mFile,"\"%s.ns\"",mName.c_str());

    452. 

  452. 	}

    453. 

  453. 	void getUseComponentsMatrix()const

    454. 

  454. 	{

    455. 

  455. 		fprintf(mFile,"\"%s.ucm\"",mName.c_str());

    456. 

  456. 	}

    457. 

  457. 	void getNormalizeWeights()const

    458. 

  458. 	{

    459. 

  459. 		fprintf(mFile,"\"%s.nw\"",mName.c_str());

    460. 

  460. 	}

    461. 

  461. 	void getDeformUserNormals()const

    462. 

  462. 	{

    463. 

  463. 		fprintf(mFile,"\"%s.dun\"",mName.c_str());

    464. 

  464. 	}

    465. 

  465. 	void getWtDrty()const

    466. 

  466. 	{

    467. 

  467. 		fprintf(mFile,"\"%s.wtd\"",mName.c_str());

    468. 

  468. 	}

    469. 

  469. 	void getBindPose()const

    470. 

  470. 	{

    471. 

  471. 		fprintf(mFile,"\"%s.bp\"",mName.c_str());

    472. 

  472. 	}

    473. 

  473. protected:

    474. 

  474. 	SkinCluster(FILE* file,const std::string& name,const std::string& parent,const std::string& nodeType,bool shared=false,bool create=true)

    475. 

  475. 		:GeometryFilter(file, name, parent, nodeType, shared, create) {}

    476. 

  476. 

    477. 

  477. };

    478. 

  478. }//namespace MayaDM

    479. 

  479. #endif//__MayaDM_SKINCLUSTER_H__

    480. 

  480.