开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llmaterialtable.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：25k
源码类别：

游戏引擎

开发平台：

C++ Builder

llmaterialtable.cpp：源码内容
  1. /** 
  2.  * @file llmaterialtable.cpp
  3.  * @brief Table of material names and IDs for viewer
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #include "linden_common.h"
  35. #include "llmaterialtable.h"
  36. #include "llstl.h"
  37. #include "material_codes.h"
  38. #include "sound_ids.h"
  39. #include "imageids.h"
  41. LLMaterialTable LLMaterialTable::basic(1);
  43. /* 
  44. Old Havok 1 constants
  46. // these are the approximately correct friction values for various materials
  47. // however Havok1's friction dynamics are not very correct, so the effective
  48. // friction coefficients that result from these numbers are approximately
  49. // 25-50% too low, more incorrect for the lower values.
  50. F32 const LLMaterialTable::FRICTION_MIN  = 0.2f; 
  51. F32 const LLMaterialTable::FRICTION_GLASS  = 0.2f;  // borosilicate glass
  52. F32 const LLMaterialTable::FRICTION_LIGHT  = 0.2f;  //
  53. F32 const LLMaterialTable::FRICTION_METAL  = 0.3f;  // steel
  54. F32 const LLMaterialTable::FRICTION_PLASTIC = 0.4f;  // HDPE
  55. F32 const LLMaterialTable::FRICTION_WOOD  = 0.6f;  // southern pine
  56. F32 const LLMaterialTable::FRICTION_FLESH  = 0.60f;  // saltwater
  57. F32 const LLMaterialTable::FRICTION_LAND  = 0.78f;  // dirt
  58. F32 const LLMaterialTable::FRICTION_STONE  = 0.8f;  // concrete
  59. F32 const LLMaterialTable::FRICTION_RUBBER  = 0.9f;  //
  60. F32 const LLMaterialTable::FRICTION_MAX  = 0.95f;  //
  61. */
  63. // #if LL_CURRENT_HAVOK_VERSION == LL_HAVOK_VERSION_460
  64. // Havok4 has more correct friction dynamics, however here we have to use
  65. // the "incorrect" equivalents for the legacy Havok1 behavior
  66. F32 const LLMaterialTable::FRICTION_MIN  = 0.15f; 
  67. F32 const LLMaterialTable::FRICTION_GLASS  = 0.13f;  // borosilicate glass
  68. F32 const LLMaterialTable::FRICTION_LIGHT  = 0.14f;  //
  69. F32 const LLMaterialTable::FRICTION_METAL  = 0.22f;  // steel
  70. F32 const LLMaterialTable::FRICTION_PLASTIC = 0.3f;  // HDPE
  71. F32 const LLMaterialTable::FRICTION_WOOD  = 0.44f;  // southern pine
  72. F32 const LLMaterialTable::FRICTION_FLESH  = 0.46f;  // saltwater
  73. F32 const LLMaterialTable::FRICTION_LAND  = 0.58f;  // dirt
  74. F32 const LLMaterialTable::FRICTION_STONE  = 0.6f;  // concrete
  75. F32 const LLMaterialTable::FRICTION_RUBBER  = 0.67f;  //
  76. F32 const LLMaterialTable::FRICTION_MAX  = 0.71f;  //
  77. // #endif
  79. F32 const LLMaterialTable::RESTITUTION_MIN  = 0.02f; 
  80. F32 const LLMaterialTable::RESTITUTION_LAND  = LLMaterialTable::RESTITUTION_MIN;
  81. F32 const LLMaterialTable::RESTITUTION_FLESH  = 0.2f;  // saltwater
  82. F32 const LLMaterialTable::RESTITUTION_STONE  = 0.4f;  // concrete
  83. F32 const LLMaterialTable::RESTITUTION_METAL  = 0.4f;  // steel
  84. F32 const LLMaterialTable::RESTITUTION_WOOD  = 0.5f;  // southern pine
  85. F32 const LLMaterialTable::RESTITUTION_GLASS  = 0.7f;  // borosilicate glass
  86. F32 const LLMaterialTable::RESTITUTION_PLASTIC = 0.7f;  // HDPE
  87. F32 const LLMaterialTable::RESTITUTION_LIGHT  = 0.7f;  //
  88. F32 const LLMaterialTable::RESTITUTION_RUBBER  = 0.9f;  //
  89. F32 const LLMaterialTable::RESTITUTION_MAX = 0.95f;
  91. F32 const LLMaterialTable::DEFAULT_FRICTION = 0.5f;
  92. F32 const LLMaterialTable::DEFAULT_RESTITUTION = 0.4f;
  94. LLMaterialTable::LLMaterialTable()
  95. : mCollisionSoundMatrix(NULL),
  96.   mSlidingSoundMatrix(NULL),
  97.   mRollingSoundMatrix(NULL)
  98. {
  99. }
  101. LLMaterialTable::LLMaterialTable(U8 isBasic)
  102. {
  103. initBasicTable();
  104. }
  106. LLMaterialTable::~LLMaterialTable()
  107. {
  108. if (mCollisionSoundMatrix)
  109. {
  110. delete [] mCollisionSoundMatrix;
  111. mCollisionSoundMatrix = NULL;
  112. }
  114. if (mSlidingSoundMatrix)
  115. {
  116. delete [] mSlidingSoundMatrix;
  117. mSlidingSoundMatrix = NULL;
  118. }
  120. if (mRollingSoundMatrix)
  121. {
  122. delete [] mRollingSoundMatrix;
  123. mRollingSoundMatrix = NULL;
  124. }
  126. for_each(mMaterialInfoList.begin(), mMaterialInfoList.end(), DeletePointer());
  127. mMaterialInfoList.clear();
  128. }
  130. void LLMaterialTable::initTableTransNames(std::map<std::string, std::string> namemap)
  131. {
  132. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  133.  iter != mMaterialInfoList.end(); ++iter)
  134. {
  135. LLMaterialInfo *infop = *iter;
  136. std::string name = infop->mName;
  137. infop->mName = namemap[name];
  138. }
  139. }
  141. void LLMaterialTable::initBasicTable()
  142. {
  143. // *TODO: Translate
  144. add(LL_MCODE_STONE,std::string("Stone"), LL_DEFAULT_STONE_UUID);
  145. add(LL_MCODE_METAL,std::string("Metal"), LL_DEFAULT_METAL_UUID);
  146. add(LL_MCODE_GLASS,std::string("Glass"), LL_DEFAULT_GLASS_UUID);
  147. add(LL_MCODE_WOOD,std::string("Wood"), LL_DEFAULT_WOOD_UUID);
  148. add(LL_MCODE_FLESH,std::string("Flesh"), LL_DEFAULT_FLESH_UUID);
  149. add(LL_MCODE_PLASTIC,std::string("Plastic"), LL_DEFAULT_PLASTIC_UUID);
  150. add(LL_MCODE_RUBBER,std::string("Rubber"), LL_DEFAULT_RUBBER_UUID);
  151. add(LL_MCODE_LIGHT,std::string("Light"), LL_DEFAULT_LIGHT_UUID);
  153. // specify densities for these materials. . . 
  154.     // these were taken from http://www.mcelwee.net/html/densities_of_various_materials.html
  156. addDensity(LL_MCODE_STONE,30.f);
  157. addDensity(LL_MCODE_METAL,50.f);
  158. addDensity(LL_MCODE_GLASS,20.f);
  159. addDensity(LL_MCODE_WOOD,10.f); 
  160. addDensity(LL_MCODE_FLESH,10.f);
  161. addDensity(LL_MCODE_PLASTIC,5.f);
  162. addDensity(LL_MCODE_RUBBER,0.5f); //
  163. addDensity(LL_MCODE_LIGHT,20.f); //
  165. // add damage and energy values
  166. addDamageAndEnergy(LL_MCODE_STONE, 1.f, 1.f, 1.f); // concrete
  167. addDamageAndEnergy(LL_MCODE_METAL, 1.f, 1.f, 1.f);  // steel
  168. addDamageAndEnergy(LL_MCODE_GLASS, 1.f, 1.f, 1.f);  // borosilicate glass
  169. addDamageAndEnergy(LL_MCODE_WOOD, 1.f, 1.f, 1.f);    // southern pine
  170. addDamageAndEnergy(LL_MCODE_FLESH, 1.f, 1.f, 1.f);  // saltwater
  171. addDamageAndEnergy(LL_MCODE_PLASTIC, 1.f, 1.f, 1.f); // HDPE
  172. addDamageAndEnergy(LL_MCODE_RUBBER, 1.f, 1.f, 1.f); //
  173. addDamageAndEnergy(LL_MCODE_LIGHT, 1.f, 1.f, 1.f); //
  175. addFriction(LL_MCODE_STONE,0.8f); // concrete
  176. addFriction(LL_MCODE_METAL,0.3f);  // steel
  177. addFriction(LL_MCODE_GLASS,0.2f);  // borosilicate glass
  178. addFriction(LL_MCODE_WOOD,0.6f);    // southern pine
  179. addFriction(LL_MCODE_FLESH,0.9f);  // saltwater
  180. addFriction(LL_MCODE_PLASTIC,0.4f); // HDPE
  181. addFriction(LL_MCODE_RUBBER,0.9f); //
  182. addFriction(LL_MCODE_LIGHT,0.2f); //
  184. addRestitution(LL_MCODE_STONE,0.4f); // concrete
  185. addRestitution(LL_MCODE_METAL,0.4f);  // steel
  186. addRestitution(LL_MCODE_GLASS,0.7f);  // borosilicate glass
  187. addRestitution(LL_MCODE_WOOD,0.5f);    // southern pine
  188. addRestitution(LL_MCODE_FLESH,0.3f);  // saltwater
  189. addRestitution(LL_MCODE_PLASTIC,0.7f); // HDPE
  190. addRestitution(LL_MCODE_RUBBER,0.9f); //
  191. addRestitution(LL_MCODE_LIGHT,0.7f); //
  193. addShatterSound(LL_MCODE_STONE,LLUUID("ea296329-0f09-4993-af1b-e6784bab1dc9"));
  194. addShatterSound(LL_MCODE_METAL,LLUUID("d1375446-1c4d-470b-9135-30132433b678"));
  195. addShatterSound(LL_MCODE_GLASS,LLUUID("85cda060-b393-48e6-81c8-2cfdfb275351"));
  196. addShatterSound(LL_MCODE_WOOD,LLUUID("6f00669f-15e0-4793-a63e-c03f62fee43a"));
  197. addShatterSound(LL_MCODE_FLESH,LLUUID("2d8c6f51-149e-4e23-8413-93a379b42b67"));
  198. addShatterSound(LL_MCODE_PLASTIC,LLUUID("d55c7f3c-e1c3-4ddc-9eff-9ef805d9190e"));
  199. addShatterSound(LL_MCODE_RUBBER,LLUUID("212b6d1e-8d9c-4986-b3aa-f3c6df8d987d"));
  200. addShatterSound(LL_MCODE_LIGHT,LLUUID("d55c7f3c-e1c3-4ddc-9eff-9ef805d9190e"));
  202. //  CollisionSounds
  203. mCollisionSoundMatrix = new LLUUID[LL_MCODE_END*LL_MCODE_END];
  204. if (mCollisionSoundMatrix)
  205. {
  206. addCollisionSound(LL_MCODE_STONE, LL_MCODE_STONE, SND_STONE_STONE);
  207. addCollisionSound(LL_MCODE_STONE, LL_MCODE_METAL, SND_STONE_METAL);
  208. addCollisionSound(LL_MCODE_STONE, LL_MCODE_GLASS, SND_STONE_GLASS);
  209. addCollisionSound(LL_MCODE_STONE, LL_MCODE_WOOD, SND_STONE_WOOD);
  210. addCollisionSound(LL_MCODE_STONE, LL_MCODE_FLESH, SND_STONE_FLESH);
  211. addCollisionSound(LL_MCODE_STONE, LL_MCODE_PLASTIC, SND_STONE_PLASTIC);
  212. addCollisionSound(LL_MCODE_STONE, LL_MCODE_RUBBER, SND_STONE_RUBBER);
  213. addCollisionSound(LL_MCODE_STONE, LL_MCODE_LIGHT, SND_STONE_PLASTIC);
  215. addCollisionSound(LL_MCODE_METAL, LL_MCODE_METAL, SND_METAL_METAL);
  216. addCollisionSound(LL_MCODE_METAL, LL_MCODE_GLASS, SND_METAL_GLASS);
  217. addCollisionSound(LL_MCODE_METAL, LL_MCODE_WOOD, SND_METAL_WOOD);
  218. addCollisionSound(LL_MCODE_METAL, LL_MCODE_FLESH, SND_METAL_FLESH);
  219. addCollisionSound(LL_MCODE_METAL, LL_MCODE_PLASTIC, SND_METAL_PLASTIC);
  220. addCollisionSound(LL_MCODE_METAL, LL_MCODE_LIGHT, SND_METAL_PLASTIC);
  221. addCollisionSound(LL_MCODE_METAL, LL_MCODE_RUBBER, SND_METAL_RUBBER);
  223. addCollisionSound(LL_MCODE_GLASS, LL_MCODE_GLASS, SND_GLASS_GLASS);
  224. addCollisionSound(LL_MCODE_GLASS, LL_MCODE_WOOD, SND_GLASS_WOOD);
  225. addCollisionSound(LL_MCODE_GLASS, LL_MCODE_FLESH, SND_GLASS_FLESH);
  226. addCollisionSound(LL_MCODE_GLASS, LL_MCODE_PLASTIC, SND_GLASS_PLASTIC);
  227. addCollisionSound(LL_MCODE_GLASS, LL_MCODE_RUBBER, SND_GLASS_RUBBER);
  228. addCollisionSound(LL_MCODE_GLASS, LL_MCODE_LIGHT, SND_GLASS_PLASTIC);
  230. addCollisionSound(LL_MCODE_WOOD, LL_MCODE_WOOD, SND_WOOD_WOOD);
  231. addCollisionSound(LL_MCODE_WOOD, LL_MCODE_FLESH, SND_WOOD_FLESH);
  232. addCollisionSound(LL_MCODE_WOOD, LL_MCODE_PLASTIC, SND_WOOD_PLASTIC);
  233. addCollisionSound(LL_MCODE_WOOD, LL_MCODE_RUBBER, SND_WOOD_RUBBER);
  234. addCollisionSound(LL_MCODE_WOOD, LL_MCODE_LIGHT, SND_WOOD_PLASTIC);
  236. addCollisionSound(LL_MCODE_FLESH, LL_MCODE_FLESH, SND_FLESH_FLESH);
  237. addCollisionSound(LL_MCODE_FLESH, LL_MCODE_PLASTIC, SND_FLESH_PLASTIC);
  238. addCollisionSound(LL_MCODE_FLESH, LL_MCODE_RUBBER, SND_FLESH_RUBBER);
  239. addCollisionSound(LL_MCODE_FLESH, LL_MCODE_LIGHT, SND_FLESH_PLASTIC);
  241. addCollisionSound(LL_MCODE_RUBBER, LL_MCODE_RUBBER, SND_RUBBER_RUBBER);
  242. addCollisionSound(LL_MCODE_RUBBER, LL_MCODE_PLASTIC, SND_RUBBER_PLASTIC);
  243. addCollisionSound(LL_MCODE_RUBBER, LL_MCODE_LIGHT, SND_RUBBER_PLASTIC);
  245. addCollisionSound(LL_MCODE_PLASTIC, LL_MCODE_PLASTIC, SND_PLASTIC_PLASTIC);
  246. addCollisionSound(LL_MCODE_PLASTIC, LL_MCODE_LIGHT, SND_PLASTIC_PLASTIC);
  248. addCollisionSound(LL_MCODE_LIGHT, LL_MCODE_LIGHT, SND_PLASTIC_PLASTIC);
  249. }
  251. //  Sliding Sounds
  252. mSlidingSoundMatrix = new LLUUID[LL_MCODE_END*LL_MCODE_END];
  253. if (mSlidingSoundMatrix)
  254. {
  255. addSlidingSound(LL_MCODE_STONE, LL_MCODE_STONE, SND_SLIDE_STONE_STONE);
  256. addSlidingSound(LL_MCODE_STONE, LL_MCODE_METAL, SND_SLIDE_STONE_STONE_01);
  257. addSlidingSound(LL_MCODE_STONE, LL_MCODE_GLASS, SND_SLIDE_STONE_STONE_01);
  258. addSlidingSound(LL_MCODE_STONE, LL_MCODE_WOOD, SND_SLIDE_STONE_WOOD);
  259. addSlidingSound(LL_MCODE_STONE, LL_MCODE_FLESH, SND_SLIDE_STONE_STONE_01);
  260. addSlidingSound(LL_MCODE_STONE, LL_MCODE_PLASTIC, SND_SLIDE_STONE_PLASTIC);
  261. addSlidingSound(LL_MCODE_STONE, LL_MCODE_RUBBER, SND_SLIDE_STONE_RUBBER);
  262. addSlidingSound(LL_MCODE_STONE, LL_MCODE_LIGHT, SND_SLIDE_STONE_PLASTIC);
  264. addSlidingSound(LL_MCODE_METAL, LL_MCODE_METAL, SND_SLIDE_METAL_METAL);
  265. addSlidingSound(LL_MCODE_METAL, LL_MCODE_GLASS, SND_SLIDE_METAL_GLASS);
  266. addSlidingSound(LL_MCODE_METAL, LL_MCODE_WOOD, SND_SLIDE_METAL_WOOD);
  267. addSlidingSound(LL_MCODE_METAL, LL_MCODE_FLESH, SND_SLIDE_METAL_FLESH);
  268. addSlidingSound(LL_MCODE_METAL, LL_MCODE_PLASTIC, SND_SLIDE_STONE_STONE_01);
  269. addSlidingSound(LL_MCODE_METAL, LL_MCODE_RUBBER, SND_SLIDE_METAL_RUBBER);
  270. addSlidingSound(LL_MCODE_METAL, LL_MCODE_LIGHT, SND_SLIDE_STONE_STONE_01);
  272. addSlidingSound(LL_MCODE_GLASS, LL_MCODE_GLASS, SND_SLIDE_STONE_STONE_01);
  273. addSlidingSound(LL_MCODE_GLASS, LL_MCODE_WOOD, SND_SLIDE_STONE_STONE_01);
  274. addSlidingSound(LL_MCODE_GLASS, LL_MCODE_FLESH, SND_SLIDE_STONE_STONE_01);
  275. addSlidingSound(LL_MCODE_GLASS, LL_MCODE_PLASTIC, SND_SLIDE_STONE_STONE_01);
  276. addSlidingSound(LL_MCODE_GLASS, LL_MCODE_RUBBER, SND_SLIDE_STONE_STONE_01);
  277. addSlidingSound(LL_MCODE_GLASS, LL_MCODE_LIGHT, SND_SLIDE_STONE_STONE_01);
  279. addSlidingSound(LL_MCODE_WOOD, LL_MCODE_WOOD, SND_SLIDE_WOOD_WOOD);
  280. addSlidingSound(LL_MCODE_WOOD, LL_MCODE_FLESH, SND_SLIDE_WOOD_FLESH);
  281. addSlidingSound(LL_MCODE_WOOD, LL_MCODE_PLASTIC, SND_SLIDE_WOOD_PLASTIC);
  282. addSlidingSound(LL_MCODE_WOOD, LL_MCODE_RUBBER, SND_SLIDE_STONE_STONE_01);
  283. addSlidingSound(LL_MCODE_WOOD, LL_MCODE_LIGHT, SND_SLIDE_WOOD_PLASTIC);
  285. addSlidingSound(LL_MCODE_FLESH, LL_MCODE_FLESH, SND_SLIDE_FLESH_FLESH);
  286. addSlidingSound(LL_MCODE_FLESH, LL_MCODE_PLASTIC, SND_SLIDE_STONE_STONE_01);
  287. addSlidingSound(LL_MCODE_FLESH, LL_MCODE_RUBBER, SND_SLIDE_STONE_STONE_01);
  288. addSlidingSound(LL_MCODE_FLESH, LL_MCODE_LIGHT, SND_SLIDE_STONE_STONE_01);
  290. addSlidingSound(LL_MCODE_RUBBER, LL_MCODE_RUBBER, SND_SLIDE_STONE_STONE_01);
  291. addSlidingSound(LL_MCODE_RUBBER, LL_MCODE_PLASTIC, SND_SLIDE_RUBBER_PLASTIC);
  292. addSlidingSound(LL_MCODE_RUBBER, LL_MCODE_LIGHT, SND_SLIDE_RUBBER_PLASTIC);
  294. addSlidingSound(LL_MCODE_PLASTIC, LL_MCODE_PLASTIC, SND_SLIDE_STONE_STONE_01);
  295. addSlidingSound(LL_MCODE_PLASTIC, LL_MCODE_LIGHT, SND_SLIDE_STONE_STONE_01);
  297. addSlidingSound(LL_MCODE_LIGHT, LL_MCODE_LIGHT, SND_SLIDE_STONE_STONE_01);
  298. }
  300. //  Rolling Sounds
  301. mRollingSoundMatrix = new LLUUID[LL_MCODE_END*LL_MCODE_END];
  302. if (mRollingSoundMatrix)
  303. {
  304. addRollingSound(LL_MCODE_STONE, LL_MCODE_STONE, SND_ROLL_STONE_STONE);
  305. addRollingSound(LL_MCODE_STONE, LL_MCODE_METAL, SND_SLIDE_STONE_STONE_01);
  306. addRollingSound(LL_MCODE_STONE, LL_MCODE_GLASS, SND_SLIDE_STONE_STONE_01);
  307. addRollingSound(LL_MCODE_STONE, LL_MCODE_WOOD, SND_ROLL_STONE_WOOD);
  308. addRollingSound(LL_MCODE_STONE, LL_MCODE_FLESH, SND_SLIDE_STONE_STONE_01);
  309. addRollingSound(LL_MCODE_STONE, LL_MCODE_PLASTIC, SND_ROLL_STONE_PLASTIC);
  310. addRollingSound(LL_MCODE_STONE, LL_MCODE_RUBBER, SND_SLIDE_STONE_STONE_01);
  311. addRollingSound(LL_MCODE_STONE, LL_MCODE_LIGHT, SND_ROLL_STONE_PLASTIC);
  313. addRollingSound(LL_MCODE_METAL, LL_MCODE_METAL, SND_SLIDE_STONE_STONE_01);
  314. addRollingSound(LL_MCODE_METAL, LL_MCODE_GLASS, SND_ROLL_METAL_GLASS);
  315. addRollingSound(LL_MCODE_METAL, LL_MCODE_WOOD, SND_ROLL_METAL_WOOD);
  316. addRollingSound(LL_MCODE_METAL, LL_MCODE_FLESH, SND_SLIDE_STONE_STONE_01);
  317. addRollingSound(LL_MCODE_METAL, LL_MCODE_PLASTIC, SND_ROLL_METAL_WOOD);
  318. addRollingSound(LL_MCODE_METAL, LL_MCODE_RUBBER, SND_SLIDE_STONE_STONE_01);
  319. addRollingSound(LL_MCODE_METAL, LL_MCODE_LIGHT, SND_ROLL_METAL_WOOD);
  321. addRollingSound(LL_MCODE_GLASS, LL_MCODE_GLASS, SND_SLIDE_STONE_STONE_01);
  322. addRollingSound(LL_MCODE_GLASS, LL_MCODE_WOOD, SND_ROLL_GLASS_WOOD);
  323. addRollingSound(LL_MCODE_GLASS, LL_MCODE_FLESH, SND_SLIDE_STONE_STONE_01);
  324. addRollingSound(LL_MCODE_GLASS, LL_MCODE_PLASTIC, SND_SLIDE_STONE_STONE_01);
  325. addRollingSound(LL_MCODE_GLASS, LL_MCODE_RUBBER, SND_SLIDE_STONE_STONE_01);
  326. addRollingSound(LL_MCODE_GLASS, LL_MCODE_LIGHT, SND_SLIDE_STONE_STONE_01);
  328. addRollingSound(LL_MCODE_WOOD, LL_MCODE_WOOD, SND_ROLL_WOOD_WOOD);
  329. addRollingSound(LL_MCODE_WOOD, LL_MCODE_FLESH, SND_ROLL_WOOD_FLESH);
  330. addRollingSound(LL_MCODE_WOOD, LL_MCODE_PLASTIC, SND_ROLL_WOOD_PLASTIC);
  331. addRollingSound(LL_MCODE_WOOD, LL_MCODE_RUBBER, SND_SLIDE_STONE_STONE_01);
  332. addRollingSound(LL_MCODE_WOOD, LL_MCODE_LIGHT, SND_ROLL_WOOD_PLASTIC);
  334. addRollingSound(LL_MCODE_FLESH, LL_MCODE_FLESH, SND_SLIDE_STONE_STONE_01);
  335. addRollingSound(LL_MCODE_FLESH, LL_MCODE_PLASTIC, SND_ROLL_FLESH_PLASTIC);
  336. addRollingSound(LL_MCODE_FLESH, LL_MCODE_RUBBER, SND_SLIDE_STONE_STONE_01);
  337. addRollingSound(LL_MCODE_FLESH, LL_MCODE_LIGHT, SND_ROLL_FLESH_PLASTIC);
  339. addRollingSound(LL_MCODE_RUBBER, LL_MCODE_RUBBER, SND_SLIDE_STONE_STONE_01);
  340. addRollingSound(LL_MCODE_RUBBER, LL_MCODE_PLASTIC, SND_SLIDE_STONE_STONE_01);
  341. addRollingSound(LL_MCODE_RUBBER, LL_MCODE_LIGHT, SND_SLIDE_STONE_STONE_01);
  343. addRollingSound(LL_MCODE_PLASTIC, LL_MCODE_PLASTIC, SND_ROLL_PLASTIC_PLASTIC);
  344. addRollingSound(LL_MCODE_PLASTIC, LL_MCODE_LIGHT, SND_ROLL_PLASTIC_PLASTIC);
  346. addRollingSound(LL_MCODE_LIGHT, LL_MCODE_LIGHT, SND_ROLL_PLASTIC_PLASTIC);
  347. }
  348. }
  350. BOOL LLMaterialTable::add(U8 mcode, const std::string& name, const LLUUID &uuid)
  351. {
  352. LLMaterialInfo *infop;
  354. infop = new LLMaterialInfo(mcode,name,uuid);
  355. if (!infop) return FALSE;
  357. // Add at the end so the order in menus matches the order in this
  358. // file.  JNC 11.30.01
  359. mMaterialInfoList.push_back(infop);
  361. return TRUE;
  362. }
  364. BOOL LLMaterialTable::addCollisionSound(U8 mcode, U8 mcode2, const LLUUID &uuid)
  365. {
  366. if (mCollisionSoundMatrix && (mcode < LL_MCODE_END) && (mcode2 < LL_MCODE_END))
  367. {
  368. mCollisionSoundMatrix[mcode * LL_MCODE_END + mcode2] = uuid;
  369. if (mcode != mcode2)
  370. {
  371. mCollisionSoundMatrix[mcode2 * LL_MCODE_END + mcode] = uuid;
  372. }
  373. }
  374. return TRUE;
  375. }
  377. BOOL LLMaterialTable::addSlidingSound(U8 mcode, U8 mcode2, const LLUUID &uuid)
  378. {
  379. if (mSlidingSoundMatrix && (mcode < LL_MCODE_END) && (mcode2 < LL_MCODE_END))
  380. {
  381. mSlidingSoundMatrix[mcode * LL_MCODE_END + mcode2] = uuid;
  382. if (mcode != mcode2)
  383. {
  384. mSlidingSoundMatrix[mcode2 * LL_MCODE_END + mcode] = uuid;
  385. }
  386. }
  387. return TRUE;
  388. }
  390. BOOL LLMaterialTable::addRollingSound(U8 mcode, U8 mcode2, const LLUUID &uuid)
  391. {
  392. if (mRollingSoundMatrix && (mcode < LL_MCODE_END) && (mcode2 < LL_MCODE_END))
  393. {
  394. mRollingSoundMatrix[mcode * LL_MCODE_END + mcode2] = uuid;
  395. if (mcode != mcode2)
  396. {
  397. mRollingSoundMatrix[mcode2 * LL_MCODE_END + mcode] = uuid;
  398. }
  399. }
  400. return TRUE;
  401. }
  403. BOOL LLMaterialTable::addShatterSound(U8 mcode, const LLUUID &uuid)
  404. {
  405. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  406.  iter != mMaterialInfoList.end(); ++iter)
  407. {
  408. LLMaterialInfo *infop = *iter;
  409. if (mcode == infop->mMCode)
  410. {
  411. infop->mShatterSoundID = uuid;
  412. return TRUE;
  413. }
  414. }
  416. return FALSE;
  417. }
  419. BOOL LLMaterialTable::addDensity(U8 mcode, const F32 &density)
  420. {
  421. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  422.  iter != mMaterialInfoList.end(); ++iter)
  423. {
  424. LLMaterialInfo *infop = *iter;
  425. if (mcode == infop->mMCode)
  426. {
  427. infop->mDensity = density;
  428. return TRUE;
  429. }
  430. }
  432. return FALSE;
  433. }
  435. BOOL LLMaterialTable::addRestitution(U8 mcode, const F32 &restitution)
  436. {
  437. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  438.  iter != mMaterialInfoList.end(); ++iter)
  439. {
  440. LLMaterialInfo *infop = *iter;
  441. if (mcode == infop->mMCode)
  442. {
  443. infop->mRestitution = restitution;
  444. return TRUE;
  445. }
  446. }
  448. return FALSE;
  449. }
  451. BOOL LLMaterialTable::addFriction(U8 mcode, const F32 &friction)
  452. {
  453. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  454.  iter != mMaterialInfoList.end(); ++iter)
  455. {
  456. LLMaterialInfo *infop = *iter;
  457. if (mcode == infop->mMCode)
  458. {
  459. infop->mFriction = friction;
  460. return TRUE;
  461. }
  462. }
  464. return FALSE;
  465. }
  467. BOOL LLMaterialTable::addDamageAndEnergy(U8 mcode, const F32 &hp_mod, const F32 &damage_mod, const F32 &ep_mod)
  468. {
  469. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  470.  iter != mMaterialInfoList.end(); ++iter)
  471. {
  472. LLMaterialInfo *infop = *iter;
  473. if (mcode == infop->mMCode)
  474. {
  475. infop->mHPModifier = hp_mod;
  476. infop->mDamageModifier = damage_mod;
  477. infop->mEPModifier = ep_mod;
  478. return TRUE;
  479. }
  480. }
  482. return FALSE;
  483. }
  485. LLUUID LLMaterialTable::getDefaultTextureID(const std::string& name)
  486. {
  487. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  488.  iter != mMaterialInfoList.end(); ++iter)
  489. {
  490. LLMaterialInfo *infop = *iter;
  491. if (name == infop->mName)
  492. {
  493. return infop->mDefaultTextureID;
  494. }
  495. }
  497. return LLUUID::null;
  498. }
  501. LLUUID LLMaterialTable::getDefaultTextureID(U8 mcode)
  502. {
  503. mcode &= LL_MCODE_MASK;
  504. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  505.  iter != mMaterialInfoList.end(); ++iter)
  506. {
  507. LLMaterialInfo *infop = *iter;
  508. if (mcode == infop->mMCode)
  509. {
  510. return infop->mDefaultTextureID;
  511. }
  512. }
  514. return LLUUID::null;
  515. }
  518. U8 LLMaterialTable::getMCode(const std::string& name)
  519. {
  520. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  521.  iter != mMaterialInfoList.end(); ++iter)
  522. {
  523. LLMaterialInfo *infop = *iter;
  524. if (name == infop->mName)
  525. {
  526. return infop->mMCode;
  527. }
  528. }
  530. return 0;
  531. }
  534. std::string LLMaterialTable::getName(U8 mcode)
  535. {
  536. mcode &= LL_MCODE_MASK;
  537. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  538.  iter != mMaterialInfoList.end(); ++iter)
  539. {
  540. LLMaterialInfo *infop = *iter;
  541. if (mcode == infop->mMCode)
  542. {
  543. return infop->mName;
  544. }
  545. }
  547. return NULL;
  548. }
  551. LLUUID LLMaterialTable::getCollisionSoundUUID(U8 mcode, U8 mcode2)
  552. {
  553. mcode &= LL_MCODE_MASK;
  554. mcode2 &= LL_MCODE_MASK;
  556. //llinfos << "code 1: " << ((U32) mcode) << " code 2:" << ((U32) mcode2) << llendl;
  557. if (mCollisionSoundMatrix && (mcode < LL_MCODE_END) && (mcode2 < LL_MCODE_END))
  558. {
  559. return(mCollisionSoundMatrix[mcode * LL_MCODE_END + mcode2]);
  560. }
  561. else
  562. {
  563. //llinfos << "Null Sound" << llendl;
  564. return(SND_NULL);
  565. }
  566. }
  568. LLUUID LLMaterialTable::getSlidingSoundUUID(U8 mcode, U8 mcode2)
  569. {
  570. mcode &= LL_MCODE_MASK;
  571. mcode2 &= LL_MCODE_MASK;
  573. if (mSlidingSoundMatrix && (mcode < LL_MCODE_END) && (mcode2 < LL_MCODE_END))
  574. {
  575. return(mSlidingSoundMatrix[mcode * LL_MCODE_END + mcode2]);
  576. }
  577. else
  578. {
  579. return(SND_NULL);
  580. }
  581. }
  583. LLUUID LLMaterialTable::getRollingSoundUUID(U8 mcode, U8 mcode2)
  584. {
  585. mcode &= LL_MCODE_MASK;
  586. mcode2 &= LL_MCODE_MASK;
  588. if (mRollingSoundMatrix && (mcode < LL_MCODE_END) && (mcode2 < LL_MCODE_END))
  589. {
  590. return(mRollingSoundMatrix[mcode * LL_MCODE_END + mcode2]);
  591. }
  592. else
  593. {
  594. return(SND_NULL);
  595. }
  596. }
  598. LLUUID LLMaterialTable::getGroundCollisionSoundUUID(U8 mcode)
  599. {
  600. //  Create material appropriate sounds for collisions with the ground 
  601. //  For now, simply return a single sound for all materials 
  602. return SND_STONE_DIRT_02;
  603. }
  605. LLUUID LLMaterialTable::getGroundSlidingSoundUUID(U8 mcode)
  606. {
  607. //  Create material-specific sound for sliding on ground
  608. //  For now, just return a single sound 
  609. return SND_SLIDE_STONE_STONE_01;
  610. }
  612. LLUUID LLMaterialTable::getGroundRollingSoundUUID(U8 mcode)
  613. {
  614. //  Create material-specific sound for rolling on ground
  615. //  For now, just return a single sound 
  616. return SND_SLIDE_STONE_STONE_01;
  617. }
  619. LLUUID LLMaterialTable::getCollisionParticleUUID(U8 mcode, U8 mcode2)
  620. {
  621. //  Returns an appropriate UUID to use as sprite at collision betweeen objects  
  622. //  For now, just return a single image 
  623. return IMG_SHOT;
  624. }
  626. LLUUID LLMaterialTable::getGroundCollisionParticleUUID(U8 mcode)
  627. {
  628. //  Returns an appropriate 
  629. //  For now, just return a single sound 
  630. return IMG_SMOKE_POOF;
  631. }
  634. F32 LLMaterialTable::getDensity(U8 mcode)
  635. {
  636. mcode &= LL_MCODE_MASK;
  637. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  638.  iter != mMaterialInfoList.end(); ++iter)
  639. {
  640. LLMaterialInfo *infop = *iter;
  641. if (mcode == infop->mMCode)
  642. {
  643. return infop->mDensity;
  644. }
  645. }
  647. return 0.f;
  648. }
  650. F32 LLMaterialTable::getRestitution(U8 mcode)
  651. {
  652. mcode &= LL_MCODE_MASK;
  653. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  654.  iter != mMaterialInfoList.end(); ++iter)
  655. {
  656. LLMaterialInfo *infop = *iter;
  657. if (mcode == infop->mMCode)
  658. {
  659. return infop->mRestitution;
  660. }
  661. }
  663. return LLMaterialTable::DEFAULT_RESTITUTION;
  664. }
  666. F32 LLMaterialTable::getFriction(U8 mcode)
  667. {
  668. mcode &= LL_MCODE_MASK;
  669. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  670.  iter != mMaterialInfoList.end(); ++iter)
  671. {
  672. LLMaterialInfo *infop = *iter;
  673. if (mcode == infop->mMCode)
  674. {
  675. return infop->mFriction;
  676. }
  677. }
  679. return LLMaterialTable::DEFAULT_FRICTION;
  680. }
  682. F32 LLMaterialTable::getHPMod(U8 mcode)
  683. {
  684. mcode &= LL_MCODE_MASK;
  685. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  686.  iter != mMaterialInfoList.end(); ++iter)
  687. {
  688. LLMaterialInfo *infop = *iter;
  689. if (mcode == infop->mMCode)
  690. {
  691. return infop->mHPModifier;
  692. }
  693. }
  695. return 1.f;
  696. }
  698. F32 LLMaterialTable::getDamageMod(U8 mcode)
  699. {
  700. mcode &= LL_MCODE_MASK;
  701. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  702.  iter != mMaterialInfoList.end(); ++iter)
  703. {
  704. LLMaterialInfo *infop = *iter;
  705. if (mcode == infop->mMCode)
  706. {
  707. return infop->mDamageModifier;
  708. }
  709. }
  711. return 1.f;
  712. }
  714. F32 LLMaterialTable::getEPMod(U8 mcode)
  715. {
  716. mcode &= LL_MCODE_MASK;
  717. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  718.  iter != mMaterialInfoList.end(); ++iter)
  719. {
  720. LLMaterialInfo *infop = *iter;
  721. if (mcode == infop->mMCode)
  722. {
  723. return infop->mEPModifier;
  724. }
  725. }
  727. return 1.f;
  728. }
  730. LLUUID LLMaterialTable::getShatterSoundUUID(U8 mcode)
  731. {
  732. mcode &= LL_MCODE_MASK;
  733. for (info_list_t::iterator iter = mMaterialInfoList.begin();
  734.  iter != mMaterialInfoList.end(); ++iter)
  735. {
  736. LLMaterialInfo *infop = *iter;
  737. if (mcode == infop->mMCode)
  738. {
  739. return infop->mShatterSoundID;
  740. }
  741. }
  743. return SND_NULL;
  744. }