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

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file v4color.h
  3.  * @brief LLColor4 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_V4COLOR_H
  33. #define LL_V4COLOR_H
  34. #include "llerror.h"
  35. //#include "vmath.h"
  36. #include "llmath.h"
  37. #include "llsd.h"
  38. class LLColor3;
  39. class LLColor4U;
  40. class LLVector4;
  41. //  LLColor4 = |x y z w|
  42. static const U32 LENGTHOFCOLOR4 = 4;
  43. static const U32 MAX_LENGTH_OF_COLOR_NAME = 15; //Give plenty of room for additional colors...
  44. class LLColor4
  45. {
  46. public:
  47. F32 mV[LENGTHOFCOLOR4];
  48. LLColor4(); // Initializes LLColor4 to (0, 0, 0, 1)
  49. LLColor4(F32 r, F32 g, F32 b); // Initializes LLColor4 to (r, g, b, 1)
  50. LLColor4(F32 r, F32 g, F32 b, F32 a); // Initializes LLColor4 to (r. g, b, a)
  51. LLColor4(U32 clr); // Initializes LLColor4 to (r=clr>>24, etc))
  52. LLColor4(const F32 *vec); // Initializes LLColor4 to (vec[0]. vec[1], vec[2], 1)
  53. LLColor4(const LLColor3 &vec, F32 a = 1.f); // Initializes LLColor4 to (vec, a)
  54. explicit LLColor4(const LLSD& sd);
  55. explicit LLColor4(const LLColor4U& color4u);  // "explicit" to avoid automatic conversion
  56. explicit LLColor4(const LLVector4& vector4);  // "explicit" to avoid automatic conversion
  57. LLSD getValue() const
  58. {
  59. LLSD ret;
  60. ret[0] = mV[0];
  61. ret[1] = mV[1];
  62. ret[2] = mV[2];
  63. ret[3] = mV[3];
  64. return ret;
  65. }
  66. void setValue(const LLSD& sd);
  67. void setHSL(F32 hue, F32 saturation, F32 luminance);
  68. void calcHSL(F32* hue, F32* saturation, F32* luminance) const;
  69. const LLColor4& setToBlack(); // zero LLColor4 to (0, 0, 0, 1)
  70. const LLColor4& setToWhite(); // zero LLColor4 to (0, 0, 0, 1)
  71. const LLColor4& setVec(F32 r, F32 g, F32 b, F32 a); // deprecated -- use set()
  72. const LLColor4& setVec(F32 r, F32 g, F32 b); // deprecated -- use set()
  73. const LLColor4& setVec(const LLColor4 &vec); // deprecated -- use set()
  74. const LLColor4& setVec(const LLColor3 &vec); // deprecated -- use set()
  75. const LLColor4& setVec(const LLColor3 &vec, F32 a); // deprecated -- use set()
  76. const LLColor4& setVec(const F32 *vec); // deprecated -- use set()
  77. const LLColor4& setVec(const LLColor4U& color4u);  // deprecated -- use set()
  78. const LLColor4& set(F32 r, F32 g, F32 b, F32 a); // Sets LLColor4 to (r, g, b, a)
  79. const LLColor4& set(F32 r, F32 g, F32 b); // Sets LLColor4 to (r, g, b) (no change in a)
  80. const LLColor4& set(const LLColor4 &vec); // Sets LLColor4 to vec
  81. const LLColor4& set(const LLColor3 &vec); // Sets LLColor4 to LLColor3 vec (no change in alpha)
  82. const LLColor4& set(const LLColor3 &vec, F32 a); // Sets LLColor4 to LLColor3 vec, with alpha specified
  83. const LLColor4& set(const F32 *vec); // Sets LLColor4 to vec
  84. const LLColor4& set(const LLColor4U& color4u); // Sets LLColor4 to color4u, rescaled.
  85. const LLColor4&    setAlpha(F32 a);
  86. F32 magVec() const; // deprecated -- use length()
  87. F32 magVecSquared() const; // deprecated -- use lengthSquared()
  88. F32 normVec(); // deprecated -- use normalize()
  89. F32 length() const; // Returns magnitude of LLColor4
  90. F32 lengthSquared() const; // Returns magnitude squared of LLColor4
  91. F32 normalize(); // deprecated -- use normalize()
  92. BOOL isOpaque() { return mV[VALPHA] == 1.f; }
  93. F32 operator[](int idx) const { return mV[idx]; }
  94. F32 &operator[](int idx) { return mV[idx]; }
  95.     const LLColor4& operator=(const LLColor3 &a); // Assigns vec3 to vec4 and returns vec4
  96. friend std::ostream&  operator<<(std::ostream& s, const LLColor4 &a); // Print a
  97. friend LLColor4 operator+(const LLColor4 &a, const LLColor4 &b); // Return vector a + b
  98. friend LLColor4 operator-(const LLColor4 &a, const LLColor4 &b); // Return vector a minus b
  99. friend LLColor4 operator*(const LLColor4 &a, const LLColor4 &b); // Return component wise a * b
  100. friend LLColor4 operator*(const LLColor4 &a, F32 k); // Return rgb times scaler k (no alpha change)
  101. friend LLColor4 operator*(F32 k, const LLColor4 &a); // Return rgb times scaler k (no alpha change)
  102. friend LLColor4 operator%(const LLColor4 &a, F32 k); // Return alpha times scaler k (no rgb change)
  103. friend LLColor4 operator%(F32 k, const LLColor4 &a); // Return alpha times scaler k (no rgb change)
  104. friend bool operator==(const LLColor4 &a, const LLColor4 &b); // Return a == b
  105. friend bool operator!=(const LLColor4 &a, const LLColor4 &b); // Return a != b
  106. friend bool operator==(const LLColor4 &a, const LLColor3 &b); // Return a == b
  107. friend bool operator!=(const LLColor4 &a, const LLColor3 &b); // Return a != b
  108. friend const LLColor4& operator+=(LLColor4 &a, const LLColor4 &b); // Return vector a + b
  109. friend const LLColor4& operator-=(LLColor4 &a, const LLColor4 &b); // Return vector a minus b
  110. friend const LLColor4& operator*=(LLColor4 &a, F32 k); // Return rgb times scaler k (no alpha change)
  111. friend const LLColor4& operator%=(LLColor4 &a, F32 k); // Return alpha times scaler k (no rgb change)
  112. friend const LLColor4& operator*=(LLColor4 &a, const LLColor4 &b); // Doesn't multiply alpha! (for lighting)
  113. // conversion
  114. operator const LLColor4U() const;
  115. // Basic color values.
  116. static LLColor4 red;
  117. static LLColor4 green;
  118. static LLColor4 blue;
  119. static LLColor4 black;
  120. static LLColor4 white;
  121. static LLColor4 yellow;
  122. static LLColor4 magenta;
  123. static LLColor4 cyan;
  124. static LLColor4 smoke;
  125. static LLColor4 grey;
  126. static LLColor4 orange;
  127. static LLColor4 purple;
  128. static LLColor4 pink;
  129. static LLColor4 transparent;
  130. // Extra color values.
  131. static LLColor4 grey1;
  132. static LLColor4 grey2;
  133. static LLColor4 grey3;
  134. static LLColor4 grey4;
  135. static LLColor4 red1;
  136. static LLColor4 red2;
  137. static LLColor4 red3;
  138. static LLColor4 red4;
  139. static LLColor4 red5;
  140. static LLColor4 green1;
  141. static LLColor4 green2;
  142. static LLColor4 green3;
  143. static LLColor4 green4;
  144. static LLColor4 green5;
  145. static LLColor4 green6;
  146. static LLColor4 blue1;
  147. static LLColor4 blue2;
  148. static LLColor4 blue3;
  149. static LLColor4 blue4;
  150. static LLColor4 blue5;
  151. static LLColor4 blue6;
  152. static LLColor4 yellow1;
  153. static LLColor4 yellow2;
  154. static LLColor4 yellow3;
  155. static LLColor4 yellow4;
  156. static LLColor4 yellow5;
  157. static LLColor4 yellow6;
  158. static LLColor4 yellow7;
  159. static LLColor4 yellow8;
  160. static LLColor4 yellow9;
  161. static LLColor4 orange1;
  162. static LLColor4 orange2;
  163. static LLColor4 orange3;
  164. static LLColor4 orange4;
  165. static LLColor4 orange5;
  166. static LLColor4 orange6;
  167. static LLColor4 magenta1;
  168. static LLColor4 magenta2;
  169. static LLColor4 magenta3;
  170. static LLColor4 magenta4;
  171. static LLColor4 purple1;
  172. static LLColor4 purple2;
  173. static LLColor4 purple3;
  174. static LLColor4 purple4;
  175. static LLColor4 purple5;
  176. static LLColor4 purple6;
  177. static LLColor4 pink1;
  178. static LLColor4 pink2;
  179. static LLColor4 cyan1;
  180. static LLColor4 cyan2;
  181. static LLColor4 cyan3;
  182. static LLColor4 cyan4;
  183. static LLColor4 cyan5;
  184. static LLColor4 cyan6;
  185. static BOOL parseColor(const std::string& buf, LLColor4* color);
  186. static BOOL parseColor4(const std::string& buf, LLColor4* color);
  187. inline void clamp();
  188. };
  189. // Non-member functions 
  190. F32 distVec(const LLColor4 &a, const LLColor4 &b); // Returns distance between a and b
  191. F32 distVec_squared(const LLColor4 &a, const LLColor4 &b); // Returns distance squared between a and b
  192. LLColor3 vec4to3(const LLColor4 &vec);
  193. LLColor4 vec3to4(const LLColor3 &vec);
  194. LLColor4 lerp(const LLColor4 &a, const LLColor4 &b, F32 u);
  195. inline LLColor4::LLColor4(void)
  196. {
  197. mV[VX] = 0.f;
  198. mV[VY] = 0.f;
  199. mV[VZ] = 0.f;
  200. mV[VW] = 1.f;
  201. }
  202. inline LLColor4::LLColor4(const LLSD& sd)
  203. {
  204. this->setValue(sd);
  205. }
  206. inline LLColor4::LLColor4(F32 r, F32 g, F32 b)
  207. {
  208. mV[VX] = r;
  209. mV[VY] = g;
  210. mV[VZ] = b;
  211. mV[VW] = 1.f;
  212. }
  213. inline LLColor4::LLColor4(F32 r, F32 g, F32 b, F32 a)
  214. {
  215. mV[VX] = r;
  216. mV[VY] = g;
  217. mV[VZ] = b;
  218. mV[VW] = a;
  219. }
  220. inline LLColor4::LLColor4(U32 clr)
  221. {
  222. mV[VX] = (clr&0xff) * (1.0f/255.0f);
  223. mV[VY] = ((clr>>8)&0xff) * (1.0f/255.0f);
  224. mV[VZ] = ((clr>>16)&0xff) * (1.0f/255.0f);
  225. mV[VW] = (clr>>24) * (1.0f/255.0f);
  226. }
  227. inline LLColor4::LLColor4(const F32 *vec)
  228. {
  229. mV[VX] = vec[VX];
  230. mV[VY] = vec[VY];
  231. mV[VZ] = vec[VZ];
  232. mV[VW] = vec[VW];
  233. }
  234. inline const LLColor4& LLColor4::setToBlack(void)
  235. {
  236. mV[VX] = 0.f;
  237. mV[VY] = 0.f;
  238. mV[VZ] = 0.f;
  239. mV[VW] = 1.f;
  240. return (*this);
  241. }
  242. inline const LLColor4& LLColor4::setToWhite(void)
  243. {
  244. mV[VX] = 1.f;
  245. mV[VY] = 1.f;
  246. mV[VZ] = 1.f;
  247. mV[VW] = 1.f;
  248. return (*this);
  249. }
  250. inline const LLColor4& LLColor4::set(F32 x, F32 y, F32 z)
  251. {
  252. mV[VX] = x;
  253. mV[VY] = y;
  254. mV[VZ] = z;
  255. //  no change to alpha!
  256. // mV[VW] = 1.f;  
  257. return (*this);
  258. }
  259. inline const LLColor4& LLColor4::set(F32 x, F32 y, F32 z, F32 a)
  260. {
  261. mV[VX] = x;
  262. mV[VY] = y;
  263. mV[VZ] = z;
  264. mV[VW] = a;  
  265. return (*this);
  266. }
  267. inline const LLColor4& LLColor4::set(const LLColor4 &vec)
  268. {
  269. mV[VX] = vec.mV[VX];
  270. mV[VY] = vec.mV[VY];
  271. mV[VZ] = vec.mV[VZ];
  272. mV[VW] = vec.mV[VW];
  273. return (*this);
  274. }
  275. inline const LLColor4& LLColor4::set(const F32 *vec)
  276. {
  277. mV[VX] = vec[VX];
  278. mV[VY] = vec[VY];
  279. mV[VZ] = vec[VZ];
  280. mV[VW] = vec[VW];
  281. return (*this);
  282. }
  283. // deprecated
  284. inline const LLColor4& LLColor4::setVec(F32 x, F32 y, F32 z)
  285. {
  286. mV[VX] = x;
  287. mV[VY] = y;
  288. mV[VZ] = z;
  289. //  no change to alpha!
  290. // mV[VW] = 1.f;  
  291. return (*this);
  292. }
  293. // deprecated
  294. inline const LLColor4& LLColor4::setVec(F32 x, F32 y, F32 z, F32 a)
  295. {
  296. mV[VX] = x;
  297. mV[VY] = y;
  298. mV[VZ] = z;
  299. mV[VW] = a;  
  300. return (*this);
  301. }
  302. // deprecated
  303. inline const LLColor4& LLColor4::setVec(const LLColor4 &vec)
  304. {
  305. mV[VX] = vec.mV[VX];
  306. mV[VY] = vec.mV[VY];
  307. mV[VZ] = vec.mV[VZ];
  308. mV[VW] = vec.mV[VW];
  309. return (*this);
  310. }
  311. // deprecated
  312. inline const LLColor4& LLColor4::setVec(const F32 *vec)
  313. {
  314. mV[VX] = vec[VX];
  315. mV[VY] = vec[VY];
  316. mV[VZ] = vec[VZ];
  317. mV[VW] = vec[VW];
  318. return (*this);
  319. }
  320. inline const LLColor4& LLColor4::setAlpha(F32 a)
  321. {
  322. mV[VW] = a;
  323. return (*this);
  324. }
  325. // LLColor4 Magnitude and Normalization Functions
  326. inline F32 LLColor4::length(void) const
  327. {
  328. return fsqrtf(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
  329. }
  330. inline F32 LLColor4::lengthSquared(void) const
  331. {
  332. return mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ];
  333. }
  334. inline F32 LLColor4::normalize(void)
  335. {
  336. F32 mag = fsqrtf(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
  337. F32 oomag;
  338. if (mag)
  339. {
  340. oomag = 1.f/mag;
  341. mV[VX] *= oomag;
  342. mV[VY] *= oomag;
  343. mV[VZ] *= oomag;
  344. }
  345. return (mag);
  346. }
  347. // deprecated
  348. inline F32 LLColor4::magVec(void) const
  349. {
  350. return fsqrtf(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
  351. }
  352. // deprecated
  353. inline F32 LLColor4::magVecSquared(void) const
  354. {
  355. return mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ];
  356. }
  357. // deprecated
  358. inline F32 LLColor4::normVec(void)
  359. {
  360. F32 mag = fsqrtf(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
  361. F32 oomag;
  362. if (mag)
  363. {
  364. oomag = 1.f/mag;
  365. mV[VX] *= oomag;
  366. mV[VY] *= oomag;
  367. mV[VZ] *= oomag;
  368. }
  369. return (mag);
  370. }
  371. // LLColor4 Operators
  372. inline LLColor4 operator+(const LLColor4 &a, const LLColor4 &b)
  373. {
  374. return LLColor4(
  375. a.mV[VX] + b.mV[VX],
  376. a.mV[VY] + b.mV[VY],
  377. a.mV[VZ] + b.mV[VZ],
  378. a.mV[VW] + b.mV[VW]);
  379. }
  380. inline LLColor4 operator-(const LLColor4 &a, const LLColor4 &b)
  381. {
  382. return LLColor4(
  383. a.mV[VX] - b.mV[VX],
  384. a.mV[VY] - b.mV[VY],
  385. a.mV[VZ] - b.mV[VZ],
  386. a.mV[VW] - b.mV[VW]);
  387. }
  388. inline LLColor4  operator*(const LLColor4 &a, const LLColor4 &b)
  389. {
  390. return LLColor4(
  391. a.mV[VX] * b.mV[VX],
  392. a.mV[VY] * b.mV[VY],
  393. a.mV[VZ] * b.mV[VZ],
  394. a.mV[VW] * b.mV[VW]);
  395. }
  396. inline LLColor4 operator*(const LLColor4 &a, F32 k)
  397. {
  398. // only affects rgb (not a!)
  399. return LLColor4(
  400. a.mV[VX] * k,
  401. a.mV[VY] * k,
  402. a.mV[VZ] * k,
  403. a.mV[VW]);
  404. }
  405. inline LLColor4 operator*(F32 k, const LLColor4 &a)
  406. {
  407. // only affects rgb (not a!)
  408. return LLColor4(
  409. a.mV[VX] * k,
  410. a.mV[VY] * k,
  411. a.mV[VZ] * k,
  412. a.mV[VW]);
  413. }
  414. inline LLColor4 operator%(F32 k, const LLColor4 &a)
  415. {
  416. // only affects alpha (not rgb!)
  417. return LLColor4(
  418. a.mV[VX],
  419. a.mV[VY],
  420. a.mV[VZ],
  421. a.mV[VW] * k);
  422. }
  423. inline LLColor4 operator%(const LLColor4 &a, F32 k)
  424. {
  425. // only affects alpha (not rgb!)
  426. return LLColor4(
  427. a.mV[VX],
  428. a.mV[VY],
  429. a.mV[VZ],
  430. a.mV[VW] * k);
  431. }
  432. inline bool operator==(const LLColor4 &a, const LLColor4 &b)
  433. {
  434. return (  (a.mV[VX] == b.mV[VX])
  435. &&(a.mV[VY] == b.mV[VY])
  436. &&(a.mV[VZ] == b.mV[VZ])
  437. &&(a.mV[VW] == b.mV[VW]));
  438. }
  439. inline bool operator!=(const LLColor4 &a, const LLColor4 &b)
  440. {
  441. return (  (a.mV[VX] != b.mV[VX])
  442. ||(a.mV[VY] != b.mV[VY])
  443. ||(a.mV[VZ] != b.mV[VZ])
  444. ||(a.mV[VW] != b.mV[VW]));
  445. }
  446. inline const LLColor4& operator+=(LLColor4 &a, const LLColor4 &b)
  447. {
  448. a.mV[VX] += b.mV[VX];
  449. a.mV[VY] += b.mV[VY];
  450. a.mV[VZ] += b.mV[VZ];
  451. a.mV[VW] += b.mV[VW];
  452. return a;
  453. }
  454. inline const LLColor4& operator-=(LLColor4 &a, const LLColor4 &b)
  455. {
  456. a.mV[VX] -= b.mV[VX];
  457. a.mV[VY] -= b.mV[VY];
  458. a.mV[VZ] -= b.mV[VZ];
  459. a.mV[VW] -= b.mV[VW];
  460. return a;
  461. }
  462. inline const LLColor4& operator*=(LLColor4 &a, F32 k)
  463. {
  464. // only affects rgb (not a!)
  465. a.mV[VX] *= k;
  466. a.mV[VY] *= k;
  467. a.mV[VZ] *= k;
  468. return a;
  469. }
  470. inline const LLColor4& operator *=(LLColor4 &a, const LLColor4 &b)
  471. {
  472. a.mV[VX] *= b.mV[VX];
  473. a.mV[VY] *= b.mV[VY];
  474. a.mV[VZ] *= b.mV[VZ];
  475. // a.mV[VW] *= b.mV[VW];
  476. return a;
  477. }
  478. inline const LLColor4& operator%=(LLColor4 &a, F32 k)
  479. {
  480. // only affects alpha (not rgb!)
  481. a.mV[VW] *= k;
  482. return a;
  483. }
  484. // Non-member functions
  485. inline F32 distVec(const LLColor4 &a, const LLColor4 &b)
  486. {
  487. LLColor4 vec = a - b;
  488. return (vec.length());
  489. }
  490. inline F32 distVec_squared(const LLColor4 &a, const LLColor4 &b)
  491. {
  492. LLColor4 vec = a - b;
  493. return (vec.lengthSquared());
  494. }
  495. inline LLColor4 lerp(const LLColor4 &a, const LLColor4 &b, F32 u)
  496. {
  497. return LLColor4(
  498. a.mV[VX] + (b.mV[VX] - a.mV[VX]) * u,
  499. a.mV[VY] + (b.mV[VY] - a.mV[VY]) * u,
  500. a.mV[VZ] + (b.mV[VZ] - a.mV[VZ]) * u,
  501. a.mV[VW] + (b.mV[VW] - a.mV[VW]) * u);
  502. }
  503. void LLColor4::clamp()
  504. {
  505. // Clamp the color...
  506. if (mV[0] < 0.f)
  507. {
  508. mV[0] = 0.f;
  509. }
  510. else if (mV[0] > 1.f)
  511. {
  512. mV[0] = 1.f;
  513. }
  514. if (mV[1] < 0.f)
  515. {
  516. mV[1] = 0.f;
  517. }
  518. else if (mV[1] > 1.f)
  519. {
  520. mV[1] = 1.f;
  521. }
  522. if (mV[2] < 0.f)
  523. {
  524. mV[2] = 0.f;
  525. }
  526. else if (mV[2] > 1.f)
  527. {
  528. mV[2] = 1.f;
  529. }
  530. if (mV[3] < 0.f)
  531. {
  532. mV[3] = 0.f;
  533. }
  534. else if (mV[3] > 1.f)
  535. {
  536. mV[3] = 1.f;
  537. }
  538. }
  539. #endif