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

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file v4coloru.h
  3.  * @brief The LLColor4U class.
  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_V4COLORU_H
  33. #define LL_V4COLORU_H
  34. #include "llerror.h"
  35. //#include "vmath.h"
  36. #include "llmath.h"
  37. //#include "v4color.h"
  38. #include "v3color.h"
  39. #include "v4color.h"
  40. //class LLColor3U;
  41. class LLColor4;
  42. //  LLColor4U = | red green blue alpha |
  43. static const U32 LENGTHOFCOLOR4U = 4;
  44. class LLColor4U
  45. {
  46. public:
  47. union
  48. {
  49. U8         mV[LENGTHOFCOLOR4U];
  50. U32        mAll;
  51. LLColor4*  mSources;
  52. LLColor4U* mSourcesU;
  53. };
  54. LLColor4U(); // Initializes LLColor4U to (0, 0, 0, 1)
  55. LLColor4U(U8 r, U8 g, U8 b); // Initializes LLColor4U to (r, g, b, 1)
  56. LLColor4U(U8 r, U8 g, U8 b, U8 a); // Initializes LLColor4U to (r. g, b, a)
  57. LLColor4U(const U8 *vec); // Initializes LLColor4U to (vec[0]. vec[1], vec[2], 1)
  58. explicit LLColor4U(const LLSD& sd)
  59. {
  60. setValue(sd);
  61. }
  62. void setValue(const LLSD& sd)
  63. {
  64. mV[0] = sd[0].asInteger();
  65. mV[1] = sd[1].asInteger();
  66. mV[2] = sd[2].asInteger();
  67. mV[3] = sd[3].asInteger();
  68. }
  69. LLSD getValue() const
  70. {
  71. LLSD ret;
  72. ret[0] = mV[0];
  73. ret[1] = mV[1];
  74. ret[2] = mV[2];
  75. ret[3] = mV[3];
  76. return ret;
  77. }
  78. const LLColor4U& setToBlack(); // zero LLColor4U to (0, 0, 0, 1)
  79. const LLColor4U& setToWhite(); // zero LLColor4U to (0, 0, 0, 1)
  80. const LLColor4U& set(U8 r, U8 g, U8 b, U8 a);// Sets LLColor4U to (r, g, b, a)
  81. const LLColor4U& set(U8 r, U8 g, U8 b); // Sets LLColor4U to (r, g, b) (no change in a)
  82. const LLColor4U& set(const LLColor4U &vec); // Sets LLColor4U to vec
  83. const LLColor4U& set(const U8 *vec); // Sets LLColor4U to vec
  84. const LLColor4U& setVec(U8 r, U8 g, U8 b, U8 a); // deprecated -- use set()
  85. const LLColor4U& setVec(U8 r, U8 g, U8 b); // deprecated -- use set()
  86. const LLColor4U& setVec(const LLColor4U &vec); // deprecated -- use set()
  87. const LLColor4U& setVec(const U8 *vec); // deprecated -- use set()
  88. const LLColor4U&    setAlpha(U8 a);
  89. F32 magVec() const; // deprecated -- use length()
  90. F32 magVecSquared() const; // deprecated -- use lengthSquared()
  91. F32 length() const; // Returns magnitude squared of LLColor4U
  92. F32 lengthSquared() const; // Returns magnitude squared of LLColor4U
  93. friend std::ostream&  operator<<(std::ostream& s, const LLColor4U &a); // Print a
  94. friend LLColor4U operator+(const LLColor4U &a, const LLColor4U &b); // Return vector a + b
  95. friend LLColor4U operator-(const LLColor4U &a, const LLColor4U &b); // Return vector a minus b
  96. friend LLColor4U operator*(const LLColor4U &a, const LLColor4U &b); // Return a * b
  97. friend bool operator==(const LLColor4U &a, const LLColor4U &b); // Return a == b
  98. friend bool operator!=(const LLColor4U &a, const LLColor4U &b); // Return a != b
  99. friend const LLColor4U& operator+=(LLColor4U &a, const LLColor4U &b); // Return vector a + b
  100. friend const LLColor4U& operator-=(LLColor4U &a, const LLColor4U &b); // Return vector a minus b
  101. friend const LLColor4U& operator*=(LLColor4U &a, U8 k); // Return rgb times scaler k (no alpha change)
  102. friend const LLColor4U& operator%=(LLColor4U &a, U8 k); // Return alpha times scaler k (no rgb change)
  103. LLColor4U addClampMax(const LLColor4U &color); // Add and clamp the max
  104. LLColor4U multAll(const F32 k); // Multiply ALL channels by scalar k
  105. const LLColor4U& combine();
  106. inline void setVecScaleClamp(const LLColor3 &color);
  107. inline void setVecScaleClamp(const LLColor4 &color);
  108. static BOOL parseColor4U(const std::string& buf, LLColor4U* value);
  109. // conversion
  110. operator const LLColor4() const
  111. {
  112. return LLColor4(*this);
  113. }
  114. static LLColor4U white;
  115. static LLColor4U black;
  116. static LLColor4U red;
  117. static LLColor4U green;
  118. static LLColor4U blue;
  119. };
  120. // Non-member functions 
  121. F32 distVec(const LLColor4U &a, const LLColor4U &b); // Returns distance between a and b
  122. F32 distVec_squared(const LLColor4U &a, const LLColor4U &b); // Returns distance squared between a and b
  123. inline LLColor4U::LLColor4U()
  124. {
  125. mV[VX] = 0;
  126. mV[VY] = 0;
  127. mV[VZ] = 0;
  128. mV[VW] = 255;
  129. }
  130. inline LLColor4U::LLColor4U(U8 r, U8 g, U8 b)
  131. {
  132. mV[VX] = r;
  133. mV[VY] = g;
  134. mV[VZ] = b;
  135. mV[VW] = 255;
  136. }
  137. inline LLColor4U::LLColor4U(U8 r, U8 g, U8 b, U8 a)
  138. {
  139. mV[VX] = r;
  140. mV[VY] = g;
  141. mV[VZ] = b;
  142. mV[VW] = a;
  143. }
  144. inline LLColor4U::LLColor4U(const U8 *vec)
  145. {
  146. mV[VX] = vec[VX];
  147. mV[VY] = vec[VY];
  148. mV[VZ] = vec[VZ];
  149. mV[VW] = vec[VW];
  150. }
  151. /*
  152. inline LLColor4U::operator LLColor4()
  153. {
  154. return(LLColor4((F32)mV[VRED]/255.f,(F32)mV[VGREEN]/255.f,(F32)mV[VBLUE]/255.f,(F32)mV[VALPHA]/255.f));
  155. }
  156. */
  157. inline const LLColor4U& LLColor4U::setToBlack(void)
  158. {
  159. mV[VX] = 0;
  160. mV[VY] = 0;
  161. mV[VZ] = 0;
  162. mV[VW] = 255;
  163. return (*this);
  164. }
  165. inline const LLColor4U& LLColor4U::setToWhite(void)
  166. {
  167. mV[VX] = 255;
  168. mV[VY] = 255;
  169. mV[VZ] = 255;
  170. mV[VW] = 255;
  171. return (*this);
  172. }
  173. inline const LLColor4U& LLColor4U::set(const U8 x, const U8 y, const U8 z)
  174. {
  175. mV[VX] = x;
  176. mV[VY] = y;
  177. mV[VZ] = z;
  178. //  no change to alpha!
  179. // mV[VW] = 255;  
  180. return (*this);
  181. }
  182. inline const LLColor4U& LLColor4U::set(const U8 r, const U8 g, const U8 b, U8 a)
  183. {
  184. mV[0] = r;
  185. mV[1] = g;
  186. mV[2] = b;
  187. mV[3] = a;  
  188. return (*this);
  189. }
  190. inline const LLColor4U& LLColor4U::set(const LLColor4U &vec)
  191. {
  192. mV[VX] = vec.mV[VX];
  193. mV[VY] = vec.mV[VY];
  194. mV[VZ] = vec.mV[VZ];
  195. mV[VW] = vec.mV[VW];
  196. return (*this);
  197. }
  198. inline const LLColor4U& LLColor4U::set(const U8 *vec)
  199. {
  200. mV[VX] = vec[VX];
  201. mV[VY] = vec[VY];
  202. mV[VZ] = vec[VZ];
  203. mV[VW] = vec[VW];
  204. return (*this);
  205. }
  206. // deprecated
  207. inline const LLColor4U& LLColor4U::setVec(const U8 x, const U8 y, const U8 z)
  208. {
  209. mV[VX] = x;
  210. mV[VY] = y;
  211. mV[VZ] = z;
  212. //  no change to alpha!
  213. // mV[VW] = 255;  
  214. return (*this);
  215. }
  216. // deprecated
  217. inline const LLColor4U& LLColor4U::setVec(const U8 r, const U8 g, const U8 b, U8 a)
  218. {
  219. mV[0] = r;
  220. mV[1] = g;
  221. mV[2] = b;
  222. mV[3] = a;  
  223. return (*this);
  224. }
  225. // deprecated
  226. inline const LLColor4U& LLColor4U::setVec(const LLColor4U &vec)
  227. {
  228. mV[VX] = vec.mV[VX];
  229. mV[VY] = vec.mV[VY];
  230. mV[VZ] = vec.mV[VZ];
  231. mV[VW] = vec.mV[VW];
  232. return (*this);
  233. }
  234. // deprecated
  235. inline const LLColor4U& LLColor4U::setVec(const U8 *vec)
  236. {
  237. mV[VX] = vec[VX];
  238. mV[VY] = vec[VY];
  239. mV[VZ] = vec[VZ];
  240. mV[VW] = vec[VW];
  241. return (*this);
  242. }
  243. inline const LLColor4U& LLColor4U::setAlpha(U8 a)
  244. {
  245. mV[VW] = a;
  246. return (*this);
  247. }
  248. // LLColor4U Magnitude and Normalization Functions
  249. inline F32 LLColor4U::length(void) const
  250. {
  251. return fsqrtf( ((F32)mV[VX]) * mV[VX] + ((F32)mV[VY]) * mV[VY] + ((F32)mV[VZ]) * mV[VZ] );
  252. }
  253. inline F32 LLColor4U::lengthSquared(void) const
  254. {
  255. return ((F32)mV[VX]) * mV[VX] + ((F32)mV[VY]) * mV[VY] + ((F32)mV[VZ]) * mV[VZ];
  256. }
  257. // deprecated
  258. inline F32 LLColor4U::magVec(void) const
  259. {
  260. return fsqrtf( ((F32)mV[VX]) * mV[VX] + ((F32)mV[VY]) * mV[VY] + ((F32)mV[VZ]) * mV[VZ] );
  261. }
  262. // deprecated
  263. inline F32 LLColor4U::magVecSquared(void) const
  264. {
  265. return ((F32)mV[VX]) * mV[VX] + ((F32)mV[VY]) * mV[VY] + ((F32)mV[VZ]) * mV[VZ];
  266. }
  267. inline LLColor4U operator+(const LLColor4U &a, const LLColor4U &b)
  268. {
  269. return LLColor4U(
  270. a.mV[VX] + b.mV[VX],
  271. a.mV[VY] + b.mV[VY],
  272. a.mV[VZ] + b.mV[VZ],
  273. a.mV[VW] + b.mV[VW]);
  274. }
  275. inline LLColor4U operator-(const LLColor4U &a, const LLColor4U &b)
  276. {
  277. return LLColor4U(
  278. a.mV[VX] - b.mV[VX],
  279. a.mV[VY] - b.mV[VY],
  280. a.mV[VZ] - b.mV[VZ],
  281. a.mV[VW] - b.mV[VW]);
  282. }
  283. inline LLColor4U  operator*(const LLColor4U &a, const LLColor4U &b)
  284. {
  285. return LLColor4U(
  286. a.mV[VX] * b.mV[VX],
  287. a.mV[VY] * b.mV[VY],
  288. a.mV[VZ] * b.mV[VZ],
  289. a.mV[VW] * b.mV[VW]);
  290. }
  291. inline LLColor4U LLColor4U::addClampMax(const LLColor4U &color)
  292. {
  293. return LLColor4U(llmin((S32)mV[VX] + color.mV[VX], 255),
  294. llmin((S32)mV[VY] + color.mV[VY], 255),
  295. llmin((S32)mV[VZ] + color.mV[VZ], 255),
  296. llmin((S32)mV[VW] + color.mV[VW], 255));
  297. }
  298. inline LLColor4U LLColor4U::multAll(const F32 k)
  299. {
  300. // Round to nearest
  301. return LLColor4U(
  302. (U8)llround(mV[VX] * k),
  303. (U8)llround(mV[VY] * k),
  304. (U8)llround(mV[VZ] * k),
  305. (U8)llround(mV[VW] * k));
  306. }
  307. /*
  308. inline LLColor4U operator*(const LLColor4U &a, U8 k)
  309. {
  310. // only affects rgb (not a!)
  311. return LLColor4U(
  312. a.mV[VX] * k,
  313. a.mV[VY] * k,
  314. a.mV[VZ] * k,
  315. a.mV[VW]);
  316. }
  317. inline LLColor4U operator*(U8 k, const LLColor4U &a)
  318. {
  319. // only affects rgb (not a!)
  320. return LLColor4U(
  321. a.mV[VX] * k,
  322. a.mV[VY] * k,
  323. a.mV[VZ] * k,
  324. a.mV[VW]);
  325. }
  326. inline LLColor4U operator%(U8 k, const LLColor4U &a)
  327. {
  328. // only affects alpha (not rgb!)
  329. return LLColor4U(
  330. a.mV[VX],
  331. a.mV[VY],
  332. a.mV[VZ],
  333. a.mV[VW] * k );
  334. }
  335. inline LLColor4U operator%(const LLColor4U &a, U8 k)
  336. {
  337. // only affects alpha (not rgb!)
  338. return LLColor4U(
  339. a.mV[VX],
  340. a.mV[VY],
  341. a.mV[VZ],
  342. a.mV[VW] * k );
  343. }
  344. */
  345. inline bool operator==(const LLColor4U &a, const LLColor4U &b)
  346. {
  347. return (  (a.mV[VX] == b.mV[VX])
  348. &&(a.mV[VY] == b.mV[VY])
  349. &&(a.mV[VZ] == b.mV[VZ])
  350. &&(a.mV[VW] == b.mV[VW]));
  351. }
  352. inline bool operator!=(const LLColor4U &a, const LLColor4U &b)
  353. {
  354. return (  (a.mV[VX] != b.mV[VX])
  355. ||(a.mV[VY] != b.mV[VY])
  356. ||(a.mV[VZ] != b.mV[VZ])
  357. ||(a.mV[VW] != b.mV[VW]));
  358. }
  359. inline const LLColor4U& operator+=(LLColor4U &a, const LLColor4U &b)
  360. {
  361. a.mV[VX] += b.mV[VX];
  362. a.mV[VY] += b.mV[VY];
  363. a.mV[VZ] += b.mV[VZ];
  364. a.mV[VW] += b.mV[VW];
  365. return a;
  366. }
  367. inline const LLColor4U& operator-=(LLColor4U &a, const LLColor4U &b)
  368. {
  369. a.mV[VX] -= b.mV[VX];
  370. a.mV[VY] -= b.mV[VY];
  371. a.mV[VZ] -= b.mV[VZ];
  372. a.mV[VW] -= b.mV[VW];
  373. return a;
  374. }
  375. inline const LLColor4U& operator*=(LLColor4U &a, U8 k)
  376. {
  377. // only affects rgb (not a!)
  378. a.mV[VX] *= k;
  379. a.mV[VY] *= k;
  380. a.mV[VZ] *= k;
  381. return a;
  382. }
  383. inline const LLColor4U& operator%=(LLColor4U &a, U8 k)
  384. {
  385. // only affects alpha (not rgb!)
  386. a.mV[VW] *= k;
  387. return a;
  388. }
  389. inline F32 distVec(const LLColor4U &a, const LLColor4U &b)
  390. {
  391. LLColor4U vec = a - b;
  392. return (vec.length());
  393. }
  394. inline F32 distVec_squared(const LLColor4U &a, const LLColor4U &b)
  395. {
  396. LLColor4U vec = a - b;
  397. return (vec.lengthSquared());
  398. }
  399. void LLColor4U::setVecScaleClamp(const LLColor4& color)
  400. {
  401. F32 color_scale_factor = 255.f;
  402. F32 max_color = llmax(color.mV[0], color.mV[1], color.mV[2]);
  403. if (max_color > 1.f)
  404. {
  405. color_scale_factor /= max_color;
  406. }
  407. const S32 MAX_COLOR = 255;
  408. S32 r = llround(color.mV[0] * color_scale_factor);
  409. if (r > MAX_COLOR)
  410. {
  411. r = MAX_COLOR;
  412. }
  413. else if (r < 0)
  414. {
  415. r = 0;
  416. }
  417. mV[0] = r;
  418. S32 g = llround(color.mV[1] * color_scale_factor);
  419. if (g > MAX_COLOR)
  420. {
  421. g = MAX_COLOR;
  422. }
  423. else if (g < 0)
  424. {
  425. g = 0;
  426. }
  427. mV[1] = g;
  428. S32 b = llround(color.mV[2] * color_scale_factor);
  429. if (b > MAX_COLOR)
  430. {
  431. b = MAX_COLOR;
  432. }
  433. else if (b < 0)
  434. {
  435. b = 0;
  436. }
  437. mV[2] = b;
  438. // Alpha shouldn't be scaled, just clamped...
  439. S32 a = llround(color.mV[3] * MAX_COLOR);
  440. if (a > MAX_COLOR)
  441. {
  442. a = MAX_COLOR;
  443. }
  444. else if (a < 0)
  445. {
  446. a = 0;
  447. }
  448. mV[3] = a;
  449. }
  450. void LLColor4U::setVecScaleClamp(const LLColor3& color)
  451. {
  452. F32 color_scale_factor = 255.f;
  453. F32 max_color = llmax(color.mV[0], color.mV[1], color.mV[2]);
  454. if (max_color > 1.f)
  455. {
  456. color_scale_factor /= max_color;
  457. }
  458. const S32 MAX_COLOR = 255;
  459. S32 r = llround(color.mV[0] * color_scale_factor);
  460. if (r > MAX_COLOR)
  461. {
  462. r = MAX_COLOR;
  463. }
  464. else
  465. if (r < 0)
  466. {
  467. r = 0;
  468. }
  469. mV[0] = r;
  470. S32 g = llround(color.mV[1] * color_scale_factor);
  471. if (g > MAX_COLOR)
  472. {
  473. g = MAX_COLOR;
  474. }
  475. else
  476. if (g < 0)
  477. {
  478. g = 0;
  479. }
  480. mV[1] = g;
  481. S32 b = llround(color.mV[2] * color_scale_factor);
  482. if (b > MAX_COLOR)
  483. {
  484. b = MAX_COLOR;
  485. }
  486. if (b < 0)
  487. {
  488. b = 0;
  489. }
  490. mV[2] = b;
  491. mV[3] = 255;
  492. }
  493. #endif