v3color.h
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:10k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file v3color.h
  3.  * @brief LLColor3 class header file.
  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.  */
  32. #ifndef LL_V3COLOR_H
  33. #define LL_V3COLOR_H
  34. class LLColor4;
  35. class LLVector4;
  36. #include "llerror.h"
  37. #include "llmath.h"
  38. #include "llsd.h"
  39. //  LLColor3 = |r g b|
  40. static const U32 LENGTHOFCOLOR3 = 3;
  41. class LLColor3
  42. {
  43. public:
  44. F32 mV[LENGTHOFCOLOR3];
  45. static LLColor3 white;
  46. static LLColor3 black;
  47. static LLColor3 grey;
  48. public:
  49. LLColor3(); // Initializes LLColor3 to (0, 0, 0)
  50. LLColor3(F32 r, F32 g, F32 b); // Initializes LLColor3 to (r, g, b)
  51. LLColor3(const F32 *vec); // Initializes LLColor3 to (vec[0]. vec[1], vec[2])
  52. LLColor3(const char *color_string);       // html format color ie "#FFDDEE"
  53. explicit LLColor3(const LLColor4& color4);  // "explicit" to avoid automatic conversion
  54. explicit LLColor3(const LLVector4& vector4);  // "explicit" to avoid automatic conversion
  55. LLColor3(const LLSD& sd);
  56. LLSD getValue() const
  57. {
  58. LLSD ret;
  59. ret[0] = mV[0];
  60. ret[1] = mV[1];
  61. ret[2] = mV[2];
  62. return ret;
  63. }
  64. void setValue(const LLSD& sd)
  65. {
  66. mV[0] = (F32) sd[0].asReal();;
  67. mV[1] = (F32) sd[1].asReal();;
  68. mV[2] = (F32) sd[2].asReal();;
  69. }
  70. void setHSL(F32 hue, F32 saturation, F32 luminance);
  71. void calcHSL(F32* hue, F32* saturation, F32* luminance) const;
  72. const LLColor3& setToBlack(); // Clears LLColor3 to (0, 0, 0)
  73. const LLColor3& setToWhite(); // Zero LLColor3 to (0, 0, 0)
  74. const LLColor3& setVec(F32 x, F32 y, F32 z); // deprecated
  75. const LLColor3& setVec(const LLColor3 &vec); // deprecated
  76. const LLColor3& setVec(const F32 *vec); // deprecated
  77. const LLColor3& set(F32 x, F32 y, F32 z); // Sets LLColor3 to (x, y, z)
  78. const LLColor3& set(const LLColor3 &vec); // Sets LLColor3 to vec
  79. const LLColor3& set(const F32 *vec); // Sets LLColor3 to vec
  80. F32 magVec() const; // deprecated
  81. F32 magVecSquared() const; // deprecated
  82. F32 normVec(); // deprecated
  83. F32 length() const; // Returns magnitude of LLColor3
  84. F32 lengthSquared() const; // Returns magnitude squared of LLColor3
  85. F32 normalize(); // Normalizes and returns the magnitude of LLColor3
  86. F32 brightness() const; // Returns brightness of LLColor3
  87. const LLColor3& operator=(const LLColor4 &a);
  88. friend std::ostream&  operator<<(std::ostream& s, const LLColor3 &a); // Print a
  89. friend LLColor3 operator+(const LLColor3 &a, const LLColor3 &b); // Return vector a + b
  90. friend LLColor3 operator-(const LLColor3 &a, const LLColor3 &b); // Return vector a minus b
  91. friend const LLColor3& operator+=(LLColor3 &a, const LLColor3 &b); // Return vector a + b
  92. friend const LLColor3& operator-=(LLColor3 &a, const LLColor3 &b); // Return vector a minus b
  93. friend const LLColor3& operator*=(LLColor3 &a, const LLColor3 &b);
  94. friend LLColor3 operator*(const LLColor3 &a, const LLColor3 &b); // Return component wise a * b
  95. friend LLColor3 operator*(const LLColor3 &a, F32 k); // Return a times scaler k
  96. friend LLColor3 operator*(F32 k, const LLColor3 &a); // Return a times scaler k
  97. friend bool operator==(const LLColor3 &a, const LLColor3 &b); // Return a == b
  98. friend bool operator!=(const LLColor3 &a, const LLColor3 &b); // Return a != b
  99. friend const LLColor3& operator*=(LLColor3 &a, F32 k); // Return a times scaler k
  100. friend LLColor3 operator-(const LLColor3 &a); // Return vector 1-rgb (inverse)
  101. inline void clamp();
  102. inline void exp(); // Do an exponential on the color
  103. };
  104. LLColor3 lerp(const LLColor3 &a, const LLColor3 &b, F32 u);
  105. void LLColor3::clamp()
  106. {
  107. // Clamp the color...
  108. if (mV[0] < 0.f)
  109. {
  110. mV[0] = 0.f;
  111. }
  112. else if (mV[0] > 1.f)
  113. {
  114. mV[0] = 1.f;
  115. }
  116. if (mV[1] < 0.f)
  117. {
  118. mV[1] = 0.f;
  119. }
  120. else if (mV[1] > 1.f)
  121. {
  122. mV[1] = 1.f;
  123. }
  124. if (mV[2] < 0.f)
  125. {
  126. mV[2] = 0.f;
  127. }
  128. else if (mV[2] > 1.f)
  129. {
  130. mV[2] = 1.f;
  131. }
  132. }
  133. // Non-member functions 
  134. F32 distVec(const LLColor3 &a, const LLColor3 &b); // Returns distance between a and b
  135. F32 distVec_squared(const LLColor3 &a, const LLColor3 &b);// Returns distance squared between a and b
  136. inline LLColor3::LLColor3(void)
  137. {
  138. mV[0] = 0.f;
  139. mV[1] = 0.f;
  140. mV[2] = 0.f;
  141. }
  142. inline LLColor3::LLColor3(F32 r, F32 g, F32 b)
  143. {
  144. mV[VX] = r;
  145. mV[VY] = g;
  146. mV[VZ] = b;
  147. }
  148. inline LLColor3::LLColor3(const F32 *vec)
  149. {
  150. mV[VX] = vec[VX];
  151. mV[VY] = vec[VY];
  152. mV[VZ] = vec[VZ];
  153. }
  154. #if LL_WINDOWS
  155. # pragma warning( disable : 4996 ) // strncpy teh sux0r
  156. #endif
  157. inline LLColor3::LLColor3(const char* color_string) // takes a string of format "RRGGBB" where RR is hex 00..FF 
  158. {
  159. if (strlen(color_string) <  6) /* Flawfinder: ignore */
  160. {
  161. mV[0] = 0.f;
  162. mV[1] = 0.f;
  163. mV[2] = 0.f;
  164. return;
  165. }
  166. char tempstr[7];
  167. strncpy(tempstr,color_string,6); /* Flawfinder: ignore */
  168. tempstr[6] = '';
  169. mV[VZ] = (F32)strtol(&tempstr[4],NULL,16)/255.f;
  170. tempstr[4] = '';
  171. mV[VY] = (F32)strtol(&tempstr[2],NULL,16)/255.f;
  172. tempstr[2] = '';
  173. mV[VX] = (F32)strtol(&tempstr[0],NULL,16)/255.f;
  174. }
  175. inline const LLColor3& LLColor3::setToBlack(void)
  176. {
  177. mV[0] = 0.f;
  178. mV[1] = 0.f;
  179. mV[2] = 0.f;
  180. return (*this);
  181. }
  182. inline const LLColor3& LLColor3::setToWhite(void)
  183. {
  184. mV[0] = 1.f;
  185. mV[1] = 1.f;
  186. mV[2] = 1.f;
  187. return (*this);
  188. }
  189. inline const LLColor3& LLColor3::set(F32 r, F32 g, F32 b)
  190. {
  191. mV[0] = r;
  192. mV[1] = g;
  193. mV[2] = b;
  194. return (*this);
  195. }
  196. inline const LLColor3& LLColor3::set(const LLColor3 &vec)
  197. {
  198. mV[0] = vec.mV[0];
  199. mV[1] = vec.mV[1];
  200. mV[2] = vec.mV[2];
  201. return (*this);
  202. }
  203. inline const LLColor3& LLColor3::set(const F32 *vec)
  204. {
  205. mV[0] = vec[0];
  206. mV[1] = vec[1];
  207. mV[2] = vec[2];
  208. return (*this);
  209. }
  210. // deprecated
  211. inline const LLColor3& LLColor3::setVec(F32 r, F32 g, F32 b)
  212. {
  213. mV[0] = r;
  214. mV[1] = g;
  215. mV[2] = b;
  216. return (*this);
  217. }
  218. // deprecated
  219. inline const LLColor3& LLColor3::setVec(const LLColor3 &vec)
  220. {
  221. mV[0] = vec.mV[0];
  222. mV[1] = vec.mV[1];
  223. mV[2] = vec.mV[2];
  224. return (*this);
  225. }
  226. // deprecated
  227. inline const LLColor3& LLColor3::setVec(const F32 *vec)
  228. {
  229. mV[0] = vec[0];
  230. mV[1] = vec[1];
  231. mV[2] = vec[2];
  232. return (*this);
  233. }
  234. inline F32 LLColor3::brightness(void) const
  235. {
  236. return (mV[0] + mV[1] + mV[2]) / 3.0f;
  237. }
  238. inline F32 LLColor3::length(void) const
  239. {
  240. return fsqrtf(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
  241. }
  242. inline F32 LLColor3::lengthSquared(void) const
  243. {
  244. return mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2];
  245. }
  246. inline F32 LLColor3::normalize(void)
  247. {
  248. F32 mag = fsqrtf(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
  249. F32 oomag;
  250. if (mag)
  251. {
  252. oomag = 1.f/mag;
  253. mV[0] *= oomag;
  254. mV[1] *= oomag;
  255. mV[2] *= oomag;
  256. }
  257. return (mag);
  258. }
  259. // deprecated
  260. inline F32 LLColor3::magVec(void) const
  261. {
  262. return fsqrtf(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
  263. }
  264. // deprecated
  265. inline F32 LLColor3::magVecSquared(void) const
  266. {
  267. return mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2];
  268. }
  269. // deprecated
  270. inline F32 LLColor3::normVec(void)
  271. {
  272. F32 mag = fsqrtf(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
  273. F32 oomag;
  274. if (mag)
  275. {
  276. oomag = 1.f/mag;
  277. mV[0] *= oomag;
  278. mV[1] *= oomag;
  279. mV[2] *= oomag;
  280. }
  281. return (mag);
  282. }
  283. inline void LLColor3::exp()
  284. {
  285. #if 0
  286. mV[0] = ::exp(mV[0]);
  287. mV[1] = ::exp(mV[1]);
  288. mV[2] = ::exp(mV[2]);
  289. #else
  290. mV[0] = (F32)LL_FAST_EXP(mV[0]);
  291. mV[1] = (F32)LL_FAST_EXP(mV[1]);
  292. mV[2] = (F32)LL_FAST_EXP(mV[2]);
  293. #endif
  294. }
  295. inline LLColor3 operator+(const LLColor3 &a, const LLColor3 &b)
  296. {
  297. return LLColor3(
  298. a.mV[0] + b.mV[0],
  299. a.mV[1] + b.mV[1],
  300. a.mV[2] + b.mV[2]);
  301. }
  302. inline LLColor3 operator-(const LLColor3 &a, const LLColor3 &b)
  303. {
  304. return LLColor3(
  305. a.mV[0] - b.mV[0],
  306. a.mV[1] - b.mV[1],
  307. a.mV[2] - b.mV[2]);
  308. }
  309. inline LLColor3  operator*(const LLColor3 &a, const LLColor3 &b)
  310. {
  311. return LLColor3(
  312. a.mV[0] * b.mV[0],
  313. a.mV[1] * b.mV[1],
  314. a.mV[2] * b.mV[2]);
  315. }
  316. inline LLColor3 operator*(const LLColor3 &a, F32 k)
  317. {
  318. return LLColor3( a.mV[0] * k, a.mV[1] * k, a.mV[2] * k );
  319. }
  320. inline LLColor3 operator*(F32 k, const LLColor3 &a)
  321. {
  322. return LLColor3( a.mV[0] * k, a.mV[1] * k, a.mV[2] * k );
  323. }
  324. inline bool operator==(const LLColor3 &a, const LLColor3 &b)
  325. {
  326. return (  (a.mV[0] == b.mV[0])
  327. &&(a.mV[1] == b.mV[1])
  328. &&(a.mV[2] == b.mV[2]));
  329. }
  330. inline bool operator!=(const LLColor3 &a, const LLColor3 &b)
  331. {
  332. return (  (a.mV[0] != b.mV[0])
  333. ||(a.mV[1] != b.mV[1])
  334. ||(a.mV[2] != b.mV[2]));
  335. }
  336. inline const LLColor3 &operator*=(LLColor3 &a, const LLColor3 &b)
  337. {
  338. a.mV[0] *= b.mV[0];
  339. a.mV[1] *= b.mV[1];
  340. a.mV[2] *= b.mV[2];
  341. return a;
  342. }
  343. inline const LLColor3& operator+=(LLColor3 &a, const LLColor3 &b)
  344. {
  345. a.mV[0] += b.mV[0];
  346. a.mV[1] += b.mV[1];
  347. a.mV[2] += b.mV[2];
  348. return a;
  349. }
  350. inline const LLColor3& operator-=(LLColor3 &a, const LLColor3 &b)
  351. {
  352. a.mV[0] -= b.mV[0];
  353. a.mV[1] -= b.mV[1];
  354. a.mV[2] -= b.mV[2];
  355. return a;
  356. }
  357. inline const LLColor3& operator*=(LLColor3 &a, F32 k)
  358. {
  359. a.mV[0] *= k;
  360. a.mV[1] *= k;
  361. a.mV[2] *= k;
  362. return a;
  363. }
  364. inline LLColor3 operator-(const LLColor3 &a)
  365. {
  366. return LLColor3(
  367. 1.f - a.mV[0],
  368. 1.f - a.mV[1],
  369. 1.f - a.mV[2] );
  370. }
  371. // Non-member functions
  372. inline F32 distVec(const LLColor3 &a, const LLColor3 &b)
  373. {
  374. F32 x = a.mV[0] - b.mV[0];
  375. F32 y = a.mV[1] - b.mV[1];
  376. F32 z = a.mV[2] - b.mV[2];
  377. return fsqrtf( x*x + y*y + z*z );
  378. }
  379. inline F32 distVec_squared(const LLColor3 &a, const LLColor3 &b)
  380. {
  381. F32 x = a.mV[0] - b.mV[0];
  382. F32 y = a.mV[1] - b.mV[1];
  383. F32 z = a.mV[2] - b.mV[2];
  384. return x*x + y*y + z*z;
  385. }
  386. inline LLColor3 lerp(const LLColor3 &a, const LLColor3 &b, F32 u)
  387. {
  388. return LLColor3(
  389. a.mV[VX] + (b.mV[VX] - a.mV[VX]) * u,
  390. a.mV[VY] + (b.mV[VY] - a.mV[VY]) * u,
  391. a.mV[VZ] + (b.mV[VZ] - a.mV[VZ]) * u);
  392. }
  393. #endif