livie
/
phoenix-firestorm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Restore llmath improvements from archived develop branch: 

* Make eligible functions constexpr
* Use constants for vector indices where applicable
* Reformat to match actual coding conventions
master
Ansariel 2025-04-17 19:50:30 +02:00
parent 441c844ec8
commit 4c6afbbb75
28 changed files with 1799 additions and 2031 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

384
indra/llcommon/indra_constants.h
View File

@ -31,15 +31,15 @@
class LLUUID;
static const F32 REGION_WIDTH_METERS = 256.f;
static const S32 REGION_WIDTH_UNITS = 256;
static const U32 REGION_WIDTH_U32 = 256;
static constexpr F32 REGION_WIDTH_METERS = 256.f;
static constexpr S32 REGION_WIDTH_UNITS = 256;
static constexpr U32 REGION_WIDTH_U32 = 256;
const F32 REGION_HEIGHT_METERS = 4096.f;
constexpr F32 REGION_HEIGHT_METERS = 4096.f;
const F32 DEFAULT_AGENT_DEPTH = 0.45f;
const F32 DEFAULT_AGENT_WIDTH = 0.60f;
const F32 DEFAULT_AGENT_HEIGHT = 1.9f;
constexpr F32 DEFAULT_AGENT_DEPTH = 0.45f;
constexpr F32 DEFAULT_AGENT_WIDTH = 0.60f;
constexpr F32 DEFAULT_AGENT_HEIGHT = 1.9f;
enum ETerrainBrushType
{
@ -67,112 +67,112 @@ enum EMouseClickType{
// keys
// Bit masks for various keyboard modifier keys.
const MASK MASK_NONE = 0x0000;
const MASK MASK_CONTROL = 0x0001; // Mapped to cmd on Macs
const MASK MASK_ALT = 0x0002;
const MASK MASK_SHIFT = 0x0004;
const MASK MASK_NORMALKEYS = 0x0007; // A real mask - only get the bits for normal modifier keys
const MASK MASK_MAC_CONTROL = 0x0008; // Un-mapped Ctrl key on Macs, not used on Windows
const MASK MASK_MODIFIERS = MASK_CONTROL|MASK_ALT|MASK_SHIFT|MASK_MAC_CONTROL;
constexpr MASK MASK_NONE = 0x0000;
constexpr MASK MASK_CONTROL = 0x0001; // Mapped to cmd on Macs
constexpr MASK MASK_ALT = 0x0002;
constexpr MASK MASK_SHIFT = 0x0004;
constexpr MASK MASK_NORMALKEYS = 0x0007; // A real mask - only get the bits for normal modifier keys
constexpr MASK MASK_MAC_CONTROL = 0x0008; // Un-mapped Ctrl key on Macs, not used on Windows
constexpr MASK MASK_MODIFIERS = MASK_CONTROL|MASK_ALT|MASK_SHIFT|MASK_MAC_CONTROL;
// Special keys go into >128
const KEY KEY_SPECIAL = 0x80; // special keys start here
const KEY KEY_RETURN = 0x81;
const KEY KEY_LEFT = 0x82;
const KEY KEY_RIGHT = 0x83;
const KEY KEY_UP = 0x84;
const KEY KEY_DOWN = 0x85;
const KEY KEY_ESCAPE = 0x86;
const KEY KEY_BACKSPACE =0x87;
const KEY KEY_DELETE = 0x88;
const KEY KEY_SHIFT = 0x89;
const KEY KEY_CONTROL = 0x8A;
const KEY KEY_ALT = 0x8B;
const KEY KEY_HOME = 0x8C;
const KEY KEY_END = 0x8D;
const KEY KEY_PAGE_UP = 0x8E;
const KEY KEY_PAGE_DOWN = 0x8F;
const KEY KEY_HYPHEN = 0x90;
const KEY KEY_EQUALS = 0x91;
const KEY KEY_INSERT = 0x92;
const KEY KEY_CAPSLOCK = 0x93;
const KEY KEY_TAB = 0x94;
const KEY KEY_ADD = 0x95;
const KEY KEY_SUBTRACT =0x96;
const KEY KEY_MULTIPLY =0x97;
const KEY KEY_DIVIDE = 0x98;
const KEY KEY_F1 = 0xA1;
const KEY KEY_F2 = 0xA2;
const KEY KEY_F3 = 0xA3;
const KEY KEY_F4 = 0xA4;
const KEY KEY_F5 = 0xA5;
const KEY KEY_F6 = 0xA6;
const KEY KEY_F7 = 0xA7;
const KEY KEY_F8 = 0xA8;
const KEY KEY_F9 = 0xA9;
const KEY KEY_F10 = 0xAA;
const KEY KEY_F11 = 0xAB;
const KEY KEY_F12 = 0xAC;
constexpr KEY KEY_SPECIAL = 0x80; // special keys start here
constexpr KEY KEY_RETURN = 0x81;
constexpr KEY KEY_LEFT = 0x82;
constexpr KEY KEY_RIGHT = 0x83;
constexpr KEY KEY_UP = 0x84;
constexpr KEY KEY_DOWN = 0x85;
constexpr KEY KEY_ESCAPE = 0x86;
constexpr KEY KEY_BACKSPACE =0x87;
constexpr KEY KEY_DELETE = 0x88;
constexpr KEY KEY_SHIFT = 0x89;
constexpr KEY KEY_CONTROL = 0x8A;
constexpr KEY KEY_ALT = 0x8B;
constexpr KEY KEY_HOME = 0x8C;
constexpr KEY KEY_END = 0x8D;
constexpr KEY KEY_PAGE_UP = 0x8E;
constexpr KEY KEY_PAGE_DOWN = 0x8F;
constexpr KEY KEY_HYPHEN = 0x90;
constexpr KEY KEY_EQUALS = 0x91;
constexpr KEY KEY_INSERT = 0x92;
constexpr KEY KEY_CAPSLOCK = 0x93;
constexpr KEY KEY_TAB = 0x94;
constexpr KEY KEY_ADD = 0x95;
constexpr KEY KEY_SUBTRACT =0x96;
constexpr KEY KEY_MULTIPLY =0x97;
constexpr KEY KEY_DIVIDE = 0x98;
constexpr KEY KEY_F1 = 0xA1;
constexpr KEY KEY_F2 = 0xA2;
constexpr KEY KEY_F3 = 0xA3;
constexpr KEY KEY_F4 = 0xA4;
constexpr KEY KEY_F5 = 0xA5;
constexpr KEY KEY_F6 = 0xA6;
constexpr KEY KEY_F7 = 0xA7;
constexpr KEY KEY_F8 = 0xA8;
constexpr KEY KEY_F9 = 0xA9;
constexpr KEY KEY_F10 = 0xAA;
constexpr KEY KEY_F11 = 0xAB;
constexpr KEY KEY_F12 = 0xAC;
const KEY KEY_PAD_UP = 0xC0;
const KEY KEY_PAD_DOWN = 0xC1;
const KEY KEY_PAD_LEFT = 0xC2;
const KEY KEY_PAD_RIGHT = 0xC3;
const KEY KEY_PAD_HOME = 0xC4;
const KEY KEY_PAD_END = 0xC5;
const KEY KEY_PAD_PGUP = 0xC6;
const KEY KEY_PAD_PGDN = 0xC7;
const KEY KEY_PAD_CENTER = 0xC8; // the 5 in the middle
const KEY KEY_PAD_INS = 0xC9;
const KEY KEY_PAD_DEL = 0xCA;
const KEY KEY_PAD_RETURN = 0xCB;
const KEY KEY_PAD_ADD = 0xCC; // not used
const KEY KEY_PAD_SUBTRACT = 0xCD; // not used
const KEY KEY_PAD_MULTIPLY = 0xCE; // not used
const KEY KEY_PAD_DIVIDE = 0xCF; // not used
constexpr KEY KEY_PAD_UP = 0xC0;
constexpr KEY KEY_PAD_DOWN = 0xC1;
constexpr KEY KEY_PAD_LEFT = 0xC2;
constexpr KEY KEY_PAD_RIGHT = 0xC3;
constexpr KEY KEY_PAD_HOME = 0xC4;
constexpr KEY KEY_PAD_END = 0xC5;
constexpr KEY KEY_PAD_PGUP = 0xC6;
constexpr KEY KEY_PAD_PGDN = 0xC7;
constexpr KEY KEY_PAD_CENTER = 0xC8; // the 5 in the middle
constexpr KEY KEY_PAD_INS = 0xC9;
constexpr KEY KEY_PAD_DEL = 0xCA;
constexpr KEY KEY_PAD_RETURN = 0xCB;
constexpr KEY KEY_PAD_ADD = 0xCC; // not used
constexpr KEY KEY_PAD_SUBTRACT = 0xCD; // not used
constexpr KEY KEY_PAD_MULTIPLY = 0xCE; // not used
constexpr KEY KEY_PAD_DIVIDE = 0xCF; // not used
const KEY KEY_BUTTON0 = 0xD0;
const KEY KEY_BUTTON1 = 0xD1;
const KEY KEY_BUTTON2 = 0xD2;
const KEY KEY_BUTTON3 = 0xD3;
const KEY KEY_BUTTON4 = 0xD4;
const KEY KEY_BUTTON5 = 0xD5;
const KEY KEY_BUTTON6 = 0xD6;
const KEY KEY_BUTTON7 = 0xD7;
const KEY KEY_BUTTON8 = 0xD8;
const KEY KEY_BUTTON9 = 0xD9;
const KEY KEY_BUTTON10 = 0xDA;
const KEY KEY_BUTTON11 = 0xDB;
const KEY KEY_BUTTON12 = 0xDC;
const KEY KEY_BUTTON13 = 0xDD;
const KEY KEY_BUTTON14 = 0xDE;
const KEY KEY_BUTTON15 = 0xDF;
constexpr KEY KEY_BUTTON0 = 0xD0;
constexpr KEY KEY_BUTTON1 = 0xD1;
constexpr KEY KEY_BUTTON2 = 0xD2;
constexpr KEY KEY_BUTTON3 = 0xD3;
constexpr KEY KEY_BUTTON4 = 0xD4;
constexpr KEY KEY_BUTTON5 = 0xD5;
constexpr KEY KEY_BUTTON6 = 0xD6;
constexpr KEY KEY_BUTTON7 = 0xD7;
constexpr KEY KEY_BUTTON8 = 0xD8;
constexpr KEY KEY_BUTTON9 = 0xD9;
constexpr KEY KEY_BUTTON10 = 0xDA;
constexpr KEY KEY_BUTTON11 = 0xDB;
constexpr KEY KEY_BUTTON12 = 0xDC;
constexpr KEY KEY_BUTTON13 = 0xDD;
constexpr KEY KEY_BUTTON14 = 0xDE;
constexpr KEY KEY_BUTTON15 = 0xDF;
const KEY KEY_NONE = 0xFF; // not sent from keyboard. For internal use only.
constexpr KEY KEY_NONE = 0xFF; // not sent from keyboard. For internal use only.
const S32 KEY_COUNT = 256;
constexpr S32 KEY_COUNT = 256;
const F32 DEFAULT_WATER_HEIGHT = 20.0f;
constexpr F32 DEFAULT_WATER_HEIGHT = 20.0f;
// Maturity ratings for simulators
const U8 SIM_ACCESS_MIN = 0; // Treated as 'unknown', usually ends up being SIM_ACCESS_PG
const U8 SIM_ACCESS_PG = 13;
const U8 SIM_ACCESS_MATURE = 21;
const U8 SIM_ACCESS_ADULT = 42; // Seriously Adult Only
const U8 SIM_ACCESS_DOWN = 254;
const U8 SIM_ACCESS_MAX = SIM_ACCESS_ADULT;
constexpr U8 SIM_ACCESS_MIN = 0; // Treated as 'unknown', usually ends up being SIM_ACCESS_PG
constexpr U8 SIM_ACCESS_PG = 13;
constexpr U8 SIM_ACCESS_MATURE = 21;
constexpr U8 SIM_ACCESS_ADULT = 42; // Seriously Adult Only
constexpr U8 SIM_ACCESS_DOWN = 254;
constexpr U8 SIM_ACCESS_MAX = SIM_ACCESS_ADULT;
// attachment constants
const U8 ATTACHMENT_ADD = 0x80;
constexpr U8 ATTACHMENT_ADD = 0x80;
// god levels
const U8 GOD_MAINTENANCE = 250;
const U8 GOD_FULL = 200;
const U8 GOD_LIAISON = 150;
const U8 GOD_CUSTOMER_SERVICE = 100;
const U8 GOD_LIKE = 1;
const U8 GOD_NOT = 0;
constexpr U8 GOD_MAINTENANCE = 250;
constexpr U8 GOD_FULL = 200;
constexpr U8 GOD_LIAISON = 150;
constexpr U8 GOD_CUSTOMER_SERVICE = 100;
constexpr U8 GOD_LIKE = 1;
constexpr U8 GOD_NOT = 0;
// "agent id" for things that should be done to ALL agents
LL_COMMON_API extern const LLUUID LL_UUID_ALL_AGENTS;
@ -239,120 +239,120 @@ LL_COMMON_API extern const LLUUID BLANK_OBJECT_NORMAL;
LL_COMMON_API extern const LLUUID BLANK_MATERIAL_ASSET_ID;
// radius within which a chat message is fully audible
const F32 CHAT_NORMAL_RADIUS = 20.f;
constexpr F32 CHAT_NORMAL_RADIUS = 20.f;
// media commands
const U32 PARCEL_MEDIA_COMMAND_STOP = 0;
const U32 PARCEL_MEDIA_COMMAND_PAUSE = 1;
const U32 PARCEL_MEDIA_COMMAND_PLAY = 2;
const U32 PARCEL_MEDIA_COMMAND_LOOP = 3;
const U32 PARCEL_MEDIA_COMMAND_TEXTURE = 4;
const U32 PARCEL_MEDIA_COMMAND_URL = 5;
const U32 PARCEL_MEDIA_COMMAND_TIME = 6;
const U32 PARCEL_MEDIA_COMMAND_AGENT = 7;
const U32 PARCEL_MEDIA_COMMAND_UNLOAD = 8;
const U32 PARCEL_MEDIA_COMMAND_AUTO_ALIGN = 9;
const U32 PARCEL_MEDIA_COMMAND_TYPE = 10;
const U32 PARCEL_MEDIA_COMMAND_SIZE = 11;
const U32 PARCEL_MEDIA_COMMAND_DESC = 12;
const U32 PARCEL_MEDIA_COMMAND_LOOP_SET = 13;
constexpr U32 PARCEL_MEDIA_COMMAND_STOP = 0;
constexpr U32 PARCEL_MEDIA_COMMAND_PAUSE = 1;
constexpr U32 PARCEL_MEDIA_COMMAND_PLAY = 2;
constexpr U32 PARCEL_MEDIA_COMMAND_LOOP = 3;
constexpr U32 PARCEL_MEDIA_COMMAND_TEXTURE = 4;
constexpr U32 PARCEL_MEDIA_COMMAND_URL = 5;
constexpr U32 PARCEL_MEDIA_COMMAND_TIME = 6;
constexpr U32 PARCEL_MEDIA_COMMAND_AGENT = 7;
constexpr U32 PARCEL_MEDIA_COMMAND_UNLOAD = 8;
constexpr U32 PARCEL_MEDIA_COMMAND_AUTO_ALIGN = 9;
constexpr U32 PARCEL_MEDIA_COMMAND_TYPE = 10;
constexpr U32 PARCEL_MEDIA_COMMAND_SIZE = 11;
constexpr U32 PARCEL_MEDIA_COMMAND_DESC = 12;
constexpr U32 PARCEL_MEDIA_COMMAND_LOOP_SET = 13;
const S32 CHAT_CHANNEL_DEBUG = S32_MAX;
// agent constants
const U32 CONTROL_AT_POS_INDEX = 0;
const U32 CONTROL_AT_NEG_INDEX = 1;
const U32 CONTROL_LEFT_POS_INDEX = 2;
const U32 CONTROL_LEFT_NEG_INDEX = 3;
const U32 CONTROL_UP_POS_INDEX = 4;
const U32 CONTROL_UP_NEG_INDEX = 5;
const U32 CONTROL_PITCH_POS_INDEX = 6;
const U32 CONTROL_PITCH_NEG_INDEX = 7;
const U32 CONTROL_YAW_POS_INDEX = 8;
const U32 CONTROL_YAW_NEG_INDEX = 9;
const U32 CONTROL_FAST_AT_INDEX = 10;
const U32 CONTROL_FAST_LEFT_INDEX = 11;
const U32 CONTROL_FAST_UP_INDEX = 12;
const U32 CONTROL_FLY_INDEX = 13;
const U32 CONTROL_STOP_INDEX = 14;
const U32 CONTROL_FINISH_ANIM_INDEX = 15;
const U32 CONTROL_STAND_UP_INDEX = 16;
const U32 CONTROL_SIT_ON_GROUND_INDEX = 17;
const U32 CONTROL_MOUSELOOK_INDEX = 18;
const U32 CONTROL_NUDGE_AT_POS_INDEX = 19;
const U32 CONTROL_NUDGE_AT_NEG_INDEX = 20;
const U32 CONTROL_NUDGE_LEFT_POS_INDEX = 21;
const U32 CONTROL_NUDGE_LEFT_NEG_INDEX = 22;
const U32 CONTROL_NUDGE_UP_POS_INDEX = 23;
const U32 CONTROL_NUDGE_UP_NEG_INDEX = 24;
const U32 CONTROL_TURN_LEFT_INDEX = 25;
const U32 CONTROL_TURN_RIGHT_INDEX = 26;
const U32 CONTROL_AWAY_INDEX = 27;
const U32 CONTROL_LBUTTON_DOWN_INDEX = 28;
const U32 CONTROL_LBUTTON_UP_INDEX = 29;
const U32 CONTROL_ML_LBUTTON_DOWN_INDEX = 30;
const U32 CONTROL_ML_LBUTTON_UP_INDEX = 31;
const U32 TOTAL_CONTROLS = 32;
constexpr U32 CONTROL_AT_POS_INDEX = 0;
constexpr U32 CONTROL_AT_NEG_INDEX = 1;
constexpr U32 CONTROL_LEFT_POS_INDEX = 2;
constexpr U32 CONTROL_LEFT_NEG_INDEX = 3;
constexpr U32 CONTROL_UP_POS_INDEX = 4;
constexpr U32 CONTROL_UP_NEG_INDEX = 5;
constexpr U32 CONTROL_PITCH_POS_INDEX = 6;
constexpr U32 CONTROL_PITCH_NEG_INDEX = 7;
constexpr U32 CONTROL_YAW_POS_INDEX = 8;
constexpr U32 CONTROL_YAW_NEG_INDEX = 9;
constexpr U32 CONTROL_FAST_AT_INDEX = 10;
constexpr U32 CONTROL_FAST_LEFT_INDEX = 11;
constexpr U32 CONTROL_FAST_UP_INDEX = 12;
constexpr U32 CONTROL_FLY_INDEX = 13;
constexpr U32 CONTROL_STOP_INDEX = 14;
constexpr U32 CONTROL_FINISH_ANIM_INDEX = 15;
constexpr U32 CONTROL_STAND_UP_INDEX = 16;
constexpr U32 CONTROL_SIT_ON_GROUND_INDEX = 17;
constexpr U32 CONTROL_MOUSELOOK_INDEX = 18;
constexpr U32 CONTROL_NUDGE_AT_POS_INDEX = 19;
constexpr U32 CONTROL_NUDGE_AT_NEG_INDEX = 20;
constexpr U32 CONTROL_NUDGE_LEFT_POS_INDEX = 21;
constexpr U32 CONTROL_NUDGE_LEFT_NEG_INDEX = 22;
constexpr U32 CONTROL_NUDGE_UP_POS_INDEX = 23;
constexpr U32 CONTROL_NUDGE_UP_NEG_INDEX = 24;
constexpr U32 CONTROL_TURN_LEFT_INDEX = 25;
constexpr U32 CONTROL_TURN_RIGHT_INDEX = 26;
constexpr U32 CONTROL_AWAY_INDEX = 27;
constexpr U32 CONTROL_LBUTTON_DOWN_INDEX = 28;
constexpr U32 CONTROL_LBUTTON_UP_INDEX = 29;
constexpr U32 CONTROL_ML_LBUTTON_DOWN_INDEX = 30;
constexpr U32 CONTROL_ML_LBUTTON_UP_INDEX = 31;
constexpr U32 TOTAL_CONTROLS = 32;
const U32 AGENT_CONTROL_AT_POS = 0x1 << CONTROL_AT_POS_INDEX; // 0x00000001
const U32 AGENT_CONTROL_AT_NEG = 0x1 << CONTROL_AT_NEG_INDEX; // 0x00000002
const U32 AGENT_CONTROL_LEFT_POS = 0x1 << CONTROL_LEFT_POS_INDEX; // 0x00000004
const U32 AGENT_CONTROL_LEFT_NEG = 0x1 << CONTROL_LEFT_NEG_INDEX; // 0x00000008
const U32 AGENT_CONTROL_UP_POS = 0x1 << CONTROL_UP_POS_INDEX; // 0x00000010
const U32 AGENT_CONTROL_UP_NEG = 0x1 << CONTROL_UP_NEG_INDEX; // 0x00000020
const U32 AGENT_CONTROL_PITCH_POS = 0x1 << CONTROL_PITCH_POS_INDEX; // 0x00000040
const U32 AGENT_CONTROL_PITCH_NEG = 0x1 << CONTROL_PITCH_NEG_INDEX; // 0x00000080
const U32 AGENT_CONTROL_YAW_POS = 0x1 << CONTROL_YAW_POS_INDEX; // 0x00000100
const U32 AGENT_CONTROL_YAW_NEG = 0x1 << CONTROL_YAW_NEG_INDEX; // 0x00000200
constexpr U32 AGENT_CONTROL_AT_POS = 0x1 << CONTROL_AT_POS_INDEX; // 0x00000001
constexpr U32 AGENT_CONTROL_AT_NEG = 0x1 << CONTROL_AT_NEG_INDEX; // 0x00000002
constexpr U32 AGENT_CONTROL_LEFT_POS = 0x1 << CONTROL_LEFT_POS_INDEX; // 0x00000004
constexpr U32 AGENT_CONTROL_LEFT_NEG = 0x1 << CONTROL_LEFT_NEG_INDEX; // 0x00000008
constexpr U32 AGENT_CONTROL_UP_POS = 0x1 << CONTROL_UP_POS_INDEX; // 0x00000010
constexpr U32 AGENT_CONTROL_UP_NEG = 0x1 << CONTROL_UP_NEG_INDEX; // 0x00000020
constexpr U32 AGENT_CONTROL_PITCH_POS = 0x1 << CONTROL_PITCH_POS_INDEX; // 0x00000040
constexpr U32 AGENT_CONTROL_PITCH_NEG = 0x1 << CONTROL_PITCH_NEG_INDEX; // 0x00000080
constexpr U32 AGENT_CONTROL_YAW_POS = 0x1 << CONTROL_YAW_POS_INDEX; // 0x00000100
constexpr U32 AGENT_CONTROL_YAW_NEG = 0x1 << CONTROL_YAW_NEG_INDEX; // 0x00000200
const U32 AGENT_CONTROL_FAST_AT = 0x1 << CONTROL_FAST_AT_INDEX; // 0x00000400
const U32 AGENT_CONTROL_FAST_LEFT = 0x1 << CONTROL_FAST_LEFT_INDEX; // 0x00000800
const U32 AGENT_CONTROL_FAST_UP = 0x1 << CONTROL_FAST_UP_INDEX; // 0x00001000
constexpr U32 AGENT_CONTROL_FAST_AT = 0x1 << CONTROL_FAST_AT_INDEX; // 0x00000400
constexpr U32 AGENT_CONTROL_FAST_LEFT = 0x1 << CONTROL_FAST_LEFT_INDEX; // 0x00000800
constexpr U32 AGENT_CONTROL_FAST_UP = 0x1 << CONTROL_FAST_UP_INDEX; // 0x00001000
const U32 AGENT_CONTROL_FLY = 0x1 << CONTROL_FLY_INDEX; // 0x00002000
const U32 AGENT_CONTROL_STOP = 0x1 << CONTROL_STOP_INDEX; // 0x00004000
const U32 AGENT_CONTROL_FINISH_ANIM = 0x1 << CONTROL_FINISH_ANIM_INDEX; // 0x00008000
const U32 AGENT_CONTROL_STAND_UP = 0x1 << CONTROL_STAND_UP_INDEX; // 0x00010000
const U32 AGENT_CONTROL_SIT_ON_GROUND = 0x1 << CONTROL_SIT_ON_GROUND_INDEX; // 0x00020000
const U32 AGENT_CONTROL_MOUSELOOK = 0x1 << CONTROL_MOUSELOOK_INDEX; // 0x00040000
constexpr U32 AGENT_CONTROL_FLY = 0x1 << CONTROL_FLY_INDEX; // 0x00002000
constexpr U32 AGENT_CONTROL_STOP = 0x1 << CONTROL_STOP_INDEX; // 0x00004000
constexpr U32 AGENT_CONTROL_FINISH_ANIM = 0x1 << CONTROL_FINISH_ANIM_INDEX; // 0x00008000
constexpr U32 AGENT_CONTROL_STAND_UP = 0x1 << CONTROL_STAND_UP_INDEX; // 0x00010000
constexpr U32 AGENT_CONTROL_SIT_ON_GROUND = 0x1 << CONTROL_SIT_ON_GROUND_INDEX; // 0x00020000
constexpr U32 AGENT_CONTROL_MOUSELOOK = 0x1 << CONTROL_MOUSELOOK_INDEX; // 0x00040000
const U32 AGENT_CONTROL_NUDGE_AT_POS = 0x1 << CONTROL_NUDGE_AT_POS_INDEX; // 0x00080000
const U32 AGENT_CONTROL_NUDGE_AT_NEG = 0x1 << CONTROL_NUDGE_AT_NEG_INDEX; // 0x00100000
const U32 AGENT_CONTROL_NUDGE_LEFT_POS = 0x1 << CONTROL_NUDGE_LEFT_POS_INDEX; // 0x00200000
const U32 AGENT_CONTROL_NUDGE_LEFT_NEG = 0x1 << CONTROL_NUDGE_LEFT_NEG_INDEX; // 0x00400000
const U32 AGENT_CONTROL_NUDGE_UP_POS = 0x1 << CONTROL_NUDGE_UP_POS_INDEX; // 0x00800000
const U32 AGENT_CONTROL_NUDGE_UP_NEG = 0x1 << CONTROL_NUDGE_UP_NEG_INDEX; // 0x01000000
const U32 AGENT_CONTROL_TURN_LEFT = 0x1 << CONTROL_TURN_LEFT_INDEX; // 0x02000000
const U32 AGENT_CONTROL_TURN_RIGHT = 0x1 << CONTROL_TURN_RIGHT_INDEX; // 0x04000000
constexpr U32 AGENT_CONTROL_NUDGE_AT_POS = 0x1 << CONTROL_NUDGE_AT_POS_INDEX; // 0x00080000
constexpr U32 AGENT_CONTROL_NUDGE_AT_NEG = 0x1 << CONTROL_NUDGE_AT_NEG_INDEX; // 0x00100000
constexpr U32 AGENT_CONTROL_NUDGE_LEFT_POS = 0x1 << CONTROL_NUDGE_LEFT_POS_INDEX; // 0x00200000
constexpr U32 AGENT_CONTROL_NUDGE_LEFT_NEG = 0x1 << CONTROL_NUDGE_LEFT_NEG_INDEX; // 0x00400000
constexpr U32 AGENT_CONTROL_NUDGE_UP_POS = 0x1 << CONTROL_NUDGE_UP_POS_INDEX; // 0x00800000
constexpr U32 AGENT_CONTROL_NUDGE_UP_NEG = 0x1 << CONTROL_NUDGE_UP_NEG_INDEX; // 0x01000000
constexpr U32 AGENT_CONTROL_TURN_LEFT = 0x1 << CONTROL_TURN_LEFT_INDEX; // 0x02000000
constexpr U32 AGENT_CONTROL_TURN_RIGHT = 0x1 << CONTROL_TURN_RIGHT_INDEX; // 0x04000000
const U32 AGENT_CONTROL_AWAY = 0x1 << CONTROL_AWAY_INDEX; // 0x08000000
constexpr U32 AGENT_CONTROL_AWAY = 0x1 << CONTROL_AWAY_INDEX; // 0x08000000
const U32 AGENT_CONTROL_LBUTTON_DOWN = 0x1 << CONTROL_LBUTTON_DOWN_INDEX; // 0x10000000
const U32 AGENT_CONTROL_LBUTTON_UP = 0x1 << CONTROL_LBUTTON_UP_INDEX; // 0x20000000
const U32 AGENT_CONTROL_ML_LBUTTON_DOWN = 0x1 << CONTROL_ML_LBUTTON_DOWN_INDEX; // 0x40000000
const U32 AGENT_CONTROL_ML_LBUTTON_UP = ((U32)0x1) << CONTROL_ML_LBUTTON_UP_INDEX; // 0x80000000
constexpr U32 AGENT_CONTROL_LBUTTON_DOWN = 0x1 << CONTROL_LBUTTON_DOWN_INDEX; // 0x10000000
constexpr U32 AGENT_CONTROL_LBUTTON_UP = 0x1 << CONTROL_LBUTTON_UP_INDEX; // 0x20000000
constexpr U32 AGENT_CONTROL_ML_LBUTTON_DOWN = 0x1 << CONTROL_ML_LBUTTON_DOWN_INDEX; // 0x40000000
constexpr U32 AGENT_CONTROL_ML_LBUTTON_UP = ((U32)0x1) << CONTROL_ML_LBUTTON_UP_INDEX; // 0x80000000
// move these up so that we can hide them in "State" for object updates
// (for now)
const U32 AGENT_ATTACH_OFFSET = 4;
const U32 AGENT_ATTACH_MASK = 0xf << AGENT_ATTACH_OFFSET;
constexpr U32 AGENT_ATTACH_OFFSET = 4;
constexpr U32 AGENT_ATTACH_MASK = 0xf << AGENT_ATTACH_OFFSET;
// RN: this method swaps the upper and lower nibbles to maintain backward
// compatibility with old objects that only used the upper nibble
#define ATTACHMENT_ID_FROM_STATE(state) ((S32)((((U8)state & AGENT_ATTACH_MASK) >> 4) | (((U8)state & ~AGENT_ATTACH_MASK) << 4)))
// DO NOT CHANGE THE SEQUENCE OF THIS LIST!!
const U8 CLICK_ACTION_NONE = 0;
const U8 CLICK_ACTION_TOUCH = 0;
const U8 CLICK_ACTION_SIT = 1;
const U8 CLICK_ACTION_BUY = 2;
const U8 CLICK_ACTION_PAY = 3;
const U8 CLICK_ACTION_OPEN = 4;
const U8 CLICK_ACTION_PLAY = 5;
const U8 CLICK_ACTION_OPEN_MEDIA = 6;
const U8 CLICK_ACTION_ZOOM = 7;
const U8 CLICK_ACTION_DISABLED = 8;
const U8 CLICK_ACTION_IGNORE = 9;
constexpr U8 CLICK_ACTION_NONE = 0;
constexpr U8 CLICK_ACTION_TOUCH = 0;
constexpr U8 CLICK_ACTION_SIT = 1;
constexpr U8 CLICK_ACTION_BUY = 2;
constexpr U8 CLICK_ACTION_PAY = 3;
constexpr U8 CLICK_ACTION_OPEN = 4;
constexpr U8 CLICK_ACTION_PLAY = 5;
constexpr U8 CLICK_ACTION_OPEN_MEDIA = 6;
constexpr U8 CLICK_ACTION_ZOOM = 7;
constexpr U8 CLICK_ACTION_DISABLED = 8;
constexpr U8 CLICK_ACTION_IGNORE = 9;
// DO NOT CHANGE THE SEQUENCE OF THIS LIST!!
constexpr U32 BEACON_SHOW_MAP = 0x0001;

14
indra/llcommon/lldefs.h
View File

@ -171,13 +171,13 @@ constexpr U32 MAXADDRSTR = 17; // 123.567.901.345 = 15 chars + \0 +
// recursion tail
template <typename T>
inline auto llmax(T data)
constexpr auto llmax(T data)
{
return data;
}
template <typename T0, typename T1, typename... Ts>
inline auto llmax(T0 d0, T1 d1, Ts... rest)
constexpr auto llmax(T0 d0, T1 d1, Ts... rest)
{
auto maxrest = llmax(d1, rest...);
return (d0 > maxrest)? d0 : maxrest;
@ -185,20 +185,20 @@ inline auto llmax(T0 d0, T1 d1, Ts... rest)
// recursion tail
template <typename T>
inline auto llmin(T data)
constexpr auto llmin(T data)
{
return data;
}
template <typename T0, typename T1, typename... Ts>
inline auto llmin(T0 d0, T1 d1, Ts... rest)
constexpr auto llmin(T0 d0, T1 d1, Ts... rest)
{
auto minrest = llmin(d1, rest...);
return (d0 < minrest) ? d0 : minrest;
}
template <typename A, typename MIN, typename MAX>
inline A llclamp(A a, MIN minval, MAX maxval)
constexpr A llclamp(A a, MIN minval, MAX maxval)
{
A aminval{ static_cast<A>(minval) }, amaxval{ static_cast<A>(maxval) };
if ( a < aminval )
@ -213,13 +213,13 @@ inline A llclamp(A a, MIN minval, MAX maxval)
}
template <class LLDATATYPE>
inline LLDATATYPE llclampf(LLDATATYPE a)
constexpr LLDATATYPE llclampf(LLDATATYPE a)
{
return llmin(llmax(a, LLDATATYPE(0)), LLDATATYPE(1));
}
template <class LLDATATYPE>
inline LLDATATYPE llclampb(LLDATATYPE a)
constexpr LLDATATYPE llclampb(LLDATATYPE a)
{
return llmin(llmax(a, LLDATATYPE(0)), LLDATATYPE(255));
}

6
indra/llcommon/stdtypes.h
View File

@ -164,14 +164,14 @@ private:
FROM mValue;
public:
narrow(FROM value): mValue(value) {}
constexpr narrow(FROM value): mValue(value) {}
/*---------------------- Narrowing unsigned to signed ----------------------*/
template <typename TO,
typename std::enable_if<std::is_unsigned<FROM>::value &&
std::is_signed<TO>::value,
bool>::type = true>
inline
constexpr
operator TO() const
{
// The reason we skip the
@ -189,7 +189,7 @@ public:
typename std::enable_if<! (std::is_unsigned<FROM>::value &&
std::is_signed<TO>::value),
bool>::type = true>
inline
constexpr
operator TO() const
{
// two different assert()s so we can tell which condition failed

26
indra/llmath/llcamera.h
View File

@ -33,23 +33,23 @@
#include "llplane.h"
#include "llvector4a.h"
const F32 DEFAULT_FIELD_OF_VIEW = 60.f * DEG_TO_RAD;
const F32 DEFAULT_ASPECT_RATIO = 640.f / 480.f;
const F32 DEFAULT_NEAR_PLANE = 0.25f;
const F32 DEFAULT_FAR_PLANE = 64.f; // far reaches across two horizontal, not diagonal, regions
constexpr F32 DEFAULT_FIELD_OF_VIEW = 60.f * DEG_TO_RAD;
constexpr F32 DEFAULT_ASPECT_RATIO = 640.f / 480.f;
constexpr F32 DEFAULT_NEAR_PLANE = 0.25f;
constexpr F32 DEFAULT_FAR_PLANE = 64.f; // far reaches across two horizontal, not diagonal, regions
const F32 MAX_ASPECT_RATIO = 50.0f;
const F32 MAX_NEAR_PLANE = 1023.9f; // Clamp the near plane just before the skybox ends
const F32 MAX_FAR_PLANE = 100000.0f; //1000000.0f; // Max allowed. Not good Z precision though.
const F32 MAX_FAR_CLIP = 512.0f;
constexpr F32 MAX_ASPECT_RATIO = 50.0f;
constexpr F32 MAX_NEAR_PLANE = 1023.9f; // Clamp the near plane just before the skybox ends
constexpr F32 MAX_FAR_PLANE = 100000.0f; //1000000.0f; // Max allowed. Not good Z precision though.
constexpr F32 MAX_FAR_CLIP = 512.0f;
const F32 MIN_ASPECT_RATIO = 0.02f;
const F32 MIN_NEAR_PLANE = 0.1f;
const F32 MIN_FAR_PLANE = 0.2f;
constexpr F32 MIN_ASPECT_RATIO = 0.02f;
constexpr F32 MIN_NEAR_PLANE = 0.1f;
constexpr F32 MIN_FAR_PLANE = 0.2f;
// Min/Max FOV values for square views. Call getMin/MaxView to get extremes based on current aspect ratio.
static const F32 MIN_FIELD_OF_VIEW = 5.0f * DEG_TO_RAD;
static const F32 MAX_FIELD_OF_VIEW = 175.f * DEG_TO_RAD;
constexpr F32 MIN_FIELD_OF_VIEW = 5.0f * DEG_TO_RAD;
constexpr F32 MAX_FIELD_OF_VIEW = 175.f * DEG_TO_RAD;
// An LLCamera is an LLCoorFrame with a view frustum.
// This means that it has several methods for moving it around

1
indra/llmath/llcoordframe.cpp
View File

@ -26,7 +26,6 @@
#include "linden_common.h"
//#include "vmath.h"
#include "v3math.h"
#include "m3math.h"
#include "v4math.h"

2
indra/llmath/llcoordframe.h
View File

@ -61,7 +61,7 @@ public:
//LLCoordFrame(const F32 *origin, const F32 *rotation); // Assumes "origin" is 1x3 and "rotation" is 1x9 array
//LLCoordFrame(const F32 *origin_and_rotation); // Assumes "origin_and_rotation" is 1x12 array
bool isFinite() { return mOrigin.isFinite() && mXAxis.isFinite() && mYAxis.isFinite() && mZAxis.isFinite(); }
bool isFinite() const { return mOrigin.isFinite() && mXAxis.isFinite() && mYAxis.isFinite() && mZAxis.isFinite(); }
void reset();
void resetAxes();

2
indra/llmath/llline.h
View File

@ -33,7 +33,7 @@
#include "stdtypes.h"
#include "v3math.h"
const F32 DEFAULT_INTERSECTION_ERROR = 0.000001f;
constexpr F32 DEFAULT_INTERSECTION_ERROR = 0.000001f;
class LLLine
{

58
indra/llmath/llmath.h
View File

@ -79,7 +79,7 @@ constexpr F32 GIMBAL_THRESHOLD = 0.000436f; // sets the gimballock threshold 0
constexpr F32 FP_MAG_THRESHOLD = 0.0000001f;
// TODO: Replace with logic like is_approx_equal
inline bool is_approx_zero( F32 f ) { return (-F_APPROXIMATELY_ZERO < f) && (f < F_APPROXIMATELY_ZERO); }
constexpr bool is_approx_zero(F32 f) { return (-F_APPROXIMATELY_ZERO < f) && (f < F_APPROXIMATELY_ZERO); }
// These functions work by interpreting sign+exp+mantissa as an unsigned
// integer.
@ -138,30 +138,14 @@ inline F64 llabs(const F64 a)
return F64(std::fabs(a));
}
inline S32 lltrunc( F32 f )
constexpr S32 lltrunc(F32 f)
{
#if LL_WINDOWS && !defined( __INTEL_COMPILER ) && (ADDRESS_SIZE == 32)
// Avoids changing the floating point control word.
// Add or subtract 0.5 - epsilon and then round
const static U32 zpfp[] = { 0xBEFFFFFF, 0x3EFFFFFF };
S32 result;
__asm {
fld f
mov eax, f
shr eax, 29
and eax, 4
fadd dword ptr [zpfp + eax]
fistp result
}
return result;
#else
return (S32)f;
#endif
return narrow(f);
}
inline S32 lltrunc( F64 f )
constexpr S32 lltrunc(F64 f)
{
return (S32)f;
return narrow(f);
}
inline S32 llfloor(F32 f)
@ -274,7 +258,7 @@ constexpr F32 FAST_MAG_BETA = 0.397824734759f;
//constexpr F32 FAST_MAG_ALPHA = 0.948059448969f;
//constexpr F32 FAST_MAG_BETA = 0.392699081699f;
inline F32 fastMagnitude(F32 a, F32 b)
constexpr F32 fastMagnitude(F32 a, F32 b)
{
a = (a > 0) ? a : -a;
b = (b > 0) ? b : -b;
@ -332,7 +316,7 @@ inline F32 llfastpow(const F32 x, const F32 y)
}
inline F32 snap_to_sig_figs(F32 foo, S32 sig_figs)
constexpr F32 snap_to_sig_figs(F32 foo, S32 sig_figs)
{
// compute the power of ten
F32 bar = 1.f;
@ -350,7 +334,7 @@ inline F32 snap_to_sig_figs(F32 foo, S32 sig_figs)
using std::lerp;
inline F32 lerp2d(F32 x00, F32 x01, F32 x10, F32 x11, F32 u, F32 v)
constexpr F32 lerp2d(F32 x00, F32 x01, F32 x10, F32 x11, F32 u, F32 v)
{
F32 a = x00 + (x01-x00)*u;
F32 b = x10 + (x11-x10)*u;
@ -358,17 +342,17 @@ inline F32 lerp2d(F32 x00, F32 x01, F32 x10, F32 x11, F32 u, F32 v)
return r;
}
inline F32 ramp(F32 x, F32 a, F32 b)
constexpr F32 ramp(F32 x, F32 a, F32 b)
{
return (a == b) ? 0.0f : ((a - x) / (a - b));
}
inline F32 rescale(F32 x, F32 x1, F32 x2, F32 y1, F32 y2)
constexpr F32 rescale(F32 x, F32 x1, F32 x2, F32 y1, F32 y2)
{
return lerp(y1, y2, ramp(x, x1, x2));
}
inline F32 clamp_rescale(F32 x, F32 x1, F32 x2, F32 y1, F32 y2)
constexpr F32 clamp_rescale(F32 x, F32 x1, F32 x2, F32 y1, F32 y2)
{
if (y1 < y2)
{
@ -381,7 +365,7 @@ inline F32 clamp_rescale(F32 x, F32 x1, F32 x2, F32 y1, F32 y2)
}
inline F32 cubic_step( F32 x, F32 x0, F32 x1, F32 s0, F32 s1 )
constexpr F32 cubic_step( F32 x, F32 x0, F32 x1, F32 s0, F32 s1 )
{
if (x <= x0)
return s0;
@ -394,14 +378,14 @@ inline F32 cubic_step( F32 x, F32 x0, F32 x1, F32 s0, F32 s1 )
return s0 + (s1 - s0) * (f * f) * (3.0f - 2.0f * f);
}
inline F32 cubic_step( F32 x )
constexpr F32 cubic_step( F32 x )
{
x = llclampf(x);
return (x * x) * (3.0f - 2.0f * x);
}
inline F32 quadratic_step( F32 x, F32 x0, F32 x1, F32 s0, F32 s1 )
constexpr F32 quadratic_step( F32 x, F32 x0, F32 x1, F32 s0, F32 s1 )
{
if (x <= x0)
return s0;
@ -415,7 +399,7 @@ inline F32 quadratic_step( F32 x, F32 x0, F32 x1, F32 s0, F32 s1 )
return (s0 * (1.f - f_squared)) + ((s1 - s0) * f_squared);
}
inline F32 llsimple_angle(F32 angle)
constexpr F32 llsimple_angle(F32 angle)
{
while(angle <= -F_PI)
angle += F_TWO_PI;
@ -425,7 +409,7 @@ inline F32 llsimple_angle(F32 angle)
}
//SDK - Renamed this to get_lower_power_two, since this is what this actually does.
inline U32 get_lower_power_two(U32 val, U32 max_power_two)
constexpr U32 get_lower_power_two(U32 val, U32 max_power_two)
{
if(!max_power_two)
{
@ -447,7 +431,7 @@ inline U32 get_lower_power_two(U32 val, U32 max_power_two)
// number of digits, then add one. We subtract 1 initially to handle
// the case where the number passed in is actually a power of two.
// WARNING: this only works with 32 bit ints.
inline U32 get_next_power_two(U32 val, U32 max_power_two)
constexpr U32 get_next_power_two(U32 val, U32 max_power_two)
{
if(!max_power_two)
{
@ -473,7 +457,7 @@ inline U32 get_next_power_two(U32 val, U32 max_power_two)
//get the gaussian value given the linear distance from axis x and guassian value o
inline F32 llgaussian(F32 x, F32 o)
{
return 1.f/(F_SQRT_TWO_PI*o)*powf(F_E, -(x*x)/(2*o*o));
return 1.f/(F_SQRT_TWO_PI*o)*powf(F_E, -(x*x)/(2.f*o*o));
}
//helper function for removing outliers
@ -526,7 +510,8 @@ inline void ll_remove_outliers(std::vector<VEC_TYPE>& data, F32 k)
// Note: in our code, values labeled as sRGB are ALWAYS gamma corrected linear values, NOT linear values with monitor gamma applied
// Note: stored color values should always be gamma corrected linear (i.e. the values returned from an on-screen color swatch)
// Note: DO NOT cache the conversion. This leads to error prone synchronization and is actually slower in the typical case due to cache misses
inline float linearTosRGB(const float val) {
inline float linearTosRGB(const float val)
{
if (val < 0.0031308f) {
return val * 12.92f;
}
@ -541,7 +526,8 @@ inline float linearTosRGB(const float val) {
// Note: Stored color values should generally be gamma corrected sRGB.
// If you're serializing the return value of this function, you're probably doing it wrong.
// Note: DO NOT cache the conversion. This leads to error prone synchronization and is actually slower in the typical case due to cache misses.
inline float sRGBtoLinear(const float val) {
inline float sRGBtoLinear(const float val)
{
if (val < 0.04045f) {
return val / 12.92f;
}

1
indra/llmath/llquaternion.cpp
View File

@ -30,7 +30,6 @@
#include "llquaternion.h"
//#include "vmath.h"
#include "v3math.h"
#include "v3dmath.h"
#include "v4math.h"

1
indra/llmath/llvolume.h
View File

@ -45,7 +45,6 @@ class LLVolumeOctree;
#include "lluuid.h"
#include "v4color.h"
//#include "vmath.h"
#include "v2math.h"
#include "v3math.h"
#include "v3dmath.h"

1
indra/llmath/m3math.cpp
View File

@ -26,7 +26,6 @@
#include "linden_common.h"
//#include "vmath.h"
#include "v3math.h"
#include "v3dmath.h"
#include "v4math.h"

1
indra/llmath/m4math.cpp
View File

@ -26,7 +26,6 @@
#include "linden_common.h"
//#include "vmath.h"
#include "v3math.h"
#include "v4math.h"
#include "m4math.h"

27
indra/llmath/v2math.cpp
View File

@ -26,7 +26,6 @@
#include "linden_common.h"
//#include "vmath.h"
#include "v2math.h"
#include "v3math.h"
#include "v4math.h"
@ -47,8 +46,8 @@ bool LLVector2::abs()
{
bool ret{ false };
if (mV[0] < 0.f) { mV[0] = -mV[0]; ret = true; }
if (mV[1] < 0.f) { mV[1] = -mV[1]; ret = true; }
if (mV[VX] < 0.f) { mV[VX] = -mV[VX]; ret = true; }
if (mV[VY] < 0.f) { mV[VY] = -mV[VY]; ret = true; }
return ret;
}
@ -67,7 +66,7 @@ F32 angle_between(const LLVector2& a, const LLVector2& b)
return angle;
}
bool are_parallel(const LLVector2 &a, const LLVector2 &b, float epsilon)
bool are_parallel(const LLVector2& a, const LLVector2& b, F32 epsilon)
{
LLVector2 an = a;
LLVector2 bn = b;
@ -84,22 +83,22 @@ bool are_parallel(const LLVector2 &a, const LLVector2 &b, float epsilon)
F32 dist_vec(const LLVector2& a, const LLVector2& b)
{
F32 x = a.mV[0] - b.mV[0];
F32 y = a.mV[1] - b.mV[1];
F32 x = a.mV[VX] - b.mV[VX];
F32 y = a.mV[VY] - b.mV[VY];
return (F32) sqrt( x*x + y*y );
}
F32 dist_vec_squared(const LLVector2& a, const LLVector2& b)
{
F32 x = a.mV[0] - b.mV[0];
F32 y = a.mV[1] - b.mV[1];
F32 x = a.mV[VX] - b.mV[VX];
F32 y = a.mV[VY] - b.mV[VY];
return x*x + y*y;
}
F32 dist_vec_squared2D(const LLVector2& a, const LLVector2& b)
{
F32 x = a.mV[0] - b.mV[0];
F32 y = a.mV[1] - b.mV[1];
F32 x = a.mV[VX] - b.mV[VX];
F32 y = a.mV[VY] - b.mV[VY];
return x*x + y*y;
}
@ -113,14 +112,14 @@ LLVector2 lerp(const LLVector2 &a, const LLVector2 &b, F32 u)
LLSD LLVector2::getValue() const
{
LLSD ret;
ret[0] = mV[0];
ret[1] = mV[1];
ret[VX] = mV[VX];
ret[VY] = mV[VY];
return ret;
}
void LLVector2::setValue(const LLSD& sd)
{
mV[0] = (F32) sd[0].asReal();
mV[1] = (F32) sd[1].asReal();
mV[VX] = (F32) sd[0].asReal();
mV[VY] = (F32) sd[1].asReal();
}

94
indra/llmath/v2math.h
View File

@ -36,7 +36,7 @@ class LLQuaternion;
// Llvector2 = |x y z w|
static const U32 LENGTHOFVECTOR2 = 2;
static constexpr U32 LENGTHOFVECTOR2 = 2;
class LLVector2
{
@ -82,7 +82,7 @@ class LLVector2
const LLVector2& scaleVec(const LLVector2& vec); // scales per component by vec
bool isNull(); // Returns true if vector has a _very_small_ length
bool isNull() const; // Returns true if vector has a _very_small_ length
bool isExactlyZero() const { return !mV[VX] && !mV[VY]; }
F32 operator[](int idx) const { return mV[idx]; }
@ -122,7 +122,7 @@ LLVector2 lerp(const LLVector2 &a, const LLVector2 &b, F32 u); // Returns a vect
// Constructors
inline LLVector2::LLVector2(void)
inline LLVector2::LLVector2()
{
mV[VX] = 0.f;
mV[VY] = 0.f;
@ -153,27 +153,27 @@ inline LLVector2::LLVector2(const LLSD &sd)
// Clear and Assignment Functions
inline void LLVector2::clear(void)
inline void LLVector2::clear()
{
mV[VX] = 0.f;
mV[VY] = 0.f;
}
inline void LLVector2::setZero(void)
inline void LLVector2::setZero()
{
mV[VX] = 0.f;
mV[VY] = 0.f;
}
// deprecated
inline void LLVector2::clearVec(void)
inline void LLVector2::clearVec()
{
mV[VX] = 0.f;
mV[VY] = 0.f;
}
// deprecated
inline void LLVector2::zeroVec(void)
inline void LLVector2::zeroVec()
{
mV[VX] = 0.f;
mV[VY] = 0.f;
@ -222,31 +222,31 @@ inline void LLVector2::setVec(const F32 *vec)
// LLVector2 Magnitude and Normalization Functions
inline F32 LLVector2::length(void) const
inline F32 LLVector2::length() const
{
return (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1]);
return sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY]);
}
inline F32 LLVector2::lengthSquared(void) const
inline F32 LLVector2::lengthSquared() const
{
return mV[0]*mV[0] + mV[1]*mV[1];
return mV[VX]*mV[VX] + mV[VY]*mV[VY];
}
inline F32 LLVector2::normalize(void)
inline F32 LLVector2::normalize()
{
F32 mag = (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1]);
F32 mag = sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY]);
F32 oomag;
if (mag > FP_MAG_THRESHOLD)
{
oomag = 1.f/mag;
mV[0] *= oomag;
mV[1] *= oomag;
mV[VX] *= oomag;
mV[VY] *= oomag;
}
else
{
mV[0] = 0.f;
mV[1] = 0.f;
mV[VX] = 0.f;
mV[VY] = 0.f;
mag = 0;
}
return (mag);
@ -259,33 +259,33 @@ inline bool LLVector2::isFinite() const
}
// deprecated
inline F32 LLVector2::magVec(void) const
inline F32 LLVector2::magVec() const
{
return (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1]);
return sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY]);
}
// deprecated
inline F32 LLVector2::magVecSquared(void) const
inline F32 LLVector2::magVecSquared() const
{
return mV[0]*mV[0] + mV[1]*mV[1];
return mV[VX]*mV[VX] + mV[VY]*mV[VY];
}
// deprecated
inline F32 LLVector2::normVec(void)
inline F32 LLVector2::normVec()
{
F32 mag = (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1]);
F32 mag = sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY]);
F32 oomag;
if (mag > FP_MAG_THRESHOLD)
{
oomag = 1.f/mag;
mV[0] *= oomag;
mV[1] *= oomag;
mV[VX] *= oomag;
mV[VY] *= oomag;
}
else
{
mV[0] = 0.f;
mV[1] = 0.f;
mV[VX] = 0.f;
mV[VY] = 0.f;
mag = 0;
}
return (mag);
@ -299,7 +299,7 @@ inline const LLVector2& LLVector2::scaleVec(const LLVector2& vec)
return *this;
}
inline bool LLVector2::isNull()
inline bool LLVector2::isNull() const
{
if (F_APPROXIMATELY_ZERO > mV[VX]*mV[VX] + mV[VY]*mV[VY])
{
@ -339,81 +339,81 @@ inline LLVector2 operator-(const LLVector2 &a, const LLVector2 &b)
inline F32 operator*(const LLVector2& a, const LLVector2& b)
{
return (a.mV[0]*b.mV[0] + a.mV[1]*b.mV[1]);
return (a.mV[VX]*b.mV[VX] + a.mV[VY]*b.mV[VY]);
}
inline LLVector2 operator%(const LLVector2& a, const LLVector2& b)
{
return LLVector2(a.mV[0]*b.mV[1] - b.mV[0]*a.mV[1], a.mV[1]*b.mV[0] - b.mV[1]*a.mV[0]);
return LLVector2(a.mV[VX]*b.mV[VY] - b.mV[VX]*a.mV[VY], a.mV[VY]*b.mV[VX] - b.mV[VY]*a.mV[VX]);
}
inline LLVector2 operator/(const LLVector2& a, F32 k)
{
F32 t = 1.f / k;
return LLVector2( a.mV[0] * t, a.mV[1] * t );
return LLVector2( a.mV[VX] * t, a.mV[VY] * t );
}
inline LLVector2 operator*(const LLVector2& a, F32 k)
{
return LLVector2( a.mV[0] * k, a.mV[1] * k );
return LLVector2( a.mV[VX] * k, a.mV[VY] * k );
}
inline LLVector2 operator*(F32 k, const LLVector2& a)
{
return LLVector2( a.mV[0] * k, a.mV[1] * k );
return LLVector2( a.mV[VX] * k, a.mV[VY] * k );
}
inline bool operator==(const LLVector2& a, const LLVector2& b)
{
return ( (a.mV[0] == b.mV[0])
&&(a.mV[1] == b.mV[1]));
return ( (a.mV[VX] == b.mV[VX])
&&(a.mV[VY] == b.mV[VY]));
}
inline bool operator!=(const LLVector2& a, const LLVector2& b)
{
return ( (a.mV[0] != b.mV[0])
||(a.mV[1] != b.mV[1]));
return ( (a.mV[VX] != b.mV[VX])
||(a.mV[VY] != b.mV[VY]));
}
inline const LLVector2& operator+=(LLVector2& a, const LLVector2& b)
{
a.mV[0] += b.mV[0];
a.mV[1] += b.mV[1];
a.mV[VX] += b.mV[VX];
a.mV[VY] += b.mV[VY];
return a;
}
inline const LLVector2& operator-=(LLVector2& a, const LLVector2& b)
{
a.mV[0] -= b.mV[0];
a.mV[1] -= b.mV[1];
a.mV[VX] -= b.mV[VX];
a.mV[VY] -= b.mV[VY];
return a;
}
inline const LLVector2& operator%=(LLVector2& a, const LLVector2& b)
{
LLVector2 ret(a.mV[0]*b.mV[1] - b.mV[0]*a.mV[1], a.mV[1]*b.mV[0] - b.mV[1]*a.mV[0]);
LLVector2 ret(a.mV[VX]*b.mV[VY] - b.mV[VX]*a.mV[VY], a.mV[VY]*b.mV[VX] - b.mV[VY]*a.mV[VX]);
a = ret;
return a;
}
inline const LLVector2& operator*=(LLVector2& a, F32 k)
{
a.mV[0] *= k;
a.mV[1] *= k;
a.mV[VX] *= k;
a.mV[VY] *= k;
return a;
}
inline const LLVector2& operator/=(LLVector2& a, F32 k)
{
F32 t = 1.f / k;
a.mV[0] *= t;
a.mV[1] *= t;
a.mV[VX] *= t;
a.mV[VY] *= t;
return a;
}
inline LLVector2 operator-(const LLVector2& a)
{
return LLVector2( -a.mV[0], -a.mV[1] );
return LLVector2( -a.mV[VX], -a.mV[VY] );
}
inline void update_min_max(LLVector2& min, LLVector2& max, const LLVector2& pos)

54
indra/llmath/v3color.cpp
View File

@ -36,16 +36,16 @@ LLColor3 LLColor3::grey (0.5f, 0.5f, 0.5f);
LLColor3::LLColor3(const LLColor4& a)
{
mV[0] = a.mV[0];
mV[1] = a.mV[1];
mV[2] = a.mV[2];
mV[VRED] = a.mV[VRED];
mV[VGREEN] = a.mV[VGREEN];
mV[VBLUE] = a.mV[VBLUE];
}
LLColor3::LLColor3(const LLVector4& a)
{
mV[0] = a.mV[0];
mV[1] = a.mV[1];
mV[2] = a.mV[2];
mV[VRED] = a.mV[VRED];
mV[VGREEN] = a.mV[VGREEN];
mV[VBLUE] = a.mV[VBLUE];
}
LLColor3::LLColor3(const LLSD& sd)
@ -55,9 +55,9 @@ LLColor3::LLColor3(const LLSD &sd)
const LLColor3& LLColor3::operator=(const LLColor4& a)
{
mV[0] = a.mV[0];
mV[1] = a.mV[1];
mV[2] = a.mV[2];
mV[VRED] = a.mV[VRED];
mV[VGREEN] = a.mV[VGREEN];
mV[VBLUE] = a.mV[VBLUE];
return (*this);
}
@ -69,11 +69,16 @@ std::ostream& operator<<(std::ostream& s, const LLColor3 &a)
static F32 hueToRgb(F32 val1In, F32 val2In, F32 valHUeIn)
{
if ( valHUeIn < 0.0f ) valHUeIn += 1.0f;
if ( valHUeIn > 1.0f ) valHUeIn -= 1.0f;
if ( ( 6.0f * valHUeIn ) < 1.0f ) return ( val1In + ( val2In - val1In ) * 6.0f * valHUeIn );
if ( ( 2.0f * valHUeIn ) < 1.0f ) return ( val2In );
if ( ( 3.0f * valHUeIn ) < 2.0f ) return ( val1In + ( val2In - val1In ) * ( ( 2.0f / 3.0f ) - valHUeIn ) * 6.0f );
if (valHUeIn < 0.0f)
valHUeIn += 1.0f;
if (valHUeIn > 1.0f)
valHUeIn -= 1.0f;
if ((6.0f * valHUeIn) < 1.0f)
return (val1In + (val2In - val1In) * 6.0f * valHUeIn);
if ((2.0f * valHUeIn) < 1.0f)
return (val2In);
if ((3.0f * valHUeIn) < 2.0f)
return (val1In + (val2In - val1In) * ((2.0f / 3.0f) - valHUeIn) * 6.0f);
return (val1In);
}
@ -136,18 +141,21 @@ void LLColor3::calcHSL(F32* hue, F32* saturation, F32* luminance) const
if (var_R >= var_Max)
H = del_B - del_G;
else
if ( var_G >= var_Max )
else if (var_G >= var_Max)
H = (1.0f / 3.0f) + del_R - del_B;
else
if ( var_B >= var_Max )
else if (var_B >= var_Max)
H = (2.0f / 3.0f) + del_G - del_R;
if ( H < 0.0f ) H += 1.0f;
if ( H > 1.0f ) H -= 1.0f;
if (H < 0.0f)
H += 1.0f;
if (H > 1.0f)
H -= 1.0f;
}
if (hue) *hue = H;
if (saturation) *saturation = S;
if (luminance) *luminance = L;
if (hue)
*hue = H;
if (saturation)
*saturation = S;
if (luminance)
*luminance = L;
}

283
indra/llmath/v3color.h
View File

@ -38,7 +38,7 @@ class LLVector4;
// LLColor3 = |r g b|
static const U32 LENGTHOFCOLOR3 = 3;
static constexpr U32 LENGTHOFCOLOR3 = 3;
class LLColor3
{
@ -58,21 +58,20 @@ public:
explicit LLColor3(const LLVector4& vector4); // "explicit" to avoid automatic conversion
LLColor3(const LLSD& sd);
LLSD getValue() const
{
LLSD ret;
ret[0] = mV[0];
ret[1] = mV[1];
ret[2] = mV[2];
ret[VRED] = mV[VRED];
ret[VGREEN] = mV[VGREEN];
ret[VBLUE] = mV[VBLUE];
return ret;
}
void setValue(const LLSD& sd)
{
mV[0] = (F32) sd[0].asReal();;
mV[1] = (F32) sd[1].asReal();;
mV[2] = (F32) sd[2].asReal();;
mV[VRED] = (F32)sd[VRED].asReal();
mV[VGREEN] = (F32)sd[VGREEN].asReal();
mV[VBLUE] = (F32)sd[VBLUE].asReal();
}
void setHSL(F32 hue, F32 saturation, F32 luminance);
@ -111,21 +110,15 @@ public:
const LLColor3& operator=(const LLColor4& a);
LL_FORCE_INLINE LLColor3 divide(const LLColor3 &col2)
LL_FORCE_INLINE LLColor3 divide(const LLColor3& col2) const
{
return LLColor3(
mV[0] / col2.mV[0],
mV[1] / col2.mV[1],
mV[2] / col2.mV[2] );
return LLColor3(mV[VRED] / col2.mV[VRED], mV[VGREEN] / col2.mV[VGREEN], mV[VBLUE] / col2.mV[VBLUE]);
}
LL_FORCE_INLINE LLColor3 color_norm()
LL_FORCE_INLINE LLColor3 color_norm() const
{
F32 l = length();
return LLColor3(
mV[0] / l,
mV[1] / l,
mV[2] / l );
return LLColor3(mV[VRED] / l, mV[VGREEN] / l, mV[VBLUE] / l);
}
friend std::ostream& operator<<(std::ostream& s, const LLColor3& a); // Print a
@ -153,33 +146,32 @@ public:
LLColor3 lerp(const LLColor3& a, const LLColor3& b, F32 u);
void LLColor3::clamp()
{
// Clamp the color...
if (mV[0] < 0.f)
if (mV[VRED] < 0.f)
{
mV[0] = 0.f;
mV[VRED] = 0.f;
}
else if (mV[0] > 1.f)
else if (mV[VRED] > 1.f)
{
mV[0] = 1.f;
mV[VRED] = 1.f;
}
if (mV[1] < 0.f)
if (mV[VGREEN] < 0.f)
{
mV[1] = 0.f;
mV[VGREEN] = 0.f;
}
else if (mV[1] > 1.f)
else if (mV[VGREEN] > 1.f)
{
mV[1] = 1.f;
mV[VGREEN] = 1.f;
}
if (mV[2] < 0.f)
if (mV[VBLUE] < 0.f)
{
mV[2] = 0.f;
mV[VBLUE] = 0.f;
}
else if (mV[2] > 1.f)
else if (mV[VBLUE] > 1.f)
{
mV[2] = 1.f;
mV[VBLUE] = 1.f;
}
}
@ -187,11 +179,11 @@ void LLColor3::clamp()
F32 distVec(const LLColor3& a, const LLColor3& b); // Returns distance between a and b
F32 distVec_squared(const LLColor3& a, const LLColor3& b); // Returns distance squared between a and b
inline LLColor3::LLColor3(void)
inline LLColor3::LLColor3()
{
mV[0] = 0.f;
mV[1] = 0.f;
mV[2] = 0.f;
mV[VRED] = 0.f;
mV[VGREEN] = 0.f;
mV[VBLUE] = 0.f;
}
inline LLColor3::LLColor3(F32 r, F32 g, F32 b)
@ -201,7 +193,6 @@ inline LLColor3::LLColor3(F32 r, F32 g, F32 b)
mV[VBLUE] = b;
}
inline LLColor3::LLColor3(const F32* vec)
{
mV[VRED] = vec[VRED];
@ -213,300 +204,284 @@ inline LLColor3::LLColor3(const char* color_string) // takes a string of format
{
if (strlen(color_string) < 6) /* Flawfinder: ignore */
{
mV[0] = 0.f;
mV[1] = 0.f;
mV[2] = 0.f;
mV[VRED] = 0.f;
mV[VGREEN] = 0.f;
mV[VBLUE] = 0.f;
return;
}
char tempstr[7];
strncpy(tempstr, color_string, 6); /* Flawfinder: ignore */
tempstr[6] = '\0';
mV[VBLUE] = (F32)strtol(&tempstr[4],NULL,16)/255.f;
mV[VBLUE] = (F32)strtol(&tempstr[4], nullptr, 16) / 255.f;
tempstr[4] = '\0';
mV[VGREEN] = (F32)strtol(&tempstr[2],NULL,16)/255.f;
mV[VGREEN] = (F32)strtol(&tempstr[2], nullptr, 16) / 255.f;
tempstr[2] = '\0';
mV[VRED] = (F32)strtol(&tempstr[0],NULL,16)/255.f;
mV[VRED] = (F32)strtol(&tempstr[0], nullptr, 16) / 255.f;
}
inline const LLColor3& LLColor3::setToBlack(void)
inline const LLColor3& LLColor3::setToBlack()
{
mV[0] = 0.f;
mV[1] = 0.f;
mV[2] = 0.f;
mV[VRED] = 0.f;
mV[VGREEN] = 0.f;
mV[VBLUE] = 0.f;
return (*this);
}
inline const LLColor3& LLColor3::setToWhite(void)
inline const LLColor3& LLColor3::setToWhite()
{
mV[0] = 1.f;
mV[1] = 1.f;
mV[2] = 1.f;
mV[VRED] = 1.f;
mV[VGREEN] = 1.f;
mV[VBLUE] = 1.f;
return (*this);
}
inline const LLColor3& LLColor3::set(F32 r, F32 g, F32 b)
{
mV[0] = r;
mV[1] = g;
mV[2] = b;
mV[VRED] = r;
mV[VGREEN] = g;
mV[VBLUE] = b;
return (*this);
}
inline const LLColor3& LLColor3::set(const LLColor3& vec)
{
mV[0] = vec.mV[0];
mV[1] = vec.mV[1];
mV[2] = vec.mV[2];
mV[VRED] = vec.mV[VRED];
mV[VGREEN] = vec.mV[VGREEN];
mV[VBLUE] = vec.mV[VBLUE];
return (*this);
}
inline const LLColor3& LLColor3::set(const F32* vec)
{
mV[0] = vec[0];
mV[1] = vec[1];
mV[2] = vec[2];
mV[VRED] = vec[VRED];
mV[VGREEN] = vec[VGREEN];
mV[VBLUE] = vec[VBLUE];
return (*this);
}
// deprecated
inline const LLColor3& LLColor3::setVec(F32 r, F32 g, F32 b)
{
mV[0] = r;
mV[1] = g;
mV[2] = b;
mV[VRED] = r;
mV[VGREEN] = g;
mV[VBLUE] = b;
return (*this);
}
// deprecated
inline const LLColor3& LLColor3::setVec(const LLColor3& vec)
{
mV[0] = vec.mV[0];
mV[1] = vec.mV[1];
mV[2] = vec.mV[2];
mV[VRED] = vec.mV[VRED];
mV[VGREEN] = vec.mV[VGREEN];
mV[VBLUE] = vec.mV[VBLUE];
return (*this);
}
// deprecated
inline const LLColor3& LLColor3::setVec(const F32* vec)
{
mV[0] = vec[0];
mV[1] = vec[1];
mV[2] = vec[2];
mV[VRED] = vec[VRED];
mV[VGREEN] = vec[VGREEN];
mV[VBLUE] = vec[VBLUE];
return (*this);
}
inline F32 LLColor3::brightness(void) const
inline F32 LLColor3::brightness() const
{
return (mV[0] + mV[1] + mV[2]) / 3.0f;
return (mV[VRED] + mV[VGREEN] + mV[VBLUE]) / 3.0f;
}
inline F32 LLColor3::length(void) const
inline F32 LLColor3::length() const
{
return (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
return sqrt(mV[VRED] * mV[VRED] + mV[VGREEN] * mV[VGREEN] + mV[VBLUE] * mV[VBLUE]);
}
inline F32 LLColor3::lengthSquared(void) const
inline F32 LLColor3::lengthSquared() const
{
return mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2];
return mV[VRED] * mV[VRED] + mV[VGREEN] * mV[VGREEN] + mV[VBLUE] * mV[VBLUE];
}
inline F32 LLColor3::normalize(void)
inline F32 LLColor3::normalize()
{
F32 mag = (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
F32 mag = sqrt(mV[VRED] * mV[VRED] + mV[VGREEN] * mV[VGREEN] + mV[VBLUE] * mV[VBLUE]);
F32 oomag;
if (mag)
{
oomag = 1.f / mag;
mV[0] *= oomag;
mV[1] *= oomag;
mV[2] *= oomag;
mV[VRED] *= oomag;
mV[VGREEN] *= oomag;
mV[VBLUE] *= oomag;
}
return (mag);
return mag;
}
// deprecated
inline F32 LLColor3::magVec(void) const
inline F32 LLColor3::magVec() const
{
return (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
return sqrt(mV[VRED] * mV[VRED] + mV[VGREEN] * mV[VGREEN] + mV[VBLUE] * mV[VBLUE]);
}
// deprecated
inline F32 LLColor3::magVecSquared(void) const
inline F32 LLColor3::magVecSquared() const
{
return mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2];
return mV[VRED] * mV[VRED] + mV[VGREEN] * mV[VGREEN] + mV[VBLUE] * mV[VBLUE];
}
// deprecated
inline F32 LLColor3::normVec(void)
inline F32 LLColor3::normVec()
{
F32 mag = (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
F32 mag = sqrt(mV[VRED] * mV[VRED] + mV[VGREEN] * mV[VGREEN] + mV[VBLUE] * mV[VBLUE]);
F32 oomag;
if (mag)
{
oomag = 1.f / mag;
mV[0] *= oomag;
mV[1] *= oomag;
mV[2] *= oomag;
mV[VRED] *= oomag;
mV[VGREEN] *= oomag;
mV[VBLUE] *= oomag;
}
return (mag);
return mag;
}
inline void LLColor3::exp()
{
#if 0
mV[0] = ::exp(mV[0]);
mV[1] = ::exp(mV[1]);
mV[2] = ::exp(mV[2]);
mV[VRED] = ::exp(mV[VRED]);
mV[VGREEN] = ::exp(mV[VGREEN]);
mV[VBLUE] = ::exp(mV[VBLUE]);
#else
mV[0] = (F32)LL_FAST_EXP(mV[0]);
mV[1] = (F32)LL_FAST_EXP(mV[1]);
mV[2] = (F32)LL_FAST_EXP(mV[2]);
mV[VRED] = (F32)LL_FAST_EXP(mV[VRED]);
mV[VGREEN] = (F32)LL_FAST_EXP(mV[VGREEN]);
mV[VBLUE] = (F32)LL_FAST_EXP(mV[VBLUE]);
#endif
}
inline LLColor3 operator+(const LLColor3& a, const LLColor3& b)
{
return LLColor3(
a.mV[0] + b.mV[0],
a.mV[1] + b.mV[1],
a.mV[2] + b.mV[2]);
return LLColor3(a.mV[VRED] + b.mV[VRED], a.mV[VGREEN] + b.mV[VGREEN], a.mV[VBLUE] + b.mV[VBLUE]);
}
inline LLColor3 operator-(const LLColor3& a, const LLColor3& b)
{
return LLColor3(
a.mV[0] - b.mV[0],
a.mV[1] - b.mV[1],
a.mV[2] - b.mV[2]);
return LLColor3(a.mV[VRED] - b.mV[VRED], a.mV[VGREEN] - b.mV[VGREEN], a.mV[VBLUE] - b.mV[VBLUE]);
}
inline LLColor3 operator*(const LLColor3& a, const LLColor3& b)
{
return LLColor3(
a.mV[0] * b.mV[0],
a.mV[1] * b.mV[1],
a.mV[2] * b.mV[2]);
return LLColor3(a.mV[VRED] * b.mV[VRED], a.mV[VGREEN] * b.mV[VGREEN], a.mV[VBLUE] * b.mV[VBLUE]);
}
inline LLColor3 operator*(const LLColor3& a, F32 k)
{
return LLColor3( a.mV[0] * k, a.mV[1] * k, a.mV[2] * k );
return LLColor3(a.mV[VRED] * k, a.mV[VGREEN] * k, a.mV[VBLUE] * k);
}
inline LLColor3 operator*(F32 k, const LLColor3& a)
{
return LLColor3( a.mV[0] * k, a.mV[1] * k, a.mV[2] * k );
return LLColor3(a.mV[VRED] * k, a.mV[VGREEN] * k, a.mV[VBLUE] * k);
}
inline bool operator==(const LLColor3& a, const LLColor3& b)
{
return ( (a.mV[0] == b.mV[0])
&&(a.mV[1] == b.mV[1])
&&(a.mV[2] == b.mV[2]));
return ((a.mV[VRED] == b.mV[VRED]) && (a.mV[VGREEN] == b.mV[VGREEN]) && (a.mV[VBLUE] == b.mV[VBLUE]));
}
inline bool operator!=(const LLColor3& a, const LLColor3& b)
{
return ( (a.mV[0] != b.mV[0])
||(a.mV[1] != b.mV[1])
||(a.mV[2] != b.mV[2]));
return ((a.mV[VRED] != b.mV[VRED]) || (a.mV[VGREEN] != b.mV[VGREEN]) || (a.mV[VBLUE] != b.mV[VBLUE]));
}
inline const LLColor3& operator*=(LLColor3& a, const LLColor3& b)
{
a.mV[0] *= b.mV[0];
a.mV[1] *= b.mV[1];
a.mV[2] *= b.mV[2];
a.mV[VRED] *= b.mV[VRED];
a.mV[VGREEN] *= b.mV[VGREEN];
a.mV[VBLUE] *= b.mV[VBLUE];
return a;
}
inline const LLColor3& operator+=(LLColor3& a, const LLColor3& b)
{
a.mV[0] += b.mV[0];
a.mV[1] += b.mV[1];
a.mV[2] += b.mV[2];
a.mV[VRED] += b.mV[VRED];
a.mV[VGREEN] += b.mV[VGREEN];
a.mV[VBLUE] += b.mV[VBLUE];
return a;
}
inline const LLColor3& operator-=(LLColor3& a, const LLColor3& b)
{
a.mV[0] -= b.mV[0];
a.mV[1] -= b.mV[1];
a.mV[2] -= b.mV[2];
a.mV[VRED] -= b.mV[VRED];
a.mV[VGREEN] -= b.mV[VGREEN];
a.mV[VBLUE] -= b.mV[VBLUE];
return a;
}
inline const LLColor3& operator*=(LLColor3& a, F32 k)
{
a.mV[0] *= k;
a.mV[1] *= k;
a.mV[2] *= k;
a.mV[VRED] *= k;
a.mV[VGREEN] *= k;
a.mV[VBLUE] *= k;
return a;
}
inline LLColor3 operator-(const LLColor3& a)
{
return LLColor3(
1.f - a.mV[0],
1.f - a.mV[1],
1.f - a.mV[2] );
return LLColor3(1.f - a.mV[VRED], 1.f - a.mV[VGREEN], 1.f - a.mV[VBLUE]);
}
// Non-member functions
inline F32 distVec(const LLColor3& a, const LLColor3& b)
{
F32 x = a.mV[0] - b.mV[0];
F32 y = a.mV[1] - b.mV[1];
F32 z = a.mV[2] - b.mV[2];
return (F32) sqrt( x*x + y*y + z*z );
F32 x = a.mV[VRED] - b.mV[VRED];
F32 y = a.mV[VGREEN] - b.mV[VGREEN];
F32 z = a.mV[VBLUE] - b.mV[VBLUE];
return sqrt(x * x + y * y + z * z);
}
inline F32 distVec_squared(const LLColor3& a, const LLColor3& b)
{
F32 x = a.mV[0] - b.mV[0];
F32 y = a.mV[1] - b.mV[1];
F32 z = a.mV[2] - b.mV[2];
F32 x = a.mV[VRED] - b.mV[VRED];
F32 y = a.mV[VGREEN] - b.mV[VGREEN];
F32 z = a.mV[VBLUE] - b.mV[VBLUE];
return x * x + y * y + z * z;
}
inline LLColor3 lerp(const LLColor3& a, const LLColor3& b, F32 u)
{
return LLColor3(
a.mV[VX] + (b.mV[VX] - a.mV[VX]) * u,
a.mV[VY] + (b.mV[VY] - a.mV[VY]) * u,
a.mV[VZ] + (b.mV[VZ] - a.mV[VZ]) * u);
return LLColor3(a.mV[VX] + (b.mV[VX] - a.mV[VX]) * u, a.mV[VY] + (b.mV[VY] - a.mV[VY]) * u, a.mV[VZ] + (b.mV[VZ] - a.mV[VZ]) * u);
}
inline const LLColor3 srgbColor3(const LLColor3 &a) {
inline const LLColor3 srgbColor3(const LLColor3& a)
{
LLColor3 srgbColor;
srgbColor.mV[0] = linearTosRGB(a.mV[0]);
srgbColor.mV[1] = linearTosRGB(a.mV[1]);
srgbColor.mV[2] = linearTosRGB(a.mV[2]);
srgbColor.mV[VRED] = linearTosRGB(a.mV[VRED]);
srgbColor.mV[VGREEN] = linearTosRGB(a.mV[VGREEN]);
srgbColor.mV[VBLUE] = linearTosRGB(a.mV[VBLUE]);
return srgbColor;
}
inline const LLColor3 linearColor3p(const F32* v) {
inline const LLColor3 linearColor3p(const F32* v)
{
LLColor3 linearColor;
linearColor.mV[0] = sRGBtoLinear(v[0]);
linearColor.mV[1] = sRGBtoLinear(v[1]);
linearColor.mV[2] = sRGBtoLinear(v[2]);
linearColor.mV[VRED] = sRGBtoLinear(v[VRED]);
linearColor.mV[VGREEN] = sRGBtoLinear(v[VGREEN]);
linearColor.mV[VBLUE] = sRGBtoLinear(v[VBLUE]);
return linearColor;
}
template<class T>
inline const LLColor3 linearColor3(const T& a) {
inline const LLColor3 linearColor3(const T& a)
{
return linearColor3p(a.mV);
}
template<class T>
inline const LLVector3 linearColor3v(const T& a) {
inline const LLVector3 linearColor3v(const T& a)
{
return LLVector3(linearColor3p(a.mV).mV);
}

60
indra/llmath/v3colorutil.h
View File

@ -30,59 +30,46 @@
#include "v3color.h"
#include "v4color.h"
inline LLColor3 componentDiv(LLColor3 const &left, LLColor3 const & right)
inline LLColor3 componentDiv(const LLColor3& left, const LLColor3& right)
{
return LLColor3(left.mV[0] / right.mV[0],
left.mV[1] / right.mV[1],
left.mV[2] / right.mV[2]);
return LLColor3(left.mV[VRED] / right.mV[VRED], left.mV[VGREEN] / right.mV[VGREEN], left.mV[VBLUE] / right.mV[VBLUE]);
}
inline LLColor3 componentMult(LLColor3 const &left, LLColor3 const & right)
inline LLColor3 componentMult(const LLColor3& left, const LLColor3& right)
{
return LLColor3(left.mV[0] * right.mV[0],
left.mV[1] * right.mV[1],
left.mV[2] * right.mV[2]);
return LLColor3(left.mV[VRED] * right.mV[VRED], left.mV[VGREEN] * right.mV[VGREEN], left.mV[VBLUE] * right.mV[VBLUE]);
}
inline LLColor3 componentExp(LLColor3 const &v)
inline LLColor3 componentExp(const LLColor3& v)
{
return LLColor3(exp(v.mV[0]),
exp(v.mV[1]),
exp(v.mV[2]));
return LLColor3(exp(v.mV[VRED]), exp(v.mV[VGREEN]), exp(v.mV[VBLUE]));
}
inline LLColor3 componentPow(LLColor3 const &v, F32 exponent)
inline LLColor3 componentPow(const LLColor3& v, F32 exponent)
{
return LLColor3(pow(v.mV[0], exponent),
pow(v.mV[1], exponent),
pow(v.mV[2], exponent));
return LLColor3(pow(v.mV[VRED], exponent), pow(v.mV[VGREEN], exponent), pow(v.mV[VBLUE], exponent));
}
inline LLColor3 componentSaturate(LLColor3 const &v)
inline LLColor3 componentSaturate(const LLColor3& v)
{
return LLColor3(std::max(std::min(v.mV[0], 1.f), 0.f),
std::max(std::min(v.mV[1], 1.f), 0.f),
std::max(std::min(v.mV[2], 1.f), 0.f));
return LLColor3(std::max(std::min(v.mV[VRED], 1.f), 0.f),
std::max(std::min(v.mV[VGREEN], 1.f), 0.f),
std::max(std::min(v.mV[VBLUE], 1.f), 0.f));
}
inline LLColor3 componentSqrt(LLColor3 const &v)
inline LLColor3 componentSqrt(const LLColor3& v)
{
return LLColor3(sqrt(v.mV[0]),
sqrt(v.mV[1]),
sqrt(v.mV[2]));
return LLColor3(sqrt(v.mV[VRED]), sqrt(v.mV[VGREEN]), sqrt(v.mV[VBLUE]));
}
inline void componentMultBy(LLColor3 & left, LLColor3 const & right)
inline void componentMultBy(LLColor3& left, const LLColor3& right)
{
left.mV[0] *= right.mV[0];
left.mV[1] *= right.mV[1];
left.mV[2] *= right.mV[2];
left.mV[VRED] *= right.mV[VRED];
left.mV[VGREEN] *= right.mV[VGREEN];
left.mV[VBLUE] *= right.mV[VBLUE];
}
inline LLColor3 colorMix(LLColor3 const & left, LLColor3 const & right, F32 amount)
inline LLColor3 colorMix(const LLColor3& left, const LLColor3& right, F32 amount)
{
return (left + ((right - left) * amount));
}
@ -94,23 +81,22 @@ inline LLColor3 smear(F32 val)
inline F32 color_intens(const LLColor3& col)
{
return col.mV[0] + col.mV[1] + col.mV[2];
return col.mV[VRED] + col.mV[VGREEN] + col.mV[VBLUE];
}
inline F32 color_max(const LLColor3& col)
{
return llmax(col.mV[0], col.mV[1], col.mV[2]);
return llmax(col.mV[VRED], col.mV[VGREEN], col.mV[VBLUE]);
}
inline F32 color_max(const LLColor4& col)
{
return llmax(col.mV[0], col.mV[1], col.mV[2]);
return llmax(col.mV[VRED], col.mV[VGREEN], col.mV[VBLUE]);
}
inline F32 color_min(const LLColor3& col)
{
return llmin(col.mV[0], col.mV[1], col.mV[2]);
return llmin(col.mV[VRED], col.mV[VGREEN], col.mV[VBLUE]);
}
#endif

27
indra/llmath/v3dmath.cpp
View File

@ -30,7 +30,6 @@
#include "v3dmath.h"
//#include "vmath.h"
#include "v4math.h"
#include "m4math.h"
#include "m3math.h"
@ -57,13 +56,13 @@ bool LLVector3d::clamp(F64 min, F64 max)
{
bool ret{ false };
if (mdV[0] < min) { mdV[0] = min; ret = true; }
if (mdV[1] < min) { mdV[1] = min; ret = true; }
if (mdV[2] < min) { mdV[2] = min; ret = true; }
if (mdV[VX] < min) { mdV[VX] = min; ret = true; }
if (mdV[VY] < min) { mdV[VY] = min; ret = true; }
if (mdV[VZ] < min) { mdV[VZ] = min; ret = true; }
if (mdV[0] > max) { mdV[0] = max; ret = true; }
if (mdV[1] > max) { mdV[1] = max; ret = true; }
if (mdV[2] > max) { mdV[2] = max; ret = true; }
if (mdV[VX] > max) { mdV[VX] = max; ret = true; }
if (mdV[VY] > max) { mdV[VY] = max; ret = true; }
if (mdV[VZ] > max) { mdV[VZ] = max; ret = true; }
return ret;
}
@ -74,9 +73,9 @@ bool LLVector3d::abs()
{
bool ret{ false };
if (mdV[0] < 0.0) { mdV[0] = -mdV[0]; ret = true; }
if (mdV[1] < 0.0) { mdV[1] = -mdV[1]; ret = true; }
if (mdV[2] < 0.0) { mdV[2] = -mdV[2]; ret = true; }
if (mdV[VX] < 0.0) { mdV[VX] = -mdV[VX]; ret = true; }
if (mdV[VY] < 0.0) { mdV[VY] = -mdV[VY]; ret = true; }
if (mdV[VZ] < 0.0) { mdV[VZ] = -mdV[VZ]; ret = true; }
return ret;
}
@ -89,9 +88,9 @@ std::ostream& operator<<(std::ostream& s, const LLVector3d &a)
const LLVector3d& LLVector3d::operator=(const LLVector4 &a)
{
mdV[0] = a.mV[0];
mdV[1] = a.mV[1];
mdV[2] = a.mV[2];
mdV[VX] = a.mV[VX];
mdV[VY] = a.mV[VY];
mdV[VZ] = a.mV[VZ];
return *this;
}
@ -135,7 +134,7 @@ bool LLVector3d::parseVector3d(const std::string& buf, LLVector3d* value)
}
LLVector3d v;
S32 count = sscanf( buf.c_str(), "%lf %lf %lf", v.mdV + 0, v.mdV + 1, v.mdV + 2 );
S32 count = sscanf(buf.c_str(), "%lf %lf %lf", v.mdV + VX, v.mdV + VY, v.mdV + VZ);
if (3 == count)
{
value->setVec(v);

193
indra/llmath/v3dmath.h
View File

@ -54,17 +54,17 @@ class LLVector3d
void setValue(const LLSD& sd)
{
mdV[0] = sd[0].asReal();
mdV[1] = sd[1].asReal();
mdV[2] = sd[2].asReal();
mdV[VX] = sd[0].asReal();
mdV[VY] = sd[1].asReal();
mdV[VZ] = sd[2].asReal();
}
LLSD getValue() const
{
LLSD ret;
ret[0] = mdV[0];
ret[1] = mdV[1];
ret[2] = mdV[2];
ret[0] = mdV[VX];
ret[1] = mdV[VY];
ret[2] = mdV[VZ];
return ret;
}
@ -127,33 +127,32 @@ class LLVector3d
friend std::ostream& operator<<(std::ostream& s, const LLVector3d& a); // Stream a
static bool parseVector3d(const std::string& buf, LLVector3d* value);
};
typedef LLVector3d LLGlobalVec;
inline const LLVector3d &LLVector3d::set(const LLVector3 &vec)
{
mdV[0] = vec.mV[0];
mdV[1] = vec.mV[1];
mdV[2] = vec.mV[2];
mdV[VX] = vec.mV[VX];
mdV[VY] = vec.mV[VY];
mdV[VZ] = vec.mV[VZ];
return *this;
}
inline const LLVector3d &LLVector3d::setVec(const LLVector3 &vec)
{
mdV[0] = vec.mV[0];
mdV[1] = vec.mV[1];
mdV[2] = vec.mV[2];
mdV[VX] = vec.mV[VX];
mdV[VY] = vec.mV[VY];
mdV[VZ] = vec.mV[VZ];
return *this;
}
inline LLVector3d::LLVector3d(void)
{
mdV[0] = 0.f;
mdV[1] = 0.f;
mdV[2] = 0.f;
mdV[VX] = 0.f;
mdV[VY] = 0.f;
mdV[VZ] = 0.f;
}
inline LLVector3d::LLVector3d(const F64 x, const F64 y, const F64 z)
@ -199,33 +198,33 @@ inline bool LLVector3d::isFinite() const
inline const LLVector3d& LLVector3d::clear(void)
{
mdV[0] = 0.f;
mdV[1] = 0.f;
mdV[2]= 0.f;
mdV[VX] = 0.f;
mdV[VY] = 0.f;
mdV[VZ] = 0.f;
return (*this);
}
inline const LLVector3d& LLVector3d::clearVec(void)
{
mdV[0] = 0.f;
mdV[1] = 0.f;
mdV[2]= 0.f;
mdV[VX] = 0.f;
mdV[VY] = 0.f;
mdV[VZ] = 0.f;
return (*this);
}
inline const LLVector3d& LLVector3d::setZero(void)
{
mdV[0] = 0.f;
mdV[1] = 0.f;
mdV[2] = 0.f;
mdV[VX] = 0.f;
mdV[VY] = 0.f;
mdV[VZ] = 0.f;
return (*this);
}
inline const LLVector3d& LLVector3d::zeroVec(void)
{
mdV[0] = 0.f;
mdV[1] = 0.f;
mdV[2] = 0.f;
mdV[VX] = 0.f;
mdV[VY] = 0.f;
mdV[VZ] = 0.f;
return (*this);
}
@ -239,17 +238,17 @@ inline const LLVector3d& LLVector3d::set(const F64 x, const F64 y, const F64
inline const LLVector3d& LLVector3d::set(const LLVector3d &vec)
{
mdV[0] = vec.mdV[0];
mdV[1] = vec.mdV[1];
mdV[2] = vec.mdV[2];
mdV[VX] = vec.mdV[VX];
mdV[VY] = vec.mdV[VY];
mdV[VZ] = vec.mdV[VZ];
return (*this);
}
inline const LLVector3d& LLVector3d::set(const F64 *vec)
{
mdV[0] = vec[0];
mdV[1] = vec[1];
mdV[2] = vec[2];
mdV[VX] = vec[0];
mdV[VY] = vec[1];
mdV[VZ] = vec[2];
return (*this);
}
@ -263,59 +262,59 @@ inline const LLVector3d& LLVector3d::setVec(const F64 x, const F64 y, const F
inline const LLVector3d& LLVector3d::setVec(const LLVector3d& vec)
{
mdV[0] = vec.mdV[0];
mdV[1] = vec.mdV[1];
mdV[2] = vec.mdV[2];
mdV[VX] = vec.mdV[VX];
mdV[VY] = vec.mdV[VY];
mdV[VZ] = vec.mdV[VZ];
return (*this);
}
inline const LLVector3d& LLVector3d::setVec(const F64* vec)
{
mdV[0] = vec[0];
mdV[1] = vec[1];
mdV[2] = vec[2];
mdV[VX] = vec[VX];
mdV[VY] = vec[VY];
mdV[VZ] = vec[VZ];
return (*this);
}
inline F64 LLVector3d::normVec(void)
inline F64 LLVector3d::normVec()
{
F64 mag = (F32) sqrt(mdV[0]*mdV[0] + mdV[1]*mdV[1] + mdV[2]*mdV[2]);
F64 mag = sqrt(mdV[VX]*mdV[VX] + mdV[VY]*mdV[VY] + mdV[VZ]*mdV[VZ]);
F64 oomag;
if (mag > FP_MAG_THRESHOLD)
{
oomag = 1.f/mag;
mdV[0] *= oomag;
mdV[1] *= oomag;
mdV[2] *= oomag;
mdV[VX] *= oomag;
mdV[VY] *= oomag;
mdV[VZ] *= oomag;
}
else
{
mdV[0] = 0.f;
mdV[1] = 0.f;
mdV[2] = 0.f;
mdV[VX] = 0.f;
mdV[VY] = 0.f;
mdV[VZ] = 0.f;
mag = 0;
}
return (mag);
}
inline F64 LLVector3d::normalize(void)
inline F64 LLVector3d::normalize()
{
F64 mag = (F32) sqrt(mdV[0]*mdV[0] + mdV[1]*mdV[1] + mdV[2]*mdV[2]);
F64 mag = sqrt(mdV[VX]*mdV[VX] + mdV[VY]*mdV[VY] + mdV[VZ]*mdV[VZ]);
F64 oomag;
if (mag > FP_MAG_THRESHOLD)
{
oomag = 1.f/mag;
mdV[0] *= oomag;
mdV[1] *= oomag;
mdV[2] *= oomag;
mdV[VX] *= oomag;
mdV[VY] *= oomag;
mdV[VZ] *= oomag;
}
else
{
mdV[0] = 0.f;
mdV[1] = 0.f;
mdV[2] = 0.f;
mdV[VX] = 0.f;
mdV[VY] = 0.f;
mdV[VZ] = 0.f;
mag = 0;
}
return (mag);
@ -323,24 +322,24 @@ inline F64 LLVector3d::normalize(void)
// LLVector3d Magnitude and Normalization Functions
inline F64 LLVector3d::magVec(void) const
inline F64 LLVector3d::magVec() const
{
return (F32) sqrt(mdV[0]*mdV[0] + mdV[1]*mdV[1] + mdV[2]*mdV[2]);
return sqrt(mdV[VX]*mdV[VX] + mdV[VY]*mdV[VY] + mdV[VZ]*mdV[VZ]);
}
inline F64 LLVector3d::magVecSquared(void) const
inline F64 LLVector3d::magVecSquared() const
{
return mdV[0]*mdV[0] + mdV[1]*mdV[1] + mdV[2]*mdV[2];
return mdV[VX]*mdV[VX] + mdV[VY]*mdV[VY] + mdV[VZ]*mdV[VZ];
}
inline F64 LLVector3d::length(void) const
inline F64 LLVector3d::length() const
{
return (F32) sqrt(mdV[0]*mdV[0] + mdV[1]*mdV[1] + mdV[2]*mdV[2]);
return sqrt(mdV[VX]*mdV[VX] + mdV[VY]*mdV[VY] + mdV[VZ]*mdV[VZ]);
}
inline F64 LLVector3d::lengthSquared(void) const
inline F64 LLVector3d::lengthSquared() const
{
return mdV[0]*mdV[0] + mdV[1]*mdV[1] + mdV[2]*mdV[2];
return mdV[VX]*mdV[VX] + mdV[VY]*mdV[VY] + mdV[VZ]*mdV[VZ];
}
inline LLVector3d operator+(const LLVector3d& a, const LLVector3d& b)
@ -357,109 +356,109 @@ inline LLVector3d operator-(const LLVector3d& a, const LLVector3d& b)
inline F64 operator*(const LLVector3d& a, const LLVector3d& b)
{
return (a.mdV[0]*b.mdV[0] + a.mdV[1]*b.mdV[1] + a.mdV[2]*b.mdV[2]);
return (a.mdV[VX]*b.mdV[VX] + a.mdV[VY]*b.mdV[VY] + a.mdV[VZ]*b.mdV[VZ]);
}
inline LLVector3d operator%(const LLVector3d& a, const LLVector3d& b)
{
return LLVector3d( a.mdV[1]*b.mdV[2] - b.mdV[1]*a.mdV[2], a.mdV[2]*b.mdV[0] - b.mdV[2]*a.mdV[0], a.mdV[0]*b.mdV[1] - b.mdV[0]*a.mdV[1] );
return LLVector3d( a.mdV[VY]*b.mdV[VZ] - b.mdV[VY]*a.mdV[VZ], a.mdV[VZ]*b.mdV[VX] - b.mdV[VZ]*a.mdV[VX], a.mdV[VX]*b.mdV[VY] - b.mdV[VX]*a.mdV[VY] );
}
inline LLVector3d operator/(const LLVector3d& a, const F64 k)
{
F64 t = 1.f / k;
return LLVector3d( a.mdV[0] * t, a.mdV[1] * t, a.mdV[2] * t );
return LLVector3d( a.mdV[VX] * t, a.mdV[VY] * t, a.mdV[VZ] * t );
}
inline LLVector3d operator*(const LLVector3d& a, const F64 k)
{
return LLVector3d( a.mdV[0] * k, a.mdV[1] * k, a.mdV[2] * k );
return LLVector3d( a.mdV[VX] * k, a.mdV[VY] * k, a.mdV[VZ] * k );
}
inline LLVector3d operator*(F64 k, const LLVector3d& a)
{
return LLVector3d( a.mdV[0] * k, a.mdV[1] * k, a.mdV[2] * k );
return LLVector3d( a.mdV[VX] * k, a.mdV[VY] * k, a.mdV[VZ] * k );
}
inline bool operator==(const LLVector3d& a, const LLVector3d& b)
{
return ( (a.mdV[0] == b.mdV[0])
&&(a.mdV[1] == b.mdV[1])
&&(a.mdV[2] == b.mdV[2]));
return ( (a.mdV[VX] == b.mdV[VX])
&&(a.mdV[VY] == b.mdV[VY])
&&(a.mdV[VZ] == b.mdV[VZ]));
}
inline bool operator!=(const LLVector3d& a, const LLVector3d& b)
{
return ( (a.mdV[0] != b.mdV[0])
||(a.mdV[1] != b.mdV[1])
||(a.mdV[2] != b.mdV[2]));
return ( (a.mdV[VX] != b.mdV[VX])
||(a.mdV[VY] != b.mdV[VY])
||(a.mdV[VZ] != b.mdV[VZ]));
}
inline const LLVector3d& operator+=(LLVector3d& a, const LLVector3d& b)
{
a.mdV[0] += b.mdV[0];
a.mdV[1] += b.mdV[1];
a.mdV[2] += b.mdV[2];
a.mdV[VX] += b.mdV[VX];
a.mdV[VY] += b.mdV[VY];
a.mdV[VZ] += b.mdV[VZ];
return a;
}
inline const LLVector3d& operator-=(LLVector3d& a, const LLVector3d& b)
{
a.mdV[0] -= b.mdV[0];
a.mdV[1] -= b.mdV[1];
a.mdV[2] -= b.mdV[2];
a.mdV[VX] -= b.mdV[VX];
a.mdV[VY] -= b.mdV[VY];
a.mdV[VZ] -= b.mdV[VZ];
return a;
}
inline const LLVector3d& operator%=(LLVector3d& a, const LLVector3d& b)
{
LLVector3d ret( a.mdV[1]*b.mdV[2] - b.mdV[1]*a.mdV[2], a.mdV[2]*b.mdV[0] - b.mdV[2]*a.mdV[0], a.mdV[0]*b.mdV[1] - b.mdV[0]*a.mdV[1]);
LLVector3d ret( a.mdV[VY]*b.mdV[VZ] - b.mdV[VY]*a.mdV[VZ], a.mdV[VZ]*b.mdV[VX] - b.mdV[VZ]*a.mdV[VX], a.mdV[VX]*b.mdV[VY] - b.mdV[VX]*a.mdV[VY]);
a = ret;
return a;
}
inline const LLVector3d& operator*=(LLVector3d& a, const F64 k)
{
a.mdV[0] *= k;
a.mdV[1] *= k;
a.mdV[2] *= k;
a.mdV[VX] *= k;
a.mdV[VY] *= k;
a.mdV[VZ] *= k;
return a;
}
inline const LLVector3d& operator/=(LLVector3d& a, const F64 k)
{
F64 t = 1.f / k;
a.mdV[0] *= t;
a.mdV[1] *= t;
a.mdV[2] *= t;
a.mdV[VX] *= t;
a.mdV[VY] *= t;
a.mdV[VZ] *= t;
return a;
}
inline LLVector3d operator-(const LLVector3d& a)
{
return LLVector3d( -a.mdV[0], -a.mdV[1], -a.mdV[2] );
return LLVector3d( -a.mdV[VX], -a.mdV[VY], -a.mdV[VZ] );
}
inline F64 dist_vec(const LLVector3d& a, const LLVector3d& b)
{
F64 x = a.mdV[0] - b.mdV[0];
F64 y = a.mdV[1] - b.mdV[1];
F64 z = a.mdV[2] - b.mdV[2];
F64 x = a.mdV[VX] - b.mdV[VX];
F64 y = a.mdV[VY] - b.mdV[VY];
F64 z = a.mdV[VZ] - b.mdV[VZ];
return (F32) sqrt( x*x + y*y + z*z );
}
inline F64 dist_vec_squared(const LLVector3d& a, const LLVector3d& b)
{
F64 x = a.mdV[0] - b.mdV[0];
F64 y = a.mdV[1] - b.mdV[1];
F64 z = a.mdV[2] - b.mdV[2];
F64 x = a.mdV[VX] - b.mdV[VX];
F64 y = a.mdV[VY] - b.mdV[VY];
F64 z = a.mdV[VZ] - b.mdV[VZ];
return x*x + y*y + z*z;
}
inline F64 dist_vec_squared2D(const LLVector3d& a, const LLVector3d& b)
{
F64 x = a.mdV[0] - b.mdV[0];
F64 y = a.mdV[1] - b.mdV[1];
F64 x = a.mdV[VX] - b.mdV[VX];
F64 y = a.mdV[VY] - b.mdV[VY];
return x*x + y*y;
}

91
indra/llmath/v3math.cpp
View File

@ -28,7 +28,6 @@
#include "v3math.h"
//#include "vmath.h"
#include "v2math.h"
#include "v4math.h"
#include "m4math.h"
@ -58,13 +57,13 @@ bool LLVector3::clamp(F32 min, F32 max)
{
bool ret{ false };
if (mV[0] < min) { mV[0] = min; ret = true; }
if (mV[1] < min) { mV[1] = min; ret = true; }
if (mV[2] < min) { mV[2] = min; ret = true; }
if (mV[VX] < min) { mV[VX] = min; ret = true; }
if (mV[VY] < min) { mV[VY] = min; ret = true; }
if (mV[VZ] < min) { mV[VZ] = min; ret = true; }
if (mV[0] > max) { mV[0] = max; ret = true; }
if (mV[1] > max) { mV[1] = max; ret = true; }
if (mV[2] > max) { mV[2] = max; ret = true; }
if (mV[VX] > max) { mV[VX] = max; ret = true; }
if (mV[VY] > max) { mV[VY] = max; ret = true; }
if (mV[VZ] > max) { mV[VZ] = max; ret = true; }
return ret;
}
@ -85,9 +84,9 @@ bool LLVector3::clampLength( F32 length_limit )
{
length_limit = 0.f;
}
mV[0] *= length_limit;
mV[1] *= length_limit;
mV[2] *= length_limit;
mV[VX] *= length_limit;
mV[VY] *= length_limit;
mV[VZ] *= length_limit;
changed = true;
}
}
@ -116,18 +115,18 @@ bool LLVector3::clampLength( F32 length_limit )
{
// yes it can be salvaged -->
// bring the components down before we normalize
mV[0] /= max_abs_component;
mV[1] /= max_abs_component;
mV[2] /= max_abs_component;
mV[VX] /= max_abs_component;
mV[VY] /= max_abs_component;
mV[VZ] /= max_abs_component;
normalize();
if (length_limit < 0.f)
{
length_limit = 0.f;
}
mV[0] *= length_limit;
mV[1] *= length_limit;
mV[2] *= length_limit;
mV[VX] *= length_limit;
mV[VY] *= length_limit;
mV[VZ] *= length_limit;
}
}
@ -138,13 +137,13 @@ bool LLVector3::clamp(const LLVector3 &min_vec, const LLVector3 &max_vec)
{
bool ret{ false };
if (mV[0] < min_vec[0]) { mV[0] = min_vec[0]; ret = true; }
if (mV[1] < min_vec[1]) { mV[1] = min_vec[1]; ret = true; }
if (mV[2] < min_vec[2]) { mV[2] = min_vec[2]; ret = true; }
if (mV[VX] < min_vec[0]) { mV[VX] = min_vec[0]; ret = true; }
if (mV[VY] < min_vec[1]) { mV[VY] = min_vec[1]; ret = true; }
if (mV[VZ] < min_vec[2]) { mV[VZ] = min_vec[2]; ret = true; }
if (mV[0] > max_vec[0]) { mV[0] = max_vec[0]; ret = true; }
if (mV[1] > max_vec[1]) { mV[1] = max_vec[1]; ret = true; }
if (mV[2] > max_vec[2]) { mV[2] = max_vec[2]; ret = true; }
if (mV[VX] > max_vec[0]) { mV[VX] = max_vec[0]; ret = true; }
if (mV[VY] > max_vec[1]) { mV[VY] = max_vec[1]; ret = true; }
if (mV[VZ] > max_vec[2]) { mV[VZ] = max_vec[2]; ret = true; }
return ret;
}
@ -156,9 +155,9 @@ bool LLVector3::abs()
{
bool ret{ false };
if (mV[0] < 0.f) { mV[0] = -mV[0]; ret = true; }
if (mV[1] < 0.f) { mV[1] = -mV[1]; ret = true; }
if (mV[2] < 0.f) { mV[2] = -mV[2]; ret = true; }
if (mV[VX] < 0.f) { mV[VX] = -mV[VX]; ret = true; }
if (mV[VY] < 0.f) { mV[VY] = -mV[VY]; ret = true; }
if (mV[VZ] < 0.f) { mV[VZ] = -mV[VZ]; ret = true; }
return ret;
}
@ -265,33 +264,33 @@ LLVector3 LLVector3::scaledVec(const LLVector3& vec) const
const LLVector3& LLVector3::set(const LLVector3d& vec)
{
mV[0] = (F32)vec.mdV[0];
mV[1] = (F32)vec.mdV[1];
mV[2] = (F32)vec.mdV[2];
mV[VX] = (F32)vec.mdV[VX];
mV[VY] = (F32)vec.mdV[VY];
mV[VZ] = (F32)vec.mdV[VZ];
return (*this);
}
const LLVector3& LLVector3::set(const LLVector4& vec)
{
mV[0] = vec.mV[0];
mV[1] = vec.mV[1];
mV[2] = vec.mV[2];
mV[VX] = vec.mV[VX];
mV[VY] = vec.mV[VY];
mV[VZ] = vec.mV[VZ];
return (*this);
}
const LLVector3& LLVector3::setVec(const LLVector3d& vec)
{
mV[0] = (F32)vec.mdV[0];
mV[1] = (F32)vec.mdV[1];
mV[2] = (F32)vec.mdV[2];
mV[VX] = (F32)vec.mdV[0];
mV[VY] = (F32)vec.mdV[1];
mV[VZ] = (F32)vec.mdV[2];
return (*this);
}
const LLVector3& LLVector3::setVec(const LLVector4& vec)
{
mV[0] = vec.mV[0];
mV[1] = vec.mV[1];
mV[2] = vec.mV[2];
mV[VX] = vec.mV[VX];
mV[VY] = vec.mV[VY];
mV[VZ] = vec.mV[VZ];
return (*this);
}
@ -299,7 +298,7 @@ LLVector3::LLVector3(const LLVector2 &vec)
{
mV[VX] = (F32)vec.mV[VX];
mV[VY] = (F32)vec.mV[VY];
mV[VZ] = 0;
mV[VZ] = 0.f;
}
LLVector3::LLVector3(const LLVector3d& vec)
@ -319,7 +318,6 @@ LLVector3::LLVector3(const LLVector4 &vec)
LLVector3::LLVector3(const LLVector4a& vec)
: LLVector3(vec.getF32ptr())
{
}
LLVector3::LLVector3(const LLSD& sd)
@ -330,17 +328,17 @@ LLVector3::LLVector3(const LLSD& sd)
LLSD LLVector3::getValue() const
{
LLSD ret;
ret[0] = mV[0];
ret[1] = mV[1];
ret[2] = mV[2];
ret[VX] = mV[VX];
ret[VY] = mV[VY];
ret[VZ] = mV[VZ];
return ret;
}
void LLVector3::setValue(const LLSD& sd)
{
mV[0] = (F32) sd[0].asReal();
mV[1] = (F32) sd[1].asReal();
mV[2] = (F32) sd[2].asReal();
mV[VX] = (F32) sd[VX].asReal();
mV[VY] = (F32) sd[VY].asReal();
mV[VZ] = (F32) sd[VZ].asReal();
}
const LLVector3& operator*=(LLVector3& a, const LLQuaternion& rot)
@ -366,7 +364,7 @@ bool LLVector3::parseVector3(const std::string& buf, LLVector3* value)
}
LLVector3 v;
S32 count = sscanf( buf.c_str(), "%f %f %f", v.mV + 0, v.mV + 1, v.mV + 2 );
S32 count = sscanf(buf.c_str(), "%f %f %f", v.mV + VX, v.mV + VY, v.mV + VZ);
if (3 == count)
{
value->setVec(v);
@ -410,4 +408,3 @@ bool box_valid_and_non_zero(const LLVector3* box)
}
return false;
}

205
indra/llmath/v3math.h
View File

@ -46,7 +46,7 @@ class LLQuaternion;
// LLvector3 = |x y z w|
static const U32 LENGTHOFVECTOR3 = 3;
static constexpr U32 LENGTHOFVECTOR3 = 3;
class LLVector3
{
@ -181,11 +181,11 @@ LLVector3 lerp(const LLVector3 &a, const LLVector3 &b, F32 u); // Returns a vect
LLVector3 point_to_box_offset(LLVector3& pos, const LLVector3* box); // Displacement from query point to nearest point on bounding box.
bool box_valid_and_non_zero(const LLVector3* box);
inline LLVector3::LLVector3(void)
inline LLVector3::LLVector3()
{
mV[0] = 0.f;
mV[1] = 0.f;
mV[2] = 0.f;
mV[VX] = 0.f;
mV[VY] = 0.f;
mV[VZ] = 0.f;
}
inline LLVector3::LLVector3(const F32 x, const F32 y, const F32 z)
@ -236,32 +236,32 @@ inline bool LLVector3::isFinite() const
// Clear and Assignment Functions
inline void LLVector3::clear(void)
inline void LLVector3::clear()
{
mV[0] = 0.f;
mV[1] = 0.f;
mV[2] = 0.f;
mV[VX] = 0.f;
mV[VY] = 0.f;
mV[VZ] = 0.f;
}
inline void LLVector3::setZero(void)
inline void LLVector3::setZero()
{
mV[0] = 0.f;
mV[1] = 0.f;
mV[2] = 0.f;
mV[VX] = 0.f;
mV[VY] = 0.f;
mV[VZ] = 0.f;
}
inline void LLVector3::clearVec(void)
inline void LLVector3::clearVec()
{
mV[0] = 0.f;
mV[1] = 0.f;
mV[2] = 0.f;
mV[VX] = 0.f;
mV[VY] = 0.f;
mV[VZ] = 0.f;
}
inline void LLVector3::zeroVec(void)
inline void LLVector3::zeroVec()
{
mV[0] = 0.f;
mV[1] = 0.f;
mV[2] = 0.f;
mV[VX] = 0.f;
mV[VY] = 0.f;
mV[VZ] = 0.f;
}
inline void LLVector3::set(F32 x, F32 y, F32 z)
@ -273,16 +273,16 @@ inline void LLVector3::set(F32 x, F32 y, F32 z)
inline void LLVector3::set(const LLVector3& vec)
{
mV[0] = vec.mV[0];
mV[1] = vec.mV[1];
mV[2] = vec.mV[2];
mV[VX] = vec.mV[VX];
mV[VY] = vec.mV[VY];
mV[VZ] = vec.mV[VZ];
}
inline void LLVector3::set(const F32* vec)
{
mV[0] = vec[0];
mV[1] = vec[1];
mV[2] = vec[2];
mV[VX] = vec[VX];
mV[VY] = vec[VY];
mV[VZ] = vec[VZ];
}
inline void LLVector3::set(const glm::vec4& vec)
@ -310,59 +310,59 @@ inline void LLVector3::setVec(F32 x, F32 y, F32 z)
// deprecated
inline void LLVector3::setVec(const LLVector3& vec)
{
mV[0] = vec.mV[0];
mV[1] = vec.mV[1];
mV[2] = vec.mV[2];
mV[VX] = vec.mV[VX];
mV[VY] = vec.mV[VY];
mV[VZ] = vec.mV[VZ];
}
// deprecated
inline void LLVector3::setVec(const F32* vec)
{
mV[0] = vec[0];
mV[1] = vec[1];
mV[2] = vec[2];
mV[VX] = vec[0];
mV[VY] = vec[1];
mV[VZ] = vec[2];
}
inline F32 LLVector3::normalize(void)
inline F32 LLVector3::normalize()
{
F32 mag = (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
F32 mag = (F32) sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
F32 oomag;
if (mag > FP_MAG_THRESHOLD)
{
oomag = 1.f/mag;
mV[0] *= oomag;
mV[1] *= oomag;
mV[2] *= oomag;
mV[VX] *= oomag;
mV[VY] *= oomag;
mV[VZ] *= oomag;
}
else
{
mV[0] = 0.f;
mV[1] = 0.f;
mV[2] = 0.f;
mV[VX] = 0.f;
mV[VY] = 0.f;
mV[VZ] = 0.f;
mag = 0;
}
return (mag);
}
// deprecated
inline F32 LLVector3::normVec(void)
inline F32 LLVector3::normVec()
{
F32 mag = (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
F32 mag = sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
F32 oomag;
if (mag > FP_MAG_THRESHOLD)
{
oomag = 1.f/mag;
mV[0] *= oomag;
mV[1] *= oomag;
mV[2] *= oomag;
mV[VX] *= oomag;
mV[VY] *= oomag;
mV[VZ] *= oomag;
}
else
{
mV[0] = 0.f;
mV[1] = 0.f;
mV[2] = 0.f;
mV[VX] = 0.f;
mV[VY] = 0.f;
mV[VZ] = 0.f;
mag = 0;
}
return (mag);
@ -370,31 +370,31 @@ inline F32 LLVector3::normVec(void)
// LLVector3 Magnitude and Normalization Functions
inline F32 LLVector3::length(void) const
inline F32 LLVector3::length() const
{
return (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
return sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
}
inline F32 LLVector3::lengthSquared(void) const
inline F32 LLVector3::lengthSquared() const
{
return mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2];
return mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ];
}
inline F32 LLVector3::magVec(void) const
inline F32 LLVector3::magVec() const
{
return (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
return sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
}
inline F32 LLVector3::magVecSquared(void) const
inline F32 LLVector3::magVecSquared() const
{
return mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2];
return mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ];
}
inline bool LLVector3::inRange( F32 min, F32 max ) const
{
return mV[0] >= min && mV[0] <= max &&
mV[1] >= min && mV[1] <= max &&
mV[2] >= min && mV[2] <= max;
return mV[VX] >= min && mV[VX] <= max &&
mV[VY] >= min && mV[VY] <= max &&
mV[VZ] >= min && mV[VZ] <= max;
}
inline LLVector3 operator+(const LLVector3& a, const LLVector3& b)
@ -411,104 +411,103 @@ inline LLVector3 operator-(const LLVector3 &a, const LLVector3 &b)
inline F32 operator*(const LLVector3& a, const LLVector3& b)
{
return (a.mV[0]*b.mV[0] + a.mV[1]*b.mV[1] + a.mV[2]*b.mV[2]);
return (a.mV[VX]*b.mV[VX] + a.mV[VY]*b.mV[VY] + a.mV[VZ]*b.mV[VZ]);
}
inline LLVector3 operator%(const LLVector3& a, const LLVector3& b)
{
return LLVector3( a.mV[1]*b.mV[2] - b.mV[1]*a.mV[2], a.mV[2]*b.mV[0] - b.mV[2]*a.mV[0], a.mV[0]*b.mV[1] - b.mV[0]*a.mV[1] );
return LLVector3( a.mV[VY]*b.mV[VZ] - b.mV[VY]*a.mV[VZ], a.mV[VZ]*b.mV[VX] - b.mV[VZ]*a.mV[VX], a.mV[VX]*b.mV[VY] - b.mV[VX]*a.mV[VY] );
}
inline LLVector3 operator/(const LLVector3& a, F32 k)
{
F32 t = 1.f / k;
return LLVector3( a.mV[0] * t, a.mV[1] * t, a.mV[2] * t );
return LLVector3( a.mV[VX] * t, a.mV[VY] * t, a.mV[VZ] * t );
}
inline LLVector3 operator*(const LLVector3& a, F32 k)
{
return LLVector3( a.mV[0] * k, a.mV[1] * k, a.mV[2] * k );
return LLVector3( a.mV[VX] * k, a.mV[VY] * k, a.mV[VZ] * k );
}
inline LLVector3 operator*(F32 k, const LLVector3& a)
{
return LLVector3( a.mV[0] * k, a.mV[1] * k, a.mV[2] * k );
return LLVector3( a.mV[VX] * k, a.mV[VY] * k, a.mV[VZ] * k );
}
inline bool operator==(const LLVector3& a, const LLVector3& b)
{
return ( (a.mV[0] == b.mV[0])
&&(a.mV[1] == b.mV[1])
&&(a.mV[2] == b.mV[2]));
return ( (a.mV[VX] == b.mV[VX])
&&(a.mV[VY] == b.mV[VY])
&&(a.mV[VZ] == b.mV[VZ]));
}
inline bool operator!=(const LLVector3& a, const LLVector3& b)
{
return ( (a.mV[0] != b.mV[0])
||(a.mV[1] != b.mV[1])
||(a.mV[2] != b.mV[2]));
return ( (a.mV[VX] != b.mV[VX])
||(a.mV[VY] != b.mV[VY])
||(a.mV[VZ] != b.mV[VZ]));
}
inline bool operator<(const LLVector3& a, const LLVector3& b)
{
return (a.mV[0] < b.mV[0]
|| (a.mV[0] == b.mV[0]
&& (a.mV[1] < b.mV[1]
|| ((a.mV[1] == b.mV[1])
&& a.mV[2] < b.mV[2]))));
return (a.mV[VX] < b.mV[VX]
|| (a.mV[VX] == b.mV[VX]
&& (a.mV[VY] < b.mV[VY]
|| ((a.mV[VY] == b.mV[VY])
&& a.mV[VZ] < b.mV[VZ]))));
}
inline const LLVector3& operator+=(LLVector3& a, const LLVector3& b)
{
a.mV[0] += b.mV[0];
a.mV[1] += b.mV[1];
a.mV[2] += b.mV[2];
a.mV[VX] += b.mV[VX];
a.mV[VY] += b.mV[VY];
a.mV[VZ] += b.mV[VZ];
return a;
}
inline const LLVector3& operator-=(LLVector3& a, const LLVector3& b)
{
a.mV[0] -= b.mV[0];
a.mV[1] -= b.mV[1];
a.mV[2] -= b.mV[2];
a.mV[VX] -= b.mV[VX];
a.mV[VY] -= b.mV[VY];
a.mV[VZ] -= b.mV[VZ];
return a;
}
inline const LLVector3& operator%=(LLVector3& a, const LLVector3& b)
{
LLVector3 ret( a.mV[1]*b.mV[2] - b.mV[1]*a.mV[2], a.mV[2]*b.mV[0] - b.mV[2]*a.mV[0], a.mV[0]*b.mV[1] - b.mV[0]*a.mV[1]);
LLVector3 ret( a.mV[VY]*b.mV[VZ] - b.mV[VY]*a.mV[VZ], a.mV[VZ]*b.mV[VX] - b.mV[VZ]*a.mV[VX], a.mV[VX]*b.mV[VY] - b.mV[VX]*a.mV[VY]);
a = ret;
return a;
}
inline const LLVector3& operator*=(LLVector3& a, F32 k)
{
a.mV[0] *= k;
a.mV[1] *= k;
a.mV[2] *= k;
a.mV[VX] *= k;
a.mV[VY] *= k;
a.mV[VZ] *= k;
return a;
}
inline const LLVector3& operator*=(LLVector3& a, const LLVector3& b)
{
a.mV[0] *= b.mV[0];
a.mV[1] *= b.mV[1];
a.mV[2] *= b.mV[2];
a.mV[VX] *= b.mV[VX];
a.mV[VY] *= b.mV[VY];
a.mV[VZ] *= b.mV[VZ];
return a;
}
inline const LLVector3& operator/=(LLVector3& a, F32 k)
{
F32 t = 1.f / k;
a.mV[0] *= t;
a.mV[1] *= t;
a.mV[2] *= t;
a.mV[VX] /= k;
a.mV[VY] /= k;
a.mV[VZ] /= k;
return a;
}
inline LLVector3 operator-(const LLVector3& a)
{
return LLVector3( -a.mV[0], -a.mV[1], -a.mV[2] );
return LLVector3(-a.mV[VX], -a.mV[VY], -a.mV[VZ]);
}
inline LLVector3::operator glm::vec3() const
@ -524,24 +523,24 @@ inline LLVector3::operator glm::vec4() const
inline F32 dist_vec(const LLVector3& a, const LLVector3& b)
{
F32 x = a.mV[0] - b.mV[0];
F32 y = a.mV[1] - b.mV[1];
F32 z = a.mV[2] - b.mV[2];
return (F32) sqrt( x*x + y*y + z*z );
F32 x = a.mV[VX] - b.mV[VX];
F32 y = a.mV[VY] - b.mV[VY];
F32 z = a.mV[VZ] - b.mV[VZ];
return sqrt( x*x + y*y + z*z );
}
inline F32 dist_vec_squared(const LLVector3& a, const LLVector3& b)
{
F32 x = a.mV[0] - b.mV[0];
F32 y = a.mV[1] - b.mV[1];
F32 z = a.mV[2] - b.mV[2];
F32 x = a.mV[VX] - b.mV[VX];
F32 y = a.mV[VY] - b.mV[VY];
F32 z = a.mV[VZ] - b.mV[VZ];
return x*x + y*y + z*z;
}
inline F32 dist_vec_squared2D(const LLVector3& a, const LLVector3& b)
{
F32 x = a.mV[0] - b.mV[0];
F32 y = a.mV[1] - b.mV[1];
F32 x = a.mV[VX] - b.mV[VX];
F32 y = a.mV[VY] - b.mV[VY];
return x*x + y*y;
}

83
indra/llmath/v4color.cpp
View File

@ -124,8 +124,7 @@ LLColor4 LLColor4::cyan6(0.2f, 0.6f, 0.6f, 1.0f);
// conversion
LLColor4::operator LLColor4U() const
{
return LLColor4U(
(U8)llclampb(ll_round(mV[VRED]*255.f)),
return LLColor4U((U8)llclampb(ll_round(mV[VRED] * 255.f)),
(U8)llclampb(ll_round(mV[VGREEN] * 255.f)),
(U8)llclampb(ll_round(mV[VBLUE] * 255.f)),
(U8)llclampb(ll_round(mV[VALPHA] * 255.f)));
@ -141,7 +140,7 @@ LLColor4::LLColor4(const LLColor3 &vec, F32 a)
LLColor4::LLColor4(const LLColor4U& color4u)
{
const F32 SCALE = 1.f/255.f;
constexpr F32 SCALE = 1.f / 255.f;
mV[VRED] = color4u.mV[VRED] * SCALE;
mV[VGREEN] = color4u.mV[VGREEN] * SCALE;
mV[VBLUE] = color4u.mV[VBLUE] * SCALE;
@ -158,7 +157,7 @@ LLColor4::LLColor4(const LLVector4& vector4)
const LLColor4& LLColor4::set(const LLColor4U& color4u)
{
const F32 SCALE = 1.f/255.f;
constexpr F32 SCALE = 1.f / 255.f;
mV[VRED] = color4u.mV[VRED] * SCALE;
mV[VGREEN] = color4u.mV[VGREEN] * SCALE;
mV[VBLUE] = color4u.mV[VBLUE] * SCALE;
@ -190,7 +189,7 @@ const LLColor4& LLColor4::set(const LLColor3 &vec, F32 a)
// deprecated -- use set()
const LLColor4& LLColor4::setVec(const LLColor4U& color4u)
{
const F32 SCALE = 1.f/255.f;
constexpr F32 SCALE = 1.f / 255.f;
mV[VRED] = color4u.mV[VRED] * SCALE;
mV[VGREEN] = color4u.mV[VGREEN] * SCALE;
mV[VBLUE] = color4u.mV[VBLUE] * SCALE;
@ -228,30 +227,30 @@ void LLColor4::setValue(const LLSD& sd)
F32 val;
bool out_of_range = false;
val = sd[0].asReal();
mV[0] = llclamp(val, 0.f, 1.f);
out_of_range = mV[0] != val;
mV[VRED] = llclamp(val, 0.f, 1.f);
out_of_range = mV[VRED] != val;
val = sd[1].asReal();
mV[1] = llclamp(val, 0.f, 1.f);
out_of_range |= mV[1] != val;
mV[VGREEN] = llclamp(val, 0.f, 1.f);
out_of_range |= mV[VGREEN] != val;
val = sd[2].asReal();
mV[2] = llclamp(val, 0.f, 1.f);
out_of_range |= mV[2] != val;
mV[VBLUE] = llclamp(val, 0.f, 1.f);
out_of_range |= mV[VBLUE] != val;
val = sd[3].asReal();
mV[3] = llclamp(val, 0.f, 1.f);
out_of_range |= mV[3] != val;
mV[VALPHA] = llclamp(val, 0.f, 1.f);
out_of_range |= mV[VALPHA] != val;
if (out_of_range)
{
LL_WARNS() << "LLSD color value out of range!" << LL_ENDL;
}
#else
mV[0] = (F32) sd[0].asReal();
mV[1] = (F32) sd[1].asReal();
mV[2] = (F32) sd[2].asReal();
mV[3] = (F32) sd[3].asReal();
mV[VRED] = (F32)sd[VRED].asReal();
mV[VGREEN] = (F32)sd[VGREEN].asReal();
mV[VBLUE] = (F32)sd[VBLUE].asReal();
mV[VALPHA] = (F32)sd[VALPHA].asReal();
#endif
}
@ -266,7 +265,6 @@ const LLColor4& LLColor4::operator=(const LLColor3 &a)
return (*this);
}
std::ostream& operator<<(std::ostream& s, const LLColor4& a)
{
s << "{ " << a.mV[VRED] << ", " << a.mV[VGREEN] << ", " << a.mV[VBLUE] << ", " << a.mV[VALPHA] << " }";
@ -275,16 +273,12 @@ std::ostream& operator<<(std::ostream& s, const LLColor4 &a)
bool operator==(const LLColor4& a, const LLColor3& b)
{
return ( (a.mV[VRED] == b.mV[VRED])
&&(a.mV[VGREEN] == b.mV[VGREEN])
&&(a.mV[VBLUE] == b.mV[VBLUE]));
return ((a.mV[VRED] == b.mV[VRED]) && (a.mV[VGREEN] == b.mV[VGREEN]) && (a.mV[VBLUE] == b.mV[VBLUE]));
}
bool operator!=(const LLColor4& a, const LLColor3& b)
{
return ( (a.mV[VRED] != b.mV[VRED])
||(a.mV[VGREEN] != b.mV[VGREEN])
||(a.mV[VBLUE] != b.mV[VBLUE]));
return ((a.mV[VRED] != b.mV[VRED]) || (a.mV[VGREEN] != b.mV[VGREEN]) || (a.mV[VBLUE] != b.mV[VBLUE]));
}
LLColor3 vec4to3(const LLColor4& vec)
@ -301,11 +295,16 @@ LLColor4 vec3to4(const LLColor3 &vec)
static F32 hueToRgb(F32 val1In, F32 val2In, F32 valHUeIn)
{
if ( valHUeIn < 0.0f ) valHUeIn += 1.0f;
if ( valHUeIn > 1.0f ) valHUeIn -= 1.0f;
if ( ( 6.0f * valHUeIn ) < 1.0f ) return ( val1In + ( val2In - val1In ) * 6.0f * valHUeIn );
if ( ( 2.0f * valHUeIn ) < 1.0f ) return ( val2In );
if ( ( 3.0f * valHUeIn ) < 2.0f ) return ( val1In + ( val2In - val1In ) * ( ( 2.0f / 3.0f ) - valHUeIn ) * 6.0f );
if (valHUeIn < 0.0f)
valHUeIn += 1.0f;
if (valHUeIn > 1.0f)
valHUeIn -= 1.0f;
if ((6.0f * valHUeIn) < 1.0f)
return (val1In + (val2In - val1In) * 6.0f * valHUeIn);
if ((2.0f * valHUeIn) < 1.0f)
return (val2In);
if ((3.0f * valHUeIn) < 2.0f)
return (val1In + (val2In - val1In) * ((2.0f / 3.0f) - valHUeIn) * 6.0f);
return (val1In);
}
@ -357,7 +356,7 @@ void LLColor4::calcHSL(F32* hue, F32* saturation, F32* luminance) const
}
else
{
if ( L < 0.5 )
if (L < 0.5f)
S = del_Max / (var_Max + var_Min);
else
S = del_Max / (2.0f - var_Max - var_Min);
@ -368,20 +367,23 @@ void LLColor4::calcHSL(F32* hue, F32* saturation, F32* luminance) const
if (var_R >= var_Max)
H = del_B - del_G;
else
if ( var_G >= var_Max )
else if (var_G >= var_Max)
H = (1.0f / 3.0f) + del_R - del_B;
else
if ( var_B >= var_Max )
else if (var_B >= var_Max)
H = (2.0f / 3.0f) + del_G - del_R;
if ( H < 0.0f ) H += 1.0f;
if ( H > 1.0f ) H -= 1.0f;
if (H < 0.0f)
H += 1.0f;
if (H > 1.0f)
H -= 1.0f;
}
if (hue) *hue = H;
if (saturation) *saturation = S;
if (luminance) *luminance = L;
if (hue)
*hue = H;
if (saturation)
*saturation = S;
if (luminance)
*luminance = L;
}
// static
@ -435,7 +437,8 @@ bool LLColor4::parseColor(const std::string& buf, LLColor4* color)
// Make sure all values are between 0 and 1.
if (v.mV[VRED] > 1.f || v.mV[VGREEN] > 1.f || v.mV[VBLUE] > 1.f || v.mV[VALPHA] > 1.f)
{
v = v * (1.f / 255.f);
constexpr F32 SCALE{ 1.f / 255.f };
v *= SCALE;
}
color->set(v);
}

178
indra/llmath/v4color.h
View File

@ -28,7 +28,6 @@
#define LL_V4COLOR_H
#include "llerror.h"
//#include "vmath.h"
#include "llmath.h"
#include "llsd.h"
@ -38,9 +37,9 @@ class LLVector4;
// LLColor4 = |x y z w|
static const U32 LENGTHOFCOLOR4 = 4;
static constexpr U32 LENGTHOFCOLOR4 = 4;
static const U32 MAX_LENGTH_OF_COLOR_NAME = 15; //Give plenty of room for additional colors...
static constexpr U32 MAX_LENGTH_OF_COLOR_NAME = 15; // Give plenty of room for additional colors...
class LLColor4
{
@ -59,10 +58,10 @@ class LLColor4
LLSD getValue() const
{
LLSD ret;
ret[0] = mV[0];
ret[1] = mV[1];
ret[2] = mV[2];
ret[3] = mV[3];
ret[VRED] = mV[VRED];
ret[VGREEN] = mV[VGREEN];
ret[VBLUE] = mV[VBLUE];
ret[VALPHA] = mV[VALPHA];
return ret;
}
@ -111,7 +110,7 @@ class LLColor4
F32 lengthSquared() const; // Returns magnitude squared of LLColor4
F32 normalize(); // deprecated -- use normalize()
bool isOpaque() { return mV[VALPHA] == 1.f; }
bool isOpaque() const { return mV[VALPHA] == 1.f; }
F32 operator[](int idx) const { return mV[idx]; }
F32& operator[](int idx) { return mV[idx]; }
@ -232,7 +231,6 @@ class LLColor4
inline void clamp();
};
// Non-member functions
F32 distVec(const LLColor4& a, const LLColor4& b); // Returns distance between a and b
F32 distVec_squared(const LLColor4& a, const LLColor4& b); // Returns distance squared between a and b
@ -240,7 +238,7 @@ LLColor3 vec4to3(const LLColor4 &vec);
LLColor4 vec3to4(const LLColor3& vec);
LLColor4 lerp(const LLColor4& a, const LLColor4& b, F32 u);
inline LLColor4::LLColor4(void)
inline LLColor4::LLColor4()
{
mV[VRED] = 0.f;
mV[VGREEN] = 0.f;
@ -277,7 +275,6 @@ inline LLColor4::LLColor4(U32 clr)
mV[VALPHA] = (clr >> 24) * (1.0f / 255.0f);
}
inline LLColor4::LLColor4(const F32* vec)
{
mV[VRED] = vec[VRED];
@ -334,7 +331,6 @@ inline const LLColor4& LLColor4::set(const LLColor4 &vec)
return (*this);
}
inline const LLColor4& LLColor4::set(const F32* vec)
{
mV[VRED] = vec[VRED];
@ -386,7 +382,6 @@ inline const LLColor4& LLColor4::setVec(const LLColor4 &vec)
return (*this);
}
// deprecated
inline const LLColor4& LLColor4::setVec(const F32* vec)
{
@ -405,19 +400,19 @@ inline const LLColor4& LLColor4::setAlpha(F32 a)
// LLColor4 Magnitude and Normalization Functions
inline F32 LLColor4::length(void) const
inline F32 LLColor4::length() const
{
return (F32) sqrt(mV[VRED]*mV[VRED] + mV[VGREEN]*mV[VGREEN] + mV[VBLUE]*mV[VBLUE]);
return sqrt(mV[VRED] * mV[VRED] + mV[VGREEN] * mV[VGREEN] + mV[VBLUE] * mV[VBLUE]);
}
inline F32 LLColor4::lengthSquared(void) const
inline F32 LLColor4::lengthSquared() const
{
return mV[VRED] * mV[VRED] + mV[VGREEN] * mV[VGREEN] + mV[VBLUE] * mV[VBLUE];
}
inline F32 LLColor4::normalize(void)
inline F32 LLColor4::normalize()
{
F32 mag = (F32) sqrt(mV[VRED]*mV[VRED] + mV[VGREEN]*mV[VGREEN] + mV[VBLUE]*mV[VBLUE]);
F32 mag = sqrt(mV[VRED] * mV[VRED] + mV[VGREEN] * mV[VGREEN] + mV[VBLUE] * mV[VBLUE]);
F32 oomag;
if (mag)
@ -427,25 +422,25 @@ inline F32 LLColor4::normalize(void)
mV[VGREEN] *= oomag;
mV[VBLUE] *= oomag;
}
return (mag);
return mag;
}
// deprecated
inline F32 LLColor4::magVec(void) const
inline F32 LLColor4::magVec() const
{
return (F32) sqrt(mV[VRED]*mV[VRED] + mV[VGREEN]*mV[VGREEN] + mV[VBLUE]*mV[VBLUE]);
return sqrt(mV[VRED] * mV[VRED] + mV[VGREEN] * mV[VGREEN] + mV[VBLUE] * mV[VBLUE]);
}
// deprecated
inline F32 LLColor4::magVecSquared(void) const
inline F32 LLColor4::magVecSquared() const
{
return mV[VRED] * mV[VRED] + mV[VGREEN] * mV[VGREEN] + mV[VBLUE] * mV[VBLUE];
}
// deprecated
inline F32 LLColor4::normVec(void)
inline F32 LLColor4::normVec()
{
F32 mag = (F32) sqrt(mV[VRED]*mV[VRED] + mV[VGREEN]*mV[VGREEN] + mV[VBLUE]*mV[VBLUE]);
F32 mag = sqrt(mV[VRED] * mV[VRED] + mV[VGREEN] * mV[VGREEN] + mV[VBLUE] * mV[VBLUE]);
F32 oomag;
if (mag)
@ -455,102 +450,63 @@ inline F32 LLColor4::normVec(void)
mV[VGREEN] *= oomag;
mV[VBLUE] *= oomag;
}
return (mag);
return mag;
}
// LLColor4 Operators
inline LLColor4 operator+(const LLColor4& a, const LLColor4& b)
{
return LLColor4(
a.mV[VRED] + b.mV[VRED],
a.mV[VGREEN] + b.mV[VGREEN],
a.mV[VBLUE] + b.mV[VBLUE],
a.mV[VALPHA] + b.mV[VALPHA]);
return LLColor4(a.mV[VRED] + b.mV[VRED], a.mV[VGREEN] + b.mV[VGREEN], a.mV[VBLUE] + b.mV[VBLUE], a.mV[VALPHA] + b.mV[VALPHA]);
}
inline LLColor4 operator-(const LLColor4& a, const LLColor4& b)
{
return LLColor4(
a.mV[VRED] - b.mV[VRED],
a.mV[VGREEN] - b.mV[VGREEN],
a.mV[VBLUE] - b.mV[VBLUE],
a.mV[VALPHA] - b.mV[VALPHA]);
return LLColor4(a.mV[VRED] - b.mV[VRED], a.mV[VGREEN] - b.mV[VGREEN], a.mV[VBLUE] - b.mV[VBLUE], a.mV[VALPHA] - b.mV[VALPHA]);
}
inline LLColor4 operator*(const LLColor4& a, const LLColor4& b)
{
return LLColor4(
a.mV[VRED] * b.mV[VRED],
a.mV[VGREEN] * b.mV[VGREEN],
a.mV[VBLUE] * b.mV[VBLUE],
a.mV[VALPHA] * b.mV[VALPHA]);
return LLColor4(a.mV[VRED] * b.mV[VRED], a.mV[VGREEN] * b.mV[VGREEN], a.mV[VBLUE] * b.mV[VBLUE], a.mV[VALPHA] * b.mV[VALPHA]);
}
inline LLColor4 operator*(const LLColor4& a, F32 k)
{
// only affects rgb (not a!)
return LLColor4(
a.mV[VRED] * k,
a.mV[VGREEN] * k,
a.mV[VBLUE] * k,
a.mV[VALPHA]);
return LLColor4(a.mV[VRED] * k, a.mV[VGREEN] * k, a.mV[VBLUE] * k, a.mV[VALPHA]);
}
inline LLColor4 operator/(const LLColor4& a, F32 k)
{
return LLColor4(
a.mV[VRED] / k,
a.mV[VGREEN] / k,
a.mV[VBLUE] / k,
a.mV[VALPHA]);
return LLColor4(a.mV[VRED] / k, a.mV[VGREEN] / k, a.mV[VBLUE] / k, a.mV[VALPHA]);
}
inline LLColor4 operator*(F32 k, const LLColor4& a)
{
// only affects rgb (not a!)
return LLColor4(
a.mV[VRED] * k,
a.mV[VGREEN] * k,
a.mV[VBLUE] * k,
a.mV[VALPHA]);
return LLColor4(a.mV[VRED] * k, a.mV[VGREEN] * k, a.mV[VBLUE] * k, a.mV[VALPHA]);
}
inline LLColor4 operator%(F32 k, const LLColor4& a)
{
// only affects alpha (not rgb!)
return LLColor4(
a.mV[VRED],
a.mV[VGREEN],
a.mV[VBLUE],
a.mV[VALPHA] * k);
return LLColor4(a.mV[VRED], a.mV[VGREEN], a.mV[VBLUE], a.mV[VALPHA] * k);
}
inline LLColor4 operator%(const LLColor4& a, F32 k)
{
// only affects alpha (not rgb!)
return LLColor4(
a.mV[VRED],
a.mV[VGREEN],
a.mV[VBLUE],
a.mV[VALPHA] * k);
return LLColor4(a.mV[VRED], a.mV[VGREEN], a.mV[VBLUE], a.mV[VALPHA] * k);
}
inline bool operator==(const LLColor4& a, const LLColor4& b)
{
return ( (a.mV[VRED] == b.mV[VRED])
&&(a.mV[VGREEN] == b.mV[VGREEN])
&&(a.mV[VBLUE] == b.mV[VBLUE])
&&(a.mV[VALPHA] == b.mV[VALPHA]));
return ((a.mV[VRED] == b.mV[VRED]) && (a.mV[VGREEN] == b.mV[VGREEN]) && (a.mV[VBLUE] == b.mV[VBLUE]) && (a.mV[VALPHA] == b.mV[VALPHA]));
}
inline bool operator!=(const LLColor4& a, const LLColor4& b)
{
return ( (a.mV[VRED] != b.mV[VRED])
||(a.mV[VGREEN] != b.mV[VGREEN])
||(a.mV[VBLUE] != b.mV[VBLUE])
||(a.mV[VALPHA] != b.mV[VALPHA]));
return ((a.mV[VRED] != b.mV[VRED]) || (a.mV[VGREEN] != b.mV[VGREEN]) || (a.mV[VBLUE] != b.mV[VBLUE]) || (a.mV[VALPHA] != b.mV[VALPHA]));
}
inline const LLColor4& operator+=(LLColor4& a, const LLColor4& b)
@ -596,25 +552,23 @@ inline const LLColor4& operator%=(LLColor4 &a, F32 k)
return a;
}
// Non-member functions
inline F32 distVec(const LLColor4& a, const LLColor4& b)
{
LLColor4 vec = a - b;
return (vec.length());
return vec.length();
}
inline F32 distVec_squared(const LLColor4& a, const LLColor4& b)
{
LLColor4 vec = a - b;
return (vec.lengthSquared());
return vec.lengthSquared();
}
inline LLColor4 lerp(const LLColor4& a, const LLColor4& b, F32 u)
{
return LLColor4(
a.mV[VRED] + (b.mV[VRED] - a.mV[VRED]) * u,
return LLColor4(a.mV[VRED] + (b.mV[VRED] - a.mV[VRED]) * u,
a.mV[VGREEN] + (b.mV[VGREEN] - a.mV[VGREEN]) * u,
a.mV[VBLUE] + (b.mV[VBLUE] - a.mV[VBLUE]) * u,
a.mV[VALPHA] + (b.mV[VALPHA] - a.mV[VALPHA]) * u);
@ -622,67 +576,68 @@ inline LLColor4 lerp(const LLColor4 &a, const LLColor4 &b, F32 u)
inline bool LLColor4::operator<(const LLColor4& rhs) const
{
if (mV[0] != rhs.mV[0])
if (mV[VRED] != rhs.mV[VRED])
{
return mV[0] < rhs.mV[0];
return mV[VRED] < rhs.mV[VRED];
}
if (mV[1] != rhs.mV[1])
if (mV[VGREEN] != rhs.mV[VGREEN])
{
return mV[1] < rhs.mV[1];
return mV[VGREEN] < rhs.mV[VGREEN];
}
if (mV[2] != rhs.mV[2])
if (mV[VBLUE] != rhs.mV[VBLUE])
{
return mV[2] < rhs.mV[2];
return mV[VBLUE] < rhs.mV[VBLUE];
}
return mV[3] < rhs.mV[3];
return mV[VALPHA] < rhs.mV[VALPHA];
}
void LLColor4::clamp()
{
// Clamp the color...
if (mV[0] < 0.f)
if (mV[VRED] < 0.f)
{
mV[0] = 0.f;
mV[VRED] = 0.f;
}
else if (mV[0] > 1.f)
else if (mV[VRED] > 1.f)
{
mV[0] = 1.f;
mV[VRED] = 1.f;
}
if (mV[1] < 0.f)
if (mV[VGREEN] < 0.f)
{
mV[1] = 0.f;
mV[VGREEN] = 0.f;
}
else if (mV[1] > 1.f)
else if (mV[VGREEN] > 1.f)
{
mV[1] = 1.f;
mV[VGREEN] = 1.f;
}
if (mV[2] < 0.f)
if (mV[VBLUE] < 0.f)
{
mV[2] = 0.f;
mV[VBLUE] = 0.f;
}
else if (mV[2] > 1.f)
else if (mV[VBLUE] > 1.f)
{
mV[2] = 1.f;
mV[VBLUE] = 1.f;
}
if (mV[3] < 0.f)
if (mV[VALPHA] < 0.f)
{
mV[3] = 0.f;
mV[VALPHA] = 0.f;
}
else if (mV[3] > 1.f)
else if (mV[VALPHA] > 1.f)
{
mV[3] = 1.f;
mV[VALPHA] = 1.f;
}
}
// Return the given linear space color value in gamma corrected (sRGB) space
inline const LLColor4 srgbColor4(const LLColor4 &a) {
inline const LLColor4 srgbColor4(const LLColor4& a)
{
LLColor4 srgbColor;
srgbColor.mV[0] = linearTosRGB(a.mV[0]);
srgbColor.mV[1] = linearTosRGB(a.mV[1]);
srgbColor.mV[2] = linearTosRGB(a.mV[2]);
srgbColor.mV[3] = a.mV[3];
srgbColor.mV[VRED] = linearTosRGB(a.mV[VRED]);
srgbColor.mV[VGREEN] = linearTosRGB(a.mV[VGREEN]);
srgbColor.mV[VBLUE] = linearTosRGB(a.mV[VBLUE]);
srgbColor.mV[VALPHA] = a.mV[VALPHA];
return srgbColor;
}
@ -691,10 +646,10 @@ inline const LLColor4 srgbColor4(const LLColor4 &a) {
inline const LLColor4 linearColor4(const LLColor4& a)
{
LLColor4 linearColor;
linearColor.mV[0] = sRGBtoLinear(a.mV[0]);
linearColor.mV[1] = sRGBtoLinear(a.mV[1]);
linearColor.mV[2] = sRGBtoLinear(a.mV[2]);
linearColor.mV[3] = a.mV[3];
linearColor.mV[VRED] = sRGBtoLinear(a.mV[VRED]);
linearColor.mV[VGREEN] = sRGBtoLinear(a.mV[VGREEN]);
linearColor.mV[VBLUE] = sRGBtoLinear(a.mV[VBLUE]);
linearColor.mV[VALPHA] = a.mV[VALPHA];
return linearColor;
}
@ -720,4 +675,3 @@ void LLColor4::write(std::vector<T>& v) const
}
#endif

49
indra/llmath/v4coloru.cpp
View File

@ -26,10 +26,7 @@
#include "linden_common.h"
//#include "v3coloru.h"
#include "v4coloru.h"
#include "v4color.h"
//#include "vmath.h"
#include "llmath.h"
// LLColor4U
@ -39,48 +36,6 @@ LLColor4U LLColor4U::red (255, 0, 0, 255);
LLColor4U LLColor4U::green( 0, 255, 0, 255);
LLColor4U LLColor4U::blue ( 0, 0, 255, 255);
// conversion
/* inlined to fix gcc compile link error
LLColor4U::operator LLColor4()
{
return(LLColor4((F32)mV[VRED]/255.f,(F32)mV[VGREEN]/255.f,(F32)mV[VBLUE]/255.f,(F32)mV[VALPHA]/255.f));
}
*/
// Constructors
/*
LLColor4U::LLColor4U(const LLColor3 &vec)
{
mV[VRED] = vec.mV[VRED];
mV[VGREEN] = vec.mV[VGREEN];
mV[VBLUE] = vec.mV[VBLUE];
mV[VALPHA] = 255;
}
*/
// Clear and Assignment Functions
// LLColor4U Operators
/*
LLColor4U LLColor4U::operator=(const LLColor3 &a)
{
mV[VRED] = a.mV[VRED];
mV[VGREEN] = a.mV[VGREEN];
mV[VBLUE] = a.mV[VBLUE];
// converting from an rgb sets a=1 (opaque)
mV[VALPHA] = 255;
return (*this);
}
*/
std::ostream& operator<<(std::ostream& s, const LLColor4U& a)
{
s << "{ " << (S32)a.mV[VRED] << ", " << (S32)a.mV[VGREEN] << ", " << (S32)a.mV[VBLUE] << ", " << (S32)a.mV[VALPHA] << " }";
@ -95,7 +50,7 @@ bool LLColor4U::parseColor4U(const std::string& buf, LLColor4U* value)
return false;
}
U32 v[4];
U32 v[4]{};
S32 count = sscanf(buf.c_str(), "%u, %u, %u, %u", v + 0, v + 1, v + 2, v + 3);
if (1 == count)
{
@ -115,6 +70,6 @@ bool LLColor4U::parseColor4U(const std::string& buf, LLColor4U* value)
}
}
value->set( U8(v[0]), U8(v[1]), U8(v[2]), U8(v[3]) );
value->set(U8(v[VRED]), U8(v[VGREEN]), U8(v[VBLUE]), U8(v[VALPHA]));
return true;
}

199
indra/llmath/v4coloru.h
View File

@ -28,51 +28,43 @@
#define LL_V4COLORU_H
#include "llerror.h"
//#include "vmath.h"
#include "llmath.h"
//#include "v4color.h"
#include "v3color.h"
#include "v4color.h"
//class LLColor3U;
class LLColor4;
// LLColor4U = | red green blue alpha |
static const U32 LENGTHOFCOLOR4U = 4;
static constexpr U32 LENGTHOFCOLOR4U = 4;
class LLColor4U
{
public:
U8 mV[LENGTHOFCOLOR4U];
LLColor4U(); // Initializes LLColor4U to (0, 0, 0, 1)
LLColor4U(U8 r, U8 g, U8 b); // Initializes LLColor4U to (r, g, b, 1)
LLColor4U(U8 r, U8 g, U8 b, U8 a); // Initializes LLColor4U to (r. g, b, a)
LLColor4U(const U8* vec); // Initializes LLColor4U to (vec[0]. vec[1], vec[2], 1)
explicit LLColor4U(const LLSD& sd)
{
setValue(sd);
}
explicit LLColor4U(const LLSD& sd) { setValue(sd); }
void setValue(const LLSD& sd)
{
mV[0] = sd[0].asInteger();
mV[1] = sd[1].asInteger();
mV[2] = sd[2].asInteger();
mV[3] = sd[3].asInteger();
mV[VRED] = sd[VRED].asInteger();
mV[VGREEN] = sd[VGREEN].asInteger();
mV[VBLUE] = sd[VBLUE].asInteger();
mV[VALPHA] = sd[VALPHA].asInteger();
}
LLSD getValue() const
{
LLSD ret;
ret[0] = mV[0];
ret[1] = mV[1];
ret[2] = mV[2];
ret[3] = mV[3];
ret[VRED] = mV[VRED];
ret[VGREEN] = mV[VGREEN];
ret[VBLUE] = mV[VBLUE];
ret[VALPHA] = mV[VALPHA];
return ret;
}
@ -119,10 +111,7 @@ public:
static bool parseColor4U(const std::string& buf, LLColor4U* value);
// conversion
operator LLColor4() const
{
return LLColor4(*this);
}
operator LLColor4() const { return LLColor4(*this); }
U32 asRGBA() const;
void fromRGBA(U32 aVal);
@ -134,12 +123,10 @@ public:
static LLColor4U blue;
};
// Non-member functions
F32 distVec(const LLColor4U& a, const LLColor4U& b); // Returns distance between a and b
F32 distVec_squared(const LLColor4U& a, const LLColor4U& b); // Returns distance squared between a and b
inline LLColor4U::LLColor4U()
{
mV[VRED] = 0;
@ -172,13 +159,6 @@ inline LLColor4U::LLColor4U(const U8 *vec)
mV[VALPHA] = vec[VALPHA];
}
/*
inline LLColor4U::operator LLColor4()
{
return(LLColor4((F32)mV[VRED]/255.f,(F32)mV[VGREEN]/255.f,(F32)mV[VBLUE]/255.f,(F32)mV[VALPHA]/255.f));
}
*/
inline const LLColor4U& LLColor4U::setToBlack(void)
{
mV[VRED] = 0;
@ -211,10 +191,10 @@ inline const LLColor4U& LLColor4U::set(const U8 x, const U8 y, const U8 z)
inline const LLColor4U& LLColor4U::set(const U8 r, const U8 g, const U8 b, U8 a)
{
mV[0] = r;
mV[1] = g;
mV[2] = b;
mV[3] = a;
mV[VRED] = r;
mV[VGREEN] = g;
mV[VBLUE] = b;
mV[VALPHA] = a;
return (*this);
}
@ -252,10 +232,10 @@ inline const LLColor4U& LLColor4U::setVec(const U8 x, const U8 y, const U8 z)
// deprecated
inline const LLColor4U& LLColor4U::setVec(const U8 r, const U8 g, const U8 b, U8 a)
{
mV[0] = r;
mV[1] = g;
mV[2] = b;
mV[3] = a;
mV[VRED] = r;
mV[VGREEN] = g;
mV[VBLUE] = b;
mV[VALPHA] = a;
return (*this);
}
@ -287,53 +267,41 @@ inline const LLColor4U& LLColor4U::setAlpha(U8 a)
// LLColor4U Magnitude and Normalization Functions
inline F32 LLColor4U::length(void) const
inline F32 LLColor4U::length() const
{
return (F32) sqrt( ((F32)mV[VRED]) * mV[VRED] + ((F32)mV[VGREEN]) * mV[VGREEN] + ((F32)mV[VBLUE]) * mV[VBLUE] );
return sqrt(((F32)mV[VRED]) * mV[VRED] + ((F32)mV[VGREEN]) * mV[VGREEN] + ((F32)mV[VBLUE]) * mV[VBLUE]);
}
inline F32 LLColor4U::lengthSquared(void) const
inline F32 LLColor4U::lengthSquared() const
{
return ((F32)mV[VRED]) * mV[VRED] + ((F32)mV[VGREEN]) * mV[VGREEN] + ((F32)mV[VBLUE]) * mV[VBLUE];
}
// deprecated
inline F32 LLColor4U::magVec(void) const
inline F32 LLColor4U::magVec() const
{
return (F32) sqrt( ((F32)mV[VRED]) * mV[VRED] + ((F32)mV[VGREEN]) * mV[VGREEN] + ((F32)mV[VBLUE]) * mV[VBLUE] );
return sqrt(((F32)mV[VRED]) * mV[VRED] + ((F32)mV[VGREEN]) * mV[VGREEN] + ((F32)mV[VBLUE]) * mV[VBLUE]);
}
// deprecated
inline F32 LLColor4U::magVecSquared(void) const
inline F32 LLColor4U::magVecSquared() const
{
return ((F32)mV[VRED]) * mV[VRED] + ((F32)mV[VGREEN]) * mV[VGREEN] + ((F32)mV[VBLUE]) * mV[VBLUE];
}
inline LLColor4U operator+(const LLColor4U& a, const LLColor4U& b)
{
return LLColor4U(
a.mV[VRED] + b.mV[VRED],
a.mV[VGREEN] + b.mV[VGREEN],
a.mV[VBLUE] + b.mV[VBLUE],
a.mV[VALPHA] + b.mV[VALPHA]);
return LLColor4U(a.mV[VRED] + b.mV[VRED], a.mV[VGREEN] + b.mV[VGREEN], a.mV[VBLUE] + b.mV[VBLUE], a.mV[VALPHA] + b.mV[VALPHA]);
}
inline LLColor4U operator-(const LLColor4U& a, const LLColor4U& b)
{
return LLColor4U(
a.mV[VRED] - b.mV[VRED],
a.mV[VGREEN] - b.mV[VGREEN],
a.mV[VBLUE] - b.mV[VBLUE],
a.mV[VALPHA] - b.mV[VALPHA]);
return LLColor4U(a.mV[VRED] - b.mV[VRED], a.mV[VGREEN] - b.mV[VGREEN], a.mV[VBLUE] - b.mV[VBLUE], a.mV[VALPHA] - b.mV[VALPHA]);
}
inline LLColor4U operator*(const LLColor4U& a, const LLColor4U& b)
{
return LLColor4U(
a.mV[VRED] * b.mV[VRED],
a.mV[VGREEN] * b.mV[VGREEN],
a.mV[VBLUE] * b.mV[VBLUE],
a.mV[VALPHA] * b.mV[VALPHA]);
return LLColor4U(a.mV[VRED] * b.mV[VRED], a.mV[VGREEN] * b.mV[VGREEN], a.mV[VBLUE] * b.mV[VBLUE], a.mV[VALPHA] * b.mV[VALPHA]);
}
inline LLColor4U LLColor4U::addClampMax(const LLColor4U& color)
@ -347,68 +315,17 @@ inline LLColor4U LLColor4U::addClampMax(const LLColor4U &color)
inline LLColor4U LLColor4U::multAll(const F32 k)
{
// Round to nearest
return LLColor4U(
(U8)ll_round(mV[VRED] * k),
(U8)ll_round(mV[VGREEN] * k),
(U8)ll_round(mV[VBLUE] * k),
(U8)ll_round(mV[VALPHA] * k));
return LLColor4U((U8)ll_round(mV[VRED] * k), (U8)ll_round(mV[VGREEN] * k), (U8)ll_round(mV[VBLUE] * k), (U8)ll_round(mV[VALPHA] * k));
}
/*
inline LLColor4U operator*(const LLColor4U &a, U8 k)
{
// only affects rgb (not a!)
return LLColor4U(
a.mV[VRED] * k,
a.mV[VGREEN] * k,
a.mV[VBLUE] * k,
a.mV[VALPHA]);
}
inline LLColor4U operator*(U8 k, const LLColor4U &a)
{
// only affects rgb (not a!)
return LLColor4U(
a.mV[VRED] * k,
a.mV[VGREEN] * k,
a.mV[VBLUE] * k,
a.mV[VALPHA]);
}
inline LLColor4U operator%(U8 k, const LLColor4U &a)
{
// only affects alpha (not rgb!)
return LLColor4U(
a.mV[VRED],
a.mV[VGREEN],
a.mV[VBLUE],
a.mV[VALPHA] * k );
}
inline LLColor4U operator%(const LLColor4U &a, U8 k)
{
// only affects alpha (not rgb!)
return LLColor4U(
a.mV[VRED],
a.mV[VGREEN],
a.mV[VBLUE],
a.mV[VALPHA] * k );
}
*/
inline bool operator==(const LLColor4U& a, const LLColor4U& b)
{
return ( (a.mV[VRED] == b.mV[VRED])
&&(a.mV[VGREEN] == b.mV[VGREEN])
&&(a.mV[VBLUE] == b.mV[VBLUE])
&&(a.mV[VALPHA] == b.mV[VALPHA]));
return ((a.mV[VRED] == b.mV[VRED]) && (a.mV[VGREEN] == b.mV[VGREEN]) && (a.mV[VBLUE] == b.mV[VBLUE]) && (a.mV[VALPHA] == b.mV[VALPHA]));
}
inline bool operator!=(const LLColor4U& a, const LLColor4U& b)
{
return ( (a.mV[VRED] != b.mV[VRED])
||(a.mV[VGREEN] != b.mV[VGREEN])
||(a.mV[VBLUE] != b.mV[VBLUE])
||(a.mV[VALPHA] != b.mV[VALPHA]));
return ((a.mV[VRED] != b.mV[VRED]) || (a.mV[VGREEN] != b.mV[VGREEN]) || (a.mV[VBLUE] != b.mV[VBLUE]) || (a.mV[VALPHA] != b.mV[VALPHA]));
}
inline const LLColor4U& operator+=(LLColor4U& a, const LLColor4U& b)
@ -460,13 +377,13 @@ inline F32 distVec_squared(const LLColor4U &a, const LLColor4U &b)
void LLColor4U::setVecScaleClamp(const LLColor4& color)
{
F32 color_scale_factor = 255.f;
F32 max_color = llmax(color.mV[0], color.mV[1], color.mV[2]);
F32 max_color = llmax(color.mV[VRED], color.mV[VGREEN], color.mV[VBLUE]);
if (max_color > 1.f)
{
color_scale_factor /= max_color;
}
const S32 MAX_COLOR = 255;
S32 r = ll_round(color.mV[0] * color_scale_factor);
constexpr S32 MAX_COLOR = 255;
S32 r = ll_round(color.mV[VRED] * color_scale_factor);
if (r > MAX_COLOR)
{
r = MAX_COLOR;
@ -475,9 +392,9 @@ void LLColor4U::setVecScaleClamp(const LLColor4& color)
{
r = 0;
}
mV[0] = r;
mV[VRED] = r;
S32 g = ll_round(color.mV[1] * color_scale_factor);
S32 g = ll_round(color.mV[VGREEN] * color_scale_factor);
if (g > MAX_COLOR)
{
g = MAX_COLOR;
@ -486,9 +403,9 @@ void LLColor4U::setVecScaleClamp(const LLColor4& color)
{
g = 0;
}
mV[1] = g;
mV[VGREEN] = g;
S32 b = ll_round(color.mV[2] * color_scale_factor);
S32 b = ll_round(color.mV[VBLUE] * color_scale_factor);
if (b > MAX_COLOR)
{
b = MAX_COLOR;
@ -497,10 +414,10 @@ void LLColor4U::setVecScaleClamp(const LLColor4& color)
{
b = 0;
}
mV[2] = b;
mV[VBLUE] = b;
// Alpha shouldn't be scaled, just clamped...
S32 a = ll_round(color.mV[3] * MAX_COLOR);
S32 a = ll_round(color.mV[VALPHA] * MAX_COLOR);
if (a > MAX_COLOR)
{
a = MAX_COLOR;
@ -509,44 +426,42 @@ void LLColor4U::setVecScaleClamp(const LLColor4& color)
{
a = 0;
}
mV[3] = a;
mV[VALPHA] = a;
}
void LLColor4U::setVecScaleClamp(const LLColor3& color)
{
F32 color_scale_factor = 255.f;
F32 max_color = llmax(color.mV[0], color.mV[1], color.mV[2]);
F32 max_color = llmax(color.mV[VRED], color.mV[VGREEN], color.mV[VBLUE]);
if (max_color > 1.f)
{
color_scale_factor /= max_color;
}
const S32 MAX_COLOR = 255;
S32 r = ll_round(color.mV[0] * color_scale_factor);
S32 r = ll_round(color.mV[VRED] * color_scale_factor);
if (r > MAX_COLOR)
{
r = MAX_COLOR;
}
else
if (r < 0)
else if (r < 0)
{
r = 0;
}
mV[0] = r;
mV[VRED] = r;
S32 g = ll_round(color.mV[1] * color_scale_factor);
S32 g = ll_round(color.mV[VGREEN] * color_scale_factor);
if (g > MAX_COLOR)
{
g = MAX_COLOR;
}
else
if (g < 0)
else if (g < 0)
{
g = 0;
}
mV[1] = g;
mV[VGREEN] = g;
S32 b = ll_round(color.mV[2] * color_scale_factor);
S32 b = ll_round(color.mV[VBLUE] * color_scale_factor);
if (b > MAX_COLOR)
{
b = MAX_COLOR;
@ -555,31 +470,29 @@ void LLColor4U::setVecScaleClamp(const LLColor3& color)
{
b = 0;
}
mV[2] = b;
mV[VBLUE] = b;
mV[3] = 255;
mV[VALPHA] = 255;
}
inline U32 LLColor4U::asRGBA() const
{
// Little endian: values are swapped in memory. The original code access the array like a U32, so we need to swap here
return (mV[3] << 24) | (mV[2] << 16) | (mV[1] << 8) | mV[0];
return (mV[VALPHA] << 24) | (mV[VBLUE] << 16) | (mV[VGREEN] << 8) | mV[VRED];
}
inline void LLColor4U::fromRGBA(U32 aVal)
{
// Little endian: values are swapped in memory. The original code access the array like a U32, so we need to swap here
mV[ 0 ] = aVal & 0xFF;
mV[VRED] = aVal & 0xFF;
aVal >>= 8;
mV[ 1 ] = aVal & 0xFF;
mV[VGREEN] = aVal & 0xFF;
aVal >>= 8;
mV[ 2 ] = aVal & 0xFF;
mV[VBLUE] = aVal & 0xFF;
aVal >>= 8;
mV[ 3 ] = aVal & 0xFF;
mV[VALPHA] = aVal & 0xFF;
}
#endif

9
indra/llmath/v4math.cpp
View File

@ -26,7 +26,6 @@
#include "linden_common.h"
//#include "vmath.h"
#include "v3math.h"
#include "v4math.h"
#include "m4math.h"
@ -64,10 +63,10 @@ bool LLVector4::abs()
{
bool ret{ false };
if (mV[0] < 0.f) { mV[0] = -mV[0]; ret = true; }
if (mV[1] < 0.f) { mV[1] = -mV[1]; ret = true; }
if (mV[2] < 0.f) { mV[2] = -mV[2]; ret = true; }
if (mV[3] < 0.f) { mV[3] = -mV[3]; ret = true; }
if (mV[VX] < 0.f) { mV[VX] = -mV[VX]; ret = true; }
if (mV[VY] < 0.f) { mV[VY] = -mV[VY]; ret = true; }
if (mV[VZ] < 0.f) { mV[VZ] = -mV[VZ]; ret = true; }
if (mV[VW] < 0.f) { mV[VW] = -mV[VW]; ret = true; }
return ret;
}

71
indra/llmath/v4math.h
View File

@ -42,7 +42,7 @@ class LLQuaternion;
// LLVector4 = |x y z w|
static const U32 LENGTHOFVECTOR4 = 4;
static constexpr U32 LENGTHOFVECTOR4 = 4;
class LLVector4
{
@ -62,19 +62,19 @@ class LLVector4
LLSD getValue() const
{
LLSD ret;
ret[0] = mV[0];
ret[1] = mV[1];
ret[2] = mV[2];
ret[3] = mV[3];
ret[VX] = mV[VX];
ret[VY] = mV[VY];
ret[VZ] = mV[VZ];
ret[VW] = mV[VW];
return ret;
}
void setValue(const LLSD& sd)
{
mV[0] = (F32)sd[0].asReal();
mV[1] = (F32)sd[1].asReal();
mV[2] = (F32)sd[2].asReal();
mV[3] = (F32)sd[3].asReal();
mV[VX] = (F32)sd[VX].asReal();
mV[VY] = (F32)sd[VY].asReal();
mV[VZ] = (F32)sd[VZ].asReal();
mV[VW] = (F32)sd[VW].asReal();
}
// GLM interop
@ -257,7 +257,7 @@ inline bool LLVector4::isFinite() const
// Clear and Assignment Functions
inline void LLVector4::clear(void)
inline void LLVector4::clear()
{
mV[VX] = 0.f;
mV[VY] = 0.f;
@ -266,7 +266,7 @@ inline void LLVector4::clear(void)
}
// deprecated
inline void LLVector4::clearVec(void)
inline void LLVector4::clearVec()
{
mV[VX] = 0.f;
mV[VY] = 0.f;
@ -275,7 +275,7 @@ inline void LLVector4::clearVec(void)
}
// deprecated
inline void LLVector4::zeroVec(void)
inline void LLVector4::zeroVec()
{
mV[VX] = 0.f;
mV[VY] = 0.f;
@ -386,22 +386,22 @@ inline void LLVector4::setVec(const F32 *vec)
// LLVector4 Magnitude and Normalization Functions
inline F32 LLVector4::length(void) const
inline F32 LLVector4::length() const
{
return (F32) sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
return sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
}
inline F32 LLVector4::lengthSquared(void) const
inline F32 LLVector4::lengthSquared() const
{
return mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ];
}
inline F32 LLVector4::magVec(void) const
inline F32 LLVector4::magVec() const
{
return (F32) sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
return sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
}
inline F32 LLVector4::magVecSquared(void) const
inline F32 LLVector4::magVecSquared() const
{
return mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ];
}
@ -538,9 +538,9 @@ inline LLVector4 lerp(const LLVector4 &a, const LLVector4 &b, F32 u)
a.mV[VW] + (b.mV[VW] - a.mV[VW]) * u);
}
inline F32 LLVector4::normalize(void)
inline F32 LLVector4::normalize()
{
F32 mag = (F32) sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
F32 mag = sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
F32 oomag;
if (mag > FP_MAG_THRESHOLD)
@ -552,18 +552,18 @@ inline F32 LLVector4::normalize(void)
}
else
{
mV[0] = 0.f;
mV[1] = 0.f;
mV[2] = 0.f;
mag = 0;
mV[VX] = 0.f;
mV[VY] = 0.f;
mV[VZ] = 0.f;
mag = 0.f;
}
return (mag);
}
// deprecated
inline F32 LLVector4::normVec(void)
inline F32 LLVector4::normVec()
{
F32 mag = (F32) sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
F32 mag = sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
F32 oomag;
if (mag > FP_MAG_THRESHOLD)
@ -575,22 +575,23 @@ inline F32 LLVector4::normVec(void)
}
else
{
mV[0] = 0.f;
mV[1] = 0.f;
mV[2] = 0.f;
mag = 0;
mV[VX] = 0.f;
mV[VY] = 0.f;
mV[VZ] = 0.f;
mag = 0.f;
}
return (mag);
}
// Because apparently some parts of the viewer use this for color info.
inline const LLVector4 srgbVector4(const LLVector4 &a) {
inline const LLVector4 srgbVector4(const LLVector4& a)
{
LLVector4 srgbColor;
srgbColor.mV[0] = linearTosRGB(a.mV[0]);
srgbColor.mV[1] = linearTosRGB(a.mV[1]);
srgbColor.mV[2] = linearTosRGB(a.mV[2]);
srgbColor.mV[3] = a.mV[3];
srgbColor.mV[VX] = linearTosRGB(a.mV[VX]);
srgbColor.mV[VY] = linearTosRGB(a.mV[VY]);
srgbColor.mV[VZ] = linearTosRGB(a.mV[VZ]);
srgbColor.mV[VW] = a.mV[VW];
return srgbColor;
}

2
indra/llmath/xform.h
View File

@ -115,7 +115,7 @@ public:
void clearChanged(U32 bits) { mChanged &= ~bits; }
void setScaleChildOffset(bool scale) { mScaleChildOffset = scale; }
bool getScaleChildOffset() { return mScaleChildOffset; }
bool getScaleChildOffset() const { return mScaleChildOffset; }
LLXform* getParent() const { return mParent; }
LLXform* getRoot() const;