Merge branch 'master' of https://github.com/FirestormViewer/phoenix-firestorm-develop
# Conflicts: # indra/llmath/v2math.cpp # indra/llmath/v2math.h # indra/llmath/v3math.h # indra/llmath/v4math.hmaster
Ansariel
commit
86f0483152
|
|
@ -16,3 +16,5 @@ e2e37cced861b98de8c1a7c9c0d3a50d2d90e433
|
|||
# ignore some of the merges of ws silliness to restore blame reporting
|
||||
5f1a19af725b90737d50a42a51a7bc1db12c7d13
|
||||
a17fd2352a9746dd3116f956dcc554f95f17e770
|
||||
# ignore beq's formatting derp
|
||||
f8204c43e89d65d981a52aebf033ead5b4b3495a
|
||||
|
|
|
|||
|
|
@ -0,0 +1,168 @@
|
|||
name: Run QA Test # Runs automated tests on a self-hosted QA machine
|
||||
|
||||
on:
|
||||
workflow_run:
|
||||
workflows: ["Build"]
|
||||
types:
|
||||
- completed
|
||||
|
||||
concurrency:
|
||||
group: qa-test-run
|
||||
cancel-in-progress: true # Cancels any queued job when a new one starts
|
||||
|
||||
jobs:
|
||||
debug-workflow:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Debug Workflow Variables
|
||||
run: |
|
||||
echo "Workflow Conclusion: ${{ github.event.workflow_run.conclusion }}"
|
||||
echo "Workflow Head Branch: ${{ github.event.workflow_run.head_branch }}"
|
||||
echo "Workflow Run ID: ${{ github.event.workflow_run.id }}"
|
||||
echo "Head Commit Message: ${{ github.event.workflow_run.head_commit.message }}"
|
||||
echo "GitHub Ref: ${{ github.ref }}"
|
||||
echo "GitHub Ref Name: ${{ github.ref_name }}"
|
||||
echo "GitHub Event Name: ${{ github.event_name }}"
|
||||
echo "GitHub Workflow Name: ${{ github.workflow }}"
|
||||
|
||||
install-viewer-and-run-tests:
|
||||
runs-on: [self-hosted, qa-machine]
|
||||
# Run test only on successful builds of Second_Life_X branches
|
||||
if: >
|
||||
github.event.workflow_run.conclusion == 'success' &&
|
||||
(
|
||||
startsWith(github.event.workflow_run.head_branch, 'Second_Life')
|
||||
)
|
||||
|
||||
steps:
|
||||
- name: Temporarily Allow PowerShell Scripts (Process Scope)
|
||||
run: |
|
||||
Set-ExecutionPolicy RemoteSigned -Scope Process -Force
|
||||
|
||||
- name: Verify viewer-sikulix-main Exists
|
||||
run: |
|
||||
if (-Not (Test-Path -Path 'C:\viewer-sikulix-main')) {
|
||||
Write-Host '❌ Error: viewer-sikulix not found on runner!'
|
||||
exit 1
|
||||
}
|
||||
Write-Host '✅ viewer-sikulix is already available.'
|
||||
|
||||
- name: Fetch & Download Windows Installer Artifact
|
||||
shell: pwsh
|
||||
run: |
|
||||
$BUILD_ID = "${{ github.event.workflow_run.id }}"
|
||||
$ARTIFACTS_URL = "https://api.github.com/repos/secondlife/viewer/actions/runs/$BUILD_ID/artifacts"
|
||||
|
||||
# Fetch the correct artifact URL
|
||||
$response = Invoke-RestMethod -Headers @{Authorization="token ${{ secrets.GITHUB_TOKEN }}" } -Uri $ARTIFACTS_URL
|
||||
$ARTIFACT_NAME = ($response.artifacts | Where-Object { $_.name -eq "Windows-installer" }).archive_download_url
|
||||
|
||||
if (-Not $ARTIFACT_NAME) {
|
||||
Write-Host "❌ Error: Windows-installer artifact not found!"
|
||||
exit 1
|
||||
}
|
||||
|
||||
Write-Host "✅ Artifact found: $ARTIFACT_NAME"
|
||||
|
||||
# Secure download path
|
||||
$DownloadPath = "$env:TEMP\secondlife-build-$BUILD_ID"
|
||||
New-Item -ItemType Directory -Path $DownloadPath -Force | Out-Null
|
||||
$InstallerPath = "$DownloadPath\installer.zip"
|
||||
|
||||
# Download the ZIP
|
||||
Invoke-WebRequest -Uri $ARTIFACT_NAME -Headers @{Authorization="token ${{ secrets.GITHUB_TOKEN }}"} -OutFile $InstallerPath
|
||||
|
||||
# Ensure download succeeded
|
||||
if (-Not (Test-Path $InstallerPath)) {
|
||||
Write-Host "❌ Error: Failed to download Windows-installer.zip"
|
||||
exit 1
|
||||
}
|
||||
|
||||
- name: Extract Installer & Locate Executable
|
||||
shell: pwsh
|
||||
run: |
|
||||
# Explicitly set BUILD_ID again (since it does not appear to persist across steps)
|
||||
$BUILD_ID = "${{ github.event.workflow_run.id }}"
|
||||
$ExtractPath = "$env:TEMP\secondlife-build-$BUILD_ID"
|
||||
$InstallerZip = "$ExtractPath\installer.zip"
|
||||
|
||||
# Print paths for debugging
|
||||
Write-Host "Extract Path: $ExtractPath"
|
||||
Write-Host "Installer ZIP Path: $InstallerZip"
|
||||
|
||||
# Verify ZIP exists before extracting
|
||||
if (-Not (Test-Path $InstallerZip)) {
|
||||
Write-Host "❌ Error: ZIP file not found at $InstallerZip!"
|
||||
exit 1
|
||||
}
|
||||
|
||||
Write-Host "✅ ZIP file exists and is valid. Extracting..."
|
||||
|
||||
Expand-Archive -Path $InstallerZip -DestinationPath $ExtractPath -Force
|
||||
|
||||
# Find installer executable
|
||||
$INSTALLER_PATH = (Get-ChildItem -Path $ExtractPath -Filter '*.exe' -Recurse | Select-Object -First 1).FullName
|
||||
|
||||
if (-Not $INSTALLER_PATH -or $INSTALLER_PATH -eq "") {
|
||||
Write-Host "❌ Error: No installer executable found in the extracted files!"
|
||||
Write-Host "📂 Extracted Files:"
|
||||
Get-ChildItem -Path $ExtractPath -Recurse | Format-Table -AutoSize
|
||||
exit 1
|
||||
}
|
||||
|
||||
Write-Host "✅ Installer found: $INSTALLER_PATH"
|
||||
echo "INSTALLER_PATH=$INSTALLER_PATH" | Out-File -FilePath $env:GITHUB_ENV -Append
|
||||
|
||||
- name: Install Second Life Using Task Scheduler (Bypass UAC)
|
||||
shell: pwsh
|
||||
run: |
|
||||
$action = New-ScheduledTaskAction -Execute "${{ env.INSTALLER_PATH }}" -Argument "/S"
|
||||
$principal = New-ScheduledTaskPrincipal -UserId "SYSTEM" -LogonType ServiceAccount -RunLevel Highest
|
||||
$task = New-ScheduledTask -Action $action -Principal $principal
|
||||
Register-ScheduledTask -TaskName "SilentSLInstaller" -InputObject $task -Force
|
||||
Start-ScheduledTask -TaskName "SilentSLInstaller"
|
||||
|
||||
- name: Wait for Installation to Complete
|
||||
shell: pwsh
|
||||
run: |
|
||||
Write-Host "Waiting for the Second Life installer to finish..."
|
||||
do {
|
||||
Start-Sleep -Seconds 5
|
||||
$installerProcess = Get-Process | Where-Object { $_.Path -eq "${{ env.INSTALLER_PATH }}" }
|
||||
} while ($installerProcess)
|
||||
|
||||
Write-Host "✅ Installation completed!"
|
||||
|
||||
- name: Cleanup Task Scheduler Entry
|
||||
shell: pwsh
|
||||
run: |
|
||||
Unregister-ScheduledTask -TaskName "SilentSLInstaller" -Confirm:$false
|
||||
Write-Host "✅ Task Scheduler entry removed."
|
||||
|
||||
- name: Delete Installer ZIP
|
||||
shell: pwsh
|
||||
run: |
|
||||
# Explicitly set BUILD_ID again
|
||||
$BUILD_ID = "${{ github.event.workflow_run.id }}"
|
||||
$DeletePath = "$env:TEMP\secondlife-build-$BUILD_ID\installer.zip"
|
||||
|
||||
Write-Host "Checking if installer ZIP exists: $DeletePath"
|
||||
|
||||
# Ensure the ZIP file exists before trying to delete it
|
||||
if (Test-Path $DeletePath) {
|
||||
Remove-Item -Path $DeletePath -Force
|
||||
Write-Host "✅ Successfully deleted: $DeletePath"
|
||||
} else {
|
||||
Write-Host "⚠️ Warning: ZIP file does not exist, skipping deletion."
|
||||
}
|
||||
|
||||
- name: Run QA Test Script
|
||||
run: |
|
||||
Write-Host "Running QA Test script..."
|
||||
python C:\viewer-sikulix-main\runTests.py
|
||||
|
||||
# - name: Upload Test Results
|
||||
# uses: actions/upload-artifact@v3
|
||||
# with:
|
||||
# name: test-results
|
||||
# path: C:\viewer-sikulix-main\regressionTest\test_results.html
|
||||
|
|
@ -107,7 +107,7 @@ if (WINDOWS)
|
|||
/Oy-
|
||||
/Oi
|
||||
/Ot
|
||||
/fp:fast
|
||||
/fp:precise
|
||||
/MP
|
||||
/permissive-
|
||||
)
|
||||
|
|
|
|||
|
|
@ -1,11 +1,5 @@
|
|||
# -*- cmake -*-
|
||||
|
||||
# cmake_minimum_required should appear before any
|
||||
# other commands to guarantee full compatibility
|
||||
# with the version specified
|
||||
## prior to 2.8, the add_custom_target commands used in setting the version did not work correctly
|
||||
#cmake_minimum_required(VERSION 3.8.0 FATAL_ERROR)
|
||||
|
||||
set(ROOT_PROJECT_NAME "SecondLife" CACHE STRING
|
||||
"The root project/makefile/solution name. Defaults to SecondLife.")
|
||||
project(${ROOT_PROJECT_NAME})
|
||||
|
|
|
|||
|
|
@ -552,12 +552,12 @@ void LLPolyMorphTarget::apply( ESex avatar_sex )
|
|||
|
||||
mLastSex = avatar_sex;
|
||||
|
||||
// Check for NaN condition (NaN is detected if a variable doesn't equal itself.
|
||||
if (mCurWeight != mCurWeight)
|
||||
// Check for NaN condition
|
||||
if (llisnan(mCurWeight))
|
||||
{
|
||||
mCurWeight = 0.0;
|
||||
mCurWeight = 0.f;
|
||||
}
|
||||
if (mLastWeight != mLastWeight)
|
||||
if (llisnan(mLastWeight))
|
||||
{
|
||||
mLastWeight = mCurWeight+.001f;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -34,15 +34,15 @@ class LLUUID;
|
|||
// <FS:Ansariel> Centralize definition of application name
|
||||
const std::string APP_NAME = "Firestorm";
|
||||
|
||||
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
|
||||
{
|
||||
|
|
@ -70,113 +70,113 @@ 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_CONTEXT_MENU = 0x99; // <FS:Ansariel> FIRE-19933: Open context menu on context menu key press
|
||||
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_CONTEXT_MENU = 0x99; // <FS:Ansariel> FIRE-19933: Open context menu on context menu key press
|
||||
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;
|
||||
|
|
@ -243,121 +243,123 @@ 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;
|
||||
constexpr U32 BEACON_FOCUS_MAP = 0x0002;
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -166,14 +166,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
|
||||
|
|
@ -191,7 +191,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
|
||||
|
|
|
|||
|
|
@ -262,6 +262,8 @@ public:
|
|||
|
||||
void setMediaURLResetTimer(F32 time);
|
||||
virtual void setLocalID(S32 local_id);
|
||||
void setRegionID(const LLUUID& id) { mRegionID = id; }
|
||||
const LLUUID& getRegionID() const { return mRegionID; }
|
||||
|
||||
// blow away all the extra stuff lurking in parcels, including urls, access lists, etc
|
||||
void clearParcel();
|
||||
|
|
@ -651,6 +653,7 @@ public:
|
|||
S32 mLocalID;
|
||||
LLUUID mBanListTransactionID;
|
||||
LLUUID mAccessListTransactionID;
|
||||
LLUUID mRegionID;
|
||||
std::map<LLUUID,LLAccessEntry> mAccessList;
|
||||
std::map<LLUUID,LLAccessEntry> mBanList;
|
||||
std::map<LLUUID,LLAccessEntry> mTempBanList;
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -26,7 +26,6 @@
|
|||
|
||||
#include "linden_common.h"
|
||||
|
||||
//#include "vmath.h"
|
||||
#include "v3math.h"
|
||||
#include "m3math.h"
|
||||
#include "v4math.h"
|
||||
|
|
|
|||
|
|
@ -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();
|
||||
|
|
|
|||
|
|
@ -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
|
||||
{
|
||||
|
|
|
|||
|
|
@ -39,18 +39,8 @@
|
|||
// llcommon depend on llmath.
|
||||
#include "is_approx_equal_fraction.h"
|
||||
|
||||
// work around for Windows & older gcc non-standard function names.
|
||||
#if LL_WINDOWS
|
||||
#include <float.h>
|
||||
#define llisnan(val) _isnan(val)
|
||||
#define llfinite(val) _finite(val)
|
||||
#elif (LL_LINUX && __GNUC__ <= 2)
|
||||
#define llisnan(val) isnan(val)
|
||||
#define llfinite(val) isfinite(val)
|
||||
#else
|
||||
#define llisnan(val) std::isnan(val)
|
||||
#define llfinite(val) std::isfinite(val)
|
||||
#endif
|
||||
#define llisnan(val) std::isnan(val)
|
||||
#define llfinite(val) std::isfinite(val)
|
||||
|
||||
// Single Precision Floating Point Routines
|
||||
// (There used to be more defined here, but they appeared to be redundant and
|
||||
|
|
@ -89,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.
|
||||
|
|
@ -148,33 +138,17 @@ 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 )
|
||||
inline S32 llfloor(F32 f)
|
||||
{
|
||||
#if LL_WINDOWS && !defined( __INTEL_COMPILER ) && (ADDRESS_SIZE == 32)
|
||||
// Avoids changing the floating point control word.
|
||||
|
|
@ -284,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;
|
||||
|
|
@ -342,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;
|
||||
|
|
@ -358,15 +332,9 @@ inline F32 snap_to_sig_figs(F32 foo, S32 sig_figs)
|
|||
return new_foo;
|
||||
}
|
||||
|
||||
// <FS:Ansariel> std::lerp fix from previous develop branch
|
||||
//inline F32 lerp(F32 a, F32 b, F32 u)
|
||||
//{
|
||||
// return a + ((b - a) * u);
|
||||
//}
|
||||
using std::lerp;
|
||||
// </FS:Ansariel>
|
||||
|
||||
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;
|
||||
|
|
@ -374,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)
|
||||
{
|
||||
|
|
@ -397,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;
|
||||
|
|
@ -410,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;
|
||||
|
|
@ -431,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;
|
||||
|
|
@ -441,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)
|
||||
{
|
||||
|
|
@ -463,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)
|
||||
{
|
||||
|
|
@ -489,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
|
||||
|
|
@ -542,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;
|
||||
}
|
||||
|
|
@ -557,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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -30,7 +30,6 @@
|
|||
|
||||
#include "llquaternion.h"
|
||||
|
||||
//#include "vmath.h"
|
||||
#include "v3math.h"
|
||||
#include "v3dmath.h"
|
||||
#include "v4math.h"
|
||||
|
|
|
|||
|
|
@ -1311,10 +1311,11 @@ void LLPath::genNGon(const LLPathParams& params, S32 sides, F32 startOff, F32 en
|
|||
c = cos(ang)*lerp(radius_start, radius_end, t);
|
||||
|
||||
|
||||
pt->mPos.set(0 + lerp(0.f,params.getShear().mV[0],s)
|
||||
pt->mPos.set(0 + lerp(0.f, params.getShear().mV[VX], s)
|
||||
+ lerp(-skew ,skew, t) * 0.5f,
|
||||
c + lerp(0.f,params.getShear().mV[1],s),
|
||||
c + lerp(0.f, params.getShear().mV[VY], s),
|
||||
s);
|
||||
|
||||
pt->mScale.set(hole_x * lerp(taper_x_begin, taper_x_end, t),
|
||||
hole_y * lerp(taper_y_begin, taper_y_end, t),
|
||||
0,1);
|
||||
|
|
@ -1344,9 +1345,9 @@ void LLPath::genNGon(const LLPathParams& params, S32 sides, F32 startOff, F32 en
|
|||
c = cos(ang)*lerp(radius_start, radius_end, t);
|
||||
s = sin(ang)*lerp(radius_start, radius_end, t);
|
||||
|
||||
pt->mPos.set(0 + lerp(0.f,params.getShear().mV[0],s)
|
||||
pt->mPos.set(0 + lerp(0.f, params.getShear().mV[VX], s)
|
||||
+ lerp(-skew ,skew, t) * 0.5f,
|
||||
c + lerp(0.f,params.getShear().mV[1],s),
|
||||
c + lerp(0.f, params.getShear().mV[VY], s),
|
||||
s);
|
||||
|
||||
pt->mScale.set(hole_x * lerp(taper_x_begin, taper_x_end, t),
|
||||
|
|
@ -1371,9 +1372,9 @@ void LLPath::genNGon(const LLPathParams& params, S32 sides, F32 startOff, F32 en
|
|||
c = cos(ang)*lerp(radius_start, radius_end, t);
|
||||
s = sin(ang)*lerp(radius_start, radius_end, t);
|
||||
|
||||
pt->mPos.set(0 + lerp(0.f,params.getShear().mV[0],s)
|
||||
pt->mPos.set(0 + lerp(0.f, params.getShear().mV[VX], s)
|
||||
+ lerp(-skew ,skew, t) * 0.5f,
|
||||
c + lerp(0.f,params.getShear().mV[1],s),
|
||||
c + lerp(0.f, params.getShear().mV[VY], s),
|
||||
s);
|
||||
pt->mScale.set(hole_x * lerp(taper_x_begin, taper_x_end, t),
|
||||
hole_y * lerp(taper_y_begin, taper_y_end, t),
|
||||
|
|
@ -1511,8 +1512,8 @@ bool LLPath::generate(const LLPathParams& params, F32 detail, S32 split,
|
|||
for (S32 i=0;i<np;i++)
|
||||
{
|
||||
F32 t = lerp(params.getBegin(),params.getEnd(),(F32)i * mStep);
|
||||
mPath[i].mPos.set(lerp(0.f,params.getShear().mV[0],t),
|
||||
lerp(0.f,params.getShear().mV[1],t),
|
||||
mPath[i].mPos.set(lerp(0.f, params.getShear().mV[VX], t),
|
||||
lerp(0.f ,params.getShear().mV[VY], t),
|
||||
t - 0.5f);
|
||||
LLQuaternion quat;
|
||||
quat.setQuat(lerp(F_PI * params.getTwistBegin(),F_PI * params.getTwist(),t),0,0,1);
|
||||
|
|
@ -1576,10 +1577,10 @@ bool LLPath::generate(const LLPathParams& params, F32 detail, S32 split,
|
|||
{
|
||||
F32 t = (F32)i * mStep;
|
||||
mPath[i].mPos.set(0,
|
||||
lerp(0.f, -sin(F_PI*params.getTwist()*t)*0.5f,t),
|
||||
lerp(-0.5f, cos(F_PI*params.getTwist()*t)*0.5f,t));
|
||||
mPath[i].mScale.set(lerp(1.f,params.getScale().mV[0],t),
|
||||
lerp(1.f,params.getScale().mV[1],t), 0.f,1.f);
|
||||
lerp(0.f, -sin(F_PI*params.getTwist() * t) * 0.5f, t),
|
||||
lerp(-0.5f, cos(F_PI*params.getTwist() * t) * 0.5f, t));
|
||||
mPath[i].mScale.set(lerp(1.f, params.getScale().mV[VX], t),
|
||||
lerp(1.f, params.getScale().mV[VY], t), 0.f, 1.f);
|
||||
mPath[i].mTexT = t;
|
||||
LLQuaternion quat;
|
||||
quat.setQuat(F_PI * params.getTwist() * t,1,0,0);
|
||||
|
|
|
|||
|
|
@ -45,7 +45,6 @@ class LLVolumeOctree;
|
|||
|
||||
#include "lluuid.h"
|
||||
#include "v4color.h"
|
||||
//#include "vmath.h"
|
||||
#include "v2math.h"
|
||||
#include "v3math.h"
|
||||
#include "v3dmath.h"
|
||||
|
|
|
|||
|
|
@ -26,7 +26,6 @@
|
|||
|
||||
#include "linden_common.h"
|
||||
|
||||
//#include "vmath.h"
|
||||
#include "v3math.h"
|
||||
#include "v3dmath.h"
|
||||
#include "v4math.h"
|
||||
|
|
|
|||
|
|
@ -26,7 +26,6 @@
|
|||
|
||||
#include "linden_common.h"
|
||||
|
||||
//#include "vmath.h"
|
||||
#include "v3math.h"
|
||||
#include "v4math.h"
|
||||
#include "m4math.h"
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
@ -74,14 +73,14 @@ F32 signed_angle_between(const LLVector2& a, const LLVector2& b)
|
|||
return rhombus_square < 0 ? -angle : angle;
|
||||
}
|
||||
|
||||
bool are_parallel(const LLVector2 &a, const LLVector2 &b, F32 epsilon)
|
||||
bool are_parallel(const LLVector2& a, const LLVector2& b, F32 epsilon)
|
||||
{
|
||||
LLVector2 an = a;
|
||||
LLVector2 bn = b;
|
||||
an.normVec();
|
||||
bn.normVec();
|
||||
F32 dot = an * bn;
|
||||
if ( (1.0f - fabs(dot)) < epsilon)
|
||||
if ((1.0f - fabs(dot)) < epsilon)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
|
@ -89,28 +88,28 @@ bool are_parallel(const LLVector2 &a, const LLVector2 &b, F32 epsilon)
|
|||
}
|
||||
|
||||
|
||||
F32 dist_vec(const LLVector2 &a, const LLVector2 &b)
|
||||
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 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 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;
|
||||
}
|
||||
|
||||
LLVector2 lerp(const LLVector2 &a, const LLVector2 &b, F32 u)
|
||||
LLVector2 lerp(const LLVector2& a, const LLVector2& b, F32 u)
|
||||
{
|
||||
return LLVector2(
|
||||
a.mV[VX] + (b.mV[VX] - a.mV[VX]) * u,
|
||||
|
|
@ -120,14 +119,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();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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]; }
|
||||
|
|
@ -113,17 +113,17 @@ class LLVector2
|
|||
|
||||
// Non-member functions
|
||||
|
||||
F32 angle_between(const LLVector2 &a, const LLVector2 &b); // Returns angle (radians) between a and b
|
||||
F32 angle_between(const LLVector2& a, const LLVector2& b); // Returns angle (radians) between a and b
|
||||
F32 signed_angle_between(const LLVector2& a, const LLVector2& b); // Returns signed angle (radians) between a and b
|
||||
bool are_parallel(const LLVector2 &a, const LLVector2 &b, F32 epsilon=F_APPROXIMATELY_ZERO); // Returns true if a and b are very close to parallel
|
||||
F32 dist_vec(const LLVector2 &a, const LLVector2 &b); // Returns distance between a and b
|
||||
F32 dist_vec_squared(const LLVector2 &a, const LLVector2 &b);// Returns distance squared between a and b
|
||||
F32 dist_vec_squared2D(const LLVector2 &a, const LLVector2 &b);// Returns distance squared between a and b ignoring Z component
|
||||
LLVector2 lerp(const LLVector2 &a, const LLVector2 &b, F32 u); // Returns a vector that is a linear interpolation between a and b
|
||||
bool are_parallel(const LLVector2& a, const LLVector2& b, F32 epsilon = F_APPROXIMATELY_ZERO); // Returns true if a and b are very close to parallel
|
||||
F32 dist_vec(const LLVector2& a, const LLVector2& b); // Returns distance between a and b
|
||||
F32 dist_vec_squared(const LLVector2& a, const LLVector2& b);// Returns distance squared between a and b
|
||||
F32 dist_vec_squared2D(const LLVector2& a, const LLVector2& b);// Returns distance squared between a and b ignoring Z component
|
||||
LLVector2 lerp(const LLVector2& a, const LLVector2& b, F32 u); // Returns a vector that is a linear interpolation between a and b
|
||||
|
||||
// Constructors
|
||||
|
||||
inline LLVector2::LLVector2(void)
|
||||
inline LLVector2::LLVector2()
|
||||
{
|
||||
clear();
|
||||
}
|
||||
|
|
@ -150,24 +150,24 @@ inline LLVector2::LLVector2(const LLSD &sd)
|
|||
|
||||
// Clear and Assignment Functions
|
||||
|
||||
inline void LLVector2::clear(void)
|
||||
inline void LLVector2::clear()
|
||||
{
|
||||
mV[VX] = mV[VY] = 0.f;
|
||||
}
|
||||
|
||||
inline void LLVector2::setZero(void)
|
||||
inline void LLVector2::setZero()
|
||||
{
|
||||
clear();
|
||||
}
|
||||
|
||||
// deprecated
|
||||
inline void LLVector2::clearVec(void)
|
||||
inline void LLVector2::clearVec()
|
||||
{
|
||||
clear();
|
||||
}
|
||||
|
||||
// deprecated
|
||||
inline void LLVector2::zeroVec(void)
|
||||
inline void LLVector2::zeroVec()
|
||||
{
|
||||
clear();
|
||||
}
|
||||
|
|
@ -210,17 +210,17 @@ inline void LLVector2::setVec(const F32 *vec)
|
|||
|
||||
// LLVector2 Magnitude and Normalization Functions
|
||||
|
||||
inline F32 LLVector2::length(void) const
|
||||
inline F32 LLVector2::length() const
|
||||
{
|
||||
return sqrt(lengthSquared());
|
||||
}
|
||||
|
||||
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 = length();
|
||||
|
||||
|
|
@ -268,7 +268,7 @@ inline const LLVector2& LLVector2::scaleVec(const LLVector2& vec)
|
|||
return *this;
|
||||
}
|
||||
|
||||
inline bool LLVector2::isNull()
|
||||
inline bool LLVector2::isNull() const
|
||||
{
|
||||
return F_APPROXIMATELY_ZERO > mV[VX]*mV[VX] + mV[VY]*mV[VY];
|
||||
}
|
||||
|
|
@ -277,9 +277,9 @@ inline bool LLVector2::isNull()
|
|||
// LLVector2 Operators
|
||||
|
||||
// For sorting. By convention, x is "more significant" than y.
|
||||
inline bool operator<(const LLVector2 &a, const LLVector2 &b)
|
||||
inline bool operator<(const LLVector2& a, const LLVector2& b)
|
||||
{
|
||||
if( a.mV[VX] == b.mV[VX] )
|
||||
if (a.mV[VX] == b.mV[VX])
|
||||
{
|
||||
return a.mV[VY] < b.mV[VY];
|
||||
}
|
||||
|
|
@ -290,92 +290,92 @@ inline bool operator<(const LLVector2 &a, const LLVector2 &b)
|
|||
}
|
||||
|
||||
|
||||
inline LLVector2 operator+(const LLVector2 &a, const LLVector2 &b)
|
||||
inline LLVector2 operator+(const LLVector2& a, const LLVector2& b)
|
||||
{
|
||||
LLVector2 c(a);
|
||||
return c += b;
|
||||
}
|
||||
|
||||
inline LLVector2 operator-(const LLVector2 &a, const LLVector2 &b)
|
||||
inline LLVector2 operator-(const LLVector2& a, const LLVector2& b)
|
||||
{
|
||||
LLVector2 c(a);
|
||||
return c -= b;
|
||||
}
|
||||
|
||||
inline F32 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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
inline const LLVector2& operator/=(LLVector2& a, F32 k)
|
||||
{
|
||||
return a *= 1.f / k;
|
||||
}
|
||||
|
||||
inline LLVector2 operator-(const LLVector2 &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)
|
||||
|
|
@ -393,7 +393,7 @@ inline void update_min_max(LLVector2& min, LLVector2& max, const LLVector2& pos)
|
|||
}
|
||||
}
|
||||
|
||||
inline std::ostream& operator<<(std::ostream& s, const LLVector2 &a)
|
||||
inline std::ostream& operator<<(std::ostream& s, const LLVector2& a)
|
||||
{
|
||||
s << "{ " << a.mV[VX] << ", " << a.mV[VY] << " }";
|
||||
return s;
|
||||
|
|
|
|||
|
|
@ -32,74 +32,79 @@
|
|||
|
||||
LLColor3 LLColor3::white(1.0f, 1.0f, 1.0f);
|
||||
LLColor3 LLColor3::black(0.0f, 0.0f, 0.0f);
|
||||
LLColor3 LLColor3::grey (0.5f, 0.5f, 0.5f);
|
||||
LLColor3 LLColor3::grey(0.5f, 0.5f, 0.5f);
|
||||
|
||||
LLColor3::LLColor3(const LLColor4 &a)
|
||||
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)
|
||||
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)
|
||||
LLColor3::LLColor3(const LLSD& sd)
|
||||
{
|
||||
setValue(sd);
|
||||
}
|
||||
|
||||
const LLColor3& LLColor3::operator=(const LLColor4 &a)
|
||||
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);
|
||||
}
|
||||
|
||||
std::ostream& operator<<(std::ostream& s, const LLColor3 &a)
|
||||
std::ostream& operator<<(std::ostream& s, const LLColor3& a)
|
||||
{
|
||||
s << "{ " << a.mV[VRED] << ", " << a.mV[VGREEN] << ", " << a.mV[VBLUE] << " }";
|
||||
return s;
|
||||
}
|
||||
|
||||
static F32 hueToRgb ( F32 val1In, F32 val2In, F32 valHUeIn )
|
||||
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 );
|
||||
return ( val1In );
|
||||
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);
|
||||
}
|
||||
|
||||
void LLColor3::setHSL ( F32 hValIn, F32 sValIn, F32 lValIn)
|
||||
void LLColor3::setHSL(F32 hValIn, F32 sValIn, F32 lValIn)
|
||||
{
|
||||
if ( sValIn < 0.00001f )
|
||||
if (sValIn < 0.00001f)
|
||||
{
|
||||
mV[VRED] = lValIn;
|
||||
mV[VRED] = lValIn;
|
||||
mV[VGREEN] = lValIn;
|
||||
mV[VBLUE] = lValIn;
|
||||
mV[VBLUE] = lValIn;
|
||||
}
|
||||
else
|
||||
{
|
||||
F32 interVal1;
|
||||
F32 interVal2;
|
||||
|
||||
if ( lValIn < 0.5f )
|
||||
interVal2 = lValIn * ( 1.0f + sValIn );
|
||||
if (lValIn < 0.5f)
|
||||
interVal2 = lValIn * (1.0f + sValIn);
|
||||
else
|
||||
interVal2 = ( lValIn + sValIn ) - ( sValIn * lValIn );
|
||||
interVal2 = (lValIn + sValIn) - (sValIn * lValIn);
|
||||
|
||||
interVal1 = 2.0f * lValIn - interVal2;
|
||||
|
||||
mV[VRED] = hueToRgb ( interVal1, interVal2, hValIn + ( 1.f / 3.f ) );
|
||||
mV[VGREEN] = hueToRgb ( interVal1, interVal2, hValIn );
|
||||
mV[VBLUE] = hueToRgb ( interVal1, interVal2, hValIn - ( 1.f / 3.f ) );
|
||||
mV[VRED] = hueToRgb(interVal1, interVal2, hValIn + (1.f / 3.f));
|
||||
mV[VGREEN] = hueToRgb(interVal1, interVal2, hValIn);
|
||||
mV[VBLUE] = hueToRgb(interVal1, interVal2, hValIn - (1.f / 3.f));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -109,45 +114,48 @@ void LLColor3::calcHSL(F32* hue, F32* saturation, F32* luminance) const
|
|||
F32 var_G = mV[VGREEN];
|
||||
F32 var_B = mV[VBLUE];
|
||||
|
||||
F32 var_Min = ( var_R < ( var_G < var_B ? var_G : var_B ) ? var_R : ( var_G < var_B ? var_G : var_B ) );
|
||||
F32 var_Max = ( var_R > ( var_G > var_B ? var_G : var_B ) ? var_R : ( var_G > var_B ? var_G : var_B ) );
|
||||
F32 var_Min = (var_R < (var_G < var_B ? var_G : var_B) ? var_R : (var_G < var_B ? var_G : var_B));
|
||||
F32 var_Max = (var_R > (var_G > var_B ? var_G : var_B) ? var_R : (var_G > var_B ? var_G : var_B));
|
||||
|
||||
F32 del_Max = var_Max - var_Min;
|
||||
|
||||
F32 L = ( var_Max + var_Min ) / 2.0f;
|
||||
F32 L = (var_Max + var_Min) / 2.0f;
|
||||
F32 H = 0.0f;
|
||||
F32 S = 0.0f;
|
||||
|
||||
if ( del_Max == 0.0f )
|
||||
if (del_Max == 0.0f)
|
||||
{
|
||||
H = 0.0f;
|
||||
S = 0.0f;
|
||||
H = 0.0f;
|
||||
S = 0.0f;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( L < 0.5 )
|
||||
S = del_Max / ( var_Max + var_Min );
|
||||
if (L < 0.5)
|
||||
S = del_Max / (var_Max + var_Min);
|
||||
else
|
||||
S = del_Max / ( 2.0f - var_Max - var_Min );
|
||||
S = del_Max / (2.0f - var_Max - var_Min);
|
||||
|
||||
F32 del_R = ( ( ( var_Max - var_R ) / 6.0f ) + ( del_Max / 2.0f ) ) / del_Max;
|
||||
F32 del_G = ( ( ( var_Max - var_G ) / 6.0f ) + ( del_Max / 2.0f ) ) / del_Max;
|
||||
F32 del_B = ( ( ( var_Max - var_B ) / 6.0f ) + ( del_Max / 2.0f ) ) / del_Max;
|
||||
F32 del_R = (((var_Max - var_R) / 6.0f) + (del_Max / 2.0f)) / del_Max;
|
||||
F32 del_G = (((var_Max - var_G) / 6.0f) + (del_Max / 2.0f)) / del_Max;
|
||||
F32 del_B = (((var_Max - var_B) / 6.0f) + (del_Max / 2.0f)) / del_Max;
|
||||
|
||||
if ( var_R >= var_Max )
|
||||
if (var_R >= var_Max)
|
||||
H = del_B - del_G;
|
||||
else
|
||||
if ( var_G >= var_Max )
|
||||
H = ( 1.0f / 3.0f ) + del_R - del_B;
|
||||
else
|
||||
if ( var_B >= var_Max )
|
||||
H = ( 2.0f / 3.0f ) + del_G - del_R;
|
||||
else if (var_G >= var_Max)
|
||||
H = (1.0f / 3.0f) + del_R - del_B;
|
||||
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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -33,14 +33,14 @@ class LLVector4;
|
|||
#include "llerror.h"
|
||||
#include "llmath.h"
|
||||
#include "llsd.h"
|
||||
#include "v3math.h" // needed for linearColor3v implemtation below
|
||||
#include "v3math.h" // needed for linearColor3v implemtation below
|
||||
#include <string.h>
|
||||
|
||||
#include <string.h> // <FS:ND/> for strlen/strncpy
|
||||
|
||||
// LLColor3 = |r g b|
|
||||
|
||||
static const U32 LENGTHOFCOLOR3 = 3;
|
||||
static constexpr U32 LENGTHOFCOLOR3 = 3;
|
||||
|
||||
class LLColor3
|
||||
{
|
||||
|
|
@ -52,44 +52,43 @@ public:
|
|||
static LLColor3 grey;
|
||||
|
||||
public:
|
||||
LLColor3(); // Initializes LLColor3 to (0, 0, 0)
|
||||
LLColor3(F32 r, F32 g, F32 b); // Initializes LLColor3 to (r, g, b)
|
||||
LLColor3(const F32 *vec); // Initializes LLColor3 to (vec[0]. vec[1], vec[2])
|
||||
LLColor3(const char *color_string); // html format color ie "#FFDDEE"
|
||||
explicit LLColor3(const LLColor4& color4); // "explicit" to avoid automatic conversion
|
||||
explicit LLColor3(const LLVector4& vector4); // "explicit" to avoid automatic conversion
|
||||
LLColor3(); // Initializes LLColor3 to (0, 0, 0)
|
||||
LLColor3(F32 r, F32 g, F32 b); // Initializes LLColor3 to (r, g, b)
|
||||
LLColor3(const F32* vec); // Initializes LLColor3 to (vec[0]. vec[1], vec[2])
|
||||
LLColor3(const char* color_string); // html format color ie "#FFDDEE"
|
||||
explicit LLColor3(const LLColor4& color4); // "explicit" to avoid automatic conversion
|
||||
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);
|
||||
void calcHSL(F32* hue, F32* saturation, F32* luminance) const;
|
||||
|
||||
const LLColor3& setToBlack(); // Clears LLColor3 to (0, 0, 0)
|
||||
const LLColor3& setToWhite(); // Zero LLColor3 to (0, 0, 0)
|
||||
const LLColor3& setToBlack(); // Clears LLColor3 to (0, 0, 0)
|
||||
const LLColor3& setToWhite(); // Zero LLColor3 to (0, 0, 0)
|
||||
|
||||
const LLColor3& setVec(F32 x, F32 y, F32 z); // deprecated
|
||||
const LLColor3& setVec(const LLColor3 &vec); // deprecated
|
||||
const LLColor3& setVec(const F32 *vec); // deprecated
|
||||
const LLColor3& setVec(F32 x, F32 y, F32 z); // deprecated
|
||||
const LLColor3& setVec(const LLColor3& vec); // deprecated
|
||||
const LLColor3& setVec(const F32* vec); // deprecated
|
||||
|
||||
const LLColor3& set(F32 x, F32 y, F32 z); // Sets LLColor3 to (x, y, z)
|
||||
const LLColor3& set(const LLColor3 &vec); // Sets LLColor3 to vec
|
||||
const LLColor3& set(const F32 *vec); // Sets LLColor3 to vec
|
||||
const LLColor3& set(F32 x, F32 y, F32 z); // Sets LLColor3 to (x, y, z)
|
||||
const LLColor3& set(const LLColor3& vec); // Sets LLColor3 to vec
|
||||
const LLColor3& set(const F32* vec); // Sets LLColor3 to vec
|
||||
|
||||
// set from a vector of unknown type and size
|
||||
// may leave some data unmodified
|
||||
|
|
@ -101,414 +100,390 @@ public:
|
|||
template<typename T>
|
||||
void write(std::vector<T>& v) const;
|
||||
|
||||
F32 magVec() const; // deprecated
|
||||
F32 magVecSquared() const; // deprecated
|
||||
F32 normVec(); // deprecated
|
||||
F32 magVec() const; // deprecated
|
||||
F32 magVecSquared() const; // deprecated
|
||||
F32 normVec(); // deprecated
|
||||
|
||||
F32 length() const; // Returns magnitude of LLColor3
|
||||
F32 lengthSquared() const; // Returns magnitude squared of LLColor3
|
||||
F32 normalize(); // Normalizes and returns the magnitude of LLColor3
|
||||
F32 length() const; // Returns magnitude of LLColor3
|
||||
F32 lengthSquared() const; // Returns magnitude squared of LLColor3
|
||||
F32 normalize(); // Normalizes and returns the magnitude of LLColor3
|
||||
|
||||
F32 brightness() const; // Returns brightness of LLColor3
|
||||
F32 brightness() const; // Returns brightness of LLColor3
|
||||
|
||||
const LLColor3& operator=(const LLColor4 &a);
|
||||
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
|
||||
friend LLColor3 operator+(const LLColor3 &a, const LLColor3 &b); // Return vector a + b
|
||||
friend LLColor3 operator-(const LLColor3 &a, const LLColor3 &b); // Return vector a minus b
|
||||
friend std::ostream& operator<<(std::ostream& s, const LLColor3& a); // Print a
|
||||
friend LLColor3 operator+(const LLColor3& a, const LLColor3& b); // Return vector a + b
|
||||
friend LLColor3 operator-(const LLColor3& a, const LLColor3& b); // Return vector a minus b
|
||||
|
||||
friend const LLColor3& operator+=(LLColor3 &a, const LLColor3 &b); // Return vector a + b
|
||||
friend const LLColor3& operator-=(LLColor3 &a, const LLColor3 &b); // Return vector a minus b
|
||||
friend const LLColor3& operator*=(LLColor3 &a, const LLColor3 &b);
|
||||
friend const LLColor3& operator+=(LLColor3& a, const LLColor3& b); // Return vector a + b
|
||||
friend const LLColor3& operator-=(LLColor3& a, const LLColor3& b); // Return vector a minus b
|
||||
friend const LLColor3& operator*=(LLColor3& a, const LLColor3& b);
|
||||
|
||||
friend LLColor3 operator*(const LLColor3 &a, const LLColor3 &b); // Return component wise a * b
|
||||
friend LLColor3 operator*(const LLColor3 &a, F32 k); // Return a times scaler k
|
||||
friend LLColor3 operator*(F32 k, const LLColor3 &a); // Return a times scaler k
|
||||
friend LLColor3 operator*(const LLColor3& a, const LLColor3& b); // Return component wise a * b
|
||||
friend LLColor3 operator*(const LLColor3& a, F32 k); // Return a times scaler k
|
||||
friend LLColor3 operator*(F32 k, const LLColor3& a); // Return a times scaler k
|
||||
|
||||
friend bool operator==(const LLColor3 &a, const LLColor3 &b); // Return a == b
|
||||
friend bool operator!=(const LLColor3 &a, const LLColor3 &b); // Return a != b
|
||||
friend bool operator==(const LLColor3& a, const LLColor3& b); // Return a == b
|
||||
friend bool operator!=(const LLColor3& a, const LLColor3& b); // Return a != b
|
||||
|
||||
friend const LLColor3& operator*=(LLColor3 &a, F32 k); // Return a times scaler k
|
||||
friend const LLColor3& operator*=(LLColor3& a, F32 k); // Return a times scaler k
|
||||
|
||||
friend LLColor3 operator-(const LLColor3 &a); // Return vector 1-rgb (inverse)
|
||||
friend LLColor3 operator-(const LLColor3& a); // Return vector 1-rgb (inverse)
|
||||
|
||||
inline void clamp();
|
||||
inline void exp(); // Do an exponential on the color
|
||||
inline void exp(); // Do an exponential on the color
|
||||
};
|
||||
|
||||
LLColor3 lerp(const LLColor3 &a, const LLColor3 &b, F32 u);
|
||||
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
// Non-member functions
|
||||
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
|
||||
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)
|
||||
{
|
||||
mV[VRED] = r;
|
||||
mV[VRED] = r;
|
||||
mV[VGREEN] = g;
|
||||
mV[VBLUE] = b;
|
||||
mV[VBLUE] = b;
|
||||
}
|
||||
|
||||
|
||||
inline LLColor3::LLColor3(const F32 *vec)
|
||||
inline LLColor3::LLColor3(const F32* vec)
|
||||
{
|
||||
mV[VRED] = vec[VRED];
|
||||
mV[VRED] = vec[VRED];
|
||||
mV[VGREEN] = vec[VGREEN];
|
||||
mV[VBLUE] = vec[VBLUE];
|
||||
mV[VBLUE] = vec[VBLUE];
|
||||
}
|
||||
|
||||
inline LLColor3::LLColor3(const char* color_string) // takes a string of format "RRGGBB" where RR is hex 00..FF
|
||||
{
|
||||
if (strlen(color_string) < 6) /* Flawfinder: ignore */
|
||||
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 */
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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;
|
||||
oomag = 1.f / mag;
|
||||
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;
|
||||
oomag = 1.f / mag;
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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];
|
||||
return 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 x * x + y * y + z * z;
|
||||
}
|
||||
|
||||
inline LLColor3 lerp(const LLColor3 &a, const LLColor3 &b, F32 u)
|
||||
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);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
}
|
||||
|
|
@ -92,25 +79,24 @@ inline LLColor3 smear(F32 val)
|
|||
return LLColor3(val, val, val);
|
||||
}
|
||||
|
||||
inline F32 color_intens(const LLColor3 &col)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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
|
||||
|
|
|
|||
|
|
@ -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,37 +88,37 @@ 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;
|
||||
}
|
||||
|
||||
const LLVector3d& LLVector3d::rotVec(const LLMatrix3 &mat)
|
||||
const LLVector3d& LLVector3d::rotVec(const LLMatrix3& mat)
|
||||
{
|
||||
*this = *this * mat;
|
||||
return *this;
|
||||
}
|
||||
|
||||
const LLVector3d& LLVector3d::rotVec(const LLQuaternion &q)
|
||||
const LLVector3d& LLVector3d::rotVec(const LLQuaternion& q)
|
||||
{
|
||||
*this = *this * q;
|
||||
return *this;
|
||||
}
|
||||
|
||||
const LLVector3d& LLVector3d::rotVec(F64 angle, const LLVector3d &vec)
|
||||
const LLVector3d& LLVector3d::rotVec(F64 angle, const LLVector3d& vec)
|
||||
{
|
||||
if ( !vec.isExactlyZero() && angle )
|
||||
if (!vec.isExactlyZero() && angle)
|
||||
{
|
||||
*this = *this * LLMatrix3((F32)angle, vec);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
const LLVector3d& LLVector3d::rotVec(F64 angle, F64 x, F64 y, F64 z)
|
||||
const LLVector3d& LLVector3d::rotVec(F64 angle, F64 x, F64 y, F64 z)
|
||||
{
|
||||
LLVector3d vec(x, y, z);
|
||||
if ( !vec.isExactlyZero() && angle )
|
||||
if (!vec.isExactlyZero() && angle)
|
||||
{
|
||||
*this = *this * LLMatrix3((F32)angle, vec);
|
||||
}
|
||||
|
|
@ -129,16 +128,16 @@ const LLVector3d& LLVector3d::rotVec(F64 angle, F64 x, F64 y, F64 z)
|
|||
|
||||
bool LLVector3d::parseVector3d(const std::string& buf, LLVector3d* value)
|
||||
{
|
||||
if( buf.empty() || value == nullptr)
|
||||
if (buf.empty() || value == nullptr)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
LLVector3d v;
|
||||
S32 count = sscanf( buf.c_str(), "%lf %lf %lf", v.mdV + 0, v.mdV + 1, v.mdV + 2 );
|
||||
if( 3 == count )
|
||||
S32 count = sscanf(buf.c_str(), "%lf %lf %lf", v.mdV + VX, v.mdV + VY, v.mdV + VZ);
|
||||
if (3 == count)
|
||||
{
|
||||
value->setVec( v );
|
||||
value->setVec(v);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -32,131 +32,130 @@
|
|||
|
||||
class LLVector3d
|
||||
{
|
||||
public:
|
||||
F64 mdV[3];
|
||||
public:
|
||||
F64 mdV[3];
|
||||
|
||||
const static LLVector3d zero;
|
||||
const static LLVector3d x_axis;
|
||||
const static LLVector3d y_axis;
|
||||
const static LLVector3d z_axis;
|
||||
const static LLVector3d x_axis_neg;
|
||||
const static LLVector3d y_axis_neg;
|
||||
const static LLVector3d z_axis_neg;
|
||||
const static LLVector3d zero;
|
||||
const static LLVector3d x_axis;
|
||||
const static LLVector3d y_axis;
|
||||
const static LLVector3d z_axis;
|
||||
const static LLVector3d x_axis_neg;
|
||||
const static LLVector3d y_axis_neg;
|
||||
const static LLVector3d z_axis_neg;
|
||||
|
||||
inline LLVector3d(); // Initializes LLVector3d to (0, 0, 0)
|
||||
inline LLVector3d(const F64 x, const F64 y, const F64 z); // Initializes LLVector3d to (x. y, z)
|
||||
inline explicit LLVector3d(const F64 *vec); // Initializes LLVector3d to (vec[0]. vec[1], vec[2])
|
||||
inline explicit LLVector3d(const LLVector3 &vec);
|
||||
explicit LLVector3d(const LLSD& sd)
|
||||
{
|
||||
setValue(sd);
|
||||
}
|
||||
inline LLVector3d(); // Initializes LLVector3d to (0, 0, 0)
|
||||
inline LLVector3d(const F64 x, const F64 y, const F64 z); // Initializes LLVector3d to (x. y, z)
|
||||
inline explicit LLVector3d(const F64 *vec); // Initializes LLVector3d to (vec[0]. vec[1], vec[2])
|
||||
inline explicit LLVector3d(const LLVector3 &vec);
|
||||
explicit LLVector3d(const LLSD& sd)
|
||||
{
|
||||
setValue(sd);
|
||||
}
|
||||
|
||||
void setValue(const LLSD& sd)
|
||||
{
|
||||
mdV[0] = sd[0].asReal();
|
||||
mdV[1] = sd[1].asReal();
|
||||
mdV[2] = sd[2].asReal();
|
||||
}
|
||||
void setValue(const LLSD& sd)
|
||||
{
|
||||
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];
|
||||
return ret;
|
||||
}
|
||||
LLSD getValue() const
|
||||
{
|
||||
LLSD ret;
|
||||
ret[0] = mdV[VX];
|
||||
ret[1] = mdV[VY];
|
||||
ret[2] = mdV[VZ];
|
||||
return ret;
|
||||
}
|
||||
|
||||
inline bool isFinite() const; // checks to see if all values of LLVector3d are finite
|
||||
bool clamp(const F64 min, const F64 max); // Clamps all values to (min,max), returns true if data changed
|
||||
bool abs(); // sets all values to absolute value of original value (first octant), returns true if changed
|
||||
inline bool isFinite() const; // checks to see if all values of LLVector3d are finite
|
||||
bool clamp(const F64 min, const F64 max); // Clamps all values to (min,max), returns true if data changed
|
||||
bool abs(); // sets all values to absolute value of original value (first octant), returns true if changed
|
||||
|
||||
inline const LLVector3d& clear(); // Clears LLVector3d to (0, 0, 0, 1)
|
||||
inline const LLVector3d& clearVec(); // deprecated
|
||||
inline const LLVector3d& setZero(); // Zero LLVector3d to (0, 0, 0, 0)
|
||||
inline const LLVector3d& zeroVec(); // deprecated
|
||||
inline const LLVector3d& set(const F64 x, const F64 y, const F64 z); // Sets LLVector3d to (x, y, z, 1)
|
||||
inline const LLVector3d& set(const LLVector3d &vec); // Sets LLVector3d to vec
|
||||
inline const LLVector3d& set(const F64 *vec); // Sets LLVector3d to vec
|
||||
inline const LLVector3d& set(const LLVector3 &vec);
|
||||
inline const LLVector3d& setVec(const F64 x, const F64 y, const F64 z); // deprecated
|
||||
inline const LLVector3d& setVec(const LLVector3d &vec); // deprecated
|
||||
inline const LLVector3d& setVec(const F64 *vec); // deprecated
|
||||
inline const LLVector3d& setVec(const LLVector3 &vec); // deprecated
|
||||
inline const LLVector3d& clear(); // Clears LLVector3d to (0, 0, 0, 1)
|
||||
inline const LLVector3d& clearVec(); // deprecated
|
||||
inline const LLVector3d& setZero(); // Zero LLVector3d to (0, 0, 0, 0)
|
||||
inline const LLVector3d& zeroVec(); // deprecated
|
||||
inline const LLVector3d& set(const F64 x, const F64 y, const F64 z); // Sets LLVector3d to (x, y, z, 1)
|
||||
inline const LLVector3d& set(const LLVector3d &vec); // Sets LLVector3d to vec
|
||||
inline const LLVector3d& set(const F64 *vec); // Sets LLVector3d to vec
|
||||
inline const LLVector3d& set(const LLVector3 &vec);
|
||||
inline const LLVector3d& setVec(const F64 x, const F64 y, const F64 z); // deprecated
|
||||
inline const LLVector3d& setVec(const LLVector3d &vec); // deprecated
|
||||
inline const LLVector3d& setVec(const F64 *vec); // deprecated
|
||||
inline const LLVector3d& setVec(const LLVector3 &vec); // deprecated
|
||||
|
||||
F64 magVec() const; // deprecated
|
||||
F64 magVecSquared() const; // deprecated
|
||||
inline F64 normVec(); // deprecated
|
||||
F64 magVec() const; // deprecated
|
||||
F64 magVecSquared() const; // deprecated
|
||||
inline F64 normVec(); // deprecated
|
||||
|
||||
F64 length() const; // Returns magnitude of LLVector3d
|
||||
F64 lengthSquared() const; // Returns magnitude squared of LLVector3d
|
||||
inline F64 normalize(); // Normalizes and returns the magnitude of LLVector3d
|
||||
F64 length() const; // Returns magnitude of LLVector3d
|
||||
F64 lengthSquared() const; // Returns magnitude squared of LLVector3d
|
||||
inline F64 normalize(); // Normalizes and returns the magnitude of LLVector3d
|
||||
|
||||
const LLVector3d& rotVec(const F64 angle, const LLVector3d &vec); // Rotates about vec by angle radians
|
||||
const LLVector3d& rotVec(const F64 angle, const F64 x, const F64 y, const F64 z); // Rotates about x,y,z by angle radians
|
||||
const LLVector3d& rotVec(const LLMatrix3 &mat); // Rotates by LLMatrix4 mat
|
||||
const LLVector3d& rotVec(const LLQuaternion &q); // Rotates by LLQuaternion q
|
||||
const LLVector3d& rotVec(const F64 angle, const LLVector3d &vec); // Rotates about vec by angle radians
|
||||
const LLVector3d& rotVec(const F64 angle, const F64 x, const F64 y, const F64 z); // Rotates about x,y,z by angle radians
|
||||
const LLVector3d& rotVec(const LLMatrix3 &mat); // Rotates by LLMatrix4 mat
|
||||
const LLVector3d& rotVec(const LLQuaternion &q); // Rotates by LLQuaternion q
|
||||
|
||||
bool isNull() const; // Returns true if vector has a _very_small_ length
|
||||
bool isExactlyZero() const { return !mdV[VX] && !mdV[VY] && !mdV[VZ]; }
|
||||
bool isNull() const; // Returns true if vector has a _very_small_ length
|
||||
bool isExactlyZero() const { return !mdV[VX] && !mdV[VY] && !mdV[VZ]; }
|
||||
|
||||
const LLVector3d& operator=(const LLVector4 &a);
|
||||
const LLVector3d& operator=(const LLVector4 &a);
|
||||
|
||||
F64 operator[](int idx) const { return mdV[idx]; }
|
||||
F64 &operator[](int idx) { return mdV[idx]; }
|
||||
F64 operator[](int idx) const { return mdV[idx]; }
|
||||
F64 &operator[](int idx) { return mdV[idx]; }
|
||||
|
||||
friend LLVector3d operator+(const LLVector3d& a, const LLVector3d& b); // Return vector a + b
|
||||
friend LLVector3d operator-(const LLVector3d& a, const LLVector3d& b); // Return vector a minus b
|
||||
friend F64 operator*(const LLVector3d& a, const LLVector3d& b); // Return a dot b
|
||||
friend LLVector3d operator%(const LLVector3d& a, const LLVector3d& b); // Return a cross b
|
||||
friend LLVector3d operator*(const LLVector3d& a, const F64 k); // Return a times scaler k
|
||||
friend LLVector3d operator/(const LLVector3d& a, const F64 k); // Return a divided by scaler k
|
||||
friend LLVector3d operator*(const F64 k, const LLVector3d& a); // Return a times scaler k
|
||||
friend bool operator==(const LLVector3d& a, const LLVector3d& b); // Return a == b
|
||||
friend bool operator!=(const LLVector3d& a, const LLVector3d& b); // Return a != b
|
||||
friend LLVector3d operator+(const LLVector3d& a, const LLVector3d& b); // Return vector a + b
|
||||
friend LLVector3d operator-(const LLVector3d& a, const LLVector3d& b); // Return vector a minus b
|
||||
friend F64 operator*(const LLVector3d& a, const LLVector3d& b); // Return a dot b
|
||||
friend LLVector3d operator%(const LLVector3d& a, const LLVector3d& b); // Return a cross b
|
||||
friend LLVector3d operator*(const LLVector3d& a, const F64 k); // Return a times scaler k
|
||||
friend LLVector3d operator/(const LLVector3d& a, const F64 k); // Return a divided by scaler k
|
||||
friend LLVector3d operator*(const F64 k, const LLVector3d& a); // Return a times scaler k
|
||||
friend bool operator==(const LLVector3d& a, const LLVector3d& b); // Return a == b
|
||||
friend bool operator!=(const LLVector3d& a, const LLVector3d& b); // Return a != b
|
||||
// [RLVa:KB] - RlvBehaviourModifierCompMin/Max
|
||||
friend bool operator<(const LLVector3 &a, const LLVector3 &b); // Return a < b
|
||||
// [/RLVa:KB]
|
||||
|
||||
friend const LLVector3d& operator+=(LLVector3d& a, const LLVector3d& b); // Return vector a + b
|
||||
friend const LLVector3d& operator-=(LLVector3d& a, const LLVector3d& b); // Return vector a minus b
|
||||
friend const LLVector3d& operator%=(LLVector3d& a, const LLVector3d& b); // Return a cross b
|
||||
friend const LLVector3d& operator*=(LLVector3d& a, const F64 k); // Return a times scaler k
|
||||
friend const LLVector3d& operator/=(LLVector3d& a, const F64 k); // Return a divided by scaler k
|
||||
friend const LLVector3d& operator+=(LLVector3d& a, const LLVector3d& b); // Return vector a + b
|
||||
friend const LLVector3d& operator-=(LLVector3d& a, const LLVector3d& b); // Return vector a minus b
|
||||
friend const LLVector3d& operator%=(LLVector3d& a, const LLVector3d& b); // Return a cross b
|
||||
friend const LLVector3d& operator*=(LLVector3d& a, const F64 k); // Return a times scaler k
|
||||
friend const LLVector3d& operator/=(LLVector3d& a, const F64 k); // Return a divided by scaler k
|
||||
|
||||
friend LLVector3d operator-(const LLVector3d& a); // Return vector -a
|
||||
friend LLVector3d operator-(const LLVector3d& a); // Return vector -a
|
||||
|
||||
friend std::ostream& operator<<(std::ostream& s, const LLVector3d& a); // Stream a
|
||||
|
||||
static bool parseVector3d(const std::string& buf, LLVector3d* value);
|
||||
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)
|
||||
|
|
@ -202,33 +201,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);
|
||||
}
|
||||
|
||||
|
|
@ -242,17 +241,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);
|
||||
}
|
||||
|
||||
|
|
@ -264,61 +263,62 @@ inline const LLVector3d& LLVector3d::setVec(const F64 x, const F64 y, const F
|
|||
return (*this);
|
||||
}
|
||||
|
||||
inline const LLVector3d& LLVector3d::setVec(const LLVector3d &vec)
|
||||
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)
|
||||
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 = (F32)sqrt(mdV[VX]*mdV[VX] + mdV[VY]*mdV[VY] + mdV[VZ]*mdV[VZ]); // This explicit cast to F32 limits the precision for numerical stability.
|
||||
// Without it, Unit test "v3dmath_h" fails at "1:angle_between" on macos.
|
||||
F64 oomag;
|
||||
|
||||
if (mag > FP_MAG_THRESHOLD)
|
||||
{
|
||||
oomag = 1.f/mag;
|
||||
mdV[0] *= oomag;
|
||||
mdV[1] *= oomag;
|
||||
mdV[2] *= oomag;
|
||||
oomag = 1.0/mag;
|
||||
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.0;
|
||||
mdV[VY] = 0.0;
|
||||
mdV[VZ] = 0.0;
|
||||
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 = (F32)sqrt(mdV[VX]*mdV[VX] + mdV[VY]*mdV[VY] + mdV[VZ]*mdV[VZ]); // Same as in normVec() above.
|
||||
F64 oomag;
|
||||
|
||||
if (mag > FP_MAG_THRESHOLD)
|
||||
{
|
||||
oomag = 1.f/mag;
|
||||
mdV[0] *= oomag;
|
||||
mdV[1] *= oomag;
|
||||
mdV[2] *= oomag;
|
||||
oomag = 1.0/mag;
|
||||
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.0;
|
||||
mdV[VY] = 0.0;
|
||||
mdV[VZ] = 0.0;
|
||||
mag = 0;
|
||||
}
|
||||
return (mag);
|
||||
|
|
@ -326,24 +326,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)
|
||||
|
|
@ -360,42 +360,42 @@ 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]));
|
||||
}
|
||||
|
||||
// [RLVa:KB] - RlvBehaviourModifierCompMin/Max
|
||||
|
|
@ -407,69 +407,69 @@ inline bool operator<(const LLVector3d& lhs, const LLVector3d& rhs)
|
|||
|
||||
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;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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,35 +115,35 @@ 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;
|
||||
}
|
||||
}
|
||||
|
||||
return changed;
|
||||
}
|
||||
|
||||
bool LLVector3::clamp(const LLVector3 &min_vec, const LLVector3 &max_vec)
|
||||
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,15 +155,15 @@ 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;
|
||||
}
|
||||
|
||||
// Quatizations
|
||||
void LLVector3::quantize16(F32 lowerxy, F32 upperxy, F32 lowerz, F32 upperz)
|
||||
void LLVector3::quantize16(F32 lowerxy, F32 upperxy, F32 lowerz, F32 upperz)
|
||||
{
|
||||
F32 x = mV[VX];
|
||||
F32 y = mV[VY];
|
||||
|
|
@ -179,7 +178,7 @@ void LLVector3::quantize16(F32 lowerxy, F32 upperxy, F32 lowerz, F32 upperz)
|
|||
mV[VZ] = z;
|
||||
}
|
||||
|
||||
void LLVector3::quantize8(F32 lowerxy, F32 upperxy, F32 lowerz, F32 upperz)
|
||||
void LLVector3::quantize8(F32 lowerxy, F32 upperxy, F32 lowerz, F32 upperz)
|
||||
{
|
||||
mV[VX] = U8_to_F32(F32_to_U8(mV[VX], lowerxy, upperxy), lowerxy, upperxy);;
|
||||
mV[VY] = U8_to_F32(F32_to_U8(mV[VY], lowerxy, upperxy), lowerxy, upperxy);
|
||||
|
|
@ -187,20 +186,20 @@ void LLVector3::quantize8(F32 lowerxy, F32 upperxy, F32 lowerz, F32 upperz)
|
|||
}
|
||||
|
||||
|
||||
void LLVector3::snap(S32 sig_digits)
|
||||
void LLVector3::snap(S32 sig_digits)
|
||||
{
|
||||
mV[VX] = snap_to_sig_figs(mV[VX], sig_digits);
|
||||
mV[VY] = snap_to_sig_figs(mV[VY], sig_digits);
|
||||
mV[VZ] = snap_to_sig_figs(mV[VZ], sig_digits);
|
||||
}
|
||||
|
||||
const LLVector3& LLVector3::rotVec(const LLMatrix3 &mat)
|
||||
const LLVector3& LLVector3::rotVec(const LLMatrix3& mat)
|
||||
{
|
||||
*this = *this * mat;
|
||||
return *this;
|
||||
}
|
||||
|
||||
const LLVector3& LLVector3::rotVec(const LLQuaternion &q)
|
||||
const LLVector3& LLVector3::rotVec(const LLQuaternion& q)
|
||||
{
|
||||
*this = *this * q;
|
||||
return *this;
|
||||
|
|
@ -228,26 +227,26 @@ const LLVector3& LLVector3::transVec(const LLMatrix4& mat)
|
|||
}
|
||||
|
||||
|
||||
const LLVector3& LLVector3::rotVec(F32 angle, const LLVector3 &vec)
|
||||
const LLVector3& LLVector3::rotVec(F32 angle, const LLVector3& vec)
|
||||
{
|
||||
if ( !vec.isExactlyZero() && angle )
|
||||
if (!vec.isExactlyZero() && angle)
|
||||
{
|
||||
*this = *this * LLQuaternion(angle, vec);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
const LLVector3& LLVector3::rotVec(F32 angle, F32 x, F32 y, F32 z)
|
||||
const LLVector3& LLVector3::rotVec(F32 angle, F32 x, F32 y, F32 z)
|
||||
{
|
||||
LLVector3 vec(x, y, z);
|
||||
if ( !vec.isExactlyZero() && angle )
|
||||
if (!vec.isExactlyZero() && angle)
|
||||
{
|
||||
*this = *this * LLQuaternion(angle, vec);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
const LLVector3& LLVector3::scaleVec(const LLVector3& vec)
|
||||
const LLVector3& LLVector3::scaleVec(const LLVector3& vec)
|
||||
{
|
||||
mV[VX] *= vec.mV[VX];
|
||||
mV[VY] *= vec.mV[VY];
|
||||
|
|
@ -256,42 +255,42 @@ const LLVector3& LLVector3::scaleVec(const LLVector3& vec)
|
|||
return *this;
|
||||
}
|
||||
|
||||
LLVector3 LLVector3::scaledVec(const LLVector3& vec) const
|
||||
LLVector3 LLVector3::scaledVec(const LLVector3& vec) const
|
||||
{
|
||||
LLVector3 ret = LLVector3(*this);
|
||||
ret.scaleVec(vec);
|
||||
return ret;
|
||||
}
|
||||
|
||||
const LLVector3& LLVector3::set(const LLVector3d &vec)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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,17 +298,17 @@ 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)
|
||||
LLVector3::LLVector3(const LLVector3d& vec)
|
||||
{
|
||||
mV[VX] = (F32)vec.mdV[VX];
|
||||
mV[VY] = (F32)vec.mdV[VY];
|
||||
mV[VZ] = (F32)vec.mdV[VZ];
|
||||
}
|
||||
|
||||
LLVector3::LLVector3(const LLVector4 &vec)
|
||||
LLVector3::LLVector3(const LLVector4& vec)
|
||||
{
|
||||
mV[VX] = (F32)vec.mV[VX];
|
||||
mV[VY] = (F32)vec.mV[VY];
|
||||
|
|
@ -319,7 +318,6 @@ LLVector3::LLVector3(const LLVector4 &vec)
|
|||
LLVector3::LLVector3(const LLVector4a& vec)
|
||||
: LLVector3(vec.getF32ptr())
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
LLVector3::LLVector3(const LLSD& sd)
|
||||
|
|
@ -330,20 +328,20 @@ 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)
|
||||
const LLVector3& operator*=(LLVector3& a, const LLQuaternion& rot)
|
||||
{
|
||||
const F32 rw = - rot.mQ[VX] * a.mV[VX] - rot.mQ[VY] * a.mV[VY] - rot.mQ[VZ] * a.mV[VZ];
|
||||
const F32 rx = rot.mQ[VW] * a.mV[VX] + rot.mQ[VY] * a.mV[VZ] - rot.mQ[VZ] * a.mV[VY];
|
||||
|
|
@ -360,16 +358,16 @@ const LLVector3& operator*=(LLVector3 &a, const LLQuaternion &rot)
|
|||
// static
|
||||
bool LLVector3::parseVector3(const std::string& buf, LLVector3* value)
|
||||
{
|
||||
if( buf.empty() || value == nullptr)
|
||||
if (buf.empty() || value == nullptr)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
LLVector3 v;
|
||||
S32 count = sscanf( buf.c_str(), "%f %f %f", v.mV + 0, v.mV + 1, v.mV + 2 );
|
||||
if( 3 == count )
|
||||
S32 count = sscanf(buf.c_str(), "%f %f %f", v.mV + VX, v.mV + VY, v.mV + VZ);
|
||||
if (3 == count)
|
||||
{
|
||||
value->setVec( v );
|
||||
value->setVec(v);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -381,7 +379,7 @@ bool LLVector3::parseVector3(const std::string& buf, LLVector3* value)
|
|||
LLVector3 point_to_box_offset(LLVector3& pos, const LLVector3* box)
|
||||
{
|
||||
LLVector3 offset;
|
||||
for (S32 k=0; k<3; k++)
|
||||
for (S32 k = 0; k < 3; k++)
|
||||
{
|
||||
offset[k] = 0;
|
||||
if (pos[k] < box[0][k])
|
||||
|
|
@ -410,4 +408,3 @@ bool box_valid_and_non_zero(const LLVector3* box)
|
|||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ class LLQuaternion;
|
|||
|
||||
// LLvector3 = |x y z w|
|
||||
|
||||
static const U32 LENGTHOFVECTOR3 = 3;
|
||||
static constexpr U32 LENGTHOFVECTOR3 = 3;
|
||||
|
||||
class LLVector3
|
||||
{
|
||||
|
|
@ -181,7 +181,7 @@ 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()
|
||||
{
|
||||
clear();
|
||||
}
|
||||
|
|
@ -230,22 +230,22 @@ inline bool LLVector3::isFinite() const
|
|||
|
||||
// Clear and Assignment Functions
|
||||
|
||||
inline void LLVector3::clear(void)
|
||||
inline void LLVector3::clear()
|
||||
{
|
||||
set(0.f, 0.f, 0.f);
|
||||
}
|
||||
|
||||
inline void LLVector3::setZero(void)
|
||||
inline void LLVector3::setZero()
|
||||
{
|
||||
clear();
|
||||
}
|
||||
|
||||
inline void LLVector3::clearVec(void)
|
||||
inline void LLVector3::clearVec()
|
||||
{
|
||||
clear();
|
||||
}
|
||||
|
||||
inline void LLVector3::zeroVec(void)
|
||||
inline void LLVector3::zeroVec()
|
||||
{
|
||||
clear();
|
||||
}
|
||||
|
|
@ -257,12 +257,12 @@ inline void LLVector3::set(F32 x, F32 y, F32 z)
|
|||
mV[VZ] = z;
|
||||
}
|
||||
|
||||
inline void LLVector3::set(const LLVector3 &vec)
|
||||
inline void LLVector3::set(const LLVector3& vec)
|
||||
{
|
||||
set(vec.mV[0], vec.mV[1], vec.mV[2]);
|
||||
set(vec.mV[VX], vec.mV[VY], vec.mV[VZ]);
|
||||
}
|
||||
|
||||
inline void LLVector3::set(const F32 *vec)
|
||||
inline void LLVector3::set(const F32* vec)
|
||||
{
|
||||
set(vec[0], vec[1], vec[2]);
|
||||
}
|
||||
|
|
@ -288,20 +288,20 @@ inline void LLVector3::setVec(F32 x, F32 y, F32 z)
|
|||
}
|
||||
|
||||
// deprecated
|
||||
inline void LLVector3::setVec(const LLVector3 &vec)
|
||||
inline void LLVector3::setVec(const LLVector3& vec)
|
||||
{
|
||||
set(vec);
|
||||
}
|
||||
|
||||
// deprecated
|
||||
inline void LLVector3::setVec(const F32 *vec)
|
||||
inline void LLVector3::setVec(const F32* vec)
|
||||
{
|
||||
set(vec);
|
||||
}
|
||||
|
||||
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]);
|
||||
|
||||
if (mag > FP_MAG_THRESHOLD)
|
||||
{
|
||||
|
|
@ -316,149 +316,149 @@ inline F32 LLVector3::normalize(void)
|
|||
}
|
||||
|
||||
// deprecated
|
||||
inline F32 LLVector3::normVec(void)
|
||||
inline F32 LLVector3::normVec()
|
||||
{
|
||||
return normalize();
|
||||
}
|
||||
|
||||
// LLVector3 Magnitude and Normalization Functions
|
||||
|
||||
inline F32 LLVector3::length(void) const
|
||||
inline F32 LLVector3::length() const
|
||||
{
|
||||
return sqrt(lengthSquared());
|
||||
}
|
||||
|
||||
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 length();
|
||||
}
|
||||
|
||||
inline F32 LLVector3::magVecSquared(void) const
|
||||
inline F32 LLVector3::magVecSquared() const
|
||||
{
|
||||
return lengthSquared();
|
||||
}
|
||||
|
||||
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)
|
||||
inline LLVector3 operator+(const LLVector3& a, const LLVector3& b)
|
||||
{
|
||||
LLVector3 c(a);
|
||||
return c += b;
|
||||
}
|
||||
|
||||
inline LLVector3 operator-(const LLVector3 &a, const LLVector3 &b)
|
||||
inline LLVector3 operator-(const LLVector3& a, const LLVector3& b)
|
||||
{
|
||||
LLVector3 c(a);
|
||||
return c -= b;
|
||||
}
|
||||
|
||||
inline F32 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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
inline const LLVector3& operator/=(LLVector3& a, F32 k)
|
||||
{
|
||||
a *= 1.f / k;
|
||||
return a;
|
||||
}
|
||||
|
||||
inline LLVector3 operator-(const LLVector3 &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
|
||||
|
|
@ -472,30 +472,30 @@ inline LLVector3::operator glm::vec4() const
|
|||
return glm::vec4(mV[VX], mV[VY], mV[VZ], 1.f);
|
||||
}
|
||||
|
||||
inline F32 dist_vec(const LLVector3 &a, const LLVector3 &b)
|
||||
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)
|
||||
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)
|
||||
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;
|
||||
}
|
||||
|
||||
inline LLVector3 projected_vec(const LLVector3 &a, const LLVector3 &b)
|
||||
inline LLVector3 projected_vec(const LLVector3& a, const LLVector3& b)
|
||||
{
|
||||
F32 bb = b * b;
|
||||
if (bb > FP_MAG_THRESHOLD * FP_MAG_THRESHOLD)
|
||||
|
|
@ -517,18 +517,18 @@ inline LLVector3 inverse_projected_vec(const LLVector3& a, const LLVector3& b)
|
|||
return normalized_a * (b_length / dot_product);
|
||||
}
|
||||
|
||||
inline LLVector3 parallel_component(const LLVector3 &a, const LLVector3 &b)
|
||||
inline LLVector3 parallel_component(const LLVector3& a, const LLVector3& b)
|
||||
{
|
||||
return projected_vec(a, b);
|
||||
}
|
||||
|
||||
inline LLVector3 orthogonal_component(const LLVector3 &a, const LLVector3 &b)
|
||||
inline LLVector3 orthogonal_component(const LLVector3& a, const LLVector3& b)
|
||||
{
|
||||
return a - projected_vec(a, b);
|
||||
}
|
||||
|
||||
|
||||
inline LLVector3 lerp(const LLVector3 &a, const LLVector3 &b, F32 u)
|
||||
inline LLVector3 lerp(const LLVector3& a, const LLVector3& b, F32 u)
|
||||
{
|
||||
return LLVector3(
|
||||
a.mV[VX] + (b.mV[VX] - a.mV[VX]) * u,
|
||||
|
|
@ -583,7 +583,7 @@ inline F32 angle_between(const LLVector3& a, const LLVector3& b)
|
|||
return atan2f(c.length(), ab); // return the angle
|
||||
}
|
||||
|
||||
inline bool are_parallel(const LLVector3 &a, const LLVector3 &b, F32 epsilon)
|
||||
inline bool are_parallel(const LLVector3& a, const LLVector3& b, F32 epsilon)
|
||||
{
|
||||
LLVector3 an = a;
|
||||
LLVector3 bn = b;
|
||||
|
|
|
|||
|
|
@ -127,65 +127,64 @@ 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)),
|
||||
(U8)llclampb(ll_round(mV[VGREEN]*255.f)),
|
||||
(U8)llclampb(ll_round(mV[VBLUE]*255.f)),
|
||||
(U8)llclampb(ll_round(mV[VALPHA]*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)));
|
||||
}
|
||||
|
||||
LLColor4::LLColor4(const LLColor3 &vec, F32 a)
|
||||
LLColor4::LLColor4(const LLColor3& vec, F32 a)
|
||||
{
|
||||
mV[VRED] = vec.mV[VRED];
|
||||
mV[VRED] = vec.mV[VRED];
|
||||
mV[VGREEN] = vec.mV[VGREEN];
|
||||
mV[VBLUE] = vec.mV[VBLUE];
|
||||
mV[VBLUE] = vec.mV[VBLUE];
|
||||
mV[VALPHA] = a;
|
||||
}
|
||||
|
||||
LLColor4::LLColor4(const LLColor4U& color4u)
|
||||
{
|
||||
const F32 SCALE = 1.f/255.f;
|
||||
mV[VRED] = color4u.mV[VRED] * SCALE;
|
||||
mV[VGREEN] = color4u.mV[VGREEN] * SCALE;
|
||||
mV[VBLUE] = color4u.mV[VBLUE] * SCALE;
|
||||
mV[VALPHA] = color4u.mV[VALPHA] * SCALE;
|
||||
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;
|
||||
mV[VALPHA] = color4u.mV[VALPHA] * SCALE;
|
||||
}
|
||||
|
||||
LLColor4::LLColor4(const LLVector4& vector4)
|
||||
{
|
||||
mV[VRED] = vector4.mV[VRED];
|
||||
mV[VRED] = vector4.mV[VRED];
|
||||
mV[VGREEN] = vector4.mV[VGREEN];
|
||||
mV[VBLUE] = vector4.mV[VBLUE];
|
||||
mV[VBLUE] = vector4.mV[VBLUE];
|
||||
mV[VALPHA] = vector4.mV[VALPHA];
|
||||
}
|
||||
|
||||
const LLColor4& LLColor4::set(const LLColor4U& color4u)
|
||||
{
|
||||
const F32 SCALE = 1.f/255.f;
|
||||
mV[VRED] = color4u.mV[VRED] * SCALE;
|
||||
mV[VGREEN] = color4u.mV[VGREEN] * SCALE;
|
||||
mV[VBLUE] = color4u.mV[VBLUE] * SCALE;
|
||||
mV[VALPHA] = color4u.mV[VALPHA] * SCALE;
|
||||
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;
|
||||
mV[VALPHA] = color4u.mV[VALPHA] * SCALE;
|
||||
return (*this);
|
||||
}
|
||||
|
||||
const LLColor4& LLColor4::set(const LLColor3 &vec)
|
||||
const LLColor4& LLColor4::set(const LLColor3& vec)
|
||||
{
|
||||
mV[VRED] = vec.mV[VRED];
|
||||
mV[VRED] = vec.mV[VRED];
|
||||
mV[VGREEN] = vec.mV[VGREEN];
|
||||
mV[VBLUE] = vec.mV[VBLUE];
|
||||
mV[VBLUE] = vec.mV[VBLUE];
|
||||
|
||||
// no change to alpha!
|
||||
// mV[VALPHA] = 1.f;
|
||||
// no change to alpha!
|
||||
// mV[VALPHA] = 1.f;
|
||||
|
||||
return (*this);
|
||||
}
|
||||
|
||||
const LLColor4& LLColor4::set(const LLColor3 &vec, F32 a)
|
||||
const LLColor4& LLColor4::set(const LLColor3& vec, F32 a)
|
||||
{
|
||||
mV[VRED] = vec.mV[VRED];
|
||||
mV[VRED] = vec.mV[VRED];
|
||||
mV[VGREEN] = vec.mV[VGREEN];
|
||||
mV[VBLUE] = vec.mV[VBLUE];
|
||||
mV[VBLUE] = vec.mV[VBLUE];
|
||||
mV[VALPHA] = a;
|
||||
return (*this);
|
||||
}
|
||||
|
|
@ -193,33 +192,33 @@ 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;
|
||||
mV[VRED] = color4u.mV[VRED] * SCALE;
|
||||
mV[VGREEN] = color4u.mV[VGREEN] * SCALE;
|
||||
mV[VBLUE] = color4u.mV[VBLUE] * SCALE;
|
||||
mV[VALPHA] = color4u.mV[VALPHA] * SCALE;
|
||||
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;
|
||||
mV[VALPHA] = color4u.mV[VALPHA] * SCALE;
|
||||
return (*this);
|
||||
}
|
||||
|
||||
// deprecated -- use set()
|
||||
const LLColor4& LLColor4::setVec(const LLColor3 &vec)
|
||||
const LLColor4& LLColor4::setVec(const LLColor3& vec)
|
||||
{
|
||||
mV[VRED] = vec.mV[VRED];
|
||||
mV[VRED] = vec.mV[VRED];
|
||||
mV[VGREEN] = vec.mV[VGREEN];
|
||||
mV[VBLUE] = vec.mV[VBLUE];
|
||||
mV[VBLUE] = vec.mV[VBLUE];
|
||||
|
||||
// no change to alpha!
|
||||
// mV[VALPHA] = 1.f;
|
||||
// no change to alpha!
|
||||
// mV[VALPHA] = 1.f;
|
||||
|
||||
return (*this);
|
||||
}
|
||||
|
||||
// deprecated -- use set()
|
||||
const LLColor4& LLColor4::setVec(const LLColor3 &vec, F32 a)
|
||||
const LLColor4& LLColor4::setVec(const LLColor3& vec, F32 a)
|
||||
{
|
||||
mV[VRED] = vec.mV[VRED];
|
||||
mV[VRED] = vec.mV[VRED];
|
||||
mV[VGREEN] = vec.mV[VGREEN];
|
||||
mV[VBLUE] = vec.mV[VBLUE];
|
||||
mV[VBLUE] = vec.mV[VBLUE];
|
||||
mV[VALPHA] = a;
|
||||
return (*this);
|
||||
}
|
||||
|
|
@ -231,110 +230,110 @@ 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
|
||||
}
|
||||
|
||||
const LLColor4& LLColor4::operator=(const LLColor3 &a)
|
||||
const LLColor4& LLColor4::operator=(const LLColor3& a)
|
||||
{
|
||||
mV[VRED] = a.mV[VRED];
|
||||
mV[VRED] = a.mV[VRED];
|
||||
mV[VGREEN] = a.mV[VGREEN];
|
||||
mV[VBLUE] = a.mV[VBLUE];
|
||||
mV[VBLUE] = a.mV[VBLUE];
|
||||
|
||||
// converting from an rgb sets a=1 (opaque)
|
||||
// converting from an rgb sets a=1 (opaque)
|
||||
mV[VALPHA] = 1.f;
|
||||
return (*this);
|
||||
}
|
||||
|
||||
|
||||
std::ostream& operator<<(std::ostream& s, const LLColor4 &a)
|
||||
std::ostream& operator<<(std::ostream& s, const LLColor4& a)
|
||||
{
|
||||
s << "{ " << a.mV[VRED] << ", " << a.mV[VGREEN] << ", " << a.mV[VBLUE] << ", " << a.mV[VALPHA] << " }";
|
||||
return s;
|
||||
}
|
||||
|
||||
bool operator==(const LLColor4 &a, const LLColor3 &b)
|
||||
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)
|
||||
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)
|
||||
LLColor3 vec4to3(const LLColor4& vec)
|
||||
{
|
||||
LLColor3 temp(vec.mV[VRED], vec.mV[VGREEN], vec.mV[VBLUE]);
|
||||
LLColor3 temp(vec.mV[VRED], vec.mV[VGREEN], vec.mV[VBLUE]);
|
||||
return temp;
|
||||
}
|
||||
|
||||
LLColor4 vec3to4(const LLColor3 &vec)
|
||||
LLColor4 vec3to4(const LLColor3& vec)
|
||||
{
|
||||
LLColor3 temp(vec.mV[VRED], vec.mV[VGREEN], vec.mV[VBLUE]);
|
||||
LLColor3 temp(vec.mV[VRED], vec.mV[VGREEN], vec.mV[VBLUE]);
|
||||
return temp;
|
||||
}
|
||||
|
||||
static F32 hueToRgb ( F32 val1In, F32 val2In, F32 valHUeIn )
|
||||
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 );
|
||||
return ( val1In );
|
||||
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);
|
||||
}
|
||||
|
||||
void LLColor4::setHSL ( F32 hValIn, F32 sValIn, F32 lValIn)
|
||||
void LLColor4::setHSL(F32 hValIn, F32 sValIn, F32 lValIn)
|
||||
{
|
||||
if ( sValIn < 0.00001f )
|
||||
if (sValIn < 0.00001f)
|
||||
{
|
||||
mV[VRED] = lValIn;
|
||||
mV[VRED] = lValIn;
|
||||
mV[VGREEN] = lValIn;
|
||||
mV[VBLUE] = lValIn;
|
||||
mV[VBLUE] = lValIn;
|
||||
}
|
||||
else
|
||||
{
|
||||
F32 interVal1;
|
||||
F32 interVal2;
|
||||
|
||||
if ( lValIn < 0.5f )
|
||||
interVal2 = lValIn * ( 1.0f + sValIn );
|
||||
if (lValIn < 0.5f)
|
||||
interVal2 = lValIn * (1.0f + sValIn);
|
||||
else
|
||||
interVal2 = ( lValIn + sValIn ) - ( sValIn * lValIn );
|
||||
interVal2 = (lValIn + sValIn) - (sValIn * lValIn);
|
||||
|
||||
interVal1 = 2.0f * lValIn - interVal2;
|
||||
|
||||
mV[VRED] = hueToRgb ( interVal1, interVal2, hValIn + ( 1.f / 3.f ) );
|
||||
mV[VGREEN] = hueToRgb ( interVal1, interVal2, hValIn );
|
||||
mV[VBLUE] = hueToRgb ( interVal1, interVal2, hValIn - ( 1.f / 3.f ) );
|
||||
mV[VRED] = hueToRgb(interVal1, interVal2, hValIn + (1.f / 3.f));
|
||||
mV[VGREEN] = hueToRgb(interVal1, interVal2, hValIn);
|
||||
mV[VBLUE] = hueToRgb(interVal1, interVal2, hValIn - (1.f / 3.f));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -344,58 +343,61 @@ void LLColor4::calcHSL(F32* hue, F32* saturation, F32* luminance) const
|
|||
F32 var_G = mV[VGREEN];
|
||||
F32 var_B = mV[VBLUE];
|
||||
|
||||
F32 var_Min = ( var_R < ( var_G < var_B ? var_G : var_B ) ? var_R : ( var_G < var_B ? var_G : var_B ) );
|
||||
F32 var_Max = ( var_R > ( var_G > var_B ? var_G : var_B ) ? var_R : ( var_G > var_B ? var_G : var_B ) );
|
||||
F32 var_Min = (var_R < (var_G < var_B ? var_G : var_B) ? var_R : (var_G < var_B ? var_G : var_B));
|
||||
F32 var_Max = (var_R > (var_G > var_B ? var_G : var_B) ? var_R : (var_G > var_B ? var_G : var_B));
|
||||
|
||||
F32 del_Max = var_Max - var_Min;
|
||||
|
||||
F32 L = ( var_Max + var_Min ) / 2.0f;
|
||||
F32 L = (var_Max + var_Min) / 2.0f;
|
||||
F32 H = 0.0f;
|
||||
F32 S = 0.0f;
|
||||
|
||||
if ( del_Max == 0.0f )
|
||||
if (del_Max == 0.0f)
|
||||
{
|
||||
H = 0.0f;
|
||||
S = 0.0f;
|
||||
H = 0.0f;
|
||||
S = 0.0f;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( L < 0.5 )
|
||||
S = del_Max / ( var_Max + var_Min );
|
||||
if (L < 0.5f)
|
||||
S = del_Max / (var_Max + var_Min);
|
||||
else
|
||||
S = del_Max / ( 2.0f - var_Max - var_Min );
|
||||
S = del_Max / (2.0f - var_Max - var_Min);
|
||||
|
||||
F32 del_R = ( ( ( var_Max - var_R ) / 6.0f ) + ( del_Max / 2.0f ) ) / del_Max;
|
||||
F32 del_G = ( ( ( var_Max - var_G ) / 6.0f ) + ( del_Max / 2.0f ) ) / del_Max;
|
||||
F32 del_B = ( ( ( var_Max - var_B ) / 6.0f ) + ( del_Max / 2.0f ) ) / del_Max;
|
||||
F32 del_R = (((var_Max - var_R) / 6.0f) + (del_Max / 2.0f)) / del_Max;
|
||||
F32 del_G = (((var_Max - var_G) / 6.0f) + (del_Max / 2.0f)) / del_Max;
|
||||
F32 del_B = (((var_Max - var_B) / 6.0f) + (del_Max / 2.0f)) / del_Max;
|
||||
|
||||
if ( var_R >= var_Max )
|
||||
if (var_R >= var_Max)
|
||||
H = del_B - del_G;
|
||||
else
|
||||
if ( var_G >= var_Max )
|
||||
H = ( 1.0f / 3.0f ) + del_R - del_B;
|
||||
else
|
||||
if ( var_B >= var_Max )
|
||||
H = ( 2.0f / 3.0f ) + del_G - del_R;
|
||||
else if (var_G >= var_Max)
|
||||
H = (1.0f / 3.0f) + del_R - del_B;
|
||||
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
|
||||
bool LLColor4::parseColor(const std::string& buf, LLColor4* color)
|
||||
{
|
||||
if( buf.empty() || color == nullptr)
|
||||
if (buf.empty() || color == nullptr)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
boost_tokenizer tokens(buf, boost::char_separator<char>(", "));
|
||||
boost_tokenizer tokens(buf, boost::char_separator<char>(", "));
|
||||
boost_tokenizer::iterator token_iter = tokens.begin();
|
||||
if (token_iter == tokens.end())
|
||||
{
|
||||
|
|
@ -404,16 +406,16 @@ bool LLColor4::parseColor(const std::string& buf, LLColor4* color)
|
|||
|
||||
// Grab the first token into a string, since we don't know
|
||||
// if this is a float or a color name.
|
||||
std::string color_name( (*token_iter) );
|
||||
std::string color_name((*token_iter));
|
||||
++token_iter;
|
||||
|
||||
if (token_iter != tokens.end())
|
||||
{
|
||||
// There are more tokens to read. This must be a vector.
|
||||
LLColor4 v;
|
||||
LLStringUtil::convertToF32( color_name, v.mV[VRED] );
|
||||
LLStringUtil::convertToF32( *token_iter, v.mV[VGREEN] );
|
||||
v.mV[VBLUE] = 0.0f;
|
||||
LLStringUtil::convertToF32(color_name, v.mV[VRED]);
|
||||
LLStringUtil::convertToF32(*token_iter, v.mV[VGREEN]);
|
||||
v.mV[VBLUE] = 0.0f;
|
||||
v.mV[VALPHA] = 1.0f;
|
||||
|
||||
++token_iter;
|
||||
|
|
@ -425,283 +427,284 @@ bool LLColor4::parseColor(const std::string& buf, LLColor4* color)
|
|||
else
|
||||
{
|
||||
// There is a z-component.
|
||||
LLStringUtil::convertToF32( *token_iter, v.mV[VBLUE] );
|
||||
LLStringUtil::convertToF32(*token_iter, v.mV[VBLUE]);
|
||||
|
||||
++token_iter;
|
||||
if (token_iter != tokens.end())
|
||||
{
|
||||
// There is an alpha component.
|
||||
LLStringUtil::convertToF32( *token_iter, v.mV[VALPHA] );
|
||||
LLStringUtil::convertToF32(*token_iter, v.mV[VALPHA]);
|
||||
}
|
||||
}
|
||||
|
||||
// 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 );
|
||||
color->set(v);
|
||||
}
|
||||
else // Single value. Read as a named color.
|
||||
{
|
||||
// We have a color name
|
||||
if ( "red" == color_name )
|
||||
if ("red" == color_name)
|
||||
{
|
||||
color->set(LLColor4::red);
|
||||
}
|
||||
else if ( "red1" == color_name )
|
||||
else if ("red1" == color_name)
|
||||
{
|
||||
color->set(LLColor4::red1);
|
||||
}
|
||||
else if ( "red2" == color_name )
|
||||
else if ("red2" == color_name)
|
||||
{
|
||||
color->set(LLColor4::red2);
|
||||
}
|
||||
else if ( "red3" == color_name )
|
||||
else if ("red3" == color_name)
|
||||
{
|
||||
color->set(LLColor4::red3);
|
||||
}
|
||||
else if ( "red4" == color_name )
|
||||
else if ("red4" == color_name)
|
||||
{
|
||||
color->set(LLColor4::red4);
|
||||
}
|
||||
else if ( "red5" == color_name )
|
||||
else if ("red5" == color_name)
|
||||
{
|
||||
color->set(LLColor4::red5);
|
||||
}
|
||||
else if( "green" == color_name )
|
||||
else if ("green" == color_name)
|
||||
{
|
||||
color->set(LLColor4::green);
|
||||
}
|
||||
else if( "green1" == color_name )
|
||||
else if ("green1" == color_name)
|
||||
{
|
||||
color->set(LLColor4::green1);
|
||||
}
|
||||
else if( "green2" == color_name )
|
||||
else if ("green2" == color_name)
|
||||
{
|
||||
color->set(LLColor4::green2);
|
||||
}
|
||||
else if( "green3" == color_name )
|
||||
else if ("green3" == color_name)
|
||||
{
|
||||
color->set(LLColor4::green3);
|
||||
}
|
||||
else if( "green4" == color_name )
|
||||
else if ("green4" == color_name)
|
||||
{
|
||||
color->set(LLColor4::green4);
|
||||
}
|
||||
else if( "green5" == color_name )
|
||||
else if ("green5" == color_name)
|
||||
{
|
||||
color->set(LLColor4::green5);
|
||||
}
|
||||
else if( "green6" == color_name )
|
||||
else if ("green6" == color_name)
|
||||
{
|
||||
color->set(LLColor4::green6);
|
||||
}
|
||||
else if( "blue" == color_name )
|
||||
else if ("blue" == color_name)
|
||||
{
|
||||
color->set(LLColor4::blue);
|
||||
}
|
||||
else if( "blue1" == color_name )
|
||||
else if ("blue1" == color_name)
|
||||
{
|
||||
color->set(LLColor4::blue1);
|
||||
}
|
||||
else if( "blue2" == color_name )
|
||||
else if ("blue2" == color_name)
|
||||
{
|
||||
color->set(LLColor4::blue2);
|
||||
}
|
||||
else if( "blue3" == color_name )
|
||||
else if ("blue3" == color_name)
|
||||
{
|
||||
color->set(LLColor4::blue3);
|
||||
}
|
||||
else if( "blue4" == color_name )
|
||||
else if ("blue4" == color_name)
|
||||
{
|
||||
color->set(LLColor4::blue4);
|
||||
}
|
||||
else if( "blue5" == color_name )
|
||||
else if ("blue5" == color_name)
|
||||
{
|
||||
color->set(LLColor4::blue5);
|
||||
}
|
||||
else if( "blue6" == color_name )
|
||||
else if ("blue6" == color_name)
|
||||
{
|
||||
color->set(LLColor4::blue6);
|
||||
}
|
||||
else if( "black" == color_name )
|
||||
else if ("black" == color_name)
|
||||
{
|
||||
color->set(LLColor4::black);
|
||||
}
|
||||
else if( "white" == color_name )
|
||||
else if ("white" == color_name)
|
||||
{
|
||||
color->set(LLColor4::white);
|
||||
}
|
||||
else if( "yellow" == color_name )
|
||||
else if ("yellow" == color_name)
|
||||
{
|
||||
color->set(LLColor4::yellow);
|
||||
}
|
||||
else if( "yellow1" == color_name )
|
||||
else if ("yellow1" == color_name)
|
||||
{
|
||||
color->set(LLColor4::yellow1);
|
||||
}
|
||||
else if( "yellow2" == color_name )
|
||||
else if ("yellow2" == color_name)
|
||||
{
|
||||
color->set(LLColor4::yellow2);
|
||||
}
|
||||
else if( "yellow3" == color_name )
|
||||
else if ("yellow3" == color_name)
|
||||
{
|
||||
color->set(LLColor4::yellow3);
|
||||
}
|
||||
else if( "yellow4" == color_name )
|
||||
else if ("yellow4" == color_name)
|
||||
{
|
||||
color->set(LLColor4::yellow4);
|
||||
}
|
||||
else if( "yellow5" == color_name )
|
||||
else if ("yellow5" == color_name)
|
||||
{
|
||||
color->set(LLColor4::yellow5);
|
||||
}
|
||||
else if( "yellow6" == color_name )
|
||||
else if ("yellow6" == color_name)
|
||||
{
|
||||
color->set(LLColor4::yellow6);
|
||||
}
|
||||
else if( "magenta" == color_name )
|
||||
else if ("magenta" == color_name)
|
||||
{
|
||||
color->set(LLColor4::magenta);
|
||||
}
|
||||
else if( "magenta1" == color_name )
|
||||
else if ("magenta1" == color_name)
|
||||
{
|
||||
color->set(LLColor4::magenta1);
|
||||
}
|
||||
else if( "magenta2" == color_name )
|
||||
else if ("magenta2" == color_name)
|
||||
{
|
||||
color->set(LLColor4::magenta2);
|
||||
}
|
||||
else if( "magenta3" == color_name )
|
||||
else if ("magenta3" == color_name)
|
||||
{
|
||||
color->set(LLColor4::magenta3);
|
||||
}
|
||||
else if( "magenta4" == color_name )
|
||||
else if ("magenta4" == color_name)
|
||||
{
|
||||
color->set(LLColor4::magenta4);
|
||||
}
|
||||
else if( "purple" == color_name )
|
||||
else if ("purple" == color_name)
|
||||
{
|
||||
color->set(LLColor4::purple);
|
||||
}
|
||||
else if( "purple1" == color_name )
|
||||
else if ("purple1" == color_name)
|
||||
{
|
||||
color->set(LLColor4::purple1);
|
||||
}
|
||||
else if( "purple2" == color_name )
|
||||
else if ("purple2" == color_name)
|
||||
{
|
||||
color->set(LLColor4::purple2);
|
||||
}
|
||||
else if( "purple3" == color_name )
|
||||
else if ("purple3" == color_name)
|
||||
{
|
||||
color->set(LLColor4::purple3);
|
||||
}
|
||||
else if( "purple4" == color_name )
|
||||
else if ("purple4" == color_name)
|
||||
{
|
||||
color->set(LLColor4::purple4);
|
||||
}
|
||||
else if( "purple5" == color_name )
|
||||
else if ("purple5" == color_name)
|
||||
{
|
||||
color->set(LLColor4::purple5);
|
||||
}
|
||||
else if( "purple6" == color_name )
|
||||
else if ("purple6" == color_name)
|
||||
{
|
||||
color->set(LLColor4::purple6);
|
||||
}
|
||||
else if( "pink" == color_name )
|
||||
else if ("pink" == color_name)
|
||||
{
|
||||
color->set(LLColor4::pink);
|
||||
}
|
||||
else if( "pink1" == color_name )
|
||||
else if ("pink1" == color_name)
|
||||
{
|
||||
color->set(LLColor4::pink1);
|
||||
}
|
||||
else if( "pink2" == color_name )
|
||||
else if ("pink2" == color_name)
|
||||
{
|
||||
color->set(LLColor4::pink2);
|
||||
}
|
||||
else if( "cyan" == color_name )
|
||||
else if ("cyan" == color_name)
|
||||
{
|
||||
color->set(LLColor4::cyan);
|
||||
}
|
||||
else if( "cyan1" == color_name )
|
||||
else if ("cyan1" == color_name)
|
||||
{
|
||||
color->set(LLColor4::cyan1);
|
||||
}
|
||||
else if( "cyan2" == color_name )
|
||||
else if ("cyan2" == color_name)
|
||||
{
|
||||
color->set(LLColor4::cyan2);
|
||||
}
|
||||
else if( "cyan3" == color_name )
|
||||
else if ("cyan3" == color_name)
|
||||
{
|
||||
color->set(LLColor4::cyan3);
|
||||
}
|
||||
else if( "cyan4" == color_name )
|
||||
else if ("cyan4" == color_name)
|
||||
{
|
||||
color->set(LLColor4::cyan4);
|
||||
}
|
||||
else if( "cyan5" == color_name )
|
||||
else if ("cyan5" == color_name)
|
||||
{
|
||||
color->set(LLColor4::cyan5);
|
||||
}
|
||||
else if( "cyan6" == color_name )
|
||||
else if ("cyan6" == color_name)
|
||||
{
|
||||
color->set(LLColor4::cyan6);
|
||||
}
|
||||
else if( "smoke" == color_name )
|
||||
else if ("smoke" == color_name)
|
||||
{
|
||||
color->set(LLColor4::smoke);
|
||||
}
|
||||
else if( "grey" == color_name )
|
||||
else if ("grey" == color_name)
|
||||
{
|
||||
color->set(LLColor4::grey);
|
||||
}
|
||||
else if( "grey1" == color_name )
|
||||
else if ("grey1" == color_name)
|
||||
{
|
||||
color->set(LLColor4::grey1);
|
||||
}
|
||||
else if( "grey2" == color_name )
|
||||
else if ("grey2" == color_name)
|
||||
{
|
||||
color->set(LLColor4::grey2);
|
||||
}
|
||||
else if( "grey3" == color_name )
|
||||
else if ("grey3" == color_name)
|
||||
{
|
||||
color->set(LLColor4::grey3);
|
||||
}
|
||||
else if( "grey4" == color_name )
|
||||
else if ("grey4" == color_name)
|
||||
{
|
||||
color->set(LLColor4::grey4);
|
||||
}
|
||||
else if( "orange" == color_name )
|
||||
else if ("orange" == color_name)
|
||||
{
|
||||
color->set(LLColor4::orange);
|
||||
}
|
||||
else if( "orange1" == color_name )
|
||||
else if ("orange1" == color_name)
|
||||
{
|
||||
color->set(LLColor4::orange1);
|
||||
}
|
||||
else if( "orange2" == color_name )
|
||||
else if ("orange2" == color_name)
|
||||
{
|
||||
color->set(LLColor4::orange2);
|
||||
}
|
||||
else if( "orange3" == color_name )
|
||||
else if ("orange3" == color_name)
|
||||
{
|
||||
color->set(LLColor4::orange3);
|
||||
}
|
||||
else if( "orange4" == color_name )
|
||||
else if ("orange4" == color_name)
|
||||
{
|
||||
color->set(LLColor4::orange4);
|
||||
}
|
||||
else if( "orange5" == color_name )
|
||||
else if ("orange5" == color_name)
|
||||
{
|
||||
color->set(LLColor4::orange5);
|
||||
}
|
||||
else if( "orange6" == color_name )
|
||||
else if ("orange6" == color_name)
|
||||
{
|
||||
color->set(LLColor4::orange6);
|
||||
}
|
||||
else if ( "clear" == color_name )
|
||||
else if ("clear" == color_name)
|
||||
{
|
||||
color->set(0.f, 0.f, 0.f, 0.f);
|
||||
}
|
||||
|
|
@ -717,21 +720,21 @@ bool LLColor4::parseColor(const std::string& buf, LLColor4* color)
|
|||
// static
|
||||
bool LLColor4::parseColor4(const std::string& buf, LLColor4* value)
|
||||
{
|
||||
if( buf.empty() || value == nullptr)
|
||||
if (buf.empty() || value == nullptr)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
LLColor4 v;
|
||||
S32 count = sscanf( buf.c_str(), "%f, %f, %f, %f", v.mV + 0, v.mV + 1, v.mV + 2, v.mV + 3 );
|
||||
if (1 == count )
|
||||
S32 count = sscanf(buf.c_str(), "%f, %f, %f, %f", v.mV + 0, v.mV + 1, v.mV + 2, v.mV + 3);
|
||||
if (1 == count)
|
||||
{
|
||||
// try this format
|
||||
count = sscanf( buf.c_str(), "%f %f %f %f", v.mV + 0, v.mV + 1, v.mV + 2, v.mV + 3 );
|
||||
count = sscanf(buf.c_str(), "%f %f %f %f", v.mV + 0, v.mV + 1, v.mV + 2, v.mV + 3);
|
||||
}
|
||||
if( 4 == count )
|
||||
if (4 == count)
|
||||
{
|
||||
value->setVec( v );
|
||||
value->setVec(v);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -28,7 +28,6 @@
|
|||
#define LL_V4COLOR_H
|
||||
|
||||
#include "llerror.h"
|
||||
//#include "vmath.h"
|
||||
#include "llmath.h"
|
||||
#include "llsd.h"
|
||||
|
||||
|
|
@ -38,216 +37,215 @@ 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
|
||||
{
|
||||
public:
|
||||
F32 mV[LENGTHOFCOLOR4];
|
||||
LLColor4(); // Initializes LLColor4 to (0, 0, 0, 1)
|
||||
LLColor4(F32 r, F32 g, F32 b); // Initializes LLColor4 to (r, g, b, 1)
|
||||
LLColor4(F32 r, F32 g, F32 b, F32 a); // Initializes LLColor4 to (r. g, b, a)
|
||||
LLColor4(const LLColor3 &vec, F32 a = 1.f); // Initializes LLColor4 to (vec, a)
|
||||
explicit LLColor4(const LLSD& sd);
|
||||
explicit LLColor4(const F32 *vec); // Initializes LLColor4 to (vec[0]. vec[1], vec[2], 1)
|
||||
explicit LLColor4(U32 clr); // Initializes LLColor4 to (r=clr>>24, etc))
|
||||
explicit LLColor4(const LLColor4U& color4u); // "explicit" to avoid automatic conversion
|
||||
explicit LLColor4(const LLVector4& vector4); // "explicit" to avoid automatic conversion
|
||||
public:
|
||||
F32 mV[LENGTHOFCOLOR4];
|
||||
LLColor4(); // Initializes LLColor4 to (0, 0, 0, 1)
|
||||
LLColor4(F32 r, F32 g, F32 b); // Initializes LLColor4 to (r, g, b, 1)
|
||||
LLColor4(F32 r, F32 g, F32 b, F32 a); // Initializes LLColor4 to (r. g, b, a)
|
||||
LLColor4(const LLColor3& vec, F32 a = 1.f); // Initializes LLColor4 to (vec, a)
|
||||
explicit LLColor4(const LLSD& sd);
|
||||
explicit LLColor4(const F32* vec); // Initializes LLColor4 to (vec[0]. vec[1], vec[2], 1)
|
||||
explicit LLColor4(U32 clr); // Initializes LLColor4 to (r=clr>>24, etc))
|
||||
explicit LLColor4(const LLColor4U& color4u); // "explicit" to avoid automatic conversion
|
||||
explicit LLColor4(const LLVector4& vector4); // "explicit" to avoid automatic conversion
|
||||
|
||||
LLSD getValue() const
|
||||
{
|
||||
LLSD ret;
|
||||
ret[0] = mV[0];
|
||||
ret[1] = mV[1];
|
||||
ret[2] = mV[2];
|
||||
ret[3] = mV[3];
|
||||
return ret;
|
||||
}
|
||||
LLSD getValue() const
|
||||
{
|
||||
LLSD ret;
|
||||
ret[VRED] = mV[VRED];
|
||||
ret[VGREEN] = mV[VGREEN];
|
||||
ret[VBLUE] = mV[VBLUE];
|
||||
ret[VALPHA] = mV[VALPHA];
|
||||
return ret;
|
||||
}
|
||||
|
||||
void setValue(const LLSD& sd);
|
||||
void setValue(const LLSD& sd);
|
||||
|
||||
void setHSL(F32 hue, F32 saturation, F32 luminance);
|
||||
void calcHSL(F32* hue, F32* saturation, F32* luminance) const;
|
||||
void setHSL(F32 hue, F32 saturation, F32 luminance);
|
||||
void calcHSL(F32* hue, F32* saturation, F32* luminance) const;
|
||||
|
||||
const LLColor4& setToBlack(); // zero LLColor4 to (0, 0, 0, 1)
|
||||
const LLColor4& setToWhite(); // zero LLColor4 to (0, 0, 0, 1)
|
||||
const LLColor4& setToBlack(); // zero LLColor4 to (0, 0, 0, 1)
|
||||
const LLColor4& setToWhite(); // zero LLColor4 to (0, 0, 0, 1)
|
||||
|
||||
const LLColor4& setVec(F32 r, F32 g, F32 b, F32 a); // deprecated -- use set()
|
||||
const LLColor4& setVec(F32 r, F32 g, F32 b); // deprecated -- use set()
|
||||
const LLColor4& setVec(const LLColor4 &vec); // deprecated -- use set()
|
||||
const LLColor4& setVec(const LLColor3 &vec); // deprecated -- use set()
|
||||
const LLColor4& setVec(const LLColor3 &vec, F32 a); // deprecated -- use set()
|
||||
const LLColor4& setVec(const F32 *vec); // deprecated -- use set()
|
||||
const LLColor4& setVec(const LLColor4U& color4u); // deprecated -- use set()
|
||||
const LLColor4& setVec(F32 r, F32 g, F32 b, F32 a); // deprecated -- use set()
|
||||
const LLColor4& setVec(F32 r, F32 g, F32 b); // deprecated -- use set()
|
||||
const LLColor4& setVec(const LLColor4& vec); // deprecated -- use set()
|
||||
const LLColor4& setVec(const LLColor3& vec); // deprecated -- use set()
|
||||
const LLColor4& setVec(const LLColor3& vec, F32 a); // deprecated -- use set()
|
||||
const LLColor4& setVec(const F32* vec); // deprecated -- use set()
|
||||
const LLColor4& setVec(const LLColor4U& color4u); // deprecated -- use set()
|
||||
|
||||
const LLColor4& set(F32 r, F32 g, F32 b, F32 a); // Sets LLColor4 to (r, g, b, a)
|
||||
const LLColor4& set(F32 r, F32 g, F32 b); // Sets LLColor4 to (r, g, b) (no change in a)
|
||||
const LLColor4& set(const LLColor4 &vec); // Sets LLColor4 to vec
|
||||
const LLColor4& set(const LLColor3 &vec); // Sets LLColor4 to LLColor3 vec (no change in alpha)
|
||||
const LLColor4& set(const LLColor3 &vec, F32 a); // Sets LLColor4 to LLColor3 vec, with alpha specified
|
||||
const LLColor4& set(const F32 *vec); // Sets LLColor4 to vec
|
||||
const LLColor4& set(const F64 *vec); // Sets LLColor4 to (double)vec
|
||||
const LLColor4& set(const LLColor4U& color4u); // Sets LLColor4 to color4u, rescaled.
|
||||
const LLColor4& set(F32 r, F32 g, F32 b, F32 a); // Sets LLColor4 to (r, g, b, a)
|
||||
const LLColor4& set(F32 r, F32 g, F32 b); // Sets LLColor4 to (r, g, b) (no change in a)
|
||||
const LLColor4& set(const LLColor4& vec); // Sets LLColor4 to vec
|
||||
const LLColor4& set(const LLColor3& vec); // Sets LLColor4 to LLColor3 vec (no change in alpha)
|
||||
const LLColor4& set(const LLColor3& vec, F32 a); // Sets LLColor4 to LLColor3 vec, with alpha specified
|
||||
const LLColor4& set(const F32* vec); // Sets LLColor4 to vec
|
||||
const LLColor4& set(const F64* vec); // Sets LLColor4 to (double)vec
|
||||
const LLColor4& set(const LLColor4U& color4u); // Sets LLColor4 to color4u, rescaled.
|
||||
|
||||
// set from a vector of unknown type and size
|
||||
// may leave some data unmodified
|
||||
template<typename T>
|
||||
const LLColor4& set(const std::vector<T>& v);
|
||||
// set from a vector of unknown type and size
|
||||
// may leave some data unmodified
|
||||
template<typename T>
|
||||
const LLColor4& set(const std::vector<T>& v);
|
||||
|
||||
// write to a vector of unknown type and size
|
||||
// maye leave some data unmodified
|
||||
template<typename T>
|
||||
void write(std::vector<T>& v) const;
|
||||
// write to a vector of unknown type and size
|
||||
// maye leave some data unmodified
|
||||
template<typename T>
|
||||
void write(std::vector<T>& v) const;
|
||||
|
||||
const LLColor4& setAlpha(F32 a);
|
||||
const LLColor4& setAlpha(F32 a);
|
||||
|
||||
F32 magVec() const; // deprecated -- use length()
|
||||
F32 magVecSquared() const; // deprecated -- use lengthSquared()
|
||||
F32 normVec(); // deprecated -- use normalize()
|
||||
F32 magVec() const; // deprecated -- use length()
|
||||
F32 magVecSquared() const; // deprecated -- use lengthSquared()
|
||||
F32 normVec(); // deprecated -- use normalize()
|
||||
|
||||
F32 length() const; // Returns magnitude of LLColor4
|
||||
F32 lengthSquared() const; // Returns magnitude squared of LLColor4
|
||||
F32 normalize(); // deprecated -- use normalize()
|
||||
F32 length() const; // Returns magnitude of 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]; }
|
||||
F32 operator[](int idx) const { return mV[idx]; }
|
||||
F32& operator[](int idx) { return mV[idx]; }
|
||||
|
||||
const LLColor4& operator=(const LLColor3 &a); // Assigns vec3 to vec4 and returns vec4
|
||||
const LLColor4& operator=(const LLColor3& a); // Assigns vec3 to vec4 and returns vec4
|
||||
|
||||
bool operator<(const LLColor4& rhs) const;
|
||||
friend std::ostream& operator<<(std::ostream& s, const LLColor4 &a); // Print a
|
||||
friend LLColor4 operator+(const LLColor4 &a, const LLColor4 &b); // Return vector a + b
|
||||
friend LLColor4 operator-(const LLColor4 &a, const LLColor4 &b); // Return vector a minus b
|
||||
friend LLColor4 operator*(const LLColor4 &a, const LLColor4 &b); // Return component wise a * b
|
||||
friend LLColor4 operator*(const LLColor4 &a, F32 k); // Return rgb times scaler k (no alpha change)
|
||||
friend LLColor4 operator/(const LLColor4 &a, F32 k); // Return rgb divided by scalar k (no alpha change)
|
||||
friend LLColor4 operator*(F32 k, const LLColor4 &a); // Return rgb times scaler k (no alpha change)
|
||||
friend LLColor4 operator%(const LLColor4 &a, F32 k); // Return alpha times scaler k (no rgb change)
|
||||
friend LLColor4 operator%(F32 k, const LLColor4 &a); // Return alpha times scaler k (no rgb change)
|
||||
bool operator<(const LLColor4& rhs) const;
|
||||
friend std::ostream& operator<<(std::ostream& s, const LLColor4& a); // Print a
|
||||
friend LLColor4 operator+(const LLColor4& a, const LLColor4& b); // Return vector a + b
|
||||
friend LLColor4 operator-(const LLColor4& a, const LLColor4& b); // Return vector a minus b
|
||||
friend LLColor4 operator*(const LLColor4& a, const LLColor4& b); // Return component wise a * b
|
||||
friend LLColor4 operator*(const LLColor4& a, F32 k); // Return rgb times scaler k (no alpha change)
|
||||
friend LLColor4 operator/(const LLColor4& a, F32 k); // Return rgb divided by scalar k (no alpha change)
|
||||
friend LLColor4 operator*(F32 k, const LLColor4& a); // Return rgb times scaler k (no alpha change)
|
||||
friend LLColor4 operator%(const LLColor4& a, F32 k); // Return alpha times scaler k (no rgb change)
|
||||
friend LLColor4 operator%(F32 k, const LLColor4& a); // Return alpha times scaler k (no rgb change)
|
||||
|
||||
friend bool operator==(const LLColor4 &a, const LLColor4 &b); // Return a == b
|
||||
friend bool operator!=(const LLColor4 &a, const LLColor4 &b); // Return a != b
|
||||
friend bool operator==(const LLColor4& a, const LLColor4& b); // Return a == b
|
||||
friend bool operator!=(const LLColor4& a, const LLColor4& b); // Return a != b
|
||||
|
||||
friend bool operator==(const LLColor4 &a, const LLColor3 &b); // Return a == b
|
||||
friend bool operator!=(const LLColor4 &a, const LLColor3 &b); // Return a != b
|
||||
friend bool operator==(const LLColor4& a, const LLColor3& b); // Return a == b
|
||||
friend bool operator!=(const LLColor4& a, const LLColor3& b); // Return a != b
|
||||
|
||||
friend const LLColor4& operator+=(LLColor4 &a, const LLColor4 &b); // Return vector a + b
|
||||
friend const LLColor4& operator-=(LLColor4 &a, const LLColor4 &b); // Return vector a minus b
|
||||
friend const LLColor4& operator*=(LLColor4 &a, F32 k); // Return rgb times scaler k (no alpha change)
|
||||
friend const LLColor4& operator%=(LLColor4 &a, F32 k); // Return alpha times scaler k (no rgb change)
|
||||
friend const LLColor4& operator+=(LLColor4& a, const LLColor4& b); // Return vector a + b
|
||||
friend const LLColor4& operator-=(LLColor4& a, const LLColor4& b); // Return vector a minus b
|
||||
friend const LLColor4& operator*=(LLColor4& a, F32 k); // Return rgb times scaler k (no alpha change)
|
||||
friend const LLColor4& operator%=(LLColor4& a, F32 k); // Return alpha times scaler k (no rgb change)
|
||||
|
||||
friend const LLColor4& operator*=(LLColor4 &a, const LLColor4 &b); // Doesn't multiply alpha! (for lighting)
|
||||
friend const LLColor4& operator*=(LLColor4& a, const LLColor4& b); // Doesn't multiply alpha! (for lighting)
|
||||
|
||||
// conversion
|
||||
operator LLColor4U() const;
|
||||
// conversion
|
||||
operator LLColor4U() const;
|
||||
|
||||
// Basic color values.
|
||||
static LLColor4 red;
|
||||
static LLColor4 green;
|
||||
static LLColor4 blue;
|
||||
static LLColor4 black;
|
||||
static LLColor4 white;
|
||||
static LLColor4 yellow;
|
||||
static LLColor4 magenta;
|
||||
static LLColor4 cyan;
|
||||
static LLColor4 smoke;
|
||||
static LLColor4 grey;
|
||||
static LLColor4 orange;
|
||||
static LLColor4 purple;
|
||||
static LLColor4 pink;
|
||||
static LLColor4 transparent;
|
||||
// Basic color values.
|
||||
static LLColor4 red;
|
||||
static LLColor4 green;
|
||||
static LLColor4 blue;
|
||||
static LLColor4 black;
|
||||
static LLColor4 white;
|
||||
static LLColor4 yellow;
|
||||
static LLColor4 magenta;
|
||||
static LLColor4 cyan;
|
||||
static LLColor4 smoke;
|
||||
static LLColor4 grey;
|
||||
static LLColor4 orange;
|
||||
static LLColor4 purple;
|
||||
static LLColor4 pink;
|
||||
static LLColor4 transparent;
|
||||
|
||||
// Extra color values.
|
||||
static LLColor4 grey1;
|
||||
static LLColor4 grey2;
|
||||
static LLColor4 grey3;
|
||||
static LLColor4 grey4;
|
||||
// Extra color values.
|
||||
static LLColor4 grey1;
|
||||
static LLColor4 grey2;
|
||||
static LLColor4 grey3;
|
||||
static LLColor4 grey4;
|
||||
// [RLVa:KB] - Checked: RLVa-2.2 (@setcam_avdist)
|
||||
static LLColor4 silhouette;
|
||||
// [/RLVa:KB]
|
||||
|
||||
static LLColor4 red1;
|
||||
static LLColor4 red2;
|
||||
static LLColor4 red3;
|
||||
static LLColor4 red4;
|
||||
static LLColor4 red5;
|
||||
static LLColor4 red1;
|
||||
static LLColor4 red2;
|
||||
static LLColor4 red3;
|
||||
static LLColor4 red4;
|
||||
static LLColor4 red5;
|
||||
|
||||
static LLColor4 green1;
|
||||
static LLColor4 green2;
|
||||
static LLColor4 green3;
|
||||
static LLColor4 green4;
|
||||
static LLColor4 green5;
|
||||
static LLColor4 green6;
|
||||
static LLColor4 green1;
|
||||
static LLColor4 green2;
|
||||
static LLColor4 green3;
|
||||
static LLColor4 green4;
|
||||
static LLColor4 green5;
|
||||
static LLColor4 green6;
|
||||
|
||||
static LLColor4 blue1;
|
||||
static LLColor4 blue2;
|
||||
static LLColor4 blue3;
|
||||
static LLColor4 blue4;
|
||||
static LLColor4 blue5;
|
||||
static LLColor4 blue6;
|
||||
static LLColor4 blue1;
|
||||
static LLColor4 blue2;
|
||||
static LLColor4 blue3;
|
||||
static LLColor4 blue4;
|
||||
static LLColor4 blue5;
|
||||
static LLColor4 blue6;
|
||||
|
||||
static LLColor4 yellow1;
|
||||
static LLColor4 yellow2;
|
||||
static LLColor4 yellow3;
|
||||
static LLColor4 yellow4;
|
||||
static LLColor4 yellow5;
|
||||
static LLColor4 yellow6;
|
||||
static LLColor4 yellow7;
|
||||
static LLColor4 yellow8;
|
||||
static LLColor4 yellow9;
|
||||
static LLColor4 yellow1;
|
||||
static LLColor4 yellow2;
|
||||
static LLColor4 yellow3;
|
||||
static LLColor4 yellow4;
|
||||
static LLColor4 yellow5;
|
||||
static LLColor4 yellow6;
|
||||
static LLColor4 yellow7;
|
||||
static LLColor4 yellow8;
|
||||
static LLColor4 yellow9;
|
||||
|
||||
static LLColor4 orange1;
|
||||
static LLColor4 orange2;
|
||||
static LLColor4 orange3;
|
||||
static LLColor4 orange4;
|
||||
static LLColor4 orange5;
|
||||
static LLColor4 orange6;
|
||||
static LLColor4 orange1;
|
||||
static LLColor4 orange2;
|
||||
static LLColor4 orange3;
|
||||
static LLColor4 orange4;
|
||||
static LLColor4 orange5;
|
||||
static LLColor4 orange6;
|
||||
|
||||
static LLColor4 magenta1;
|
||||
static LLColor4 magenta2;
|
||||
static LLColor4 magenta3;
|
||||
static LLColor4 magenta4;
|
||||
static LLColor4 magenta1;
|
||||
static LLColor4 magenta2;
|
||||
static LLColor4 magenta3;
|
||||
static LLColor4 magenta4;
|
||||
|
||||
static LLColor4 purple1;
|
||||
static LLColor4 purple2;
|
||||
static LLColor4 purple3;
|
||||
static LLColor4 purple4;
|
||||
static LLColor4 purple5;
|
||||
static LLColor4 purple6;
|
||||
static LLColor4 purple1;
|
||||
static LLColor4 purple2;
|
||||
static LLColor4 purple3;
|
||||
static LLColor4 purple4;
|
||||
static LLColor4 purple5;
|
||||
static LLColor4 purple6;
|
||||
|
||||
static LLColor4 pink1;
|
||||
static LLColor4 pink2;
|
||||
static LLColor4 pink1;
|
||||
static LLColor4 pink2;
|
||||
|
||||
static LLColor4 cyan1;
|
||||
static LLColor4 cyan2;
|
||||
static LLColor4 cyan3;
|
||||
static LLColor4 cyan4;
|
||||
static LLColor4 cyan5;
|
||||
static LLColor4 cyan6;
|
||||
static LLColor4 cyan1;
|
||||
static LLColor4 cyan2;
|
||||
static LLColor4 cyan3;
|
||||
static LLColor4 cyan4;
|
||||
static LLColor4 cyan5;
|
||||
static LLColor4 cyan6;
|
||||
|
||||
static bool parseColor(const std::string& buf, LLColor4* color);
|
||||
static bool parseColor4(const std::string& buf, LLColor4* color);
|
||||
static bool parseColor(const std::string& buf, LLColor4* color);
|
||||
static bool parseColor4(const std::string& buf, LLColor4* color);
|
||||
|
||||
inline void clamp();
|
||||
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
|
||||
LLColor3 vec4to3(const LLColor4 &vec);
|
||||
LLColor4 vec3to4(const LLColor3 &vec);
|
||||
LLColor4 lerp(const LLColor4 &a, const LLColor4 &b, F32 u);
|
||||
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
|
||||
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[VRED] = 0.f;
|
||||
mV[VGREEN] = 0.f;
|
||||
mV[VBLUE] = 0.f;
|
||||
mV[VBLUE] = 0.f;
|
||||
mV[VALPHA] = 1.f;
|
||||
}
|
||||
|
||||
|
|
@ -258,149 +256,146 @@ inline LLColor4::LLColor4(const LLSD& sd)
|
|||
|
||||
inline LLColor4::LLColor4(F32 r, F32 g, F32 b)
|
||||
{
|
||||
mV[VRED] = r;
|
||||
mV[VRED] = r;
|
||||
mV[VGREEN] = g;
|
||||
mV[VBLUE] = b;
|
||||
mV[VBLUE] = b;
|
||||
mV[VALPHA] = 1.f;
|
||||
}
|
||||
|
||||
inline LLColor4::LLColor4(F32 r, F32 g, F32 b, F32 a)
|
||||
{
|
||||
mV[VRED] = r;
|
||||
mV[VRED] = r;
|
||||
mV[VGREEN] = g;
|
||||
mV[VBLUE] = b;
|
||||
mV[VBLUE] = b;
|
||||
mV[VALPHA] = a;
|
||||
}
|
||||
|
||||
inline LLColor4::LLColor4(U32 clr)
|
||||
{
|
||||
mV[VRED] = (clr&0xff) * (1.0f/255.0f);
|
||||
mV[VGREEN] = ((clr>>8)&0xff) * (1.0f/255.0f);
|
||||
mV[VBLUE] = ((clr>>16)&0xff) * (1.0f/255.0f);
|
||||
mV[VALPHA] = (clr>>24) * (1.0f/255.0f);
|
||||
mV[VRED] = (clr & 0xff) * (1.0f / 255.0f);
|
||||
mV[VGREEN] = ((clr >> 8) & 0xff) * (1.0f / 255.0f);
|
||||
mV[VBLUE] = ((clr >> 16) & 0xff) * (1.0f / 255.0f);
|
||||
mV[VALPHA] = (clr >> 24) * (1.0f / 255.0f);
|
||||
}
|
||||
|
||||
|
||||
inline LLColor4::LLColor4(const F32 *vec)
|
||||
inline LLColor4::LLColor4(const F32* vec)
|
||||
{
|
||||
mV[VRED] = vec[VRED];
|
||||
mV[VRED] = vec[VRED];
|
||||
mV[VGREEN] = vec[VGREEN];
|
||||
mV[VBLUE] = vec[VBLUE];
|
||||
mV[VBLUE] = vec[VBLUE];
|
||||
mV[VALPHA] = vec[VALPHA];
|
||||
}
|
||||
|
||||
inline const LLColor4& LLColor4::setToBlack(void)
|
||||
inline const LLColor4& LLColor4::setToBlack(void)
|
||||
{
|
||||
mV[VRED] = 0.f;
|
||||
mV[VRED] = 0.f;
|
||||
mV[VGREEN] = 0.f;
|
||||
mV[VBLUE] = 0.f;
|
||||
mV[VBLUE] = 0.f;
|
||||
mV[VALPHA] = 1.f;
|
||||
return (*this);
|
||||
}
|
||||
|
||||
inline const LLColor4& LLColor4::setToWhite(void)
|
||||
inline const LLColor4& LLColor4::setToWhite(void)
|
||||
{
|
||||
mV[VRED] = 1.f;
|
||||
mV[VRED] = 1.f;
|
||||
mV[VGREEN] = 1.f;
|
||||
mV[VBLUE] = 1.f;
|
||||
mV[VBLUE] = 1.f;
|
||||
mV[VALPHA] = 1.f;
|
||||
return (*this);
|
||||
}
|
||||
|
||||
inline const LLColor4& LLColor4::set(F32 x, F32 y, F32 z)
|
||||
inline const LLColor4& LLColor4::set(F32 x, F32 y, F32 z)
|
||||
{
|
||||
mV[VRED] = x;
|
||||
mV[VRED] = x;
|
||||
mV[VGREEN] = y;
|
||||
mV[VBLUE] = z;
|
||||
mV[VBLUE] = z;
|
||||
|
||||
// no change to alpha!
|
||||
// mV[VALPHA] = 1.f;
|
||||
// no change to alpha!
|
||||
// mV[VALPHA] = 1.f;
|
||||
|
||||
return (*this);
|
||||
}
|
||||
|
||||
inline const LLColor4& LLColor4::set(F32 x, F32 y, F32 z, F32 a)
|
||||
inline const LLColor4& LLColor4::set(F32 x, F32 y, F32 z, F32 a)
|
||||
{
|
||||
mV[VRED] = x;
|
||||
mV[VRED] = x;
|
||||
mV[VGREEN] = y;
|
||||
mV[VBLUE] = z;
|
||||
mV[VBLUE] = z;
|
||||
mV[VALPHA] = a;
|
||||
return (*this);
|
||||
}
|
||||
|
||||
inline const LLColor4& LLColor4::set(const LLColor4 &vec)
|
||||
inline const LLColor4& LLColor4::set(const LLColor4& vec)
|
||||
{
|
||||
mV[VRED] = vec.mV[VRED];
|
||||
mV[VRED] = vec.mV[VRED];
|
||||
mV[VGREEN] = vec.mV[VGREEN];
|
||||
mV[VBLUE] = vec.mV[VBLUE];
|
||||
mV[VBLUE] = vec.mV[VBLUE];
|
||||
mV[VALPHA] = vec.mV[VALPHA];
|
||||
return (*this);
|
||||
}
|
||||
|
||||
|
||||
inline const LLColor4& LLColor4::set(const F32 *vec)
|
||||
inline const LLColor4& LLColor4::set(const F32* vec)
|
||||
{
|
||||
mV[VRED] = vec[VRED];
|
||||
mV[VRED] = vec[VRED];
|
||||
mV[VGREEN] = vec[VGREEN];
|
||||
mV[VBLUE] = vec[VBLUE];
|
||||
mV[VBLUE] = vec[VBLUE];
|
||||
mV[VALPHA] = vec[VALPHA];
|
||||
return (*this);
|
||||
}
|
||||
|
||||
inline const LLColor4& LLColor4::set(const F64 *vec)
|
||||
inline const LLColor4& LLColor4::set(const F64* vec)
|
||||
{
|
||||
mV[VRED] = static_cast<F32>(vec[VRED]);
|
||||
mV[VRED] = static_cast<F32>(vec[VRED]);
|
||||
mV[VGREEN] = static_cast<F32>(vec[VGREEN]);
|
||||
mV[VBLUE] = static_cast<F32>(vec[VBLUE]);
|
||||
mV[VBLUE] = static_cast<F32>(vec[VBLUE]);
|
||||
mV[VALPHA] = static_cast<F32>(vec[VALPHA]);
|
||||
return (*this);
|
||||
}
|
||||
|
||||
// deprecated
|
||||
inline const LLColor4& LLColor4::setVec(F32 x, F32 y, F32 z)
|
||||
inline const LLColor4& LLColor4::setVec(F32 x, F32 y, F32 z)
|
||||
{
|
||||
mV[VRED] = x;
|
||||
mV[VRED] = x;
|
||||
mV[VGREEN] = y;
|
||||
mV[VBLUE] = z;
|
||||
mV[VBLUE] = z;
|
||||
|
||||
// no change to alpha!
|
||||
// mV[VALPHA] = 1.f;
|
||||
// no change to alpha!
|
||||
// mV[VALPHA] = 1.f;
|
||||
|
||||
return (*this);
|
||||
}
|
||||
|
||||
// deprecated
|
||||
inline const LLColor4& LLColor4::setVec(F32 x, F32 y, F32 z, F32 a)
|
||||
inline const LLColor4& LLColor4::setVec(F32 x, F32 y, F32 z, F32 a)
|
||||
{
|
||||
mV[VRED] = x;
|
||||
mV[VRED] = x;
|
||||
mV[VGREEN] = y;
|
||||
mV[VBLUE] = z;
|
||||
mV[VBLUE] = z;
|
||||
mV[VALPHA] = a;
|
||||
return (*this);
|
||||
}
|
||||
|
||||
// deprecated
|
||||
inline const LLColor4& LLColor4::setVec(const LLColor4 &vec)
|
||||
inline const LLColor4& LLColor4::setVec(const LLColor4& vec)
|
||||
{
|
||||
mV[VRED] = vec.mV[VRED];
|
||||
mV[VRED] = vec.mV[VRED];
|
||||
mV[VGREEN] = vec.mV[VGREEN];
|
||||
mV[VBLUE] = vec.mV[VBLUE];
|
||||
mV[VBLUE] = vec.mV[VBLUE];
|
||||
mV[VALPHA] = vec.mV[VALPHA];
|
||||
return (*this);
|
||||
}
|
||||
|
||||
|
||||
// deprecated
|
||||
inline const LLColor4& LLColor4::setVec(const F32 *vec)
|
||||
inline const LLColor4& LLColor4::setVec(const F32* vec)
|
||||
{
|
||||
mV[VRED] = vec[VRED];
|
||||
mV[VRED] = vec[VRED];
|
||||
mV[VGREEN] = vec[VGREEN];
|
||||
mV[VBLUE] = vec[VBLUE];
|
||||
mV[VBLUE] = vec[VBLUE];
|
||||
mV[VALPHA] = vec[VALPHA];
|
||||
return (*this);
|
||||
}
|
||||
|
||||
inline const LLColor4& LLColor4::setAlpha(F32 a)
|
||||
inline const LLColor4& LLColor4::setAlpha(F32 a)
|
||||
{
|
||||
mV[VALPHA] = a;
|
||||
return (*this);
|
||||
|
|
@ -408,155 +403,116 @@ 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];
|
||||
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)
|
||||
{
|
||||
oomag = 1.f/mag;
|
||||
oomag = 1.f / mag;
|
||||
mV[VRED] *= oomag;
|
||||
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];
|
||||
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)
|
||||
{
|
||||
oomag = 1.f/mag;
|
||||
oomag = 1.f / mag;
|
||||
mV[VRED] *= oomag;
|
||||
mV[VGREEN] *= oomag;
|
||||
mV[VBLUE] *= oomag;
|
||||
}
|
||||
return (mag);
|
||||
return mag;
|
||||
}
|
||||
|
||||
// LLColor4 Operators
|
||||
|
||||
|
||||
inline LLColor4 operator+(const LLColor4 &a, const LLColor4 &b)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
inline const LLColor4& operator+=(LLColor4& a, const LLColor4& b)
|
||||
{
|
||||
a.mV[VRED] += b.mV[VRED];
|
||||
a.mV[VGREEN] += b.mV[VGREEN];
|
||||
|
|
@ -565,7 +521,7 @@ inline const LLColor4& operator+=(LLColor4 &a, const LLColor4 &b)
|
|||
return a;
|
||||
}
|
||||
|
||||
inline const LLColor4& operator-=(LLColor4 &a, const LLColor4 &b)
|
||||
inline const LLColor4& operator-=(LLColor4& a, const LLColor4& b)
|
||||
{
|
||||
a.mV[VRED] -= b.mV[VRED];
|
||||
a.mV[VGREEN] -= b.mV[VGREEN];
|
||||
|
|
@ -574,7 +530,7 @@ inline const LLColor4& operator-=(LLColor4 &a, const LLColor4 &b)
|
|||
return a;
|
||||
}
|
||||
|
||||
inline const LLColor4& operator*=(LLColor4 &a, F32 k)
|
||||
inline const LLColor4& operator*=(LLColor4& a, F32 k)
|
||||
{
|
||||
// only affects rgb (not a!)
|
||||
a.mV[VRED] *= k;
|
||||
|
|
@ -583,121 +539,120 @@ inline const LLColor4& operator*=(LLColor4 &a, F32 k)
|
|||
return a;
|
||||
}
|
||||
|
||||
inline const LLColor4& operator *=(LLColor4 &a, const LLColor4 &b)
|
||||
inline const LLColor4& operator*=(LLColor4& a, const LLColor4& b)
|
||||
{
|
||||
a.mV[VRED] *= b.mV[VRED];
|
||||
a.mV[VGREEN] *= b.mV[VGREEN];
|
||||
a.mV[VBLUE] *= b.mV[VBLUE];
|
||||
// a.mV[VALPHA] *= b.mV[VALPHA];
|
||||
// a.mV[VALPHA] *= b.mV[VALPHA];
|
||||
return a;
|
||||
}
|
||||
|
||||
inline const LLColor4& operator%=(LLColor4 &a, F32 k)
|
||||
inline const LLColor4& operator%=(LLColor4& a, F32 k)
|
||||
{
|
||||
// only affects alpha (not rgb!)
|
||||
a.mV[VALPHA] *= k;
|
||||
return a;
|
||||
}
|
||||
|
||||
|
||||
// Non-member functions
|
||||
|
||||
inline F32 distVec(const LLColor4 &a, const LLColor4 &b)
|
||||
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)
|
||||
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)
|
||||
inline LLColor4 lerp(const LLColor4& a, const LLColor4& b, F32 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);
|
||||
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);
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
// Return the given gamma corrected (sRGB) color in linear space
|
||||
inline const LLColor4 linearColor4(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;
|
||||
}
|
||||
|
|
@ -723,4 +678,3 @@ void LLColor4::write(std::vector<T>& v) const
|
|||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -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,49 +36,7 @@ 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)
|
||||
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] << " }";
|
||||
return s;
|
||||
|
|
@ -90,31 +45,31 @@ std::ostream& operator<<(std::ostream& s, const LLColor4U &a)
|
|||
// static
|
||||
bool LLColor4U::parseColor4U(const std::string& buf, LLColor4U* value)
|
||||
{
|
||||
if( buf.empty() || value == nullptr)
|
||||
if (buf.empty() || value == nullptr)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
U32 v[4];
|
||||
S32 count = sscanf( buf.c_str(), "%u, %u, %u, %u", v + 0, v + 1, v + 2, v + 3 );
|
||||
if (1 == count )
|
||||
U32 v[4]{};
|
||||
S32 count = sscanf(buf.c_str(), "%u, %u, %u, %u", v + 0, v + 1, v + 2, v + 3);
|
||||
if (1 == count)
|
||||
{
|
||||
// try this format
|
||||
count = sscanf( buf.c_str(), "%u %u %u %u", v + 0, v + 1, v + 2, v + 3 );
|
||||
count = sscanf(buf.c_str(), "%u %u %u %u", v + 0, v + 1, v + 2, v + 3);
|
||||
}
|
||||
if( 4 != count )
|
||||
if (4 != count)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
for( S32 i = 0; i < 4; i++ )
|
||||
for (S32 i = 0; i < 4; i++)
|
||||
{
|
||||
if( v[i] > U8_MAX )
|
||||
if (v[i] > U8_MAX)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -28,104 +28,93 @@
|
|||
#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);
|
||||
}
|
||||
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); }
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
const LLColor4U& setToBlack(); // zero LLColor4U to (0, 0, 0, 1)
|
||||
const LLColor4U& setToWhite(); // zero LLColor4U to (0, 0, 0, 1)
|
||||
const LLColor4U& setToBlack(); // zero LLColor4U to (0, 0, 0, 1)
|
||||
const LLColor4U& setToWhite(); // zero LLColor4U to (0, 0, 0, 1)
|
||||
|
||||
const LLColor4U& set(U8 r, U8 g, U8 b, U8 a);// Sets LLColor4U to (r, g, b, a)
|
||||
const LLColor4U& set(U8 r, U8 g, U8 b); // Sets LLColor4U to (r, g, b) (no change in a)
|
||||
const LLColor4U& set(const LLColor4U &vec); // Sets LLColor4U to vec
|
||||
const LLColor4U& set(const U8 *vec); // Sets LLColor4U to vec
|
||||
const LLColor4U& set(U8 r, U8 g, U8 b, U8 a); // Sets LLColor4U to (r, g, b, a)
|
||||
const LLColor4U& set(U8 r, U8 g, U8 b); // Sets LLColor4U to (r, g, b) (no change in a)
|
||||
const LLColor4U& set(const LLColor4U& vec); // Sets LLColor4U to vec
|
||||
const LLColor4U& set(const U8* vec); // Sets LLColor4U to vec
|
||||
|
||||
const LLColor4U& setVec(U8 r, U8 g, U8 b, U8 a); // deprecated -- use set()
|
||||
const LLColor4U& setVec(U8 r, U8 g, U8 b); // deprecated -- use set()
|
||||
const LLColor4U& setVec(const LLColor4U &vec); // deprecated -- use set()
|
||||
const LLColor4U& setVec(const U8 *vec); // deprecated -- use set()
|
||||
const LLColor4U& setVec(U8 r, U8 g, U8 b, U8 a); // deprecated -- use set()
|
||||
const LLColor4U& setVec(U8 r, U8 g, U8 b); // deprecated -- use set()
|
||||
const LLColor4U& setVec(const LLColor4U& vec); // deprecated -- use set()
|
||||
const LLColor4U& setVec(const U8* vec); // deprecated -- use set()
|
||||
|
||||
const LLColor4U& setAlpha(U8 a);
|
||||
const LLColor4U& setAlpha(U8 a);
|
||||
|
||||
F32 magVec() const; // deprecated -- use length()
|
||||
F32 magVecSquared() const; // deprecated -- use lengthSquared()
|
||||
F32 magVec() const; // deprecated -- use length()
|
||||
F32 magVecSquared() const; // deprecated -- use lengthSquared()
|
||||
|
||||
F32 length() const; // Returns magnitude squared of LLColor4U
|
||||
F32 lengthSquared() const; // Returns magnitude squared of LLColor4U
|
||||
F32 length() const; // Returns magnitude squared of LLColor4U
|
||||
F32 lengthSquared() const; // Returns magnitude squared of LLColor4U
|
||||
|
||||
friend std::ostream& operator<<(std::ostream& s, const LLColor4U &a); // Print a
|
||||
friend LLColor4U operator+(const LLColor4U &a, const LLColor4U &b); // Return vector a + b
|
||||
friend LLColor4U operator-(const LLColor4U &a, const LLColor4U &b); // Return vector a minus b
|
||||
friend LLColor4U operator*(const LLColor4U &a, const LLColor4U &b); // Return a * b
|
||||
friend bool operator==(const LLColor4U &a, const LLColor4U &b); // Return a == b
|
||||
friend bool operator!=(const LLColor4U &a, const LLColor4U &b); // Return a != b
|
||||
friend std::ostream& operator<<(std::ostream& s, const LLColor4U& a); // Print a
|
||||
friend LLColor4U operator+(const LLColor4U& a, const LLColor4U& b); // Return vector a + b
|
||||
friend LLColor4U operator-(const LLColor4U& a, const LLColor4U& b); // Return vector a minus b
|
||||
friend LLColor4U operator*(const LLColor4U& a, const LLColor4U& b); // Return a * b
|
||||
friend bool operator==(const LLColor4U& a, const LLColor4U& b); // Return a == b
|
||||
friend bool operator!=(const LLColor4U& a, const LLColor4U& b); // Return a != b
|
||||
|
||||
friend const LLColor4U& operator+=(LLColor4U &a, const LLColor4U &b); // Return vector a + b
|
||||
friend const LLColor4U& operator-=(LLColor4U &a, const LLColor4U &b); // Return vector a minus b
|
||||
friend const LLColor4U& operator*=(LLColor4U &a, U8 k); // Return rgb times scaler k (no alpha change)
|
||||
friend const LLColor4U& operator%=(LLColor4U &a, U8 k); // Return alpha times scaler k (no rgb change)
|
||||
friend const LLColor4U& operator+=(LLColor4U& a, const LLColor4U& b); // Return vector a + b
|
||||
friend const LLColor4U& operator-=(LLColor4U& a, const LLColor4U& b); // Return vector a minus b
|
||||
friend const LLColor4U& operator*=(LLColor4U& a, U8 k); // Return rgb times scaler k (no alpha change)
|
||||
friend const LLColor4U& operator%=(LLColor4U& a, U8 k); // Return alpha times scaler k (no rgb change)
|
||||
|
||||
LLColor4U addClampMax(const LLColor4U &color); // Add and clamp the max
|
||||
LLColor4U addClampMax(const LLColor4U& color); // Add and clamp the max
|
||||
|
||||
LLColor4U multAll(const F32 k); // Multiply ALL channels by scalar k
|
||||
LLColor4U multAll(const F32 k); // Multiply ALL channels by scalar k
|
||||
|
||||
inline void setVecScaleClamp(const LLColor3 &color);
|
||||
inline void setVecScaleClamp(const LLColor4 &color);
|
||||
inline void setVecScaleClamp(const LLColor3& color);
|
||||
inline void setVecScaleClamp(const LLColor4& color);
|
||||
|
||||
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 );
|
||||
U32 asRGBA() const;
|
||||
void fromRGBA(U32 aVal);
|
||||
|
||||
static LLColor4U white;
|
||||
static LLColor4U black;
|
||||
|
|
@ -134,104 +123,95 @@ 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
|
||||
|
||||
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;
|
||||
mV[VRED] = 0;
|
||||
mV[VGREEN] = 0;
|
||||
mV[VBLUE] = 0;
|
||||
mV[VBLUE] = 0;
|
||||
mV[VALPHA] = 255;
|
||||
}
|
||||
|
||||
inline LLColor4U::LLColor4U(U8 r, U8 g, U8 b)
|
||||
{
|
||||
mV[VRED] = r;
|
||||
mV[VRED] = r;
|
||||
mV[VGREEN] = g;
|
||||
mV[VBLUE] = b;
|
||||
mV[VBLUE] = b;
|
||||
mV[VALPHA] = 255;
|
||||
}
|
||||
|
||||
inline LLColor4U::LLColor4U(U8 r, U8 g, U8 b, U8 a)
|
||||
{
|
||||
mV[VRED] = r;
|
||||
mV[VRED] = r;
|
||||
mV[VGREEN] = g;
|
||||
mV[VBLUE] = b;
|
||||
mV[VBLUE] = b;
|
||||
mV[VALPHA] = a;
|
||||
}
|
||||
|
||||
inline LLColor4U::LLColor4U(const U8 *vec)
|
||||
inline LLColor4U::LLColor4U(const U8* vec)
|
||||
{
|
||||
mV[VRED] = vec[VRED];
|
||||
mV[VRED] = vec[VRED];
|
||||
mV[VGREEN] = vec[VGREEN];
|
||||
mV[VBLUE] = vec[VBLUE];
|
||||
mV[VBLUE] = vec[VBLUE];
|
||||
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;
|
||||
mV[VRED] = 0;
|
||||
mV[VGREEN] = 0;
|
||||
mV[VBLUE] = 0;
|
||||
mV[VBLUE] = 0;
|
||||
mV[VALPHA] = 255;
|
||||
return (*this);
|
||||
}
|
||||
|
||||
inline const LLColor4U& LLColor4U::setToWhite(void)
|
||||
{
|
||||
mV[VRED] = 255;
|
||||
mV[VRED] = 255;
|
||||
mV[VGREEN] = 255;
|
||||
mV[VBLUE] = 255;
|
||||
mV[VBLUE] = 255;
|
||||
mV[VALPHA] = 255;
|
||||
return (*this);
|
||||
}
|
||||
|
||||
inline const LLColor4U& LLColor4U::set(const U8 x, const U8 y, const U8 z)
|
||||
{
|
||||
mV[VRED] = x;
|
||||
mV[VRED] = x;
|
||||
mV[VGREEN] = y;
|
||||
mV[VBLUE] = z;
|
||||
mV[VBLUE] = z;
|
||||
|
||||
// no change to alpha!
|
||||
// mV[VALPHA] = 255;
|
||||
// no change to alpha!
|
||||
// mV[VALPHA] = 255;
|
||||
|
||||
return (*this);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
inline const LLColor4U& LLColor4U::set(const LLColor4U &vec)
|
||||
inline const LLColor4U& LLColor4U::set(const LLColor4U& vec)
|
||||
{
|
||||
mV[VRED] = vec.mV[VRED];
|
||||
mV[VRED] = vec.mV[VRED];
|
||||
mV[VGREEN] = vec.mV[VGREEN];
|
||||
mV[VBLUE] = vec.mV[VBLUE];
|
||||
mV[VBLUE] = vec.mV[VBLUE];
|
||||
mV[VALPHA] = vec.mV[VALPHA];
|
||||
return (*this);
|
||||
}
|
||||
|
||||
inline const LLColor4U& LLColor4U::set(const U8 *vec)
|
||||
inline const LLColor4U& LLColor4U::set(const U8* vec)
|
||||
{
|
||||
mV[VRED] = vec[VRED];
|
||||
mV[VRED] = vec[VRED];
|
||||
mV[VGREEN] = vec[VGREEN];
|
||||
mV[VBLUE] = vec[VBLUE];
|
||||
mV[VBLUE] = vec[VBLUE];
|
||||
mV[VALPHA] = vec[VALPHA];
|
||||
return (*this);
|
||||
}
|
||||
|
|
@ -239,12 +219,12 @@ inline const LLColor4U& LLColor4U::set(const U8 *vec)
|
|||
// deprecated
|
||||
inline const LLColor4U& LLColor4U::setVec(const U8 x, const U8 y, const U8 z)
|
||||
{
|
||||
mV[VRED] = x;
|
||||
mV[VRED] = x;
|
||||
mV[VGREEN] = y;
|
||||
mV[VBLUE] = z;
|
||||
mV[VBLUE] = z;
|
||||
|
||||
// no change to alpha!
|
||||
// mV[VALPHA] = 255;
|
||||
// no change to alpha!
|
||||
// mV[VALPHA] = 255;
|
||||
|
||||
return (*this);
|
||||
}
|
||||
|
|
@ -252,29 +232,29 @@ 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);
|
||||
}
|
||||
|
||||
// deprecated
|
||||
inline const LLColor4U& LLColor4U::setVec(const LLColor4U &vec)
|
||||
inline const LLColor4U& LLColor4U::setVec(const LLColor4U& vec)
|
||||
{
|
||||
mV[VRED] = vec.mV[VRED];
|
||||
mV[VRED] = vec.mV[VRED];
|
||||
mV[VGREEN] = vec.mV[VGREEN];
|
||||
mV[VBLUE] = vec.mV[VBLUE];
|
||||
mV[VBLUE] = vec.mV[VBLUE];
|
||||
mV[VALPHA] = vec.mV[VALPHA];
|
||||
return (*this);
|
||||
}
|
||||
|
||||
// deprecated
|
||||
inline const LLColor4U& LLColor4U::setVec(const U8 *vec)
|
||||
inline const LLColor4U& LLColor4U::setVec(const U8* vec)
|
||||
{
|
||||
mV[VRED] = vec[VRED];
|
||||
mV[VRED] = vec[VRED];
|
||||
mV[VGREEN] = vec[VGREEN];
|
||||
mV[VBLUE] = vec[VBLUE];
|
||||
mV[VBLUE] = vec[VBLUE];
|
||||
mV[VALPHA] = vec[VALPHA];
|
||||
return (*this);
|
||||
}
|
||||
|
|
@ -287,131 +267,68 @@ 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)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
inline LLColor4U LLColor4U::addClampMax(const LLColor4U& color)
|
||||
{
|
||||
return LLColor4U(llmin((S32)mV[VRED] + color.mV[VRED], 255),
|
||||
llmin((S32)mV[VGREEN] + color.mV[VGREEN], 255),
|
||||
llmin((S32)mV[VBLUE] + color.mV[VBLUE], 255),
|
||||
llmin((S32)mV[VALPHA] + color.mV[VALPHA], 255));
|
||||
llmin((S32)mV[VGREEN] + color.mV[VGREEN], 255),
|
||||
llmin((S32)mV[VBLUE] + color.mV[VBLUE], 255),
|
||||
llmin((S32)mV[VALPHA] + color.mV[VALPHA], 255));
|
||||
}
|
||||
|
||||
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));
|
||||
}
|
||||
/*
|
||||
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]);
|
||||
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*(U8 k, const LLColor4U &a)
|
||||
inline bool operator==(const LLColor4U& a, const LLColor4U& b)
|
||||
{
|
||||
// only affects rgb (not a!)
|
||||
return LLColor4U(
|
||||
a.mV[VRED] * k,
|
||||
a.mV[VGREEN] * k,
|
||||
a.mV[VBLUE] * k,
|
||||
a.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 LLColor4U operator%(U8 k, const LLColor4U &a)
|
||||
inline bool operator!=(const LLColor4U& a, const LLColor4U& b)
|
||||
{
|
||||
// only affects alpha (not rgb!)
|
||||
return LLColor4U(
|
||||
a.mV[VRED],
|
||||
a.mV[VGREEN],
|
||||
a.mV[VBLUE],
|
||||
a.mV[VALPHA] * k );
|
||||
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 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]));
|
||||
}
|
||||
|
||||
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]));
|
||||
}
|
||||
|
||||
inline const LLColor4U& operator+=(LLColor4U &a, const LLColor4U &b)
|
||||
inline const LLColor4U& operator+=(LLColor4U& a, const LLColor4U& b)
|
||||
{
|
||||
a.mV[VRED] += b.mV[VRED];
|
||||
a.mV[VGREEN] += b.mV[VGREEN];
|
||||
|
|
@ -420,7 +337,7 @@ inline const LLColor4U& operator+=(LLColor4U &a, const LLColor4U &b)
|
|||
return a;
|
||||
}
|
||||
|
||||
inline const LLColor4U& operator-=(LLColor4U &a, const LLColor4U &b)
|
||||
inline const LLColor4U& operator-=(LLColor4U& a, const LLColor4U& b)
|
||||
{
|
||||
a.mV[VRED] -= b.mV[VRED];
|
||||
a.mV[VGREEN] -= b.mV[VGREEN];
|
||||
|
|
@ -429,7 +346,7 @@ inline const LLColor4U& operator-=(LLColor4U &a, const LLColor4U &b)
|
|||
return a;
|
||||
}
|
||||
|
||||
inline const LLColor4U& operator*=(LLColor4U &a, U8 k)
|
||||
inline const LLColor4U& operator*=(LLColor4U& a, U8 k)
|
||||
{
|
||||
// only affects rgb (not a!)
|
||||
a.mV[VRED] *= k;
|
||||
|
|
@ -438,20 +355,20 @@ inline const LLColor4U& operator*=(LLColor4U &a, U8 k)
|
|||
return a;
|
||||
}
|
||||
|
||||
inline const LLColor4U& operator%=(LLColor4U &a, U8 k)
|
||||
inline const LLColor4U& operator%=(LLColor4U& a, U8 k)
|
||||
{
|
||||
// only affects alpha (not rgb!)
|
||||
a.mV[VALPHA] *= k;
|
||||
return a;
|
||||
}
|
||||
|
||||
inline F32 distVec(const LLColor4U &a, const LLColor4U &b)
|
||||
inline F32 distVec(const LLColor4U& a, const LLColor4U& b)
|
||||
{
|
||||
LLColor4U vec = a - b;
|
||||
return (vec.length());
|
||||
}
|
||||
|
||||
inline F32 distVec_squared(const LLColor4U &a, const LLColor4U &b)
|
||||
inline F32 distVec_squared(const LLColor4U& a, const LLColor4U& b)
|
||||
{
|
||||
LLColor4U vec = a - b;
|
||||
return (vec.lengthSquared());
|
||||
|
|
@ -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 )
|
||||
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
|
||||
|
||||
|
|
|
|||
|
|
@ -26,7 +26,6 @@
|
|||
|
||||
#include "linden_common.h"
|
||||
|
||||
//#include "vmath.h"
|
||||
#include "v3math.h"
|
||||
#include "v4math.h"
|
||||
#include "m4math.h"
|
||||
|
|
@ -36,13 +35,13 @@
|
|||
// LLVector4
|
||||
|
||||
// Axis-Angle rotations
|
||||
const LLVector4& LLVector4::rotVec(const LLMatrix4 &mat)
|
||||
const LLVector4& LLVector4::rotVec(const LLMatrix4& mat)
|
||||
{
|
||||
*this = *this * mat;
|
||||
return *this;
|
||||
}
|
||||
|
||||
const LLVector4& LLVector4::rotVec(const LLQuaternion &q)
|
||||
const LLVector4& LLVector4::rotVec(const LLQuaternion& q)
|
||||
{
|
||||
*this = *this * q;
|
||||
return *this;
|
||||
|
|
@ -64,16 +63,16 @@ 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;
|
||||
}
|
||||
|
||||
|
||||
std::ostream& operator<<(std::ostream& s, const LLVector4 &a)
|
||||
std::ostream& operator<<(std::ostream& s, const LLVector4& a)
|
||||
{
|
||||
s << "{ " << a.mV[VX] << ", " << a.mV[VY] << ", " << a.mV[VZ] << ", " << a.mV[VW] << " }";
|
||||
return s;
|
||||
|
|
@ -108,12 +107,12 @@ bool are_parallel(const LLVector4 &a, const LLVector4 &b, F32 epsilon)
|
|||
}
|
||||
|
||||
|
||||
LLVector3 vec4to3(const LLVector4 &vec)
|
||||
LLVector3 vec4to3(const LLVector4& vec)
|
||||
{
|
||||
return LLVector3( vec.mV[VX], vec.mV[VY], vec.mV[VZ] );
|
||||
}
|
||||
|
||||
LLVector4 vec3to4(const LLVector3 &vec)
|
||||
LLVector4 vec3to4(const LLVector3& vec)
|
||||
{
|
||||
return LLVector4(vec.mV[VX], vec.mV[VY], vec.mV[VZ]);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -42,110 +42,110 @@ class LLQuaternion;
|
|||
|
||||
// LLVector4 = |x y z w|
|
||||
|
||||
static const U32 LENGTHOFVECTOR4 = 4;
|
||||
static constexpr U32 LENGTHOFVECTOR4 = 4;
|
||||
|
||||
class LLVector4
|
||||
{
|
||||
public:
|
||||
F32 mV[LENGTHOFVECTOR4];
|
||||
LLVector4(); // Initializes LLVector4 to (0, 0, 0, 1)
|
||||
explicit LLVector4(const F32 *vec); // Initializes LLVector4 to (vec[0]. vec[1], vec[2], vec[3])
|
||||
explicit LLVector4(const F64 *vec); // Initialized LLVector4 to ((F32) vec[0], (F32) vec[1], (F32) vec[3], (F32) vec[4]);
|
||||
explicit LLVector4(const LLVector2 &vec);
|
||||
explicit LLVector4(const LLVector2 &vec, F32 z, F32 w);
|
||||
explicit LLVector4(const LLVector3 &vec); // Initializes LLVector4 to (vec, 1)
|
||||
explicit LLVector4(const LLVector3 &vec, F32 w); // Initializes LLVector4 to (vec, w)
|
||||
explicit LLVector4(const LLSD &sd);
|
||||
LLVector4(F32 x, F32 y, F32 z); // Initializes LLVector4 to (x. y, z, 1)
|
||||
LLVector4(F32 x, F32 y, F32 z, F32 w);
|
||||
public:
|
||||
F32 mV[LENGTHOFVECTOR4];
|
||||
LLVector4(); // Initializes LLVector4 to (0, 0, 0, 1)
|
||||
explicit LLVector4(const F32 *vec); // Initializes LLVector4 to (vec[0]. vec[1], vec[2], vec[3])
|
||||
explicit LLVector4(const F64 *vec); // Initialized LLVector4 to ((F32) vec[0], (F32) vec[1], (F32) vec[3], (F32) vec[4]);
|
||||
explicit LLVector4(const LLVector2 &vec);
|
||||
explicit LLVector4(const LLVector2 &vec, F32 z, F32 w);
|
||||
explicit LLVector4(const LLVector3 &vec); // Initializes LLVector4 to (vec, 1)
|
||||
explicit LLVector4(const LLVector3 &vec, F32 w); // Initializes LLVector4 to (vec, w)
|
||||
explicit LLVector4(const LLSD &sd);
|
||||
LLVector4(F32 x, F32 y, F32 z); // Initializes LLVector4 to (x. y, z, 1)
|
||||
LLVector4(F32 x, F32 y, F32 z, F32 w);
|
||||
|
||||
LLSD getValue() const
|
||||
{
|
||||
LLSD ret;
|
||||
ret[0] = mV[0];
|
||||
ret[1] = mV[1];
|
||||
ret[2] = mV[2];
|
||||
ret[3] = mV[3];
|
||||
return ret;
|
||||
}
|
||||
LLSD getValue() const
|
||||
{
|
||||
LLSD ret;
|
||||
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();
|
||||
}
|
||||
void setValue(const LLSD& sd)
|
||||
{
|
||||
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
|
||||
explicit LLVector4(const glm::vec3& vec); // Initializes LLVector4 to (vec, 1)
|
||||
explicit LLVector4(const glm::vec4& vec); // Initializes LLVector4 to vec
|
||||
explicit operator glm::vec3() const; // Initializes glm::vec3 to (vec[0]. vec[1], vec[2])
|
||||
explicit operator glm::vec4() const; // Initializes glm::vec4 to (vec[0]. vec[1], vec[2], vec[3])
|
||||
// GLM interop
|
||||
explicit LLVector4(const glm::vec3& vec); // Initializes LLVector4 to (vec, 1)
|
||||
explicit LLVector4(const glm::vec4& vec); // Initializes LLVector4 to vec
|
||||
explicit operator glm::vec3() const; // Initializes glm::vec3 to (vec[0]. vec[1], vec[2])
|
||||
explicit operator glm::vec4() const; // Initializes glm::vec4 to (vec[0]. vec[1], vec[2], vec[3])
|
||||
|
||||
inline bool isFinite() const; // checks to see if all values of LLVector3 are finite
|
||||
inline bool isFinite() const; // checks to see if all values of LLVector3 are finite
|
||||
|
||||
inline void clear(); // Clears LLVector4 to (0, 0, 0, 1)
|
||||
inline void clearVec(); // deprecated
|
||||
inline void zeroVec(); // deprecated
|
||||
inline void clear(); // Clears LLVector4 to (0, 0, 0, 1)
|
||||
inline void clearVec(); // deprecated
|
||||
inline void zeroVec(); // deprecated
|
||||
|
||||
inline void set(F32 x, F32 y, F32 z); // Sets LLVector4 to (x, y, z, 1)
|
||||
inline void set(F32 x, F32 y, F32 z, F32 w); // Sets LLVector4 to (x, y, z, w)
|
||||
inline void set(const LLVector4 &vec); // Sets LLVector4 to vec
|
||||
inline void set(const LLVector3 &vec, F32 w = 1.f); // Sets LLVector4 to LLVector3 vec
|
||||
inline void set(const F32 *vec); // Sets LLVector4 to vec
|
||||
inline void set(const glm::vec4& vec); // Sets LLVector4 to vec
|
||||
inline void set(const glm::vec3& vec, F32 w = 1.f); // Sets LLVector4 to LLVector3 vec with w defaulted to 1
|
||||
inline void set(F32 x, F32 y, F32 z); // Sets LLVector4 to (x, y, z, 1)
|
||||
inline void set(F32 x, F32 y, F32 z, F32 w); // Sets LLVector4 to (x, y, z, w)
|
||||
inline void set(const LLVector4 &vec); // Sets LLVector4 to vec
|
||||
inline void set(const LLVector3 &vec, F32 w = 1.f); // Sets LLVector4 to LLVector3 vec
|
||||
inline void set(const F32 *vec); // Sets LLVector4 to vec
|
||||
inline void set(const glm::vec4& vec); // Sets LLVector4 to vec
|
||||
inline void set(const glm::vec3& vec, F32 w = 1.f); // Sets LLVector4 to LLVector3 vec with w defaulted to 1
|
||||
|
||||
inline void setVec(F32 x, F32 y, F32 z); // deprecated
|
||||
inline void setVec(F32 x, F32 y, F32 z, F32 w); // deprecated
|
||||
inline void setVec(const LLVector4 &vec); // deprecated
|
||||
inline void setVec(const LLVector3 &vec, F32 w = 1.f); // deprecated
|
||||
inline void setVec(const F32 *vec); // deprecated
|
||||
inline void setVec(F32 x, F32 y, F32 z); // deprecated
|
||||
inline void setVec(F32 x, F32 y, F32 z, F32 w); // deprecated
|
||||
inline void setVec(const LLVector4 &vec); // deprecated
|
||||
inline void setVec(const LLVector3 &vec, F32 w = 1.f); // deprecated
|
||||
inline void setVec(const F32 *vec); // deprecated
|
||||
|
||||
F32 length() const; // Returns magnitude of LLVector4
|
||||
F32 lengthSquared() const; // Returns magnitude squared of LLVector4
|
||||
F32 normalize(); // Normalizes and returns the magnitude of LLVector4
|
||||
F32 length() const; // Returns magnitude of LLVector4
|
||||
F32 lengthSquared() const; // Returns magnitude squared of LLVector4
|
||||
F32 normalize(); // Normalizes and returns the magnitude of LLVector4
|
||||
|
||||
F32 magVec() const; // deprecated
|
||||
F32 magVecSquared() const; // deprecated
|
||||
F32 normVec(); // deprecated
|
||||
F32 magVec() const; // deprecated
|
||||
F32 magVecSquared() const; // deprecated
|
||||
F32 normVec(); // deprecated
|
||||
|
||||
// Sets all values to absolute value of their original values
|
||||
// Returns true if data changed
|
||||
bool abs();
|
||||
// Sets all values to absolute value of their original values
|
||||
// Returns true if data changed
|
||||
bool abs();
|
||||
|
||||
bool isExactlyClear() const { return (mV[VW] == 1.0f) && !mV[VX] && !mV[VY] && !mV[VZ]; }
|
||||
bool isExactlyZero() const { return !mV[VW] && !mV[VX] && !mV[VY] && !mV[VZ]; }
|
||||
bool isExactlyClear() const { return (mV[VW] == 1.0f) && !mV[VX] && !mV[VY] && !mV[VZ]; }
|
||||
bool isExactlyZero() const { return !mV[VW] && !mV[VX] && !mV[VY] && !mV[VZ]; }
|
||||
|
||||
const LLVector4& rotVec(F32 angle, const LLVector4 &vec); // Rotates about vec by angle radians
|
||||
const LLVector4& rotVec(F32 angle, F32 x, F32 y, F32 z); // Rotates about x,y,z by angle radians
|
||||
const LLVector4& rotVec(const LLMatrix4 &mat); // Rotates by MAT4 mat
|
||||
const LLVector4& rotVec(const LLQuaternion &q); // Rotates by QUAT q
|
||||
const LLVector4& rotVec(F32 angle, const LLVector4 &vec); // Rotates about vec by angle radians
|
||||
const LLVector4& rotVec(F32 angle, F32 x, F32 y, F32 z); // Rotates about x,y,z by angle radians
|
||||
const LLVector4& rotVec(const LLMatrix4 &mat); // Rotates by MAT4 mat
|
||||
const LLVector4& rotVec(const LLQuaternion &q); // Rotates by QUAT q
|
||||
|
||||
const LLVector4& scaleVec(const LLVector4& vec); // Scales component-wise by vec
|
||||
const LLVector4& scaleVec(const LLVector4& vec); // Scales component-wise by vec
|
||||
|
||||
F32 operator[](int idx) const { return mV[idx]; }
|
||||
F32 &operator[](int idx) { return mV[idx]; }
|
||||
F32 operator[](int idx) const { return mV[idx]; }
|
||||
F32 &operator[](int idx) { return mV[idx]; }
|
||||
|
||||
friend std::ostream& operator<<(std::ostream& s, const LLVector4 &a); // Print a
|
||||
friend LLVector4 operator+(const LLVector4 &a, const LLVector4 &b); // Return vector a + b
|
||||
friend LLVector4 operator-(const LLVector4 &a, const LLVector4 &b); // Return vector a minus b
|
||||
friend F32 operator*(const LLVector4 &a, const LLVector4 &b); // Return a dot b
|
||||
friend LLVector4 operator%(const LLVector4 &a, const LLVector4 &b); // Return a cross b
|
||||
friend LLVector4 operator/(const LLVector4 &a, F32 k); // Return a divided by scaler k
|
||||
friend LLVector4 operator*(const LLVector4 &a, F32 k); // Return a times scaler k
|
||||
friend LLVector4 operator*(F32 k, const LLVector4 &a); // Return a times scaler k
|
||||
friend bool operator==(const LLVector4 &a, const LLVector4 &b); // Return a == b
|
||||
friend bool operator!=(const LLVector4 &a, const LLVector4 &b); // Return a != b
|
||||
friend std::ostream& operator<<(std::ostream& s, const LLVector4 &a); // Print a
|
||||
friend LLVector4 operator+(const LLVector4 &a, const LLVector4 &b); // Return vector a + b
|
||||
friend LLVector4 operator-(const LLVector4 &a, const LLVector4 &b); // Return vector a minus b
|
||||
friend F32 operator*(const LLVector4 &a, const LLVector4 &b); // Return a dot b
|
||||
friend LLVector4 operator%(const LLVector4 &a, const LLVector4 &b); // Return a cross b
|
||||
friend LLVector4 operator/(const LLVector4 &a, F32 k); // Return a divided by scaler k
|
||||
friend LLVector4 operator*(const LLVector4 &a, F32 k); // Return a times scaler k
|
||||
friend LLVector4 operator*(F32 k, const LLVector4 &a); // Return a times scaler k
|
||||
friend bool operator==(const LLVector4 &a, const LLVector4 &b); // Return a == b
|
||||
friend bool operator!=(const LLVector4 &a, const LLVector4 &b); // Return a != b
|
||||
|
||||
friend const LLVector4& operator+=(LLVector4 &a, const LLVector4 &b); // Return vector a + b
|
||||
friend const LLVector4& operator-=(LLVector4 &a, const LLVector4 &b); // Return vector a minus b
|
||||
friend const LLVector4& operator%=(LLVector4 &a, const LLVector4 &b); // Return a cross b
|
||||
friend const LLVector4& operator*=(LLVector4 &a, F32 k); // Return a times scaler k
|
||||
friend const LLVector4& operator/=(LLVector4 &a, F32 k); // Return a divided by scaler k
|
||||
friend const LLVector4& operator+=(LLVector4 &a, const LLVector4 &b); // Return vector a + b
|
||||
friend const LLVector4& operator-=(LLVector4 &a, const LLVector4 &b); // Return vector a minus b
|
||||
friend const LLVector4& operator%=(LLVector4 &a, const LLVector4 &b); // Return a cross b
|
||||
friend const LLVector4& operator*=(LLVector4 &a, F32 k); // Return a times scaler k
|
||||
friend const LLVector4& operator/=(LLVector4 &a, F32 k); // Return a divided by scaler k
|
||||
|
||||
friend LLVector4 operator-(const LLVector4 &a); // Return vector -a
|
||||
friend LLVector4 operator-(const LLVector4 &a); // Return vector -a
|
||||
};
|
||||
|
||||
// Non-member functions
|
||||
|
|
@ -241,19 +241,19 @@ inline bool LLVector4::isFinite() const
|
|||
|
||||
// Clear and Assignment Functions
|
||||
|
||||
inline void LLVector4::clear(void)
|
||||
inline void LLVector4::clear()
|
||||
{
|
||||
set(0.f, 0.f, 0.f, 1.f);
|
||||
}
|
||||
|
||||
// deprecated
|
||||
inline void LLVector4::clearVec(void)
|
||||
inline void LLVector4::clearVec()
|
||||
{
|
||||
clear();
|
||||
}
|
||||
|
||||
// deprecated
|
||||
inline void LLVector4::zeroVec(void)
|
||||
inline void LLVector4::zeroVec()
|
||||
{
|
||||
set(0.f, 0.f, 0.f, 0.f);
|
||||
}
|
||||
|
|
@ -271,12 +271,12 @@ inline void LLVector4::set(F32 x, F32 y, F32 z, F32 w)
|
|||
mV[VW] = w;
|
||||
}
|
||||
|
||||
inline void LLVector4::set(const LLVector4 &vec)
|
||||
inline void LLVector4::set(const LLVector4& vec)
|
||||
{
|
||||
set(vec.mV);
|
||||
}
|
||||
|
||||
inline void LLVector4::set(const LLVector3 &vec, F32 w)
|
||||
inline void LLVector4::set(const LLVector3& vec, F32 w)
|
||||
{
|
||||
mV[VX] = vec.mV[VX];
|
||||
mV[VY] = vec.mV[VY];
|
||||
|
|
@ -284,7 +284,7 @@ inline void LLVector4::set(const LLVector3 &vec, F32 w)
|
|||
mV[VW] = w;
|
||||
}
|
||||
|
||||
inline void LLVector4::set(const F32 *vec)
|
||||
inline void LLVector4::set(const F32* vec)
|
||||
{
|
||||
mV[VX] = vec[VX];
|
||||
mV[VY] = vec[VY];
|
||||
|
|
@ -320,94 +320,94 @@ inline void LLVector4::setVec(F32 x, F32 y, F32 z, F32 w)
|
|||
}
|
||||
|
||||
// deprecated
|
||||
inline void LLVector4::setVec(const LLVector4 &vec)
|
||||
inline void LLVector4::setVec(const LLVector4& vec)
|
||||
{
|
||||
set(vec);
|
||||
}
|
||||
|
||||
// deprecated
|
||||
inline void LLVector4::setVec(const LLVector3 &vec, F32 w)
|
||||
inline void LLVector4::setVec(const LLVector3& vec, F32 w)
|
||||
{
|
||||
set(vec, w);
|
||||
}
|
||||
|
||||
// deprecated
|
||||
inline void LLVector4::setVec(const F32 *vec)
|
||||
inline void LLVector4::setVec(const F32* vec)
|
||||
{
|
||||
set(vec);
|
||||
}
|
||||
|
||||
// LLVector4 Magnitude and Normalization Functions
|
||||
|
||||
inline F32 LLVector4::length(void) const
|
||||
inline F32 LLVector4::length() const
|
||||
{
|
||||
return sqrt(lengthSquared());
|
||||
}
|
||||
|
||||
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 length();
|
||||
}
|
||||
|
||||
inline F32 LLVector4::magVecSquared(void) const
|
||||
inline F32 LLVector4::magVecSquared() const
|
||||
{
|
||||
return lengthSquared();
|
||||
}
|
||||
|
||||
// LLVector4 Operators
|
||||
|
||||
inline LLVector4 operator+(const LLVector4 &a, const LLVector4 &b)
|
||||
inline LLVector4 operator+(const LLVector4& a, const LLVector4& b)
|
||||
{
|
||||
LLVector4 c(a);
|
||||
return c += b;
|
||||
}
|
||||
|
||||
inline LLVector4 operator-(const LLVector4 &a, const LLVector4 &b)
|
||||
inline LLVector4 operator-(const LLVector4& a, const LLVector4& b)
|
||||
{
|
||||
LLVector4 c(a);
|
||||
return c -= b;
|
||||
}
|
||||
|
||||
inline F32 operator*(const LLVector4 &a, const LLVector4 &b)
|
||||
inline F32 operator*(const LLVector4& a, const LLVector4& b)
|
||||
{
|
||||
return a.mV[VX]*b.mV[VX] + a.mV[VY]*b.mV[VY] + a.mV[VZ]*b.mV[VZ];
|
||||
}
|
||||
|
||||
inline LLVector4 operator%(const LLVector4 &a, const LLVector4 &b)
|
||||
inline LLVector4 operator%(const LLVector4& a, const LLVector4& b)
|
||||
{
|
||||
return LLVector4(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 LLVector4 operator/(const LLVector4 &a, F32 k)
|
||||
inline LLVector4 operator/(const LLVector4& a, F32 k)
|
||||
{
|
||||
F32 t = 1.f / k;
|
||||
return LLVector4( a.mV[VX] * t, a.mV[VY] * t, a.mV[VZ] * t );
|
||||
}
|
||||
|
||||
|
||||
inline LLVector4 operator*(const LLVector4 &a, F32 k)
|
||||
inline LLVector4 operator*(const LLVector4& a, F32 k)
|
||||
{
|
||||
return LLVector4( a.mV[VX] * k, a.mV[VY] * k, a.mV[VZ] * k );
|
||||
}
|
||||
|
||||
inline LLVector4 operator*(F32 k, const LLVector4 &a)
|
||||
inline LLVector4 operator*(F32 k, const LLVector4& a)
|
||||
{
|
||||
return LLVector4( a.mV[VX] * k, a.mV[VY] * k, a.mV[VZ] * k );
|
||||
}
|
||||
|
||||
inline bool operator==(const LLVector4 &a, const LLVector4 &b)
|
||||
inline bool operator==(const LLVector4& a, const LLVector4& b)
|
||||
{
|
||||
return ( (a.mV[VX] == b.mV[VX])
|
||||
&&(a.mV[VY] == b.mV[VY])
|
||||
&&(a.mV[VZ] == b.mV[VZ]));
|
||||
}
|
||||
|
||||
inline bool operator!=(const LLVector4 &a, const LLVector4 &b)
|
||||
inline bool operator!=(const LLVector4& a, const LLVector4& b)
|
||||
{
|
||||
return ( (a.mV[VX] != b.mV[VX])
|
||||
||(a.mV[VY] != b.mV[VY])
|
||||
|
|
@ -415,7 +415,7 @@ inline bool operator!=(const LLVector4 &a, const LLVector4 &b)
|
|||
||(a.mV[VW] != b.mV[VW]) );
|
||||
}
|
||||
|
||||
inline const LLVector4& operator+=(LLVector4 &a, const LLVector4 &b)
|
||||
inline const LLVector4& operator+=(LLVector4& a, const LLVector4& b)
|
||||
{
|
||||
a.mV[VX] += b.mV[VX];
|
||||
a.mV[VY] += b.mV[VY];
|
||||
|
|
@ -423,7 +423,7 @@ inline const LLVector4& operator+=(LLVector4 &a, const LLVector4 &b)
|
|||
return a;
|
||||
}
|
||||
|
||||
inline const LLVector4& operator-=(LLVector4 &a, const LLVector4 &b)
|
||||
inline const LLVector4& operator-=(LLVector4& a, const LLVector4& b)
|
||||
{
|
||||
a.mV[VX] -= b.mV[VX];
|
||||
a.mV[VY] -= b.mV[VY];
|
||||
|
|
@ -431,14 +431,14 @@ inline const LLVector4& operator-=(LLVector4 &a, const LLVector4 &b)
|
|||
return a;
|
||||
}
|
||||
|
||||
inline const LLVector4& operator%=(LLVector4 &a, const LLVector4 &b)
|
||||
inline const LLVector4& operator%=(LLVector4& a, const LLVector4& b)
|
||||
{
|
||||
LLVector4 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 LLVector4& operator*=(LLVector4 &a, F32 k)
|
||||
inline const LLVector4& operator*=(LLVector4& a, F32 k)
|
||||
{
|
||||
a.mV[VX] *= k;
|
||||
a.mV[VY] *= k;
|
||||
|
|
@ -446,12 +446,12 @@ inline const LLVector4& operator*=(LLVector4 &a, F32 k)
|
|||
return a;
|
||||
}
|
||||
|
||||
inline const LLVector4& operator/=(LLVector4 &a, F32 k)
|
||||
inline const LLVector4& operator/=(LLVector4& a, F32 k)
|
||||
{
|
||||
return a *= 1.f / k;
|
||||
}
|
||||
|
||||
inline LLVector4 operator-(const LLVector4 &a)
|
||||
inline LLVector4 operator-(const LLVector4& a)
|
||||
{
|
||||
return LLVector4( -a.mV[VX], -a.mV[VY], -a.mV[VZ] );
|
||||
}
|
||||
|
|
@ -459,7 +459,7 @@ inline LLVector4 operator-(const LLVector4 &a)
|
|||
// [RLVa:KB] - RlvBehaviourModifierCompMin/Max
|
||||
inline bool operator<(const LLVector4& lhs, const LLVector4& rhs)
|
||||
{
|
||||
return std::tie(lhs.mV[0], lhs.mV[1], lhs.mV[2], lhs.mV[3]) < std::tie(rhs.mV[0], rhs.mV[1], rhs.mV[2], rhs.mV[3]);
|
||||
return std::tie(lhs.mV[VX], lhs.mV[VY], lhs.mV[VZ], lhs.mV[VW]) < std::tie(rhs.mV[VX], rhs.mV[VY], rhs.mV[VZ], rhs.mV[VW]);
|
||||
}
|
||||
// [/RLVa:KB]
|
||||
|
||||
|
|
@ -473,19 +473,19 @@ inline LLVector4::operator glm::vec4() const
|
|||
return glm::make_vec4(mV);
|
||||
}
|
||||
|
||||
inline F32 dist_vec(const LLVector4 &a, const LLVector4 &b)
|
||||
inline F32 dist_vec(const LLVector4& a, const LLVector4& b)
|
||||
{
|
||||
LLVector4 vec = a - b;
|
||||
return vec.length();
|
||||
}
|
||||
|
||||
inline F32 dist_vec_squared(const LLVector4 &a, const LLVector4 &b)
|
||||
inline F32 dist_vec_squared(const LLVector4& a, const LLVector4& b)
|
||||
{
|
||||
LLVector4 vec = a - b;
|
||||
return vec.lengthSquared();
|
||||
}
|
||||
|
||||
inline LLVector4 lerp(const LLVector4 &a, const LLVector4 &b, F32 u)
|
||||
inline LLVector4 lerp(const LLVector4& a, const LLVector4& b, F32 u)
|
||||
{
|
||||
return LLVector4(
|
||||
a.mV[VX] + (b.mV[VX] - a.mV[VX]) * u,
|
||||
|
|
@ -494,7 +494,7 @@ 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 = sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
|
||||
|
||||
|
|
@ -504,29 +504,29 @@ 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()
|
||||
{
|
||||
return normalize();
|
||||
}
|
||||
|
||||
// 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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -126,7 +126,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;
|
||||
|
|
|
|||
|
|
@ -1405,6 +1405,7 @@ char const* const _PREHASH_HoverHeight = LLMessageStringTable::getInstance()->ge
|
|||
char const* const _PREHASH_Experience = LLMessageStringTable::getInstance()->getString("Experience");
|
||||
char const* const _PREHASH_ExperienceID = LLMessageStringTable::getInstance()->getString("ExperienceID");
|
||||
char const* const _PREHASH_LargeGenericMessage = LLMessageStringTable::getInstance()->getString("LargeGenericMessage");
|
||||
char const* const _PREHASH_MetaData = LLMessageStringTable::getInstance()->getString("MetaData");
|
||||
|
||||
// <FS:CR> Aurora Sim
|
||||
char const* const _PREHASH_RegionSizeX = LLMessageStringTable::getInstance()->getString("RegionSizeX");
|
||||
|
|
|
|||
|
|
@ -1405,6 +1405,7 @@ extern char const* const _PREHASH_HoverHeight;
|
|||
extern char const* const _PREHASH_Experience;
|
||||
extern char const* const _PREHASH_ExperienceID;
|
||||
extern char const* const _PREHASH_LargeGenericMessage;
|
||||
extern char const* const _PREHASH_MetaData;
|
||||
|
||||
// <FS:CR> Aurora Sim
|
||||
extern char const* const _PREHASH_RegionSizeX;
|
||||
|
|
|
|||
|
|
@ -57,16 +57,16 @@ const U32 FLAGS_CAMERA_SOURCE = (1U << 22);
|
|||
|
||||
//const U32 FLAGS_UNUSED_001 = (1U << 23); // was FLAGS_CAST_SHADOWS
|
||||
|
||||
//const U32 FLAGS_UNUSED_002 = (1U << 24);
|
||||
//const U32 FLAGS_UNUSED_003 = (1U << 25);
|
||||
//const U32 FLAGS_UNUSED_004 = (1U << 26);
|
||||
//const U32 FLAGS_UNUSED_005 = (1U << 27);
|
||||
const U32 FLAGS_SERVER_AUTOPILOT = (1U << 24); // Update was for an agent AND that agent is being autopiloted from the server
|
||||
//const U32 FLAGS_UNUSED_002 = (1U << 25);
|
||||
//const U32 FLAGS_UNUSED_003 = (1U << 26);
|
||||
//const U32 FLAGS_UNUSED_004 = (1U << 27);
|
||||
|
||||
const U32 FLAGS_OBJECT_OWNER_MODIFY = (1U << 28);
|
||||
|
||||
const U32 FLAGS_TEMPORARY_ON_REZ = (1U << 29);
|
||||
//const U32 FLAGS_UNUSED_006 = (1U << 30); // was FLAGS_TEMPORARY
|
||||
//const U32 FLAGS_UNUSED_007 = (1U << 31); // was FLAGS_ZLIB_COMPRESSED
|
||||
//const U32 FLAGS_UNUSED_005 = (1U << 30); // was FLAGS_TEMPORARY
|
||||
//const U32 FLAGS_UNUSED_006 = (1U << 31); // was FLAGS_ZLIB_COMPRESSED
|
||||
|
||||
const U32 FLAGS_LOCAL = FLAGS_ANIM_SOURCE | FLAGS_CAMERA_SOURCE;
|
||||
const U32 FLAGS_WORLD = FLAGS_USE_PHYSICS | FLAGS_PHANTOM | FLAGS_TEMPORARY_ON_REZ;
|
||||
|
|
|
|||
|
|
@ -641,6 +641,11 @@ bool LLImageGL::setSize(S32 width, S32 height, S32 ncomponents, S32 discard_leve
|
|||
if(discard_level > 0)
|
||||
{
|
||||
mMaxDiscardLevel = llmax(mMaxDiscardLevel, (S8)discard_level);
|
||||
// <FS:minerjr> [FIRE-35361] RenderMaxTextureResolution caps texture resolution lower than intended
|
||||
// 2K textures could set the mMaxDiscardLevel above MAX_DISCARD_LEVEL, which would
|
||||
// cause them to not be down-scaled so they would get stuck at 0 discard all the time.
|
||||
mMaxDiscardLevel = llmax(mMaxDiscardLevel, (S8)MAX_DISCARD_LEVEL);
|
||||
// </FS:minerjr> [FIRE-35361]
|
||||
}
|
||||
}
|
||||
else
|
||||
|
|
|
|||
|
|
@ -126,7 +126,7 @@ public:
|
|||
|
||||
void setSelected(bool is_selected);
|
||||
|
||||
bool getCollapsible() { return mCollapsible; };
|
||||
bool getCollapsible() const { return mCollapsible; };
|
||||
|
||||
void setCollapsible(bool collapsible) { mCollapsible = collapsible; };
|
||||
void changeOpenClose(bool is_open);
|
||||
|
|
@ -181,7 +181,7 @@ public:
|
|||
|
||||
void setHeaderVisible(bool value);
|
||||
|
||||
bool getHeaderVisible() { return mHeaderVisible;}
|
||||
bool getHeaderVisible() const { return mHeaderVisible;}
|
||||
|
||||
S32 mExpandedHeight; // Height of expanded ctrl.
|
||||
// Used to restore height after expand.
|
||||
|
|
|
|||
|
|
@ -46,7 +46,6 @@ LLChatEntry::LLChatEntry(const Params& p)
|
|||
mPrevLinesCount(0),
|
||||
mSingleLineMode(false),
|
||||
mPrevExpandedLineCount(S32_MAX),
|
||||
// <FS:Ansariel> FIRE-12537: CTRL-UP discards current input
|
||||
mCurrentInput("")
|
||||
{
|
||||
// Initialize current history line iterator
|
||||
|
|
@ -195,9 +194,7 @@ bool LLChatEntry::handleSpecialKey(const KEY key, const MASK mask)
|
|||
{
|
||||
needsReflow();
|
||||
}
|
||||
// <FS:Ansariel> FIRE-12537: CTRL-UP discards current input
|
||||
mCurrentInput = "";
|
||||
|
||||
break;
|
||||
|
||||
case KEY_UP:
|
||||
|
|
@ -205,12 +202,10 @@ bool LLChatEntry::handleSpecialKey(const KEY key, const MASK mask)
|
|||
{
|
||||
if (!mLineHistory.empty() && mCurrentHistoryLine > mLineHistory.begin())
|
||||
{
|
||||
// <FS:Ansariel> FIRE-12537: CTRL-UP discards current input
|
||||
if (mCurrentHistoryLine == mLineHistory.end())
|
||||
{
|
||||
mCurrentInput = getText();
|
||||
}
|
||||
// </FS:Ansariel>
|
||||
|
||||
setText(*(--mCurrentHistoryLine));
|
||||
endOfDoc();
|
||||
|
|
@ -226,19 +221,15 @@ bool LLChatEntry::handleSpecialKey(const KEY key, const MASK mask)
|
|||
case KEY_DOWN:
|
||||
if (mHasHistory && MASK_CONTROL == mask)
|
||||
{
|
||||
if (!mLineHistory.empty() && mCurrentHistoryLine < (mLineHistory.end() - 1) )
|
||||
if (!mLineHistory.empty() && mCurrentHistoryLine < (mLineHistory.end() - 1))
|
||||
{
|
||||
setText(*(++mCurrentHistoryLine));
|
||||
endOfDoc();
|
||||
}
|
||||
else if (!mLineHistory.empty() && mCurrentHistoryLine == (mLineHistory.end() - 1) )
|
||||
else if (!mLineHistory.empty() && mCurrentHistoryLine == (mLineHistory.end() - 1))
|
||||
{
|
||||
mCurrentHistoryLine++;
|
||||
// <FS:Ansariel> FIRE-12537: CTRL-UP discards current input
|
||||
//std::string empty("");
|
||||
//setText(empty);
|
||||
setText(mCurrentInput);
|
||||
// </FS:Ansariel>
|
||||
needsReflow();
|
||||
endOfDoc();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -109,7 +109,6 @@ private:
|
|||
S32 mPrevLinesCount;
|
||||
S32 mPrevExpandedLineCount;
|
||||
|
||||
// <FS:Ansariel> FIRE-12537: CTRL-UP discards current input
|
||||
std::string mCurrentInput;
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -36,8 +36,8 @@
|
|||
// Constants
|
||||
//
|
||||
|
||||
const bool RADIO_STYLE = true;
|
||||
const bool CHECK_STYLE = false;
|
||||
constexpr bool RADIO_STYLE = true;
|
||||
constexpr bool CHECK_STYLE = false;
|
||||
|
||||
//
|
||||
// Classes
|
||||
|
|
@ -98,7 +98,7 @@ public:
|
|||
// LLUICtrl interface
|
||||
virtual void setValue(const LLSD& value );
|
||||
virtual LLSD getValue() const;
|
||||
bool get() { return (bool)getValue().asBoolean(); }
|
||||
bool get() const { return (bool)getValue().asBoolean(); }
|
||||
void set(bool value) { setValue(value); }
|
||||
|
||||
virtual void setTentative(bool b);
|
||||
|
|
@ -110,7 +110,7 @@ public:
|
|||
virtual void onCommit();
|
||||
|
||||
// LLCheckBoxCtrl interface
|
||||
virtual bool toggle() { return mButton->toggleState(); } // returns new state
|
||||
virtual bool toggle() { return mButton->toggleState(); } // returns new state
|
||||
|
||||
void setBtnFocus() { mButton->setFocus(true); }
|
||||
|
||||
|
|
|
|||
|
|
@ -73,21 +73,21 @@ protected:
|
|||
public:
|
||||
~LLContainerView();
|
||||
|
||||
/*virtual*/ bool postBuild();
|
||||
/*virtual*/ bool addChild(LLView* view, S32 tab_group = 0);
|
||||
bool postBuild() override;
|
||||
bool addChild(LLView* view, S32 tab_group = 0) override;
|
||||
|
||||
/*virtual*/ bool handleDoubleClick(S32 x, S32 y, MASK mask);
|
||||
/*virtual*/ bool handleMouseDown(S32 x, S32 y, MASK mask);
|
||||
/*virtual*/ bool handleMouseUp(S32 x, S32 y, MASK mask);
|
||||
bool handleDoubleClick(S32 x, S32 y, MASK mask) override;
|
||||
bool handleMouseDown(S32 x, S32 y, MASK mask) override;
|
||||
bool handleMouseUp(S32 x, S32 y, MASK mask) override;
|
||||
|
||||
/*virtual*/ void draw();
|
||||
/*virtual*/ void reshape(S32 width, S32 height, bool called_from_parent = true);
|
||||
/*virtual*/ LLRect getRequiredRect(); // Return the height of this object, given the set options.
|
||||
void draw() override;
|
||||
void reshape(S32 width, S32 height, bool called_from_parent = true) override;
|
||||
LLRect getRequiredRect() override; // Return the height of this object, given the set options.
|
||||
|
||||
void setLabel(const std::string& label);
|
||||
void showLabel(bool show) { mShowLabel = show; }
|
||||
void setDisplayChildren(bool displayChildren);
|
||||
bool getDisplayChildren() { return mDisplayChildren; }
|
||||
bool getDisplayChildren() const { return mDisplayChildren; }
|
||||
void setScrollContainer(LLScrollContainer* scroll) {mScrollContainer = scroll;}
|
||||
|
||||
private:
|
||||
|
|
|
|||
|
|
@ -112,8 +112,8 @@ public:
|
|||
virtual bool overlapsScreenChannel() const { return mOverlapsScreenChannel && getVisible() && isDocked(); }
|
||||
virtual void setOverlapsScreenChannel(bool overlaps) { mOverlapsScreenChannel = overlaps; }
|
||||
|
||||
bool getUniqueDocking() { return mUniqueDocking; }
|
||||
bool getUseTongue() { return mUseTongue; }
|
||||
bool getUniqueDocking() const { return mUniqueDocking; }
|
||||
bool getUseTongue() const { return mUseTongue; }
|
||||
|
||||
void setUseTongue(bool use_tongue) { mUseTongue = use_tongue;}
|
||||
private:
|
||||
|
|
|
|||
|
|
@ -156,7 +156,7 @@ void LLDockControl::repositionDockable()
|
|||
}
|
||||
}
|
||||
|
||||
bool LLDockControl::isDockVisible()
|
||||
bool LLDockControl::isDockVisible() const
|
||||
{
|
||||
bool res = true;
|
||||
|
||||
|
|
|
|||
|
|
@ -61,19 +61,19 @@ public:
|
|||
void off();
|
||||
void forceRecalculatePosition();
|
||||
void setDock(LLView* dockWidget);
|
||||
LLView* getDock()
|
||||
LLView* getDock() const
|
||||
{
|
||||
return mDockWidgetHandle.get();
|
||||
}
|
||||
void repositionDockable();
|
||||
void drawToungue();
|
||||
bool isDockVisible();
|
||||
bool isDockVisible() const;
|
||||
|
||||
// gets a rect that bounds possible positions for a dockable control (EXT-1111)
|
||||
void getAllowedRect(LLRect& rect);
|
||||
|
||||
S32 getTongueWidth() { return mDockTongue->getWidth(); }
|
||||
S32 getTongueHeight() { return mDockTongue->getHeight(); }
|
||||
S32 getTongueWidth() const { return mDockTongue->getWidth(); }
|
||||
S32 getTongueHeight() const { return mDockTongue->getHeight(); }
|
||||
|
||||
private:
|
||||
virtual void moveDockable();
|
||||
|
|
|
|||
|
|
@ -68,7 +68,7 @@ public:
|
|||
void setMaxTitleWidth(S32 max_width) {mMaxTitleWidth = llmin(max_width, mMaxTitleWidth); }
|
||||
S32 getMaxTitleWidth() const { return mMaxTitleWidth; }
|
||||
void setButtonsRect(const LLRect& rect){ mButtonsRect = rect; }
|
||||
LLRect getButtonsRect() { return mButtonsRect; }
|
||||
LLRect getButtonsRect() const { return mButtonsRect; }
|
||||
void setTitleVisible(bool visible);
|
||||
|
||||
virtual void setTitle( const std::string& title ) = 0;
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ protected:
|
|||
LLFilterEditor(const Params&);
|
||||
friend class LLUICtrlFactory;
|
||||
|
||||
/*virtual*/ void handleKeystroke();
|
||||
void handleKeystroke() override;
|
||||
};
|
||||
|
||||
#endif // LL_FILTEREDITOR_H
|
||||
|
|
|
|||
|
|
@ -107,12 +107,12 @@ void LLFlashTimer::stopFlashing()
|
|||
mCurrentTickCount = 0;
|
||||
}
|
||||
|
||||
bool LLFlashTimer::isFlashingInProgress()
|
||||
bool LLFlashTimer::isFlashingInProgress() const
|
||||
{
|
||||
return mIsFlashingInProgress;
|
||||
}
|
||||
|
||||
bool LLFlashTimer::isCurrentlyHighlighted()
|
||||
bool LLFlashTimer::isCurrentlyHighlighted() const
|
||||
{
|
||||
return mIsCurrentlyHighlighted;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -51,8 +51,8 @@ public:
|
|||
void startFlashing();
|
||||
void stopFlashing();
|
||||
|
||||
bool isFlashingInProgress();
|
||||
bool isCurrentlyHighlighted();
|
||||
bool isFlashingInProgress() const;
|
||||
bool isCurrentlyHighlighted() const;
|
||||
/*
|
||||
* Use this instead of deleting this object.
|
||||
* The next call to tick() will return true and that will destroy this object.
|
||||
|
|
|
|||
|
|
@ -1361,7 +1361,7 @@ void LLFlatListViewEx::updateNoItemsMessage(const std::string& filter_string)
|
|||
}
|
||||
}
|
||||
|
||||
bool LLFlatListViewEx::getForceShowingUnmatchedItems()
|
||||
bool LLFlatListViewEx::getForceShowingUnmatchedItems() const
|
||||
{
|
||||
return mForceShowingUnmatchedItems;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -116,7 +116,7 @@ public:
|
|||
};
|
||||
|
||||
// disable traversal when finding widget to hand focus off to
|
||||
/*virtual*/ bool canFocusChildren() const { return false; }
|
||||
/*virtual*/ bool canFocusChildren() const override { return false; }
|
||||
|
||||
/**
|
||||
* Connects callback to signal called when Return key is pressed.
|
||||
|
|
@ -129,15 +129,15 @@ public:
|
|||
boost::signals2::connection setDoubleClickCallback( const mouse_signal_t::slot_type& cb ) { return mItemsPanel->setDoubleClickCallback(cb); }
|
||||
|
||||
/** Overridden LLPanel's reshape, height is ignored, the list sets its height to accommodate all items */
|
||||
virtual void reshape(S32 width, S32 height, bool called_from_parent = true);
|
||||
virtual void reshape(S32 width, S32 height, bool called_from_parent = true) override;
|
||||
|
||||
/** Returns full rect of child panel */
|
||||
const LLRect& getItemsRect() const;
|
||||
|
||||
LLRect getRequiredRect() { return getItemsRect(); }
|
||||
LLRect getRequiredRect() override { return getItemsRect(); }
|
||||
|
||||
/** Returns distance between items */
|
||||
const S32 getItemsPad() { return mItemPad; }
|
||||
const S32 getItemsPad() const { return mItemPad; }
|
||||
|
||||
/**
|
||||
* Adds and item and LLSD value associated with it to the list at specified position
|
||||
|
|
@ -272,13 +272,13 @@ public:
|
|||
void setCommitOnSelectionChange(bool b) { mCommitOnSelectionChange = b; }
|
||||
|
||||
/** Get number of selected items in the list */
|
||||
U32 numSelected() const {return static_cast<U32>(mSelectedItemPairs.size()); }
|
||||
U32 numSelected() const { return static_cast<U32>(mSelectedItemPairs.size()); }
|
||||
|
||||
/** Get number of (visible) items in the list */
|
||||
U32 size(const bool only_visible_items = true) const;
|
||||
|
||||
/** Removes all items from the list */
|
||||
virtual void clear();
|
||||
virtual void clear() override;
|
||||
|
||||
/**
|
||||
* Removes all items that can be detached from the list but doesn't destroy
|
||||
|
|
@ -302,10 +302,10 @@ public:
|
|||
|
||||
void scrollToShowFirstSelectedItem();
|
||||
|
||||
void selectFirstItem ();
|
||||
void selectLastItem ();
|
||||
void selectFirstItem();
|
||||
void selectLastItem();
|
||||
|
||||
virtual S32 notify(const LLSD& info) ;
|
||||
virtual S32 notify(const LLSD& info) override;
|
||||
|
||||
virtual ~LLFlatListView();
|
||||
|
||||
|
|
@ -354,8 +354,8 @@ protected:
|
|||
|
||||
virtual bool selectNextItemPair(bool is_up_direction, bool reset_selection);
|
||||
|
||||
virtual bool canSelectAll() const;
|
||||
virtual void selectAll();
|
||||
virtual bool canSelectAll() const override;
|
||||
virtual void selectAll() override;
|
||||
|
||||
virtual bool isSelected(item_pair_t* item_pair) const;
|
||||
|
||||
|
|
@ -372,15 +372,15 @@ protected:
|
|||
*/
|
||||
void notifyParentItemsRectChanged();
|
||||
|
||||
virtual bool handleKeyHere(KEY key, MASK mask);
|
||||
virtual bool handleKeyHere(KEY key, MASK mask) override;
|
||||
|
||||
virtual bool postBuild();
|
||||
virtual bool postBuild() override;
|
||||
|
||||
virtual void onFocusReceived();
|
||||
virtual void onFocusReceived() override;
|
||||
|
||||
virtual void onFocusLost();
|
||||
virtual void onFocusLost() override;
|
||||
|
||||
virtual void draw();
|
||||
virtual void draw() override;
|
||||
|
||||
LLRect getLastSelectedItemRect();
|
||||
|
||||
|
|
@ -492,7 +492,7 @@ public:
|
|||
void setNoItemsMsg(const std::string& msg) { mNoItemsMsg = msg; }
|
||||
void setNoFilteredItemsMsg(const std::string& msg) { mNoFilteredItemsMsg = msg; }
|
||||
|
||||
bool getForceShowingUnmatchedItems();
|
||||
bool getForceShowingUnmatchedItems() const;
|
||||
|
||||
/**
|
||||
* Sets filtered out items to stay visible. Can result in rect changes,
|
||||
|
|
@ -504,7 +504,7 @@ public:
|
|||
* Sets up new filter string and filters the list.
|
||||
*/
|
||||
void setFilterSubString(const std::string& filter_str, bool notify_parent);
|
||||
std::string getFilterSubString() { return mFilterSubString; }
|
||||
std::string getFilterSubString() const { return mFilterSubString; }
|
||||
|
||||
/**
|
||||
* Filters the list, rearranges and notifies parent about shape changes.
|
||||
|
|
|
|||
|
|
@ -2332,7 +2332,7 @@ void LLFloater::setCanDrag(bool can_drag)
|
|||
}
|
||||
}
|
||||
|
||||
bool LLFloater::getCanDrag()
|
||||
bool LLFloater::getCanDrag() const
|
||||
{
|
||||
return mDragHandle->getEnabled();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -46,24 +46,24 @@ class LLMultiFloater;
|
|||
class LLFloater;
|
||||
|
||||
|
||||
const bool RESIZE_YES = true;
|
||||
const bool RESIZE_NO = false;
|
||||
constexpr bool RESIZE_YES = true;
|
||||
constexpr bool RESIZE_NO = false;
|
||||
|
||||
const bool DRAG_ON_TOP = false;
|
||||
const bool DRAG_ON_LEFT = true;
|
||||
constexpr bool DRAG_ON_TOP = false;
|
||||
constexpr bool DRAG_ON_LEFT = true;
|
||||
|
||||
const bool MINIMIZE_YES = true;
|
||||
const bool MINIMIZE_NO = false;
|
||||
constexpr bool MINIMIZE_YES = true;
|
||||
constexpr bool MINIMIZE_NO = false;
|
||||
|
||||
const bool CLOSE_YES = true;
|
||||
const bool CLOSE_NO = false;
|
||||
constexpr bool CLOSE_YES = true;
|
||||
constexpr bool CLOSE_NO = false;
|
||||
|
||||
const bool ADJUST_VERTICAL_YES = true;
|
||||
const bool ADJUST_VERTICAL_NO = false;
|
||||
constexpr bool ADJUST_VERTICAL_YES = true;
|
||||
constexpr bool ADJUST_VERTICAL_NO = false;
|
||||
|
||||
const F32 CONTEXT_CONE_IN_ALPHA = 0.f;
|
||||
const F32 CONTEXT_CONE_OUT_ALPHA = 1.f;
|
||||
const F32 CONTEXT_CONE_FADE_TIME = .08f;
|
||||
constexpr F32 CONTEXT_CONE_IN_ALPHA = 0.f;
|
||||
constexpr F32 CONTEXT_CONE_OUT_ALPHA = 1.f;
|
||||
constexpr F32 CONTEXT_CONE_FADE_TIME = .08f;
|
||||
|
||||
namespace LLFloaterEnums
|
||||
{
|
||||
|
|
@ -238,7 +238,7 @@ public:
|
|||
/*virtual*/ void setIsChrome(bool is_chrome);
|
||||
/*virtual*/ void setRect(const LLRect &rect);
|
||||
void setIsSingleInstance(bool is_single_instance);
|
||||
bool getIsSingleInstance() { return mSingleInstance; }
|
||||
bool getIsSingleInstance() const { return mSingleInstance; }
|
||||
|
||||
void initFloater(const Params& p);
|
||||
|
||||
|
|
@ -287,18 +287,18 @@ public:
|
|||
static bool isShown(const LLFloater* floater);
|
||||
static bool isVisible(const LLFloater* floater);
|
||||
static bool isMinimized(const LLFloater* floater);
|
||||
bool isFirstLook() { return mFirstLook; } // EXT-2653: This function is necessary to prevent overlapping for secondary showed toasts
|
||||
bool isFirstLook() const { return mFirstLook; } // EXT-2653: This function is necessary to prevent overlapping for secondary showed toasts
|
||||
virtual bool isFrontmost();
|
||||
bool isDependent() { return !mDependeeHandle.isDead(); }
|
||||
bool isDependent() const { return !mDependeeHandle.isDead(); }
|
||||
void setCanMinimize(bool can_minimize);
|
||||
void setCanClose(bool can_close);
|
||||
void setCanTearOff(bool can_tear_off);
|
||||
virtual void setCanResize(bool can_resize);
|
||||
void setCanDrag(bool can_drag);
|
||||
bool getCanDrag();
|
||||
bool getCanDrag() const;
|
||||
void setCanSnooze(bool can_snooze); // <FS:Ansariel> FIRE-11724: Snooze group chat
|
||||
void setHost(LLMultiFloater* host);
|
||||
bool isResizable() const { return mResizable; }
|
||||
bool isResizable() const { return mResizable; }
|
||||
void setResizeLimits( S32 min_width, S32 min_height );
|
||||
void getResizeLimits( S32* min_width, S32* min_height ) { *min_width = mMinWidth; *min_height = mMinHeight; }
|
||||
|
||||
|
|
@ -362,7 +362,7 @@ public:
|
|||
virtual void setDocked(bool docked, bool pop_on_undock = true);
|
||||
|
||||
virtual void setTornOff(bool torn_off) { mTornOff = torn_off; }
|
||||
bool isTornOff() {return mTornOff;}
|
||||
bool isTornOff() const { return mTornOff; }
|
||||
void setOpenPositioning(LLFloaterEnums::EOpenPositioning pos) {mPositioning = pos;}
|
||||
|
||||
|
||||
|
|
@ -394,6 +394,9 @@ public:
|
|||
|
||||
bool isPositioning(LLFloaterEnums::EOpenPositioning p) const { return (p == mPositioning); }
|
||||
|
||||
void setAutoFocus(bool focus) { mAutoFocus = focus; } // whether to automatically take focus when opened
|
||||
bool getAutoFocus() const { return mAutoFocus; }
|
||||
|
||||
// <COLOSI opensim multi-currency support>
|
||||
// update currency symbols in titles (if there) and force update of display
|
||||
void updateCurrencySymbols() { mTitle.updateCurrencySymbols(); mShortTitle.updateCurrencySymbols(); applyTitle(); }
|
||||
|
|
@ -422,8 +425,6 @@ protected:
|
|||
void setExpandedRect(const LLRect& rect) { mExpandedRect = rect; } // size when not minimized
|
||||
const LLRect& getExpandedRect() const { return mExpandedRect; }
|
||||
|
||||
void setAutoFocus(bool focus) { mAutoFocus = focus; } // whether to automatically take focus when opened
|
||||
bool getAutoFocus() const { return mAutoFocus; }
|
||||
LLDragHandle* getDragHandle() const { return mDragHandle; }
|
||||
|
||||
void destroy(); // Don't call this directly. You probably want to call closeFloater()
|
||||
|
|
@ -444,7 +445,6 @@ protected:
|
|||
private:
|
||||
void setForeground(bool b); // called only by floaterview
|
||||
void cleanupHandles(); // remove handles to dead floaters
|
||||
void createMinimizeButton();
|
||||
void buildButtons(const Params& p);
|
||||
|
||||
// Images and tooltips are named in the XML, but we want to look them
|
||||
|
|
|
|||
|
|
@ -30,7 +30,6 @@
|
|||
#define LL_LLFLOATERREGLISTENER_H
|
||||
|
||||
#include "lleventapi.h"
|
||||
#include <string>
|
||||
|
||||
class LLSD;
|
||||
|
||||
|
|
|
|||
|
|
@ -54,7 +54,7 @@ protected:
|
|||
LLFlyoutButton(const Params&);
|
||||
friend class LLUICtrlFactory;
|
||||
public:
|
||||
virtual void draw();
|
||||
void draw() override;
|
||||
|
||||
void setToggleState(bool state);
|
||||
|
||||
|
|
|
|||
|
|
@ -97,7 +97,7 @@ public:
|
|||
LLFocusableElement* getLastKeyboardFocus() const { return mLastKeyboardFocus; }
|
||||
bool childHasKeyboardFocus( const LLView* parent ) const;
|
||||
void removeKeyboardFocusWithoutCallback( const LLFocusableElement* focus );
|
||||
bool getKeystrokesOnly() { return mKeystrokesOnly; }
|
||||
bool getKeystrokesOnly() const { return mKeystrokesOnly; }
|
||||
void setKeystrokesOnly(bool keystrokes_only) { mKeystrokesOnly = keystrokes_only; }
|
||||
|
||||
F32 getFocusFlashAmt() const;
|
||||
|
|
|
|||
|
|
@ -124,11 +124,11 @@ public:
|
|||
void setSelectCallback(const signal_t::slot_type& cb) { mSelectSignal.connect(cb); }
|
||||
void setReshapeCallback(const signal_t::slot_type& cb) { mReshapeSignal.connect(cb); }
|
||||
|
||||
bool getAllowMultiSelect() { return mAllowMultiSelect; }
|
||||
bool getAllowDrag() { return mAllowDrag; }
|
||||
bool getAllowMultiSelect() const { return mAllowMultiSelect; }
|
||||
bool getAllowDrag() const { return mAllowDrag; }
|
||||
|
||||
void setSingleFolderMode(bool is_single_mode) { mSingleFolderMode = is_single_mode; }
|
||||
bool isSingleFolderMode() { return mSingleFolderMode; }
|
||||
bool isSingleFolderMode() const { return mSingleFolderMode; }
|
||||
|
||||
// Close all folders in the view
|
||||
void closeAllFolders();
|
||||
|
|
@ -142,7 +142,7 @@ public:
|
|||
virtual S32 getItemHeight() const;
|
||||
|
||||
void arrangeAll() { mArrangeGeneration++; }
|
||||
S32 getArrangeGeneration() { return mArrangeGeneration; }
|
||||
S32 getArrangeGeneration() const { return mArrangeGeneration; }
|
||||
|
||||
// applies filters to control visibility of items
|
||||
virtual void filter( LLFolderViewFilter& filter);
|
||||
|
|
@ -233,27 +233,27 @@ public:
|
|||
void setShowSelectionContext(bool show) { mShowSelectionContext = show; }
|
||||
bool getShowSelectionContext();
|
||||
void setShowSingleSelection(bool show);
|
||||
bool getShowSingleSelection() { return mShowSingleSelection; }
|
||||
F32 getSelectionFadeElapsedTime() { return mMultiSelectionFadeTimer.getElapsedTimeF32(); }
|
||||
bool getUseEllipses() { return mUseEllipses; }
|
||||
S32 getSelectedCount() { return (S32)mSelectedItems.size(); }
|
||||
bool getShowSingleSelection() const { return mShowSingleSelection; }
|
||||
F32 getSelectionFadeElapsedTime() const { return mMultiSelectionFadeTimer.getElapsedTimeF32(); }
|
||||
bool getUseEllipses() const { return mUseEllipses; }
|
||||
S32 getSelectedCount() const { return (S32)mSelectedItems.size(); }
|
||||
|
||||
void update(); // needs to be called periodically (e.g. once per frame)
|
||||
void update(); // needs to be called periodically (e.g. once per frame)
|
||||
|
||||
bool needsAutoSelect() { return mNeedsAutoSelect && !mAutoSelectOverride; }
|
||||
bool needsAutoRename() { return mNeedsAutoRename; }
|
||||
bool needsAutoSelect() const { return mNeedsAutoSelect && !mAutoSelectOverride; }
|
||||
bool needsAutoRename() const { return mNeedsAutoRename; }
|
||||
void setNeedsAutoRename(bool val) { mNeedsAutoRename = val; }
|
||||
void setPinningSelectedItem(bool val) { mPinningSelectedItem = val; }
|
||||
void setAutoSelectOverride(bool val) { mAutoSelectOverride = val; }
|
||||
|
||||
bool showItemLinkOverlays() { return mShowItemLinkOverlays; }
|
||||
bool showItemLinkOverlays() const { return mShowItemLinkOverlays; }
|
||||
|
||||
void setCallbackRegistrar(LLUICtrl::CommitCallbackRegistry::ScopedRegistrar* registrar) { mCallbackRegistrar = registrar; }
|
||||
void setEnableRegistrar(LLUICtrl::EnableCallbackRegistry::ScopedRegistrar* registrar) { mEnableRegistrar = registrar; }
|
||||
|
||||
void setForceArrange(bool force) { mForceArrange = force; }
|
||||
|
||||
LLPanel* getParentPanel() { return mParentPanel.get(); }
|
||||
LLPanel* getParentPanel() const { return mParentPanel.get(); }
|
||||
// DEBUG only
|
||||
void dumpSelectionInformation();
|
||||
|
||||
|
|
@ -261,7 +261,7 @@ public:
|
|||
|
||||
void setShowEmptyMessage(bool show_msg) { mShowEmptyMessage = show_msg; }
|
||||
|
||||
bool useLabelSuffix() { return mUseLabelSuffix; }
|
||||
bool useLabelSuffix() const { return mUseLabelSuffix; }
|
||||
virtual void updateMenu();
|
||||
|
||||
void finishRenamingItem( void );
|
||||
|
|
@ -401,7 +401,7 @@ public:
|
|||
virtual ~LLSelectFirstFilteredItem() {}
|
||||
virtual void doFolder(LLFolderViewFolder* folder);
|
||||
virtual void doItem(LLFolderViewItem* item);
|
||||
bool wasItemSelected() { return mItemSelected || mFolderSelected; }
|
||||
bool wasItemSelected() const { return mItemSelected || mFolderSelected; }
|
||||
protected:
|
||||
bool mItemSelected;
|
||||
bool mFolderSelected;
|
||||
|
|
|
|||
|
|
@ -301,7 +301,7 @@ public:
|
|||
// Does not need filter update
|
||||
virtual void refreshSuffix();
|
||||
|
||||
bool isSingleFolderMode() { return mSingleFolderMode; }
|
||||
bool isSingleFolderMode() const { return mSingleFolderMode; }
|
||||
|
||||
// LLView functionality
|
||||
virtual bool handleRightMouseDown( S32 x, S32 y, MASK mask );
|
||||
|
|
@ -454,9 +454,6 @@ public:
|
|||
// doesn't delete it.
|
||||
virtual void extractItem( LLFolderViewItem* item, bool deparent_model = true);
|
||||
|
||||
// This function is called by a child that needs to be resorted.
|
||||
void resort(LLFolderViewItem* item);
|
||||
|
||||
void setAutoOpenCountdown(F32 countdown) { mAutoOpenCountdown = countdown; }
|
||||
|
||||
// folders can be opened. This will usually be called by internal
|
||||
|
|
|
|||
|
|
@ -170,7 +170,7 @@ std::string LLKeywords::getAttribute(std::string_view key)
|
|||
return (it != mAttributes.end()) ? it->second : "";
|
||||
}
|
||||
|
||||
LLUIColor LLKeywords::getColorGroup(std::string_view key_in)
|
||||
LLUIColor LLKeywords::getColorGroup(std::string_view key_in) const
|
||||
{
|
||||
std::string color_group = "ScriptText";
|
||||
if (key_in == "functions")
|
||||
|
|
|
|||
|
|
@ -115,8 +115,8 @@ public:
|
|||
~LLKeywords();
|
||||
|
||||
void clearLoaded() { mLoaded = false; }
|
||||
LLUIColor getColorGroup(std::string_view key_in);
|
||||
bool isLoaded() const { return mLoaded; }
|
||||
LLUIColor getColorGroup(std::string_view key_in) const;
|
||||
bool isLoaded() const { return mLoaded; }
|
||||
// <FS:Ansariel> Re-add support for Cinder's legacy file format
|
||||
bool loadFromLegacyFile(const std::string& filename);
|
||||
|
||||
|
|
|
|||
|
|
@ -36,8 +36,8 @@
|
|||
#include "lliconctrl.h"
|
||||
#include "boost/foreach.hpp"
|
||||
|
||||
static const F32 MIN_FRACTIONAL_SIZE = 0.00001f;
|
||||
static const F32 MAX_FRACTIONAL_SIZE = 1.f;
|
||||
static constexpr F32 MIN_FRACTIONAL_SIZE = 0.00001f;
|
||||
static constexpr F32 MAX_FRACTIONAL_SIZE = 1.f;
|
||||
|
||||
static LLDefaultChildRegistry::Register<LLLayoutStack> register_layout_stack("layout_stack");
|
||||
static LLLayoutStack::LayoutStackRegistry::Register<LLLayoutPanel> register_layout_panel("layout_panel");
|
||||
|
|
|
|||
|
|
@ -80,9 +80,6 @@ public:
|
|||
/*virtual*/ bool addChild(LLView* child, S32 tab_group = 0);
|
||||
/*virtual*/ void reshape(S32 width, S32 height, bool called_from_parent = true);
|
||||
|
||||
|
||||
static LLView* fromXML(LLXMLNodePtr node, LLView *parent, LLXMLNodePtr output_node = NULL);
|
||||
|
||||
typedef enum e_animate
|
||||
{
|
||||
NO_ANIMATE,
|
||||
|
|
@ -91,7 +88,7 @@ public:
|
|||
|
||||
void addPanel(LLLayoutPanel* panel, EAnimate animate = NO_ANIMATE);
|
||||
void collapsePanel(LLPanel* panel, bool collapsed = true);
|
||||
S32 getNumPanels() { return static_cast<S32>(mPanels.size()); }
|
||||
S32 getNumPanels() const { return static_cast<S32>(mPanels.size()); }
|
||||
|
||||
void updateLayout();
|
||||
|
||||
|
|
@ -204,7 +201,6 @@ public:
|
|||
bool isCollapsed() const { return mCollapsed;}
|
||||
|
||||
void setOrientation(LLView::EOrientation orientation);
|
||||
void storeOriginalDim();
|
||||
|
||||
void setIgnoreReshape(bool ignore) { mIgnoreReshape = ignore; }
|
||||
|
||||
|
|
|
|||
|
|
@ -323,8 +323,6 @@ public:
|
|||
S32 calcCursorPos(S32 mouse_x);
|
||||
bool handleSpecialKey(KEY key, MASK mask);
|
||||
bool handleSelectionKey(KEY key, MASK mask);
|
||||
bool handleControlKey(KEY key, MASK mask);
|
||||
S32 handleCommitKey(KEY key, MASK mask);
|
||||
void updateTextPadding();
|
||||
|
||||
// Draw the background image depending on enabled/focused state.
|
||||
|
|
@ -461,7 +459,7 @@ private:
|
|||
mText = ed->getText();
|
||||
}
|
||||
|
||||
void doRollback( LLLineEditor* ed )
|
||||
void doRollback(LLLineEditor* ed) const
|
||||
{
|
||||
ed->mCursorPos = mCursorPos;
|
||||
ed->mScrollHPos = mScrollHPos;
|
||||
|
|
@ -472,7 +470,7 @@ private:
|
|||
ed->mPrevText = mText;
|
||||
}
|
||||
|
||||
std::string getText() { return mText; }
|
||||
std::string getText() const { return mText; }
|
||||
|
||||
private:
|
||||
std::string mText;
|
||||
|
|
|
|||
|
|
@ -65,8 +65,8 @@ public:
|
|||
|
||||
boost::signals2::connection setMouseDownCallback( const mouse_signal_t::slot_type& cb );
|
||||
|
||||
/*virtual*/ bool handleMouseDown(S32 x, S32 y, MASK mask);
|
||||
/*virtual*/ bool handleKeyHere(KEY key, MASK mask );
|
||||
bool handleMouseDown(S32 x, S32 y, MASK mask) override;
|
||||
bool handleKeyHere(KEY key, MASK mask) override;
|
||||
|
||||
void hideMenu();
|
||||
|
||||
|
|
|
|||
|
|
@ -440,8 +440,6 @@ protected:
|
|||
public:
|
||||
virtual ~LLMenuGL( void );
|
||||
|
||||
void parseChildXML(LLXMLNodePtr child, LLView* parent);
|
||||
|
||||
// LLView Functionality
|
||||
/*virtual*/ bool handleUnicodeCharHere( llwchar uni_char );
|
||||
/*virtual*/ bool handleHover( S32 x, S32 y, MASK mask );
|
||||
|
|
|
|||
|
|
@ -430,7 +430,7 @@ LLFloater* LLMultiFloater::getActiveFloater()
|
|||
return (LLFloater*)mTabContainer->getCurrentPanel();
|
||||
}
|
||||
|
||||
S32 LLMultiFloater::getFloaterCount()
|
||||
S32 LLMultiFloater::getFloaterCount() const
|
||||
{
|
||||
return mTabContainer->getTabCount();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -66,7 +66,7 @@ public:
|
|||
|
||||
virtual LLFloater* getActiveFloater();
|
||||
virtual bool isFloaterFlashing(LLFloater* floaterp);
|
||||
virtual S32 getFloaterCount();
|
||||
virtual S32 getFloaterCount() const;
|
||||
|
||||
virtual void setFloaterFlashing(LLFloater* floaterp, bool flashing);
|
||||
virtual bool closeAllFloaters(); //Returns false if the floater could not be closed due to pending confirmation dialogs
|
||||
|
|
|
|||
|
|
@ -117,10 +117,10 @@ public:
|
|||
/*virtual*/ void onMouseLeave(S32 x, S32 y, MASK mask) override;
|
||||
/*virtual*/ void draw() override;
|
||||
|
||||
S32 getMaxNumSliders() { return mMaxNumSliders; }
|
||||
S32 getCurNumSliders() { return static_cast<S32>(mValue.size()); }
|
||||
F32 getOverlapThreshold() { return mOverlapThreshold; }
|
||||
bool canAddSliders() { return mValue.size() < mMaxNumSliders; }
|
||||
S32 getMaxNumSliders() const { return mMaxNumSliders; }
|
||||
S32 getCurNumSliders() const { return static_cast<S32>(mValue.size()); }
|
||||
F32 getOverlapThreshold() const { return mOverlapThreshold; }
|
||||
bool canAddSliders() const { return mValue.size() < mMaxNumSliders; }
|
||||
|
||||
|
||||
protected:
|
||||
|
|
|
|||
|
|
@ -124,10 +124,10 @@ public:
|
|||
F32 getMinValue() const { return mMultiSlider->getMinValue(); }
|
||||
F32 getMaxValue() const { return mMultiSlider->getMaxValue(); }
|
||||
|
||||
S32 getMaxNumSliders() { return mMultiSlider->getMaxNumSliders(); }
|
||||
S32 getCurNumSliders() { return mMultiSlider->getCurNumSliders(); }
|
||||
F32 getOverlapThreshold() { return mMultiSlider->getOverlapThreshold(); }
|
||||
bool canAddSliders() { return mMultiSlider->canAddSliders(); }
|
||||
S32 getMaxNumSliders() const { return mMultiSlider->getMaxNumSliders(); }
|
||||
S32 getCurNumSliders() const { return mMultiSlider->getCurNumSliders(); }
|
||||
F32 getOverlapThreshold() const { return mMultiSlider->getOverlapThreshold(); }
|
||||
bool canAddSliders() const { return mMultiSlider->canAddSliders(); }
|
||||
|
||||
void setLabel(const std::string& label) { if (mLabelBox) mLabelBox->setText(label); }
|
||||
void setLabelColor(const LLUIColor& c) { mTextEnabledColor = c; }
|
||||
|
|
@ -147,7 +147,6 @@ public:
|
|||
|
||||
static void onEditorCommit(LLUICtrl* ctrl, const LLSD& userdata);
|
||||
static void onEditorGainFocus(LLFocusableElement* caller, void *userdata);
|
||||
static void onEditorChangeFocus(LLUICtrl* caller, S32 direction, void *userdata);
|
||||
|
||||
private:
|
||||
void updateText();
|
||||
|
|
|
|||
|
|
@ -248,7 +248,6 @@ public:
|
|||
LLNotificationForm(const LLSD& sd);
|
||||
LLNotificationForm(const std::string& name, const Params& p);
|
||||
|
||||
void fromLLSD(const LLSD& sd);
|
||||
LLSD asLLSD() const;
|
||||
|
||||
S32 getNumElements() { return static_cast<S32>(mFormData.size()); }
|
||||
|
|
@ -267,8 +266,8 @@ public:
|
|||
bool getIgnored();
|
||||
void setIgnored(bool ignored);
|
||||
|
||||
EIgnoreType getIgnoreType() { return mIgnore; }
|
||||
std::string getIgnoreMessage() { return mIgnoreMsg; }
|
||||
EIgnoreType getIgnoreType()const { return mIgnore; }
|
||||
std::string getIgnoreMessage() const { return mIgnoreMsg; }
|
||||
|
||||
private:
|
||||
LLSD mFormData;
|
||||
|
|
@ -976,8 +975,6 @@ private:
|
|||
/*virtual*/ void initSingleton() override;
|
||||
/*virtual*/ void cleanupSingleton() override;
|
||||
|
||||
void loadPersistentNotifications();
|
||||
|
||||
bool expirationFilter(LLNotificationPtr pNotification);
|
||||
bool expirationHandler(const LLSD& payload);
|
||||
bool uniqueFilter(LLNotificationPtr pNotification);
|
||||
|
|
|
|||
|
|
@ -48,9 +48,9 @@ public:
|
|||
LLProgressBar(const Params&);
|
||||
virtual ~LLProgressBar();
|
||||
|
||||
void setValue(const LLSD& value);
|
||||
void setValue(const LLSD& value) override;
|
||||
|
||||
/*virtual*/ void draw();
|
||||
void draw() override;
|
||||
|
||||
private:
|
||||
F32 mPercentDone;
|
||||
|
|
|
|||
|
|
@ -61,7 +61,7 @@ public:
|
|||
void setResizeLimits( S32 min_size, S32 max_size ) { mMinSize = min_size; mMaxSize = max_size; }
|
||||
void setEnableSnapping(bool enable) { mSnappingEnabled = enable; }
|
||||
void setAllowDoubleClickSnapping(bool allow) { mAllowDoubleClickSnapping = allow; }
|
||||
bool canResize() { return getEnabled() && mMaxSize > mMinSize; }
|
||||
bool canResize() const { return getEnabled() && mMaxSize > mMinSize; }
|
||||
void setResizeListener(boost::function<void(void*)> listener) {mResizeListener = listener;}
|
||||
void setImagePanel(LLPanel * panelp);
|
||||
LLPanel * getImagePanel() const;
|
||||
|
|
|
|||
|
|
@ -50,10 +50,10 @@ protected:
|
|||
LLResizeHandle(const LLResizeHandle::Params&);
|
||||
friend class LLUICtrlFactory;
|
||||
public:
|
||||
virtual void draw();
|
||||
virtual bool handleHover(S32 x, S32 y, MASK mask);
|
||||
virtual bool handleMouseDown(S32 x, S32 y, MASK mask);
|
||||
virtual bool handleMouseUp(S32 x, S32 y, MASK mask);
|
||||
void draw() override;
|
||||
bool handleHover(S32 x, S32 y, MASK mask) override;
|
||||
bool handleMouseDown(S32 x, S32 y, MASK mask) override;
|
||||
bool handleMouseUp(S32 x, S32 y, MASK mask) override;
|
||||
|
||||
void setResizeLimits( S32 min_width, S32 min_height ) { mMinWidth = min_width; mMinHeight = min_height; }
|
||||
|
||||
|
|
@ -71,8 +71,8 @@ private:
|
|||
const ECorner mCorner;
|
||||
};
|
||||
|
||||
const S32 RESIZE_HANDLE_HEIGHT = 11;
|
||||
const S32 RESIZE_HANDLE_WIDTH = 11;
|
||||
constexpr S32 RESIZE_HANDLE_HEIGHT = 11;
|
||||
constexpr S32 RESIZE_HANDLE_WIDTH = 11;
|
||||
|
||||
#endif // LL_RESIZEHANDLE_H
|
||||
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@ public:
|
|||
void writeRNG(const std::string& name, LLXMLNodePtr node, const LLInitParam::BaseBlock& block, const std::string& xml_namespace);
|
||||
void addDefinition(const std::string& type_name, const LLInitParam::BaseBlock& block);
|
||||
|
||||
/*virtual*/ std::string getCurrentElementName() { return LLStringUtil::null; }
|
||||
std::string getCurrentElementName() override { return LLStringUtil::null; }
|
||||
|
||||
LLRNGWriter();
|
||||
|
||||
|
|
|
|||
|
|
@ -105,7 +105,7 @@ public:
|
|||
virtual const LLSD getAltValue() const;
|
||||
virtual void setValue(const LLSD& value) { }
|
||||
virtual void setAltValue(const LLSD& value) { }
|
||||
virtual const std::string &getToolTip() const { return mToolTip; }
|
||||
virtual const std::string& getToolTip() const { return mToolTip; }
|
||||
virtual void setToolTip(const std::string &str) { mToolTip = str; }
|
||||
virtual bool getVisible() const { return true; }
|
||||
virtual void setWidth(S32 width) { mWidth = width; }
|
||||
|
|
|
|||
|
|
@ -168,7 +168,6 @@ public:
|
|||
void deleteAllItems() { clearRows(); }
|
||||
|
||||
// Sets an array of column descriptors
|
||||
void setColumnHeadings(const LLSD& headings);
|
||||
void sortByColumnIndex(U32 column, bool ascending);
|
||||
|
||||
// LLCtrlListInterface functions
|
||||
|
|
@ -333,7 +332,7 @@ public:
|
|||
void setAllowKeyboardMovement(bool b) { mAllowKeyboardMovement = b; }
|
||||
|
||||
void setMaxSelectable(U32 max_selected) { mMaxSelectable = max_selected; }
|
||||
S32 getMaxSelectable() { return mMaxSelectable; }
|
||||
S32 getMaxSelectable() const { return mMaxSelectable; }
|
||||
|
||||
// <FS:Ansariel> Convenience method
|
||||
LLScrollbar* getScrollbar() const { return mScrollbar; }
|
||||
|
|
@ -357,7 +356,7 @@ public:
|
|||
// support right-click context menus for avatar/group lists
|
||||
enum ContextMenuType { MENU_NONE, MENU_AVATAR, MENU_GROUP };
|
||||
void setContextMenu(const ContextMenuType &menu) { mContextMenuType = menu; }
|
||||
ContextMenuType getContextMenuType() { return mContextMenuType; }
|
||||
ContextMenuType getContextMenuType() const { return mContextMenuType; }
|
||||
|
||||
// Overridden from LLView
|
||||
/*virtual*/ void draw();
|
||||
|
|
@ -385,7 +384,6 @@ public:
|
|||
virtual void fitContents(S32 max_width, S32 max_height);
|
||||
|
||||
virtual LLRect getRequiredRect();
|
||||
static bool rowPreceeds(LLScrollListItem *new_row, LLScrollListItem *test_row);
|
||||
|
||||
LLRect getItemListRect() { return mItemListRect; }
|
||||
|
||||
|
|
@ -407,7 +405,6 @@ public:
|
|||
* then display all items.
|
||||
*/
|
||||
void setPageLines(S32 page_lines );
|
||||
void setCollapseEmptyColumns(bool collapse);
|
||||
|
||||
LLScrollListItem* hitItem(S32 x,S32 y);
|
||||
virtual void scrollToShowSelected();
|
||||
|
|
@ -424,7 +421,7 @@ public:
|
|||
|
||||
void setNumDynamicColumns(S32 num) { mNumDynamicWidthColumns = num; }
|
||||
void updateStaticColumnWidth(LLScrollListColumn* col, S32 new_width);
|
||||
S32 getTotalStaticColumnWidth() { return mTotalStaticColumnWidth; }
|
||||
S32 getTotalStaticColumnWidth() const { return mTotalStaticColumnWidth; }
|
||||
|
||||
std::string getSortColumnName();
|
||||
bool getSortAscending() { return mSortColumns.empty() ? true : mSortColumns.back().second; }
|
||||
|
|
|
|||
|
|
@ -132,7 +132,6 @@ public:
|
|||
|
||||
static void onEditorCommit(LLUICtrl* ctrl, const LLSD& userdata);
|
||||
static void onEditorGainFocus(LLFocusableElement* caller, void *userdata);
|
||||
static void onEditorChangeFocus(LLUICtrl* caller, S32 direction, void *userdata);
|
||||
|
||||
protected:
|
||||
virtual std::string _getSearchText() const
|
||||
|
|
|
|||
|
|
@ -99,7 +99,6 @@ public:
|
|||
void onEditorCommit(const LLSD& data);
|
||||
static void onEditorGainFocus(LLFocusableElement* caller, void *userdata);
|
||||
static void onEditorLostFocus(LLFocusableElement* caller, void *userdata);
|
||||
static void onEditorChangeFocus(LLUICtrl* caller, S32 direction, void *userdata);
|
||||
|
||||
void onUpBtn(const LLSD& data);
|
||||
void onDownBtn(const LLSD& data);
|
||||
|
|
|
|||
|
|
@ -72,7 +72,7 @@ public:
|
|||
void setStat(const std::string& stat_name);
|
||||
|
||||
void setRange(F32 bar_min, F32 bar_max);
|
||||
void getRange(F32& bar_min, F32& bar_max) { bar_min = mTargetMinBar; bar_max = mTargetMaxBar; }
|
||||
void getRange(F32& bar_min, F32& bar_max) const { bar_min = mTargetMinBar; bar_max = mTargetMaxBar; }
|
||||
|
||||
/*virtual*/ LLRect getRequiredRect(); // Return the height of this object, given the set options.
|
||||
|
||||
|
|
|
|||
|
|
@ -36,7 +36,6 @@
|
|||
#include "llglheaders.h"
|
||||
#include "lltracerecording.h"
|
||||
#include "lltracethreadrecorder.h"
|
||||
//#include "llviewercontrol.h"
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
|
|
|||
|
|
@ -99,9 +99,7 @@ public:
|
|||
void setMin(const F32 min);
|
||||
void setMax(const F32 max);
|
||||
|
||||
virtual void draw();
|
||||
|
||||
/*virtual*/ void setValue(const LLSD& value);
|
||||
void draw() override;
|
||||
|
||||
private:
|
||||
LLTrace::StatType<LLTrace::CountAccumulator>* mNewStatFloatp;
|
||||
|
|
@ -133,9 +131,6 @@ private:
|
|||
};
|
||||
typedef std::vector<Threshold> threshold_vec_t;
|
||||
threshold_vec_t mThresholds;
|
||||
//S32 mNumThresholds;
|
||||
//F32 mThresholds[4];
|
||||
//LLColor4 mThresholdColors[4];
|
||||
};
|
||||
|
||||
#endif // LL_LLSTATGRAPH_H
|
||||
|
|
|
|||
|
|
@ -29,7 +29,6 @@
|
|||
|
||||
#include "llstatbar.h"
|
||||
#include "llcontainerview.h"
|
||||
#include <vector>
|
||||
|
||||
class LLStatBar;
|
||||
|
||||
|
|
|
|||
|
|
@ -1511,17 +1511,17 @@ LLPanel* LLTabContainer::getCurrentPanel()
|
|||
return NULL;
|
||||
}
|
||||
|
||||
S32 LLTabContainer::getCurrentPanelIndex()
|
||||
S32 LLTabContainer::getCurrentPanelIndex() const
|
||||
{
|
||||
return mCurrentTabIdx;
|
||||
}
|
||||
|
||||
S32 LLTabContainer::getTabCount()
|
||||
S32 LLTabContainer::getTabCount() const
|
||||
{
|
||||
return static_cast<S32>(mTabList.size());
|
||||
}
|
||||
|
||||
LLPanel* LLTabContainer::getPanelByIndex(S32 index)
|
||||
LLPanel* LLTabContainer::getPanelByIndex(S32 index) const
|
||||
{
|
||||
if (index >= 0 && index < (S32)mTabList.size())
|
||||
{
|
||||
|
|
@ -1530,7 +1530,7 @@ LLPanel* LLTabContainer::getPanelByIndex(S32 index)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
S32 LLTabContainer::getIndexForPanel(LLPanel* panel)
|
||||
S32 LLTabContainer::getIndexForPanel(LLPanel* panel) const
|
||||
{
|
||||
for (S32 index = 0; index < (S32)mTabList.size(); index++)
|
||||
{
|
||||
|
|
@ -1542,7 +1542,7 @@ S32 LLTabContainer::getIndexForPanel(LLPanel* panel)
|
|||
return -1;
|
||||
}
|
||||
|
||||
S32 LLTabContainer::getPanelIndexByTitle(std::string_view title)
|
||||
S32 LLTabContainer::getPanelIndexByTitle(std::string_view title) const
|
||||
{
|
||||
for (S32 index = 0 ; index < (S32)mTabList.size(); index++)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -199,15 +199,15 @@ public:
|
|||
void removeTabPanel( LLPanel* child );
|
||||
void lockTabs(S32 num_tabs = 0);
|
||||
void unlockTabs();
|
||||
S32 getNumLockedTabs() { return mLockedTabCount; }
|
||||
S32 getNumLockedTabs() const { return mLockedTabCount; }
|
||||
void enableTabButton(S32 which, bool enable);
|
||||
void deleteAllTabs();
|
||||
LLPanel* getCurrentPanel();
|
||||
S32 getCurrentPanelIndex();
|
||||
S32 getTabCount();
|
||||
LLPanel* getPanelByIndex(S32 index);
|
||||
S32 getIndexForPanel(LLPanel* panel);
|
||||
S32 getPanelIndexByTitle(std::string_view title);
|
||||
S32 getCurrentPanelIndex() const;
|
||||
S32 getTabCount() const;
|
||||
LLPanel* getPanelByIndex(S32 index) const;
|
||||
S32 getIndexForPanel(LLPanel* panel) const;
|
||||
S32 getPanelIndexByTitle(std::string_view title) const;
|
||||
LLPanel* getPanelByName(std::string_view name);
|
||||
S32 getTotalTabWidth() const;
|
||||
void setCurrentTabName(const std::string& name);
|
||||
|
|
|
|||
|
|
@ -145,7 +145,6 @@ public:
|
|||
/*virtual*/ void setStyle(LLStyleConstSP style) { mStyle = style; }
|
||||
/*virtual*/ void setToken( LLKeywordToken* token ) { mToken = token; }
|
||||
/*virtual*/ LLKeywordToken* getToken() const { return mToken; }
|
||||
/*virtual*/ bool getToolTip( std::string& msg ) const;
|
||||
/*virtual*/ void setToolTip(const std::string& tooltip);
|
||||
/*virtual*/ void dump() const;
|
||||
|
||||
|
|
@ -477,7 +476,7 @@ public:
|
|||
virtual void setText(const LLStringExplicit &utf8str , const LLStyle::Params& input_params = LLStyle::Params()); // uses default style
|
||||
/*virtual*/ const std::string& getText() const override;
|
||||
void setMaxTextLength(S32 length) { mMaxTextByteLength = length; }
|
||||
S32 getMaxTextLength() { return mMaxTextByteLength; }
|
||||
S32 getMaxTextLength() const { return mMaxTextByteLength; }
|
||||
|
||||
// wide-char versions
|
||||
void setWText(const LLWString& text);
|
||||
|
|
@ -516,10 +515,10 @@ public:
|
|||
LLRect getTextBoundingRect();
|
||||
LLRect getVisibleDocumentRect() const;
|
||||
|
||||
S32 getVPad() { return mVPad; }
|
||||
S32 getHPad() { return mHPad; }
|
||||
F32 getLineSpacingMult() { return mLineSpacingMult; }
|
||||
S32 getLineSpacingPixels() { return mLineSpacingPixels; } // only for multiline
|
||||
S32 getVPad() const { return mVPad; }
|
||||
S32 getHPad() const { return mHPad; }
|
||||
F32 getLineSpacingMult() const { return mLineSpacingMult; }
|
||||
S32 getLineSpacingPixels() const { return mLineSpacingPixels; } // only for multiline
|
||||
|
||||
S32 getDocIndexFromLocalCoord( S32 local_x, S32 local_y, bool round, bool hit_past_end_of_line = true) const;
|
||||
LLRect getLocalRectFromDocIndex(S32 pos) const;
|
||||
|
|
@ -529,7 +528,7 @@ public:
|
|||
bool getReadOnly() const { return mReadOnly; }
|
||||
|
||||
void setSkipLinkUnderline(bool skip_link_underline) { mSkipLinkUnderline = skip_link_underline; }
|
||||
bool getSkipLinkUnderline() { return mSkipLinkUnderline; }
|
||||
bool getSkipLinkUnderline() const { return mSkipLinkUnderline; }
|
||||
|
||||
void setParseURLs(bool parse_urls) { mParseHTML = parse_urls; }
|
||||
|
||||
|
|
@ -539,15 +538,15 @@ public:
|
|||
// cursor manipulation
|
||||
bool setCursor(S32 row, S32 column);
|
||||
// [SL:KB] - Patch: UI-Notecards | Checked: 2010-09-12 (Catznip-2.1.2d) | Added: Catznip-2.1.2d
|
||||
S32 getCursorPos() { return mCursorPos; }
|
||||
S32 getCursorPos() const { return mCursorPos; }
|
||||
// [/SL:KB
|
||||
bool setCursorPos(S32 cursor_pos, bool keep_cursor_offset = false);
|
||||
virtual void startOfLine(); // <FS> Added virtual modifier
|
||||
void endOfLine();
|
||||
void startOfDoc();
|
||||
void endOfDoc();
|
||||
void changePage( S32 delta );
|
||||
void changeLine( S32 delta );
|
||||
void changePage(S32 delta);
|
||||
void changeLine(S32 delta);
|
||||
|
||||
bool scrolledToStart();
|
||||
bool scrolledToEnd();
|
||||
|
|
@ -572,9 +571,6 @@ public:
|
|||
void setWordWrap(bool wrap);
|
||||
LLScrollContainer* getScrollContainer() const { return mScroller; }
|
||||
|
||||
// <FS:Ansariel> Getter for line spacing (pixels)
|
||||
S32 getLineSpacingPixels() const { return mLineSpacingPixels; }
|
||||
|
||||
protected:
|
||||
// protected member variables
|
||||
// List of offsets and segment index of the start of each line. Always has at least one node (0).
|
||||
|
|
@ -722,7 +718,6 @@ protected:
|
|||
|
||||
void appendTextImpl(const std::string &new_text, const LLStyle::Params& input_params = LLStyle::Params());
|
||||
void appendAndHighlightTextImpl(const std::string &new_text, S32 highlight_part, const LLStyle::Params& style_params, bool underline_on_hover_only = false);
|
||||
S32 normalizeUri(std::string& uri);
|
||||
|
||||
protected:
|
||||
// virtual
|
||||
|
|
|
|||
|
|
@ -46,29 +46,29 @@ protected:
|
|||
friend class LLUICtrlFactory;
|
||||
|
||||
public:
|
||||
virtual ~LLTextBox();
|
||||
~LLTextBox() override;
|
||||
|
||||
/*virtual*/ bool handleMouseDown(S32 x, S32 y, MASK mask);
|
||||
/*virtual*/ bool handleMouseUp(S32 x, S32 y, MASK mask);
|
||||
/*virtual*/ bool handleHover(S32 x, S32 y, MASK mask);
|
||||
bool handleMouseDown(S32 x, S32 y, MASK mask) override;
|
||||
bool handleMouseUp(S32 x, S32 y, MASK mask) override;
|
||||
bool handleHover(S32 x, S32 y, MASK mask) override;
|
||||
|
||||
/*virtual*/ void setEnabled(bool enabled);
|
||||
void setEnabled(bool enabled) override;
|
||||
|
||||
/*virtual*/ void setText( const LLStringExplicit& text, const LLStyle::Params& input_params = LLStyle::Params() );
|
||||
void setText(const LLStringExplicit& text, const LLStyle::Params& input_params = LLStyle::Params()) override;
|
||||
|
||||
void setRightAlign() { mHAlign = LLFontGL::RIGHT; }
|
||||
void setHAlign( LLFontGL::HAlign align ) { mHAlign = align; }
|
||||
void setClickedCallback( boost::function<void (void*)> cb, void* userdata = NULL );
|
||||
void setRightAlign() { mHAlign = LLFontGL::RIGHT; }
|
||||
void setHAlign(LLFontGL::HAlign align) { mHAlign = align; }
|
||||
void setClickedCallback(boost::function<void(void*)> cb, void* userdata = NULL);
|
||||
|
||||
void reshapeToFitText(bool called_from_parent = false);
|
||||
void reshapeToFitText(bool called_from_parent = false);
|
||||
|
||||
S32 getTextPixelWidth();
|
||||
S32 getTextPixelHeight();
|
||||
S32 getTextPixelWidth();
|
||||
S32 getTextPixelHeight();
|
||||
|
||||
/*virtual*/ LLSD getValue() const;
|
||||
/*virtual*/ bool setTextArg( const std::string& key, const LLStringExplicit& text );
|
||||
LLSD getValue() const override;
|
||||
bool setTextArg(const std::string& key, const LLStringExplicit& text) override;
|
||||
|
||||
void setShowCursorHand(bool show_cursor) { mShowCursorHand = show_cursor; }
|
||||
void setShowCursorHand(bool show_cursor) { mShowCursorHand = show_cursor; }
|
||||
|
||||
// <COLOSI opensim multi-currency support>
|
||||
// Set all LLUIStrings to dirty after currency symbol change to force them to be updated.
|
||||
|
|
@ -76,14 +76,14 @@ public:
|
|||
// </COLOSI opensim multi-currency support>
|
||||
|
||||
protected:
|
||||
void onUrlLabelUpdated(const std::string &url, const std::string &label);
|
||||
void onUrlLabelUpdated(const std::string& url, const std::string& label);
|
||||
|
||||
LLUIString mText;
|
||||
callback_t mClickedCallback;
|
||||
bool mShowCursorHand;
|
||||
|
||||
protected:
|
||||
virtual std::string _getSearchText() const
|
||||
virtual std::string _getSearchText() const override
|
||||
{
|
||||
return LLTextBase::_getSearchText() + mText.getString();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -217,7 +217,6 @@ public:
|
|||
const LLUUID& getSourceID() const { return mSourceID; }
|
||||
|
||||
const LLTextSegmentPtr getPreviousSegment() const;
|
||||
const LLTextSegmentPtr getLastSegment() const;
|
||||
void getSelectedSegments(segment_vec_t& segments) const;
|
||||
|
||||
void setShowContextMenu(bool show) { mShowContextMenu = show; }
|
||||
|
|
@ -236,8 +235,6 @@ protected:
|
|||
// </FS:Ansariel>
|
||||
void drawPreeditMarker();
|
||||
|
||||
void assignEmbedded(const std::string &s);
|
||||
|
||||
void removeCharOrTab();
|
||||
|
||||
void indentSelectedLines( S32 spaces );
|
||||
|
|
@ -257,7 +254,6 @@ protected:
|
|||
|
||||
void autoIndent();
|
||||
|
||||
void findEmbeddedItemSegments(S32 start, S32 end);
|
||||
void getSegmentsInRange(segment_vec_t& segments, S32 start, S32 end, bool include_partial) const;
|
||||
|
||||
virtual llwchar pasteEmbeddedItem(llwchar ext_char) { return ext_char; }
|
||||
|
|
@ -326,7 +322,7 @@ private:
|
|||
// Methods
|
||||
//
|
||||
void pasteHelper(bool is_primary);
|
||||
void cleanStringForPaste(LLWString & clean_string);
|
||||
void cleanStringForPaste(LLWString& clean_string);
|
||||
void pasteTextWithLinebreaks(LLWString & clean_string);
|
||||
|
||||
void onKeyStroke();
|
||||
|
|
|
|||
|
|
@ -68,7 +68,7 @@ public:
|
|||
void reshape(S32 width, S32 height, bool called_from_parent = true);
|
||||
void setEnabled(bool enabled);
|
||||
void setCommandId(const LLCommandId& id) { mId = id; }
|
||||
LLCommandId getCommandId() { return mId; }
|
||||
LLCommandId getCommandId() const { return mId; }
|
||||
|
||||
void setStartDragCallback(tool_startdrag_callback_t cb) { mStartDragItemCallback = cb; }
|
||||
void setHandleDragCallback(tool_handledrag_callback_t cb) { mHandleDragItemCallback = cb; }
|
||||
|
|
@ -309,7 +309,7 @@ public:
|
|||
|
||||
// Methods used in loading and saving toolbar settings
|
||||
void setButtonType(LLToolBarEnums::ButtonType button_type);
|
||||
LLToolBarEnums::ButtonType getButtonType() { return mButtonType; }
|
||||
LLToolBarEnums::ButtonType getButtonType() const { return mButtonType; }
|
||||
command_id_list_t& getCommandsList() { return mButtonCommands; }
|
||||
void clearCommandsList();
|
||||
|
||||
|
|
|
|||
|
|
@ -390,22 +390,22 @@ void LLToolTip::draw()
|
|||
}
|
||||
}
|
||||
|
||||
bool LLToolTip::isFading()
|
||||
bool LLToolTip::isFading() const
|
||||
{
|
||||
return mFadeTimer.getStarted();
|
||||
}
|
||||
|
||||
F32 LLToolTip::getVisibleTime()
|
||||
F32 LLToolTip::getVisibleTime() const
|
||||
{
|
||||
return mVisibleTimer.getStarted() ? mVisibleTimer.getElapsedTimeF32() : 0.f;
|
||||
}
|
||||
|
||||
bool LLToolTip::hasClickCallback()
|
||||
bool LLToolTip::hasClickCallback() const
|
||||
{
|
||||
return mHasClickCallback;
|
||||
}
|
||||
|
||||
void LLToolTip::getToolTipMessage(std::string & message)
|
||||
void LLToolTip::getToolTipMessage(std::string& message) const
|
||||
{
|
||||
if (mTextBox)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -44,15 +44,15 @@ public:
|
|||
Params();
|
||||
};
|
||||
LLToolTipView(const LLToolTipView::Params&);
|
||||
/*virtual*/ bool handleHover(S32 x, S32 y, MASK mask);
|
||||
/*virtual*/ bool handleMouseDown(S32 x, S32 y, MASK mask);
|
||||
/*virtual*/ bool handleMiddleMouseDown(S32 x, S32 y, MASK mask);
|
||||
/*virtual*/ bool handleRightMouseDown(S32 x, S32 y, MASK mask);
|
||||
/*virtual*/ bool handleScrollWheel( S32 x, S32 y, S32 clicks );
|
||||
bool handleHover(S32 x, S32 y, MASK mask) override;
|
||||
bool handleMouseDown(S32 x, S32 y, MASK mask) override;
|
||||
bool handleMiddleMouseDown(S32 x, S32 y, MASK mask) override;
|
||||
bool handleRightMouseDown(S32 x, S32 y, MASK mask) override;
|
||||
bool handleScrollWheel( S32 x, S32 y, S32 clicks ) override;
|
||||
|
||||
void drawStickyRect();
|
||||
|
||||
/*virtual*/ void draw();
|
||||
void draw() override;
|
||||
};
|
||||
|
||||
class LLToolTip : public LLPanel
|
||||
|
|
@ -98,20 +98,20 @@ public:
|
|||
|
||||
Params();
|
||||
};
|
||||
/*virtual*/ void draw();
|
||||
/*virtual*/ bool handleHover(S32 x, S32 y, MASK mask);
|
||||
/*virtual*/ void onMouseLeave(S32 x, S32 y, MASK mask);
|
||||
/*virtual*/ void setVisible(bool visible);
|
||||
void draw() override;
|
||||
bool handleHover(S32 x, S32 y, MASK mask) override;
|
||||
void onMouseLeave(S32 x, S32 y, MASK mask) override;
|
||||
void setVisible(bool visible) override;
|
||||
|
||||
bool isFading();
|
||||
F32 getVisibleTime();
|
||||
bool hasClickCallback();
|
||||
bool isFading() const;
|
||||
F32 getVisibleTime() const;
|
||||
bool hasClickCallback() const;
|
||||
|
||||
LLToolTip(const Params& p);
|
||||
virtual void initFromParams(const LLToolTip::Params& params);
|
||||
|
||||
void getToolTipMessage(std::string & message);
|
||||
bool isTooltipPastable() { return mIsTooltipPastable; }
|
||||
void getToolTipMessage(std::string & message) const;
|
||||
bool isTooltipPastable() const { return mIsTooltipPastable; }
|
||||
|
||||
protected:
|
||||
void updateTextBox();
|
||||
|
|
|
|||
|
|
@ -160,7 +160,7 @@ public:
|
|||
sanitizeRange();
|
||||
}
|
||||
|
||||
S32 clamp(S32 input)
|
||||
S32 clamp(S32 input) const
|
||||
{
|
||||
if (input < mMin) return mMin;
|
||||
if (input > mMax) return mMax;
|
||||
|
|
@ -174,8 +174,8 @@ public:
|
|||
sanitizeRange();
|
||||
}
|
||||
|
||||
S32 getMin() { return mMin; }
|
||||
S32 getMax() { return mMax; }
|
||||
S32 getMin() const { return mMin; }
|
||||
S32 getMax() const { return mMax; }
|
||||
|
||||
bool operator==(const RangeS32& other) const
|
||||
{
|
||||
|
|
@ -229,7 +229,7 @@ public:
|
|||
mValue = clamp(value);
|
||||
}
|
||||
|
||||
S32 get()
|
||||
S32 get() const
|
||||
{
|
||||
return mValue;
|
||||
}
|
||||
|
|
@ -262,7 +262,7 @@ public:
|
|||
static std::string getLanguage(); // static for lldateutil_test compatibility
|
||||
|
||||
//helper functions (should probably move free standing rendering helper functions here)
|
||||
LLView* getRootView() { return mRootView; }
|
||||
LLView* getRootView() const { return mRootView; }
|
||||
void setRootView(LLView* view) { mRootView = view; }
|
||||
/**
|
||||
* Walk the LLView tree to resolve a path
|
||||
|
|
@ -305,7 +305,7 @@ public:
|
|||
LLControlGroup& getControlControlGroup (std::string_view controlname);
|
||||
F32 getMouseIdleTime() { return mMouseIdleTimer.getElapsedTimeF32(); }
|
||||
void resetMouseIdleTimer() { mMouseIdleTimer.reset(); }
|
||||
LLWindow* getWindow() { return mWindow; }
|
||||
LLWindow* getWindow() const { return mWindow; }
|
||||
|
||||
void addPopup(LLView*);
|
||||
void removePopup(LLView*);
|
||||
|
|
|
|||
|
|
@ -28,23 +28,23 @@
|
|||
#define LL_LLUICONSTANTS_H
|
||||
|
||||
// spacing for small font lines of text, like LLTextBoxes
|
||||
const S32 LINE = 16;
|
||||
constexpr S32 LINE = 16;
|
||||
|
||||
// spacing for larger lines of text
|
||||
const S32 LINE_BIG = 24;
|
||||
constexpr S32 LINE_BIG = 24;
|
||||
|
||||
// default vertical padding
|
||||
const S32 VPAD = 4;
|
||||
constexpr S32 VPAD = 4;
|
||||
|
||||
// default horizontal padding
|
||||
const S32 HPAD = 4;
|
||||
constexpr S32 HPAD = 4;
|
||||
|
||||
// Account History, how far to look into past
|
||||
const S32 SUMMARY_INTERVAL = 7; // one week
|
||||
const S32 SUMMARY_MAX = 8; //
|
||||
const S32 DETAILS_INTERVAL = 1; // one day
|
||||
const S32 DETAILS_MAX = 30; // one month
|
||||
const S32 TRANSACTIONS_INTERVAL = 1;// one day
|
||||
const S32 TRANSACTIONS_MAX = 30; // one month
|
||||
constexpr S32 SUMMARY_INTERVAL = 7; // one week
|
||||
constexpr S32 SUMMARY_MAX = 8; //
|
||||
constexpr S32 DETAILS_INTERVAL = 1; // one day
|
||||
constexpr S32 DETAILS_MAX = 30; // one month
|
||||
constexpr S32 TRANSACTIONS_INTERVAL = 1;// one day
|
||||
constexpr S32 TRANSACTIONS_MAX = 30; // one month
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -39,9 +39,9 @@
|
|||
#include "llviewmodel.h" // *TODO move dependency to .cpp file
|
||||
#include "llsearchablecontrol.h"
|
||||
|
||||
const bool TAKE_FOCUS_YES = true;
|
||||
const bool TAKE_FOCUS_NO = false;
|
||||
const S32 DROP_SHADOW_FLOATER = 5;
|
||||
constexpr bool TAKE_FOCUS_YES = true;
|
||||
constexpr bool TAKE_FOCUS_NO = false;
|
||||
constexpr S32 DROP_SHADOW_FLOATER = 5;
|
||||
|
||||
class LLUICtrl
|
||||
: public LLView, public boost::signals2::trackable
|
||||
|
|
|
|||
|
|
@ -184,7 +184,7 @@ fail:
|
|||
template<class T>
|
||||
static T* getDefaultWidget(std::string_view name)
|
||||
{
|
||||
typename T::Params widget_params;
|
||||
typename T::Params widget_params{};
|
||||
widget_params.name = std::string(name);
|
||||
return create<T>(widget_params);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ public:
|
|||
LLUndoAction(): mClusterID(0) {};
|
||||
virtual ~LLUndoAction(){};
|
||||
private:
|
||||
S32 mClusterID;
|
||||
S32 mClusterID;
|
||||
};
|
||||
|
||||
LLUndoBuffer( LLUndoAction (*create_func()), S32 initial_count );
|
||||
|
|
@ -51,8 +51,8 @@ public:
|
|||
LLUndoAction *getNextAction(bool setClusterBegin = true);
|
||||
bool undoAction();
|
||||
bool redoAction();
|
||||
bool canUndo() { return (mNextAction != mFirstAction); }
|
||||
bool canRedo() { return (mNextAction != mLastAction); }
|
||||
bool canUndo() const { return (mNextAction != mFirstAction); }
|
||||
bool canRedo() const { return (mNextAction != mLastAction); }
|
||||
|
||||
void flushActions();
|
||||
|
||||
|
|
|
|||
|
|
@ -45,8 +45,6 @@
|
|||
class LLUrlAction
|
||||
{
|
||||
public:
|
||||
LLUrlAction();
|
||||
|
||||
/// load a Url in the user's preferred web browser
|
||||
static void openURL(std::string url);
|
||||
|
||||
|
|
|
|||
|
|
@ -1249,7 +1249,7 @@ void LLUrlEntryParcel::processParcelInfo(const LLParcelData& parcel_data)
|
|||
//
|
||||
LLUrlEntryPlace::LLUrlEntryPlace()
|
||||
{
|
||||
mPattern = boost::regex("((hop://[-\\w\\.\\:\\@]+/)|((x-grid-location-info://[-\\w\\.]+/region/)|(secondlife://)))\\S+/?(\\d+/\\d+/\\d+|\\d+/\\d+)/?", // <AW: hop:// protocol>
|
||||
mPattern = boost::regex("((hop://[-\\w\\.\\:\\@]+/)|((x-grid-location-info://[-\\w\\.]+/region/)|(secondlife://)))\\S+(?:/?(-?\\d+/-?\\d+/-?\\d+|-?\\d+/-?\\d+)/?)?", // <AW: hop:// protocol>
|
||||
boost::regex::perl|boost::regex::icase);
|
||||
mMenuName = "menu_url_slurl.xml";
|
||||
mTooltip = LLTrans::getString("TooltipSLURL");
|
||||
|
|
|
|||
|
|
@ -31,7 +31,6 @@
|
|||
//#include "linden_common.h"
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include "llstyle.h"
|
||||
|
||||
///
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue