/indra/llprimitive/llmaterialtable.cpp

https://bitbucket.org/lindenlab/viewer-beta/ · C++ · 738 lines · 569 code · 100 blank · 69 comment · 97 complexity · 5dd8a5762e91eff8886ae61bb57797e3 MD5 · raw file

  1. /**
  2. * @file llmaterialtable.cpp
  3. * @brief Table of material names and IDs for viewer
  4. *
  5. * $LicenseInfo:firstyear=2001&license=viewerlgpl$
  6. * Second Life Viewer Source Code
  7. * Copyright (C) 2010, Linden Research, Inc.
  8. *
  9. * This library is free software; you can redistribute it and/or
  10. * modify it under the terms of the GNU Lesser General Public
  11. * License as published by the Free Software Foundation;
  12. * version 2.1 of the License only.
  13. *
  14. * This library is distributed in the hope that it will be useful,
  15. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17. * Lesser General Public License for more details.
  18. *
  19. * You should have received a copy of the GNU Lesser General Public
  20. * License along with this library; if not, write to the Free Software
  21. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22. *
  23. * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
  24. * $/LicenseInfo$
  25. */
  26. #include "linden_common.h"
  27. #include "llmaterialtable.h"
  28. #include "llstl.h"
  29. #include "material_codes.h"
  30. #include "sound_ids.h"
  31. #include "imageids.h"
  32. LLMaterialTable LLMaterialTable::basic(1);
  33. /*
  34. Old Havok 1 constants
  35. // these are the approximately correct friction values for various materials
  36. // however Havok1's friction dynamics are not very correct, so the effective
  37. // friction coefficients that result from these numbers are approximately
  38. // 25-50% too low, more incorrect for the lower values.
  39. F32 const LLMaterialTable::FRICTION_MIN = 0.2f;
  40. F32 const LLMaterialTable::FRICTION_GLASS = 0.2f; // borosilicate glass
  41. F32 const LLMaterialTable::FRICTION_LIGHT = 0.2f; //
  42. F32 const LLMaterialTable::FRICTION_METAL = 0.3f; // steel
  43. F32 const LLMaterialTable::FRICTION_PLASTIC = 0.4f; // HDPE
  44. F32 const LLMaterialTable::FRICTION_WOOD = 0.6f; // southern pine
  45. F32 const LLMaterialTable::FRICTION_FLESH = 0.60f; // saltwater
  46. F32 const LLMaterialTable::FRICTION_LAND = 0.78f; // dirt
  47. F32 const LLMaterialTable::FRICTION_STONE = 0.8f; // concrete
  48. F32 const LLMaterialTable::FRICTION_RUBBER = 0.9f; //
  49. F32 const LLMaterialTable::FRICTION_MAX = 0.95f; //
  50. */
  51. // #if LL_CURRENT_HAVOK_VERSION == LL_HAVOK_VERSION_460
  52. // Havok4 has more correct friction dynamics, however here we have to use
  53. // the "incorrect" equivalents for the legacy Havok1 behavior
  54. F32 const LLMaterialTable::FRICTION_MIN = 0.15f;
  55. F32 const LLMaterialTable::FRICTION_GLASS = 0.13f; // borosilicate glass
  56. F32 const LLMaterialTable::FRICTION_LIGHT = 0.14f; //
  57. F32 const LLMaterialTable::FRICTION_METAL = 0.22f; // steel
  58. F32 const LLMaterialTable::FRICTION_PLASTIC = 0.3f; // HDPE
  59. F32 const LLMaterialTable::FRICTION_WOOD = 0.44f; // southern pine
  60. F32 const LLMaterialTable::FRICTION_FLESH = 0.46f; // saltwater
  61. F32 const LLMaterialTable::FRICTION_LAND = 0.58f; // dirt
  62. F32 const LLMaterialTable::FRICTION_STONE = 0.6f; // concrete
  63. F32 const LLMaterialTable::FRICTION_RUBBER = 0.67f; //
  64. F32 const LLMaterialTable::FRICTION_MAX = 0.71f; //
  65. // #endif
  66. F32 const LLMaterialTable::RESTITUTION_MIN = 0.02f;
  67. F32 const LLMaterialTable::RESTITUTION_LAND = LLMaterialTable::RESTITUTION_MIN;
  68. F32 const LLMaterialTable::RESTITUTION_FLESH = 0.2f; // saltwater
  69. F32 const LLMaterialTable::RESTITUTION_STONE = 0.4f; // concrete
  70. F32 const LLMaterialTable::RESTITUTION_METAL = 0.4f; // steel
  71. F32 const LLMaterialTable::RESTITUTION_WOOD = 0.5f; // southern pine
  72. F32 const LLMaterialTable::RESTITUTION_GLASS = 0.7f; // borosilicate glass
  73. F32 const LLMaterialTable::RESTITUTION_PLASTIC = 0.7f; // HDPE
  74. F32 const LLMaterialTable::RESTITUTION_LIGHT = 0.7f; //
  75. F32 const LLMaterialTable::RESTITUTION_RUBBER = 0.9f; //
  76. F32 const LLMaterialTable::RESTITUTION_MAX = 0.95f;
  77. F32 const LLMaterialTable::DEFAULT_FRICTION = 0.5f;
  78. F32 const LLMaterialTable::DEFAULT_RESTITUTION = 0.4f;
  79. LLMaterialTable::LLMaterialTable()
  80. : mCollisionSoundMatrix(NULL),
  81. mSlidingSoundMatrix(NULL),
  82. mRollingSoundMatrix(NULL)
  83. {
  84. }
  85. LLMaterialTable::LLMaterialTable(U8 isBasic)
  86. {
  87. initBasicTable();
  88. }
  89. LLMaterialTable::~LLMaterialTable()
  90. {
  91. if (mCollisionSoundMatrix)
  92. {
  93. delete [] mCollisionSoundMatrix;
  94. mCollisionSoundMatrix = NULL;
  95. }
  96. if (mSlidingSoundMatrix)
  97. {
  98. delete [] mSlidingSoundMatrix;
  99. mSlidingSoundMatrix = NULL;
  100. }
  101. if (mRollingSoundMatrix)
  102. {
  103. delete [] mRollingSoundMatrix;
  104. mRollingSoundMatrix = NULL;
  105. }
  106. for_each(mMaterialInfoList.begin(), mMaterialInfoList.end(), DeletePointer());
  107. mMaterialInfoList.clear();
  108. }
  109. void LLMaterialTable::initTableTransNames(std::map<std::string, std::string> namemap)
  110. {
  111. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  112. iter != mMaterialInfoList.end(); ++iter)
  113. {
  114. LLMaterialInfo *infop = *iter;
  115. std::string name = infop->mName;
  116. infop->mName = namemap[name];
  117. }
  118. }
  119. void LLMaterialTable::initBasicTable()
  120. {
  121. // *TODO: Translate
  122. add(LL_MCODE_STONE,std::string("Stone"), LL_DEFAULT_STONE_UUID);
  123. add(LL_MCODE_METAL,std::string("Metal"), LL_DEFAULT_METAL_UUID);
  124. add(LL_MCODE_GLASS,std::string("Glass"), LL_DEFAULT_GLASS_UUID);
  125. add(LL_MCODE_WOOD,std::string("Wood"), LL_DEFAULT_WOOD_UUID);
  126. add(LL_MCODE_FLESH,std::string("Flesh"), LL_DEFAULT_FLESH_UUID);
  127. add(LL_MCODE_PLASTIC,std::string("Plastic"), LL_DEFAULT_PLASTIC_UUID);
  128. add(LL_MCODE_RUBBER,std::string("Rubber"), LL_DEFAULT_RUBBER_UUID);
  129. add(LL_MCODE_LIGHT,std::string("Light"), LL_DEFAULT_LIGHT_UUID);
  130. // specify densities for these materials. . .
  131. // these were taken from http://www.mcelwee.net/html/densities_of_various_materials.html
  132. addDensity(LL_MCODE_STONE,30.f);
  133. addDensity(LL_MCODE_METAL,50.f);
  134. addDensity(LL_MCODE_GLASS,20.f);
  135. addDensity(LL_MCODE_WOOD,10.f);
  136. addDensity(LL_MCODE_FLESH,10.f);
  137. addDensity(LL_MCODE_PLASTIC,5.f);
  138. addDensity(LL_MCODE_RUBBER,0.5f); //
  139. addDensity(LL_MCODE_LIGHT,20.f); //
  140. // add damage and energy values
  141. addDamageAndEnergy(LL_MCODE_STONE, 1.f, 1.f, 1.f); // concrete
  142. addDamageAndEnergy(LL_MCODE_METAL, 1.f, 1.f, 1.f); // steel
  143. addDamageAndEnergy(LL_MCODE_GLASS, 1.f, 1.f, 1.f); // borosilicate glass
  144. addDamageAndEnergy(LL_MCODE_WOOD, 1.f, 1.f, 1.f); // southern pine
  145. addDamageAndEnergy(LL_MCODE_FLESH, 1.f, 1.f, 1.f); // saltwater
  146. addDamageAndEnergy(LL_MCODE_PLASTIC, 1.f, 1.f, 1.f); // HDPE
  147. addDamageAndEnergy(LL_MCODE_RUBBER, 1.f, 1.f, 1.f); //
  148. addDamageAndEnergy(LL_MCODE_LIGHT, 1.f, 1.f, 1.f); //
  149. addFriction(LL_MCODE_STONE,0.8f); // concrete
  150. addFriction(LL_MCODE_METAL,0.3f); // steel
  151. addFriction(LL_MCODE_GLASS,0.2f); // borosilicate glass
  152. addFriction(LL_MCODE_WOOD,0.6f); // southern pine
  153. addFriction(LL_MCODE_FLESH,0.9f); // saltwater
  154. addFriction(LL_MCODE_PLASTIC,0.4f); // HDPE
  155. addFriction(LL_MCODE_RUBBER,0.9f); //
  156. addFriction(LL_MCODE_LIGHT,0.2f); //
  157. addRestitution(LL_MCODE_STONE,0.4f); // concrete
  158. addRestitution(LL_MCODE_METAL,0.4f); // steel
  159. addRestitution(LL_MCODE_GLASS,0.7f); // borosilicate glass
  160. addRestitution(LL_MCODE_WOOD,0.5f); // southern pine
  161. addRestitution(LL_MCODE_FLESH,0.3f); // saltwater
  162. addRestitution(LL_MCODE_PLASTIC,0.7f); // HDPE
  163. addRestitution(LL_MCODE_RUBBER,0.9f); //
  164. addRestitution(LL_MCODE_LIGHT,0.7f); //
  165. addShatterSound(LL_MCODE_STONE,LLUUID("ea296329-0f09-4993-af1b-e6784bab1dc9"));
  166. addShatterSound(LL_MCODE_METAL,LLUUID("d1375446-1c4d-470b-9135-30132433b678"));
  167. addShatterSound(LL_MCODE_GLASS,LLUUID("85cda060-b393-48e6-81c8-2cfdfb275351"));
  168. addShatterSound(LL_MCODE_WOOD,LLUUID("6f00669f-15e0-4793-a63e-c03f62fee43a"));
  169. addShatterSound(LL_MCODE_FLESH,LLUUID("2d8c6f51-149e-4e23-8413-93a379b42b67"));
  170. addShatterSound(LL_MCODE_PLASTIC,LLUUID("d55c7f3c-e1c3-4ddc-9eff-9ef805d9190e"));
  171. addShatterSound(LL_MCODE_RUBBER,LLUUID("212b6d1e-8d9c-4986-b3aa-f3c6df8d987d"));
  172. addShatterSound(LL_MCODE_LIGHT,LLUUID("d55c7f3c-e1c3-4ddc-9eff-9ef805d9190e"));
  173. // CollisionSounds
  174. mCollisionSoundMatrix = new LLUUID[LL_MCODE_END*LL_MCODE_END];
  175. if (mCollisionSoundMatrix)
  176. {
  177. addCollisionSound(LL_MCODE_STONE, LL_MCODE_STONE, SND_STONE_STONE);
  178. addCollisionSound(LL_MCODE_STONE, LL_MCODE_METAL, SND_STONE_METAL);
  179. addCollisionSound(LL_MCODE_STONE, LL_MCODE_GLASS, SND_STONE_GLASS);
  180. addCollisionSound(LL_MCODE_STONE, LL_MCODE_WOOD, SND_STONE_WOOD);
  181. addCollisionSound(LL_MCODE_STONE, LL_MCODE_FLESH, SND_STONE_FLESH);
  182. addCollisionSound(LL_MCODE_STONE, LL_MCODE_PLASTIC, SND_STONE_PLASTIC);
  183. addCollisionSound(LL_MCODE_STONE, LL_MCODE_RUBBER, SND_STONE_RUBBER);
  184. addCollisionSound(LL_MCODE_STONE, LL_MCODE_LIGHT, SND_STONE_PLASTIC);
  185. addCollisionSound(LL_MCODE_METAL, LL_MCODE_METAL, SND_METAL_METAL);
  186. addCollisionSound(LL_MCODE_METAL, LL_MCODE_GLASS, SND_METAL_GLASS);
  187. addCollisionSound(LL_MCODE_METAL, LL_MCODE_WOOD, SND_METAL_WOOD);
  188. addCollisionSound(LL_MCODE_METAL, LL_MCODE_FLESH, SND_METAL_FLESH);
  189. addCollisionSound(LL_MCODE_METAL, LL_MCODE_PLASTIC, SND_METAL_PLASTIC);
  190. addCollisionSound(LL_MCODE_METAL, LL_MCODE_LIGHT, SND_METAL_PLASTIC);
  191. addCollisionSound(LL_MCODE_METAL, LL_MCODE_RUBBER, SND_METAL_RUBBER);
  192. addCollisionSound(LL_MCODE_GLASS, LL_MCODE_GLASS, SND_GLASS_GLASS);
  193. addCollisionSound(LL_MCODE_GLASS, LL_MCODE_WOOD, SND_GLASS_WOOD);
  194. addCollisionSound(LL_MCODE_GLASS, LL_MCODE_FLESH, SND_GLASS_FLESH);
  195. addCollisionSound(LL_MCODE_GLASS, LL_MCODE_PLASTIC, SND_GLASS_PLASTIC);
  196. addCollisionSound(LL_MCODE_GLASS, LL_MCODE_RUBBER, SND_GLASS_RUBBER);
  197. addCollisionSound(LL_MCODE_GLASS, LL_MCODE_LIGHT, SND_GLASS_PLASTIC);
  198. addCollisionSound(LL_MCODE_WOOD, LL_MCODE_WOOD, SND_WOOD_WOOD);
  199. addCollisionSound(LL_MCODE_WOOD, LL_MCODE_FLESH, SND_WOOD_FLESH);
  200. addCollisionSound(LL_MCODE_WOOD, LL_MCODE_PLASTIC, SND_WOOD_PLASTIC);
  201. addCollisionSound(LL_MCODE_WOOD, LL_MCODE_RUBBER, SND_WOOD_RUBBER);
  202. addCollisionSound(LL_MCODE_WOOD, LL_MCODE_LIGHT, SND_WOOD_PLASTIC);
  203. addCollisionSound(LL_MCODE_FLESH, LL_MCODE_FLESH, SND_FLESH_FLESH);
  204. addCollisionSound(LL_MCODE_FLESH, LL_MCODE_PLASTIC, SND_FLESH_PLASTIC);
  205. addCollisionSound(LL_MCODE_FLESH, LL_MCODE_RUBBER, SND_FLESH_RUBBER);
  206. addCollisionSound(LL_MCODE_FLESH, LL_MCODE_LIGHT, SND_FLESH_PLASTIC);
  207. addCollisionSound(LL_MCODE_RUBBER, LL_MCODE_RUBBER, SND_RUBBER_RUBBER);
  208. addCollisionSound(LL_MCODE_RUBBER, LL_MCODE_PLASTIC, SND_RUBBER_PLASTIC);
  209. addCollisionSound(LL_MCODE_RUBBER, LL_MCODE_LIGHT, SND_RUBBER_PLASTIC);
  210. addCollisionSound(LL_MCODE_PLASTIC, LL_MCODE_PLASTIC, SND_PLASTIC_PLASTIC);
  211. addCollisionSound(LL_MCODE_PLASTIC, LL_MCODE_LIGHT, SND_PLASTIC_PLASTIC);
  212. addCollisionSound(LL_MCODE_LIGHT, LL_MCODE_LIGHT, SND_PLASTIC_PLASTIC);
  213. }
  214. // Sliding Sounds
  215. mSlidingSoundMatrix = new LLUUID[LL_MCODE_END*LL_MCODE_END];
  216. if (mSlidingSoundMatrix)
  217. {
  218. addSlidingSound(LL_MCODE_STONE, LL_MCODE_STONE, SND_SLIDE_STONE_STONE);
  219. addSlidingSound(LL_MCODE_STONE, LL_MCODE_METAL, SND_SLIDE_STONE_STONE_01);
  220. addSlidingSound(LL_MCODE_STONE, LL_MCODE_GLASS, SND_SLIDE_STONE_STONE_01);
  221. addSlidingSound(LL_MCODE_STONE, LL_MCODE_WOOD, SND_SLIDE_STONE_WOOD);
  222. addSlidingSound(LL_MCODE_STONE, LL_MCODE_FLESH, SND_SLIDE_STONE_STONE_01);
  223. addSlidingSound(LL_MCODE_STONE, LL_MCODE_PLASTIC, SND_SLIDE_STONE_PLASTIC);
  224. addSlidingSound(LL_MCODE_STONE, LL_MCODE_RUBBER, SND_SLIDE_STONE_RUBBER);
  225. addSlidingSound(LL_MCODE_STONE, LL_MCODE_LIGHT, SND_SLIDE_STONE_PLASTIC);
  226. addSlidingSound(LL_MCODE_METAL, LL_MCODE_METAL, SND_SLIDE_METAL_METAL);
  227. addSlidingSound(LL_MCODE_METAL, LL_MCODE_GLASS, SND_SLIDE_METAL_GLASS);
  228. addSlidingSound(LL_MCODE_METAL, LL_MCODE_WOOD, SND_SLIDE_METAL_WOOD);
  229. addSlidingSound(LL_MCODE_METAL, LL_MCODE_FLESH, SND_SLIDE_METAL_FLESH);
  230. addSlidingSound(LL_MCODE_METAL, LL_MCODE_PLASTIC, SND_SLIDE_STONE_STONE_01);
  231. addSlidingSound(LL_MCODE_METAL, LL_MCODE_RUBBER, SND_SLIDE_METAL_RUBBER);
  232. addSlidingSound(LL_MCODE_METAL, LL_MCODE_LIGHT, SND_SLIDE_STONE_STONE_01);
  233. addSlidingSound(LL_MCODE_GLASS, LL_MCODE_GLASS, SND_SLIDE_STONE_STONE_01);
  234. addSlidingSound(LL_MCODE_GLASS, LL_MCODE_WOOD, SND_SLIDE_STONE_STONE_01);
  235. addSlidingSound(LL_MCODE_GLASS, LL_MCODE_FLESH, SND_SLIDE_STONE_STONE_01);
  236. addSlidingSound(LL_MCODE_GLASS, LL_MCODE_PLASTIC, SND_SLIDE_STONE_STONE_01);
  237. addSlidingSound(LL_MCODE_GLASS, LL_MCODE_RUBBER, SND_SLIDE_STONE_STONE_01);
  238. addSlidingSound(LL_MCODE_GLASS, LL_MCODE_LIGHT, SND_SLIDE_STONE_STONE_01);
  239. addSlidingSound(LL_MCODE_WOOD, LL_MCODE_WOOD, SND_SLIDE_WOOD_WOOD);
  240. addSlidingSound(LL_MCODE_WOOD, LL_MCODE_FLESH, SND_SLIDE_WOOD_FLESH);
  241. addSlidingSound(LL_MCODE_WOOD, LL_MCODE_PLASTIC, SND_SLIDE_WOOD_PLASTIC);
  242. addSlidingSound(LL_MCODE_WOOD, LL_MCODE_RUBBER, SND_SLIDE_STONE_STONE_01);
  243. addSlidingSound(LL_MCODE_WOOD, LL_MCODE_LIGHT, SND_SLIDE_WOOD_PLASTIC);
  244. addSlidingSound(LL_MCODE_FLESH, LL_MCODE_FLESH, SND_SLIDE_FLESH_FLESH);
  245. addSlidingSound(LL_MCODE_FLESH, LL_MCODE_PLASTIC, SND_SLIDE_STONE_STONE_01);
  246. addSlidingSound(LL_MCODE_FLESH, LL_MCODE_RUBBER, SND_SLIDE_STONE_STONE_01);
  247. addSlidingSound(LL_MCODE_FLESH, LL_MCODE_LIGHT, SND_SLIDE_STONE_STONE_01);
  248. addSlidingSound(LL_MCODE_RUBBER, LL_MCODE_RUBBER, SND_SLIDE_STONE_STONE_01);
  249. addSlidingSound(LL_MCODE_RUBBER, LL_MCODE_PLASTIC, SND_SLIDE_RUBBER_PLASTIC);
  250. addSlidingSound(LL_MCODE_RUBBER, LL_MCODE_LIGHT, SND_SLIDE_RUBBER_PLASTIC);
  251. addSlidingSound(LL_MCODE_PLASTIC, LL_MCODE_PLASTIC, SND_SLIDE_STONE_STONE_01);
  252. addSlidingSound(LL_MCODE_PLASTIC, LL_MCODE_LIGHT, SND_SLIDE_STONE_STONE_01);
  253. addSlidingSound(LL_MCODE_LIGHT, LL_MCODE_LIGHT, SND_SLIDE_STONE_STONE_01);
  254. }
  255. // Rolling Sounds
  256. mRollingSoundMatrix = new LLUUID[LL_MCODE_END*LL_MCODE_END];
  257. if (mRollingSoundMatrix)
  258. {
  259. addRollingSound(LL_MCODE_STONE, LL_MCODE_STONE, SND_ROLL_STONE_STONE);
  260. addRollingSound(LL_MCODE_STONE, LL_MCODE_METAL, SND_SLIDE_STONE_STONE_01);
  261. addRollingSound(LL_MCODE_STONE, LL_MCODE_GLASS, SND_SLIDE_STONE_STONE_01);
  262. addRollingSound(LL_MCODE_STONE, LL_MCODE_WOOD, SND_ROLL_STONE_WOOD);
  263. addRollingSound(LL_MCODE_STONE, LL_MCODE_FLESH, SND_SLIDE_STONE_STONE_01);
  264. addRollingSound(LL_MCODE_STONE, LL_MCODE_PLASTIC, SND_ROLL_STONE_PLASTIC);
  265. addRollingSound(LL_MCODE_STONE, LL_MCODE_RUBBER, SND_SLIDE_STONE_STONE_01);
  266. addRollingSound(LL_MCODE_STONE, LL_MCODE_LIGHT, SND_ROLL_STONE_PLASTIC);
  267. addRollingSound(LL_MCODE_METAL, LL_MCODE_METAL, SND_SLIDE_STONE_STONE_01);
  268. addRollingSound(LL_MCODE_METAL, LL_MCODE_GLASS, SND_ROLL_METAL_GLASS);
  269. addRollingSound(LL_MCODE_METAL, LL_MCODE_WOOD, SND_ROLL_METAL_WOOD);
  270. addRollingSound(LL_MCODE_METAL, LL_MCODE_FLESH, SND_SLIDE_STONE_STONE_01);
  271. addRollingSound(LL_MCODE_METAL, LL_MCODE_PLASTIC, SND_ROLL_METAL_WOOD);
  272. addRollingSound(LL_MCODE_METAL, LL_MCODE_RUBBER, SND_SLIDE_STONE_STONE_01);
  273. addRollingSound(LL_MCODE_METAL, LL_MCODE_LIGHT, SND_ROLL_METAL_WOOD);
  274. addRollingSound(LL_MCODE_GLASS, LL_MCODE_GLASS, SND_SLIDE_STONE_STONE_01);
  275. addRollingSound(LL_MCODE_GLASS, LL_MCODE_WOOD, SND_ROLL_GLASS_WOOD);
  276. addRollingSound(LL_MCODE_GLASS, LL_MCODE_FLESH, SND_SLIDE_STONE_STONE_01);
  277. addRollingSound(LL_MCODE_GLASS, LL_MCODE_PLASTIC, SND_SLIDE_STONE_STONE_01);
  278. addRollingSound(LL_MCODE_GLASS, LL_MCODE_RUBBER, SND_SLIDE_STONE_STONE_01);
  279. addRollingSound(LL_MCODE_GLASS, LL_MCODE_LIGHT, SND_SLIDE_STONE_STONE_01);
  280. addRollingSound(LL_MCODE_WOOD, LL_MCODE_WOOD, SND_ROLL_WOOD_WOOD);
  281. addRollingSound(LL_MCODE_WOOD, LL_MCODE_FLESH, SND_ROLL_WOOD_FLESH);
  282. addRollingSound(LL_MCODE_WOOD, LL_MCODE_PLASTIC, SND_ROLL_WOOD_PLASTIC);
  283. addRollingSound(LL_MCODE_WOOD, LL_MCODE_RUBBER, SND_SLIDE_STONE_STONE_01);
  284. addRollingSound(LL_MCODE_WOOD, LL_MCODE_LIGHT, SND_ROLL_WOOD_PLASTIC);
  285. addRollingSound(LL_MCODE_FLESH, LL_MCODE_FLESH, SND_SLIDE_STONE_STONE_01);
  286. addRollingSound(LL_MCODE_FLESH, LL_MCODE_PLASTIC, SND_ROLL_FLESH_PLASTIC);
  287. addRollingSound(LL_MCODE_FLESH, LL_MCODE_RUBBER, SND_SLIDE_STONE_STONE_01);
  288. addRollingSound(LL_MCODE_FLESH, LL_MCODE_LIGHT, SND_ROLL_FLESH_PLASTIC);
  289. addRollingSound(LL_MCODE_RUBBER, LL_MCODE_RUBBER, SND_SLIDE_STONE_STONE_01);
  290. addRollingSound(LL_MCODE_RUBBER, LL_MCODE_PLASTIC, SND_SLIDE_STONE_STONE_01);
  291. addRollingSound(LL_MCODE_RUBBER, LL_MCODE_LIGHT, SND_SLIDE_STONE_STONE_01);
  292. addRollingSound(LL_MCODE_PLASTIC, LL_MCODE_PLASTIC, SND_ROLL_PLASTIC_PLASTIC);
  293. addRollingSound(LL_MCODE_PLASTIC, LL_MCODE_LIGHT, SND_ROLL_PLASTIC_PLASTIC);
  294. addRollingSound(LL_MCODE_LIGHT, LL_MCODE_LIGHT, SND_ROLL_PLASTIC_PLASTIC);
  295. }
  296. }
  297. BOOL LLMaterialTable::add(U8 mcode, const std::string& name, const LLUUID &uuid)
  298. {
  299. LLMaterialInfo *infop;
  300. infop = new LLMaterialInfo(mcode,name,uuid);
  301. if (!infop) return FALSE;
  302. // Add at the end so the order in menus matches the order in this
  303. // file. JNC 11.30.01
  304. mMaterialInfoList.push_back(infop);
  305. return TRUE;
  306. }
  307. BOOL LLMaterialTable::addCollisionSound(U8 mcode, U8 mcode2, const LLUUID &uuid)
  308. {
  309. if (mCollisionSoundMatrix && (mcode < LL_MCODE_END) && (mcode2 < LL_MCODE_END))
  310. {
  311. mCollisionSoundMatrix[mcode * LL_MCODE_END + mcode2] = uuid;
  312. if (mcode != mcode2)
  313. {
  314. mCollisionSoundMatrix[mcode2 * LL_MCODE_END + mcode] = uuid;
  315. }
  316. }
  317. return TRUE;
  318. }
  319. BOOL LLMaterialTable::addSlidingSound(U8 mcode, U8 mcode2, const LLUUID &uuid)
  320. {
  321. if (mSlidingSoundMatrix && (mcode < LL_MCODE_END) && (mcode2 < LL_MCODE_END))
  322. {
  323. mSlidingSoundMatrix[mcode * LL_MCODE_END + mcode2] = uuid;
  324. if (mcode != mcode2)
  325. {
  326. mSlidingSoundMatrix[mcode2 * LL_MCODE_END + mcode] = uuid;
  327. }
  328. }
  329. return TRUE;
  330. }
  331. BOOL LLMaterialTable::addRollingSound(U8 mcode, U8 mcode2, const LLUUID &uuid)
  332. {
  333. if (mRollingSoundMatrix && (mcode < LL_MCODE_END) && (mcode2 < LL_MCODE_END))
  334. {
  335. mRollingSoundMatrix[mcode * LL_MCODE_END + mcode2] = uuid;
  336. if (mcode != mcode2)
  337. {
  338. mRollingSoundMatrix[mcode2 * LL_MCODE_END + mcode] = uuid;
  339. }
  340. }
  341. return TRUE;
  342. }
  343. BOOL LLMaterialTable::addShatterSound(U8 mcode, const LLUUID &uuid)
  344. {
  345. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  346. iter != mMaterialInfoList.end(); ++iter)
  347. {
  348. LLMaterialInfo *infop = *iter;
  349. if (mcode == infop->mMCode)
  350. {
  351. infop->mShatterSoundID = uuid;
  352. return TRUE;
  353. }
  354. }
  355. return FALSE;
  356. }
  357. BOOL LLMaterialTable::addDensity(U8 mcode, const F32 &density)
  358. {
  359. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  360. iter != mMaterialInfoList.end(); ++iter)
  361. {
  362. LLMaterialInfo *infop = *iter;
  363. if (mcode == infop->mMCode)
  364. {
  365. infop->mDensity = density;
  366. return TRUE;
  367. }
  368. }
  369. return FALSE;
  370. }
  371. BOOL LLMaterialTable::addRestitution(U8 mcode, const F32 &restitution)
  372. {
  373. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  374. iter != mMaterialInfoList.end(); ++iter)
  375. {
  376. LLMaterialInfo *infop = *iter;
  377. if (mcode == infop->mMCode)
  378. {
  379. infop->mRestitution = restitution;
  380. return TRUE;
  381. }
  382. }
  383. return FALSE;
  384. }
  385. BOOL LLMaterialTable::addFriction(U8 mcode, const F32 &friction)
  386. {
  387. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  388. iter != mMaterialInfoList.end(); ++iter)
  389. {
  390. LLMaterialInfo *infop = *iter;
  391. if (mcode == infop->mMCode)
  392. {
  393. infop->mFriction = friction;
  394. return TRUE;
  395. }
  396. }
  397. return FALSE;
  398. }
  399. BOOL LLMaterialTable::addDamageAndEnergy(U8 mcode, const F32 &hp_mod, const F32 &damage_mod, const F32 &ep_mod)
  400. {
  401. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  402. iter != mMaterialInfoList.end(); ++iter)
  403. {
  404. LLMaterialInfo *infop = *iter;
  405. if (mcode == infop->mMCode)
  406. {
  407. infop->mHPModifier = hp_mod;
  408. infop->mDamageModifier = damage_mod;
  409. infop->mEPModifier = ep_mod;
  410. return TRUE;
  411. }
  412. }
  413. return FALSE;
  414. }
  415. LLUUID LLMaterialTable::getDefaultTextureID(const std::string& name)
  416. {
  417. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  418. iter != mMaterialInfoList.end(); ++iter)
  419. {
  420. LLMaterialInfo *infop = *iter;
  421. if (name == infop->mName)
  422. {
  423. return infop->mDefaultTextureID;
  424. }
  425. }
  426. return LLUUID::null;
  427. }
  428. LLUUID LLMaterialTable::getDefaultTextureID(U8 mcode)
  429. {
  430. mcode &= LL_MCODE_MASK;
  431. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  432. iter != mMaterialInfoList.end(); ++iter)
  433. {
  434. LLMaterialInfo *infop = *iter;
  435. if (mcode == infop->mMCode)
  436. {
  437. return infop->mDefaultTextureID;
  438. }
  439. }
  440. return LLUUID::null;
  441. }
  442. U8 LLMaterialTable::getMCode(const std::string& name)
  443. {
  444. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  445. iter != mMaterialInfoList.end(); ++iter)
  446. {
  447. LLMaterialInfo *infop = *iter;
  448. if (name == infop->mName)
  449. {
  450. return infop->mMCode;
  451. }
  452. }
  453. return 0;
  454. }
  455. std::string LLMaterialTable::getName(U8 mcode)
  456. {
  457. mcode &= LL_MCODE_MASK;
  458. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  459. iter != mMaterialInfoList.end(); ++iter)
  460. {
  461. LLMaterialInfo *infop = *iter;
  462. if (mcode == infop->mMCode)
  463. {
  464. return infop->mName;
  465. }
  466. }
  467. return std::string();
  468. }
  469. LLUUID LLMaterialTable::getCollisionSoundUUID(U8 mcode, U8 mcode2)
  470. {
  471. mcode &= LL_MCODE_MASK;
  472. mcode2 &= LL_MCODE_MASK;
  473. //llinfos << "code 1: " << ((U32) mcode) << " code 2:" << ((U32) mcode2) << llendl;
  474. if (mCollisionSoundMatrix && (mcode < LL_MCODE_END) && (mcode2 < LL_MCODE_END))
  475. {
  476. return(mCollisionSoundMatrix[mcode * LL_MCODE_END + mcode2]);
  477. }
  478. else
  479. {
  480. //llinfos << "Null Sound" << llendl;
  481. return(SND_NULL);
  482. }
  483. }
  484. LLUUID LLMaterialTable::getSlidingSoundUUID(U8 mcode, U8 mcode2)
  485. {
  486. mcode &= LL_MCODE_MASK;
  487. mcode2 &= LL_MCODE_MASK;
  488. if (mSlidingSoundMatrix && (mcode < LL_MCODE_END) && (mcode2 < LL_MCODE_END))
  489. {
  490. return(mSlidingSoundMatrix[mcode * LL_MCODE_END + mcode2]);
  491. }
  492. else
  493. {
  494. return(SND_NULL);
  495. }
  496. }
  497. LLUUID LLMaterialTable::getRollingSoundUUID(U8 mcode, U8 mcode2)
  498. {
  499. mcode &= LL_MCODE_MASK;
  500. mcode2 &= LL_MCODE_MASK;
  501. if (mRollingSoundMatrix && (mcode < LL_MCODE_END) && (mcode2 < LL_MCODE_END))
  502. {
  503. return(mRollingSoundMatrix[mcode * LL_MCODE_END + mcode2]);
  504. }
  505. else
  506. {
  507. return(SND_NULL);
  508. }
  509. }
  510. LLUUID LLMaterialTable::getGroundCollisionSoundUUID(U8 mcode)
  511. {
  512. // Create material appropriate sounds for collisions with the ground
  513. // For now, simply return a single sound for all materials
  514. return SND_STONE_DIRT_02;
  515. }
  516. LLUUID LLMaterialTable::getGroundSlidingSoundUUID(U8 mcode)
  517. {
  518. // Create material-specific sound for sliding on ground
  519. // For now, just return a single sound
  520. return SND_SLIDE_STONE_STONE_01;
  521. }
  522. LLUUID LLMaterialTable::getGroundRollingSoundUUID(U8 mcode)
  523. {
  524. // Create material-specific sound for rolling on ground
  525. // For now, just return a single sound
  526. return SND_SLIDE_STONE_STONE_01;
  527. }
  528. LLUUID LLMaterialTable::getCollisionParticleUUID(U8 mcode, U8 mcode2)
  529. {
  530. // Returns an appropriate UUID to use as sprite at collision betweeen objects
  531. // For now, just return a single image
  532. return IMG_SHOT;
  533. }
  534. LLUUID LLMaterialTable::getGroundCollisionParticleUUID(U8 mcode)
  535. {
  536. // Returns an appropriate
  537. // For now, just return a single sound
  538. return IMG_SMOKE_POOF;
  539. }
  540. F32 LLMaterialTable::getDensity(U8 mcode)
  541. {
  542. mcode &= LL_MCODE_MASK;
  543. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  544. iter != mMaterialInfoList.end(); ++iter)
  545. {
  546. LLMaterialInfo *infop = *iter;
  547. if (mcode == infop->mMCode)
  548. {
  549. return infop->mDensity;
  550. }
  551. }
  552. return 0.f;
  553. }
  554. F32 LLMaterialTable::getRestitution(U8 mcode)
  555. {
  556. mcode &= LL_MCODE_MASK;
  557. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  558. iter != mMaterialInfoList.end(); ++iter)
  559. {
  560. LLMaterialInfo *infop = *iter;
  561. if (mcode == infop->mMCode)
  562. {
  563. return infop->mRestitution;
  564. }
  565. }
  566. return LLMaterialTable::DEFAULT_RESTITUTION;
  567. }
  568. F32 LLMaterialTable::getFriction(U8 mcode)
  569. {
  570. mcode &= LL_MCODE_MASK;
  571. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  572. iter != mMaterialInfoList.end(); ++iter)
  573. {
  574. LLMaterialInfo *infop = *iter;
  575. if (mcode == infop->mMCode)
  576. {
  577. return infop->mFriction;
  578. }
  579. }
  580. return LLMaterialTable::DEFAULT_FRICTION;
  581. }
  582. F32 LLMaterialTable::getHPMod(U8 mcode)
  583. {
  584. mcode &= LL_MCODE_MASK;
  585. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  586. iter != mMaterialInfoList.end(); ++iter)
  587. {
  588. LLMaterialInfo *infop = *iter;
  589. if (mcode == infop->mMCode)
  590. {
  591. return infop->mHPModifier;
  592. }
  593. }
  594. return 1.f;
  595. }
  596. F32 LLMaterialTable::getDamageMod(U8 mcode)
  597. {
  598. mcode &= LL_MCODE_MASK;
  599. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  600. iter != mMaterialInfoList.end(); ++iter)
  601. {
  602. LLMaterialInfo *infop = *iter;
  603. if (mcode == infop->mMCode)
  604. {
  605. return infop->mDamageModifier;
  606. }
  607. }
  608. return 1.f;
  609. }
  610. F32 LLMaterialTable::getEPMod(U8 mcode)
  611. {
  612. mcode &= LL_MCODE_MASK;
  613. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  614. iter != mMaterialInfoList.end(); ++iter)
  615. {
  616. LLMaterialInfo *infop = *iter;
  617. if (mcode == infop->mMCode)
  618. {
  619. return infop->mEPModifier;
  620. }
  621. }
  622. return 1.f;
  623. }
  624. LLUUID LLMaterialTable::getShatterSoundUUID(U8 mcode)
  625. {
  626. mcode &= LL_MCODE_MASK;
  627. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  628. iter != mMaterialInfoList.end(); ++iter)
  629. {
  630. LLMaterialInfo *infop = *iter;
  631. if (mcode == infop->mMCode)
  632. {
  633. return infop->mShatterSoundID;
  634. }
  635. }
  636. return SND_NULL;
  637. }