diff --git a/VisualizationModules/LibCore/CMakeLists.txt b/VisualizationModules/LibCore/CMakeLists.txt index 080f4c674d..6acce2eec9 100644 --- a/VisualizationModules/LibCore/CMakeLists.txt +++ b/VisualizationModules/LibCore/CMakeLists.txt @@ -34,6 +34,8 @@ cvfMatrix4.inl cvfObject.h cvfObject.inl cvfPlane.h +cvfPropertySet.h +cvfPropertySetCollection.h cvfQuat.h cvfQuat.inl cvfRect.h @@ -44,6 +46,7 @@ cvfTBBControl.h cvfTimer.h cvfTrace.h cvfValueArray.h +cvfVariant.h cvfVector2.h cvfVector2.inl cvfVector3.h @@ -64,11 +67,14 @@ cvfLogger.cpp cvfMath.cpp cvfObject.cpp cvfPlane.cpp +cvfPropertySet.cpp +cvfPropertySetCollection.cpp cvfString.cpp cvfSystem.cpp cvfTimer.cpp cvfTBBControl.cpp cvfTrace.cpp +cvfVariant.cpp cvfVector2.cpp cvfVector3.cpp cvfVector4.cpp diff --git a/VisualizationModules/LibCore/cvfAssert.cpp b/VisualizationModules/LibCore/cvfAssert.cpp index 864bd7b0cd..272c2ab8ef 100644 --- a/VisualizationModules/LibCore/cvfAssert.cpp +++ b/VisualizationModules/LibCore/cvfAssert.cpp @@ -95,7 +95,11 @@ Assert::FailAction AssertHandlerConsole::handleAssert(const char* fileName, int // Does the job on both Windows and Linux (creates a console on Windows if one doesn't exist) reportToConsole(fileName, lineNumber, expr, msg); +#ifdef WIN32 + __debugbreak(); +#else abort(); +#endif // Shouldn't really matter since we always abort return Assert::CONTINUE; diff --git a/VisualizationModules/LibCore/cvfColor3.cpp b/VisualizationModules/LibCore/cvfColor3.cpp index 6bfce28c2e..d1e606cf2a 100644 --- a/VisualizationModules/LibCore/cvfColor3.cpp +++ b/VisualizationModules/LibCore/cvfColor3.cpp @@ -388,6 +388,7 @@ Color3ub::Color3ub(ColorIdent colorIdent) case SKY_BLUE: set(135, 206, 235); break; case VIOLET: set(238, 130, 238); break; case YELLOW_GREEN: set(154, 205, 50); break; + case CEETRON: set( 81, 134, 148); break; default: CVF_FAIL_MSG("Unknown ColorIdent"); } diff --git a/VisualizationModules/LibCore/cvfColor3.h b/VisualizationModules/LibCore/cvfColor3.h index 66b1ca27c8..0b6e894e2f 100644 --- a/VisualizationModules/LibCore/cvfColor3.h +++ b/VisualizationModules/LibCore/cvfColor3.h @@ -73,7 +73,9 @@ public: SEA_GREEN, ///< Sea green (46, 139, 87) SKY_BLUE, ///< Sky blue (135, 206, 235) VIOLET, ///< Violet (238, 130, 238) - YELLOW_GREEN ///< Yellow green (154, 205, 50) + YELLOW_GREEN, ///< Yellow green (154, 205, 50) + + CEETRON ///< Ceetron Color (81, 134, 148) }; }; diff --git a/VisualizationModules/LibCore/cvfPropertySet.cpp b/VisualizationModules/LibCore/cvfPropertySet.cpp new file mode 100644 index 0000000000..dac0d3feb1 --- /dev/null +++ b/VisualizationModules/LibCore/cvfPropertySet.cpp @@ -0,0 +1,161 @@ +//################################################################################################## +// +// Custom Visualization Core library +// Copyright (C) 2011-2012 Ceetron AS +// +// This library is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. +// +// See the GNU General Public License at <> +// for more details. +// +//################################################################################################## + +#include "cvfBase.h" +#include "cvfPropertySet.h" + +namespace cvf { + + +//================================================================================================== +/// +/// \class cvf::PropertySet +/// \ingroup Core +/// +/// +/// +//================================================================================================== + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +PropertySet::PropertySet(const String& classType) + : m_classType(classType) +{ +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +PropertySet::~PropertySet() +{ +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +bool PropertySet::operator==(const PropertySet& rhs) const +{ + if (m_classType == rhs.m_classType) + { + return (m_propMap == rhs.m_propMap); + } + + return false; +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +String PropertySet::classType() const +{ + return m_classType; +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +bool PropertySet::isEmpty() const +{ + return m_propMap.empty(); +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +Variant PropertySet::value(const String& key) const +{ + std::map::const_iterator it = m_propMap.find(key); + if (it != m_propMap.end()) + { + return it->second; + } + else + { + return Variant(); + } +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +void PropertySet::setValue(const String& key, const Variant& data) +{ + m_propMap[key] = data; +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +bool PropertySet::contains(const String& key) const +{ + if (m_propMap.find(key) != m_propMap.end()) + { + return true; + } + else + { + return false; + } + +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +std::vector PropertySet::allKeys() const +{ + std::vector all; + std::map::const_iterator it; + for (it = m_propMap.begin(); it != m_propMap.end(); ++it) + { + all.push_back(it->first); + } + + return all; +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +std::vector PropertySet::allValues() const +{ + std::vector all; + std::map::const_iterator it; + for (it = m_propMap.begin(); it != m_propMap.end(); ++it) + { + all.push_back(it->second); + } + + return all; +} + + + + +} // namespace gc diff --git a/VisualizationModules/LibCore/cvfPropertySet.h b/VisualizationModules/LibCore/cvfPropertySet.h new file mode 100644 index 0000000000..cf2f0969df --- /dev/null +++ b/VisualizationModules/LibCore/cvfPropertySet.h @@ -0,0 +1,60 @@ +//################################################################################################## +// +// Custom Visualization Core library +// Copyright (C) 2011-2012 Ceetron AS +// +// This library is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. +// +// See the GNU General Public License at <> +// for more details. +// +//################################################################################################## + +#pragma once + +#include "cvfObject.h" +#include "cvfVariant.h" +#include "cvfString.h" + +#include + +namespace cvf { + + +//================================================================================================== +// +// +// +//================================================================================================== +class PropertySet : public Object +{ +public: + PropertySet(const String& classType); + ~PropertySet(); + + bool operator==(const PropertySet& rhs) const; + + String classType() const; + bool isEmpty() const; + + Variant value(const String& key) const; + void setValue(const String& key, const Variant& data); + bool contains(const String& key) const; + + std::vector allKeys() const; + std::vector allValues() const; + +private: + String m_classType; + std::map m_propMap; +}; + + +} // namespace cvf diff --git a/VisualizationModules/LibCore/cvfPropertySetCollection.cpp b/VisualizationModules/LibCore/cvfPropertySetCollection.cpp new file mode 100644 index 0000000000..f751d2170a --- /dev/null +++ b/VisualizationModules/LibCore/cvfPropertySetCollection.cpp @@ -0,0 +1,157 @@ +//################################################################################################## +// +// Custom Visualization Core library +// Copyright (C) 2011-2012 Ceetron AS +// +// This library is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. +// +// See the GNU General Public License at <> +// for more details. +// +//################################################################################################## + +#include "cvfBase.h" +#include "cvfPropertySetCollection.h" + +namespace cvf { + + + +//================================================================================================== +/// +/// \class cvf::PropertySetCollection +/// \ingroup Core +/// +/// +/// +//================================================================================================== + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +PropertySetCollection::PropertySetCollection() +{ +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +PropertySetCollection::~PropertySetCollection() +{ +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +size_t PropertySetCollection::count() const +{ + return m_propertySets.size(); +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +PropertySet* PropertySetCollection::propertySet(size_t index) +{ + CVF_ASSERT(index < m_propertySets.size()); + return m_propertySets.at(index); +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +const PropertySet* PropertySetCollection::propertySet(size_t index) const +{ + CVF_ASSERT(index < m_propertySets.size()); + return m_propertySets.at(index); +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +void PropertySetCollection::addPropertySet(PropertySet* propertySet) +{ + CVF_ASSERT(propertySet); + m_propertySets.push_back(propertySet); +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +size_t PropertySetCollection::countOfType(const String& classType) const +{ + size_t classCount = 0; + const size_t totNumSets = m_propertySets.size(); + for (size_t i = 0; i < totNumSets; i++) + { + const PropertySet* ps = m_propertySets.at(i); + if (ps->classType() == classType) + { + classCount++; + } + } + + return classCount; +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +PropertySet* PropertySetCollection::propertySetOfType(const String& classType, size_t index) +{ + size_t classCount = 0; + const size_t totNumSets = m_propertySets.size(); + for (size_t i = 0; i < totNumSets; i++) + { + PropertySet* ps = m_propertySets.at(i); + if (ps->classType() == classType) + { + if (classCount == index) + { + return ps; + } + + classCount++; + } + } + + CVF_FAIL_MSG("Specified index is of of range"); + + return NULL; +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +PropertySet* PropertySetCollection::firstPropertySetOfType(const String& classType) +{ + const size_t totNumSets = m_propertySets.size(); + for (size_t i = 0; i < totNumSets; i++) + { + PropertySet* ps = m_propertySets.at(i); + if (ps->classType() == classType) + { + return ps; + } + } + + return NULL; +} + + +} // namespace gc diff --git a/VisualizationModules/LibCore/cvfPropertySetCollection.h b/VisualizationModules/LibCore/cvfPropertySetCollection.h new file mode 100644 index 0000000000..2b8b628aea --- /dev/null +++ b/VisualizationModules/LibCore/cvfPropertySetCollection.h @@ -0,0 +1,56 @@ +//################################################################################################## +// +// Custom Visualization Core library +// Copyright (C) 2011-2012 Ceetron AS +// +// This library is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. +// +// See the GNU General Public License at <> +// for more details. +// +//################################################################################################## + +#pragma once + +#include "cvfObject.h" +#include "cvfPropertySet.h" +#include "cvfCollection.h" + +#include + +namespace cvf { + + +//================================================================================================== +// +// +// +//================================================================================================== +class PropertySetCollection : public Object +{ +public: + PropertySetCollection(); + ~PropertySetCollection(); + + size_t count() const; + PropertySet* propertySet(size_t index); + const PropertySet* propertySet(size_t index) const; + void addPropertySet(PropertySet* propertySet); + + size_t countOfType(const String& classType) const; + PropertySet* propertySetOfType(const String& classType, size_t index); + PropertySet* firstPropertySetOfType(const String& classType); + +private: + Collection m_propertySets; +}; + + +} // namespace cvf diff --git a/VisualizationModules/LibCore/cvfString.cpp b/VisualizationModules/LibCore/cvfString.cpp index 22c9142313..9e9b6754b8 100644 --- a/VisualizationModules/LibCore/cvfString.cpp +++ b/VisualizationModules/LibCore/cvfString.cpp @@ -23,11 +23,12 @@ #include "cvfMath.h" #include - #include #include #include #include +#include +#include namespace cvf { @@ -682,28 +683,14 @@ String String::fromUtf8(const char* utfStr) //-------------------------------------------------------------------------------------------------- -/// +/// Returns a null-terminated sequence of wchar_t characters //-------------------------------------------------------------------------------------------------- -const wchar_t* String::ptr() const +const wchar_t* String::c_str() const { return m_string.c_str(); } -//-------------------------------------------------------------------------------------------------- -/// -//-------------------------------------------------------------------------------------------------- -wchar_t* String::ptr() -{ - if (m_string.size() < 1) - { - return NULL; - } - - return &(m_string[0]); -} - - //-------------------------------------------------------------------------------------------------- /// Convert the given number to a string with the specified format /// @@ -738,16 +725,25 @@ String String::number(float n, char format, int precision) //-------------------------------------------------------------------------------------------------- double String::toDouble(bool* ok) const { - wchar_t* endPtr; + double val = 0; + std::wstringstream stream(m_string); + stream >> val; - double val = wcstod(ptr(), &endPtr); + bool convertOk = !stream.fail(); if (ok) { - *ok = (endPtr != ptr()); + *ok = convertOk; } - return val; + if (convertOk) + { + return val; + } + else + { + return 0; + } } @@ -761,16 +757,16 @@ double String::toDouble(bool* ok) const //-------------------------------------------------------------------------------------------------- double String::toDouble(double defaultValue) const { - wchar_t* endPtr; - - double val = wcstod(ptr(), &endPtr); - - if (endPtr == ptr()) + bool ok = false; + double val = toDouble(&ok); + if (ok) { - val = defaultValue; + return val; + } + else + { + return defaultValue; } - - return val; } @@ -783,16 +779,25 @@ double String::toDouble(double defaultValue) const //-------------------------------------------------------------------------------------------------- float String::toFloat(bool* ok) const { - wchar_t* endPtr; + float val = 0; + std::wstringstream stream(m_string); + stream >> val; - double val = wcstod(ptr(), &endPtr); + bool convertOk = !stream.fail(); if (ok) { - *ok = (endPtr != ptr()); + *ok = convertOk; } - return static_cast(val); + if (convertOk) + { + return val; + } + else + { + return 0; + } } @@ -806,16 +811,16 @@ float String::toFloat(bool* ok) const //-------------------------------------------------------------------------------------------------- float String::toFloat(float defaultValue) const { - wchar_t* endPtr; - - double val = wcstod(ptr(), &endPtr); - - if (endPtr == ptr()) + bool ok = false; + float val = toFloat(&ok); + if (ok) { - val = defaultValue; + return val; + } + else + { + return defaultValue; } - - return static_cast(val); } @@ -828,16 +833,25 @@ float String::toFloat(float defaultValue) const //-------------------------------------------------------------------------------------------------- int String::toInt(bool* ok) const { - wchar_t* endPtr; + int val = 0; + std::wstringstream stream(m_string); + stream >> val; - long val = wcstol(ptr(), &endPtr, 10); + bool convertOk = !stream.fail(); if (ok) { - *ok = (endPtr != ptr()); + *ok = convertOk; } - return static_cast(val); + if (convertOk) + { + return val; + } + else + { + return 0; + } } @@ -851,16 +865,121 @@ int String::toInt(bool* ok) const //-------------------------------------------------------------------------------------------------- int String::toInt(int defaultValue) const { - wchar_t* endPtr; - - long val = wcstol(ptr(), &endPtr, 10); - - if (endPtr == ptr()) + bool ok = false; + int val = toInt(&ok); + if (ok) { - val = static_cast(defaultValue); + return val; + } + else + { + return defaultValue; + } +} + + +//-------------------------------------------------------------------------------------------------- +/// Convert the contents of the string to an unsigned integer value +/// +/// \param ok If not NULL, this will be set to true if conversion is ok, or to false if not +/// +/// \return Returns the unsigned integer value found at the start of the string. 0 if an error occurred. +//-------------------------------------------------------------------------------------------------- +uint String::toUInt(bool* ok) const +{ + // The functions in the standard library does not honor unsignedness but gladly converts a negative integer + // to an unsigned integer, so use our int64 implementation instead + bool convertOk = false; + int64 val = toInt64(&convertOk); + if (convertOk) + { + if (val > std::numeric_limits::max() || val < 0) + { + convertOk = false; + } } - return static_cast(val); + if (ok) + { + *ok = convertOk; + } + + if (convertOk) + { + return static_cast(val); + } + else + { + return 0; + } +} + + +//-------------------------------------------------------------------------------------------------- +/// Convert the contents of the string to an unsigned integer value +/// +/// \param defaultValue The value returned if the conversion failed. +/// +/// \return Returns the value found at the start of the string or defaultValue if the +/// conversion was not possible. +//-------------------------------------------------------------------------------------------------- +uint String::toUInt(uint defaultValue) const +{ + bool ok = false; + uint val = toUInt(&ok); + if (ok) + { + return val; + } + else + { + return defaultValue; + } +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +int64 String::toInt64(bool* ok) const +{ + int64 val = 0; + std::wstringstream stream(m_string); + stream >> val; + + bool convertOk = !stream.fail(); + + if (ok) + { + *ok = convertOk; + } + + if (convertOk) + { + return val; + } + else + { + return 0; + } +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +int64 String::toInt64(int64 defaultValue) const +{ + bool ok = false; + int64 val = toInt64(&ok); + if (ok) + { + return val; + } + else + { + return defaultValue; + } } @@ -1012,7 +1131,7 @@ struct ArgInfo //-------------------------------------------------------------------------------------------------- static ArgInfo findSmallestArgs(const String &s) { - const wchar_t* strBegin = s.ptr(); + const wchar_t* strBegin = s.c_str(); const wchar_t* strEnd = strBegin + s.size(); ArgInfo argInfo; @@ -1083,17 +1202,16 @@ static ArgInfo findSmallestArgs(const String &s) //-------------------------------------------------------------------------------------------------- static String replaceArgs(const String &s, const ArgInfo& info, int fieldWidth, const String& arg, const wchar_t& fillChar) { - const wchar_t* strBegin = s.ptr(); + const wchar_t* strBegin = s.c_str(); const wchar_t* strEnd = strBegin + s.size(); unsigned int absFieldWidth = static_cast(Math::abs(fieldWidth)); size_t resultLength = s.size() - info.totalArgLength + info.smallestArgCount*CVF_MAX(absFieldWidth, arg.size()); - String result; - result.resize(resultLength); - - wchar_t* resultBuffer = result.ptr(); - wchar_t* rc = resultBuffer; + std::wstring resultString; + resultString.resize(resultLength); + wchar_t* resultBuffer = &resultString[0]; + wchar_t* rc = resultBuffer; const wchar_t* c = strBegin; int repl_cnt = 0; @@ -1143,7 +1261,7 @@ static String replaceArgs(const String &s, const ArgInfo& info, int fieldWidth, } } - memcpy(rc, arg.ptr(), arg.size()*sizeof(wchar_t)); + memcpy(rc, arg.c_str(), arg.size()*sizeof(wchar_t)); rc += arg.size(); if (fieldWidth < 0) @@ -1168,7 +1286,7 @@ static String replaceArgs(const String &s, const ArgInfo& info, int fieldWidth, CVF_ASSERT(rc == resultBuffer + resultLength); - return result; + return String(resultString); } @@ -1389,5 +1507,6 @@ void String::swap(String& other) m_string.swap(other.m_string); } + } // namespace cvf diff --git a/VisualizationModules/LibCore/cvfString.h b/VisualizationModules/LibCore/cvfString.h index 8d8922de74..7a0d45e0b0 100644 --- a/VisualizationModules/LibCore/cvfString.h +++ b/VisualizationModules/LibCore/cvfString.h @@ -72,6 +72,7 @@ public: String subString(size_t start, size_t length = npos) const; void replace(const String& before, const String& after); + const wchar_t* c_str() const; CharArray toAscii() const; // Useful when you need a const char* pointer. std::string toStdString() const; std::wstring toStdWString() const; @@ -83,9 +84,6 @@ public: size_t size() const; void resize(size_t size); - const wchar_t* ptr() const; - wchar_t* ptr(); - static String number(float n, char format = 'g', int precision = -1); static String number(double n, char format = 'g', int precision = -1); @@ -95,6 +93,10 @@ public: float toFloat(float defaultValue) const; int toInt(bool* ok = NULL) const; int toInt(int defaultValue) const; + uint toUInt(bool* ok = NULL) const; + uint toUInt(uint defaultValue) const; + int64 toInt64(bool* ok = NULL) const; + int64 toInt64(int64 defaultValue) const; String arg(const String& a, int fieldWidth = 0, const wchar_t& fillChar = ' ') const; String arg(char a, int fieldWidth = 0, const wchar_t& fillChar = ' ') const; diff --git a/VisualizationModules/LibCore/cvfTrace.h b/VisualizationModules/LibCore/cvfTrace.h index 31f2dc262b..1d6fa9877b 100644 --- a/VisualizationModules/LibCore/cvfTrace.h +++ b/VisualizationModules/LibCore/cvfTrace.h @@ -40,7 +40,10 @@ private: static void showTraceOutput(String text, bool addNewLine); }; -#define CVF_TRACE_FILELINE Trace::showFileLineNumber(__FILE__, __LINE__, ""); -#define CVF_TRACE_FILELINE_MSG(message) Trace::showFileLineNumber(__FILE__, __LINE__, message); -} +}// namespace cvf + + +#define CVF_TRACE_FILELINE cvf::Trace::showFileLineNumber(__FILE__, __LINE__, ""); +#define CVF_TRACE_FILELINE_MSG(message) cvf::Trace::showFileLineNumber(__FILE__, __LINE__, message); + diff --git a/VisualizationModules/LibCore/cvfVariant.cpp b/VisualizationModules/LibCore/cvfVariant.cpp new file mode 100644 index 0000000000..971e3df03f --- /dev/null +++ b/VisualizationModules/LibCore/cvfVariant.cpp @@ -0,0 +1,434 @@ +//################################################################################################## +// +// Custom Visualization Core library +// Copyright (C) 2011-2012 Ceetron AS +// +// This library is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. +// +// See the GNU General Public License at <> +// for more details. +// +//################################################################################################## + +#include "cvfBase.h" +#include "cvfVariant.h" + +namespace cvf { + + +//================================================================================================== +/// +/// \class cvf::Variant +/// \ingroup Core +/// +/// +/// +//================================================================================================== + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +Variant::Variant() +: m_type(INVALID) +{ +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +Variant::Variant(const Variant& other) +: m_type(other.m_type), + m_data(other.m_data), + m_arrayData(other.m_arrayData) +{ +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +Variant::~Variant() +{ +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +Variant& Variant::operator=(Variant rhs) +{ + // Copy-and-swap (copy already done since parameter is passed by value) + rhs.swap(*this); + return *this; +} + + +//-------------------------------------------------------------------------------------------------- +/// Compares two variants and returns true if they are equal +//-------------------------------------------------------------------------------------------------- +bool Variant::operator==(const Variant& rhs) const +{ + if (m_type != rhs.m_type) + { + return false; + } + + switch (m_type) + { + case INVALID: return true; + case INT: return getInt() == rhs.getInt(); + case UINT: return getUInt() == rhs.getUInt(); + case DOUBLE: return getDouble() == rhs.getDouble(); + case FLOAT: return getFloat() == rhs.getFloat(); + case BOOL: return getBool() == rhs.getBool(); + case VEC3D: return getVec3d() == rhs.getVec3d(); + case COLOR3F: return getColor3f() == rhs.getColor3f(); + case STRING: return getString() == rhs.getString(); + case ARRAY: return getArray() == rhs.getArray(); + } + + CVF_FAIL_MSG("Unhandled variant type"); + return false; +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +Variant::Type Variant::type() const +{ + return m_type; +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +bool Variant::isValid() const +{ + return (m_type != INVALID); +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +Variant::Variant(int val) +: m_type(INT) +{ + assignData(&val, sizeof(val)); +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +int Variant::getInt() const +{ + CVF_ASSERT(m_type == INT); + CVF_ASSERT(m_data.size() == sizeof(int)); + const ubyte* rawPtr = m_data.empty() ? 0 : &m_data.front(); + if (rawPtr) + { + const int* valPtr = reinterpret_cast(rawPtr); + return *valPtr; + } + else + { + return 0; + } +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +Variant::Variant(uint val) +: m_type(UINT) +{ + assignData(&val, sizeof(val)); +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +uint Variant::getUInt() const +{ + CVF_ASSERT(m_type == UINT); + CVF_ASSERT(m_data.size() == sizeof(uint)); + const ubyte* rawPtr = m_data.empty() ? 0 : &m_data.front(); + if (rawPtr) + { + const uint* valPtr = reinterpret_cast(rawPtr); + return *valPtr; + } + else + { + return 0; + } +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +Variant::Variant(double val) +: m_type(DOUBLE) +{ + assignData(&val, sizeof(val)); +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +double Variant::getDouble() const +{ + CVF_ASSERT(m_type == DOUBLE); + CVF_ASSERT(m_data.size() == sizeof(double)); + const ubyte* rawPtr = m_data.empty() ? 0 : &m_data.front(); + if (rawPtr) + { + const double* valPtr = reinterpret_cast(rawPtr); + return *valPtr; + } + else + { + return 0; + } +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +Variant::Variant(float val) +: m_type(FLOAT) +{ + assignData(&val, sizeof(val)); +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +float Variant::getFloat() const +{ + CVF_ASSERT(m_type == FLOAT); + CVF_ASSERT(m_data.size() == sizeof(float)); + const ubyte* rawPtr = m_data.empty() ? 0 : &m_data.front(); + if (rawPtr) + { + const float* valPtr = reinterpret_cast(rawPtr); + return *valPtr; + } + else + { + return 0; + } +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +Variant::Variant(bool val) +: m_type(BOOL) +{ + ubyte tmpVal = val ? 1u : 0; + assignData(&tmpVal, 1); +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +bool Variant::getBool() const +{ + CVF_ASSERT(m_type == BOOL); + CVF_ASSERT(m_data.size() == 1); + const ubyte* rawPtr = m_data.empty() ? 0 : &m_data.front(); + if (rawPtr) + { + if (*rawPtr == 1u) + { + return true; + } + else + { + return false; + } + } + else + { + return false; + } + +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +Variant::Variant(const Vec3d& val) +: m_type(VEC3D) +{ + assignData(val.ptr(), 3*sizeof(double)); +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +Vec3d Variant::getVec3d() const +{ + CVF_ASSERT(m_type == VEC3D); + CVF_ASSERT(m_data.size() == 3*sizeof(double)); + const ubyte* rawPtr = m_data.empty() ? 0 : &m_data.front(); + if (rawPtr) + { + const double* valPtr = reinterpret_cast(rawPtr); + return Vec3d(valPtr[0], valPtr[1], valPtr[2]); + } + else + { + return Vec3d(0, 0, 0); + } +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +Variant::Variant(const Color3f& val) +: m_type(COLOR3F) +{ + assignData(val.ptr(), 3*sizeof(float)); +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +Color3f Variant::getColor3f() const +{ + CVF_ASSERT(m_type == COLOR3F); + CVF_ASSERT(m_data.size() == 3*sizeof(float)); + const ubyte* rawPtr = m_data.empty() ? 0 : &m_data.front(); + if (rawPtr) + { + const float* valPtr = reinterpret_cast(rawPtr); + return Color3f(valPtr[0], valPtr[1], valPtr[2]); + } + else + { + return Color3f(0, 0, 0); + } +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +Variant::Variant(const String& val) +: m_type(STRING) +{ + size_t strSize = val.size(); + if (strSize > 0) + { + assignData(val.c_str(), strSize*sizeof(wchar_t)); + } +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +Variant::Variant(const char* val) +: m_type(STRING) +{ + String strVal(val); + size_t strSize = strVal.size(); + if (strSize > 0) + { + assignData(strVal.c_str(), strSize*sizeof(wchar_t)); + } +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +Variant::Variant(const std::vector& arr) +: m_type(ARRAY), + m_arrayData(arr) +{ +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +std::vector Variant::getArray() const +{ + CVF_ASSERT(m_type == ARRAY); + return m_arrayData; +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +String Variant::getString() const +{ + CVF_ASSERT(m_type == STRING); + + // Array must contain at least one wchar_t + const ubyte* rawPtr = m_data.empty() ? 0 : &m_data.front(); + const size_t numWideCars = m_data.size()/sizeof(wchar_t); + if (rawPtr && numWideCars > 0) + { + const wchar_t* valPtr = reinterpret_cast(rawPtr); + std::wstring tmpWideString(valPtr, numWideCars); + return String(tmpWideString); + } + else + { + return String(); + } +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +void Variant::swap(Variant& other) +{ + std::swap(m_type, other.m_type); + m_data.swap(other.m_data); + m_arrayData.swap(other.m_arrayData); +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +void Variant::assignData(const void* pointerToData, size_t dataSizeInBytes) +{ + CVF_ASSERT(m_arrayData.size() == 0); + + m_data.assign(reinterpret_cast(pointerToData), reinterpret_cast(pointerToData) + dataSizeInBytes); + CVF_ASSERT(m_data.size() == dataSizeInBytes); +} + + +} // namespace gc diff --git a/VisualizationModules/LibCore/cvfVariant.h b/VisualizationModules/LibCore/cvfVariant.h new file mode 100644 index 0000000000..0983c37d24 --- /dev/null +++ b/VisualizationModules/LibCore/cvfVariant.h @@ -0,0 +1,98 @@ +//################################################################################################## +// +// Custom Visualization Core library +// Copyright (C) 2011-2012 Ceetron AS +// +// This library is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. +// +// See the GNU General Public License at <> +// for more details. +// +//################################################################################################## + +#pragma once + +#include "cvfVector3.h" +#include "cvfColor3.h" +#include "cvfString.h" + +#include +#include + +namespace cvf { + + +//================================================================================================== +// +// +// +//================================================================================================== +class Variant +{ +public: + enum Type + { + INVALID, + INT, + UINT, + DOUBLE, + FLOAT, + BOOL, + VEC3D, + COLOR3F, + STRING, + ARRAY + }; + +public: + Variant(); + Variant(const Variant& other); + ~Variant(); + + Variant(int val); + Variant(uint val); + Variant(double val); + Variant(float val); + Variant(bool val); + Variant(const Vec3d& val); + Variant(const Color3f& val); + Variant(const String& val); + Variant(const char* val); + Variant(const std::vector& arr); + + Variant& operator=(Variant rhs); + + bool operator==(const Variant& rhs) const; + + Type type() const; + bool isValid() const; + + int getInt() const; + uint getUInt() const; + double getDouble() const; + float getFloat() const; + bool getBool() const; + Vec3d getVec3d() const; + Color3f getColor3f() const; + cvf::String getString() const; + std::vector getArray() const; + + void swap(Variant& other); + +private: + void assignData(const void* pointerToData, size_t dataSizeInBytes); + +private: + Type m_type; // Type of for this variant + std::vector m_data; // Data payload for single values + std::vector m_arrayData;// Data payload when storing an array (of variants) +}; + +} // namespace cvf diff --git a/VisualizationModules/LibGeometry/cvfBoundingBox.cpp b/VisualizationModules/LibGeometry/cvfBoundingBox.cpp index 095caad849..bcfa45d71f 100644 --- a/VisualizationModules/LibGeometry/cvfBoundingBox.cpp +++ b/VisualizationModules/LibGeometry/cvfBoundingBox.cpp @@ -388,7 +388,7 @@ const BoundingBox BoundingBox::getTransformed(const Mat4d& matrix) const //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- -String BoundingBox::toString() const +String BoundingBox::debugString() const { String str = "BoundingBox:"; str += " min: x=" + String::number(m_min.x()) + " y=" + String::number(m_min.y()) + " z=" + String::number(m_min.z()); diff --git a/VisualizationModules/LibGeometry/cvfBoundingBox.h b/VisualizationModules/LibGeometry/cvfBoundingBox.h index e0d8671fb6..514c1ca897 100644 --- a/VisualizationModules/LibGeometry/cvfBoundingBox.h +++ b/VisualizationModules/LibGeometry/cvfBoundingBox.h @@ -67,7 +67,7 @@ public: void transform(const Mat4d& matrix); const BoundingBox getTransformed(const Mat4d& matrix) const; - String toString() const; + String debugString() const; private: Vec3d m_min; diff --git a/VisualizationModules/LibGeometry/cvfGeometryUtils.cpp b/VisualizationModules/LibGeometry/cvfGeometryUtils.cpp index 7fd9f8dfae..f78f84fc30 100644 --- a/VisualizationModules/LibGeometry/cvfGeometryUtils.cpp +++ b/VisualizationModules/LibGeometry/cvfGeometryUtils.cpp @@ -245,6 +245,62 @@ void GeometryUtils::createDisc(double radius, uint numSlices, GeometryBuilder* b } +//-------------------------------------------------------------------------------------------------- +/// Create a disk with a hole in the middle +//-------------------------------------------------------------------------------------------------- +void GeometryUtils::createDisc(double outerRadius, double innerRadius, uint numSlices, GeometryBuilder* builder) +{ + CVF_ASSERT(numSlices >= 4); + CVF_ASSERT(builder); + + double da = 2*PI_D/numSlices; + + Vec3fArray verts; + verts.reserve(2*numSlices); + + Vec3f point = Vec3f::ZERO; + + uint i; + for (i = 0; i < numSlices; i++) + { + // Precompute this one (A = i*da;) + double sinA = Math::sin(i*da); + double cosA = Math::cos(i*da); + + point.x() = static_cast(-sinA*innerRadius); + point.y() = static_cast( cosA*innerRadius); + + verts.add(point); + + point.x() = static_cast(-sinA*outerRadius); + point.y() = static_cast( cosA*outerRadius); + + verts.add(point); + } + + uint baseNodeIdx = builder->addVertices(verts); + + uint conn[3] = { baseNodeIdx, 0, 0}; + + for (i = 0; i < numSlices - 1; ++i) + { + uint startIdx = baseNodeIdx + 2*i; + + conn[0] = startIdx + 0; + conn[1] = startIdx + 3; + conn[2] = startIdx + 1; + builder->addTriangle(conn[0], conn[1], conn[2]); + + conn[0] = startIdx + 2; + conn[1] = startIdx + 3; + conn[2] = startIdx + 0; + builder->addTriangle(conn[0], conn[1], conn[2]); + } + + builder->addTriangle(baseNodeIdx + 0, baseNodeIdx + 1, baseNodeIdx + numSlices*2 - 1); + builder->addTriangle(baseNodeIdx + 0, baseNodeIdx + numSlices*2 - 1, baseNodeIdx + numSlices*2 - 2); +} + // void GeometryUtils::generatePointsOnCircle(double radius, int numPoints, Vec3fArray* generatedPoints) // { @@ -851,7 +907,7 @@ void GeometryUtils::removeUnusedVertices(const UIntValueArray& vertexIndices, UI newToOldMapping->squeeze(); } -bool GeometryUtils::project(const Mat4d& projectionMultViewMatrix, const Vec2ui& viewportPosition, const Vec2ui& viewportSize, const Vec3d& point, Vec3d* out) +bool GeometryUtils::project(const Mat4d& projectionMultViewMatrix, const Vec2i& viewportPosition, const Vec2ui& viewportSize, const Vec3d& point, Vec3d* out) { CVF_ASSERT(out); diff --git a/VisualizationModules/LibGeometry/cvfGeometryUtils.h b/VisualizationModules/LibGeometry/cvfGeometryUtils.h index 6d6ebdad1b..3f04d4c966 100644 --- a/VisualizationModules/LibGeometry/cvfGeometryUtils.h +++ b/VisualizationModules/LibGeometry/cvfGeometryUtils.h @@ -39,6 +39,7 @@ public: static void createBox(const Vec3f& centerPos, float extentX, float extentY, float extentZ, GeometryBuilder* builder); static void createDisc(double radius, uint numSlices, GeometryBuilder* builder); + static void createDisc(double outerRadius, double innerRadius, uint numSlices, GeometryBuilder* builder); static void createSphere(double radius, uint numSlices, uint numStacks, GeometryBuilder* builder); @@ -57,7 +58,7 @@ public: static void removeUnusedVertices(const UIntValueArray& vertexIndices, UIntArray* newVertexIndices, UIntArray* newToOldMapping, uint maxVertexCount); - static bool project(const Mat4d& projectionMultViewMatrix, const Vec2ui& viewportPosition, const Vec2ui& viewportSize, const Vec3d& point, Vec3d* out); + static bool project(const Mat4d& projectionMultViewMatrix, const Vec2i& viewportPosition, const Vec2ui& viewportSize, const Vec3d& point, Vec3d* out); }; } diff --git a/VisualizationModules/LibGeometry/cvfRay.cpp b/VisualizationModules/LibGeometry/cvfRay.cpp index 484f185ea0..a198cfeab1 100644 --- a/VisualizationModules/LibGeometry/cvfRay.cpp +++ b/VisualizationModules/LibGeometry/cvfRay.cpp @@ -39,9 +39,14 @@ namespace cvf { /// //-------------------------------------------------------------------------------------------------- Ray::Ray() +: m_origin(Vec3d::ZERO), + m_direction(-Vec3d::Z_AXIS), + m_minDistance(cvf::UNDEFINED_DOUBLE), + m_maxDistance(cvf::UNDEFINED_DOUBLE), + m_minDistanceSquared(cvf::UNDEFINED_DOUBLE), + m_maxDistanceSquared(cvf::UNDEFINED_DOUBLE), + m_distanceLimitedRay(false) { - m_origin = Vec3d::ZERO; - m_direction = -Vec3d::Z_AXIS; } @@ -52,6 +57,11 @@ Ray::Ray(const Ray& other) : Object() { m_origin = other.origin(); m_direction = other.direction(); + m_minDistance = other.m_minDistance; + m_maxDistance = other.m_maxDistance; + m_minDistanceSquared = other.m_minDistanceSquared; + m_maxDistanceSquared = other.m_maxDistanceSquared; + m_distanceLimitedRay = other.m_distanceLimitedRay; } @@ -60,7 +70,6 @@ Ray::Ray(const Ray& other) : Object() //-------------------------------------------------------------------------------------------------- Ray::~Ray() { - } @@ -162,6 +171,22 @@ bool Ray::triangleIntersect(const Vec3d& v1, const Vec3d& v2, const Vec3d& v3, V } } + // Distance filtering + if (m_distanceLimitedRay) + { + double distanceSquared = origin().pointDistanceSquared(fp); + + if (m_minDistanceSquared < cvf::UNDEFINED_DOUBLE_THRESHOLD && distanceSquared < m_minDistanceSquared) + { + return false; + } + + if (m_maxDistanceSquared < cvf::UNDEFINED_DOUBLE_THRESHOLD && distanceSquared > m_maxDistanceSquared) + { + return false; + } + } + if (intersectionPoint) { *intersectionPoint = fp; @@ -211,6 +236,22 @@ bool Ray::quadIntersect(const Vec3d& v1, const Vec3d& v2, const Vec3d& v3, const } } + // Distance filtering + if (m_distanceLimitedRay) + { + double distanceSquared = origin().pointDistanceSquared(fp); + + if (m_minDistanceSquared < cvf::UNDEFINED_DOUBLE_THRESHOLD && distanceSquared < m_minDistanceSquared) + { + return false; + } + + if (m_maxDistanceSquared < cvf::UNDEFINED_DOUBLE_THRESHOLD && distanceSquared > m_maxDistanceSquared) + { + return false; + } + } + if (intersectionPoint) { *intersectionPoint = fp; @@ -312,6 +353,22 @@ bool Ray::boxIntersect(const BoundingBox& box, Vec3d* intersectionPoint) const } } + // Distance filtering + if (m_distanceLimitedRay) + { + double distanceSquared = origin().pointDistanceSquared(hitPoint); + + if (m_minDistanceSquared < cvf::UNDEFINED_DOUBLE_THRESHOLD && distanceSquared < m_minDistanceSquared) + { + return false; + } + + if (m_maxDistanceSquared < cvf::UNDEFINED_DOUBLE_THRESHOLD && distanceSquared > m_maxDistanceSquared) + { + return false; + } + } + if (intersectionPoint) { *intersectionPoint = hitPoint; @@ -348,6 +405,22 @@ bool Ray::planeIntersect(const Plane& plane, Vec3d* intersectionPoint) const double t = v0/vd; if (t >= 0) { + // Distance filtering + if (m_distanceLimitedRay) + { + double distanceSquared = origin().pointDistanceSquared(m_origin + t*m_direction); + + if (m_minDistanceSquared < cvf::UNDEFINED_DOUBLE_THRESHOLD && distanceSquared < m_minDistanceSquared) + { + return false; + } + + if (m_maxDistanceSquared < cvf::UNDEFINED_DOUBLE_THRESHOLD && distanceSquared > m_maxDistanceSquared) + { + return false; + } + } + if (intersectionPoint) { *intersectionPoint = m_origin + t*m_direction; @@ -364,15 +437,78 @@ bool Ray::planeIntersect(const Plane& plane, Vec3d* intersectionPoint) const //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- -String Ray::toString() const +String Ray::debugString() const { String str = "Ray: "; str += " origin: x=" + String::number(m_origin.x()) + " y=" + String::number(m_origin.y()) + " z=" + String::number(m_origin.z()); str += " direction: x=" + String::number(m_direction.x()) + " y=" + String::number(m_direction.y()) + " z=" + String::number(m_direction.z()); + str += " minDist: " + String::number(m_minDistance); + str += " maxDist: " + String::number(m_maxDistance); return str; } -} // namespace cvf +//-------------------------------------------------------------------------------------------------- +/// Set the minimum distance (from the origin) that the ray will hit. +/// +/// Useful for limiting the ray when picking on models with clipping planes. +/// Set to tsv::UNDEFINED_DOUBLE +//-------------------------------------------------------------------------------------------------- +void Ray::setMinimumDistance(double distance) +{ + m_minDistance = distance; + if (m_minDistance >= 0 && m_minDistance < cvf::UNDEFINED_DOUBLE_THRESHOLD) + { + m_minDistanceSquared = m_minDistance*m_minDistance; + } + else + { + m_minDistanceSquared = cvf::UNDEFINED_DOUBLE; + } + + m_distanceLimitedRay = (m_minDistanceSquared < cvf::UNDEFINED_DOUBLE_THRESHOLD) || (m_maxDistanceSquared < cvf::UNDEFINED_DOUBLE_THRESHOLD); +} + + +//-------------------------------------------------------------------------------------------------- +/// Set the maximum distance (from the origin) that the ray will hit. +/// +/// Useful for limiting the ray when picking on models with clipping planes +//-------------------------------------------------------------------------------------------------- +void Ray::setMaximumDistance(double distance) +{ + m_maxDistance = distance; + + if (m_maxDistance >= 0 && m_maxDistance < cvf::UNDEFINED_DOUBLE_THRESHOLD) + { + m_maxDistanceSquared = m_maxDistance*m_maxDistance; + } + else + { + m_maxDistanceSquared = cvf::UNDEFINED_DOUBLE; + } + + m_distanceLimitedRay = (m_minDistanceSquared < cvf::UNDEFINED_DOUBLE_THRESHOLD) || (m_maxDistanceSquared < cvf::UNDEFINED_DOUBLE_THRESHOLD); +} + + +//-------------------------------------------------------------------------------------------------- +/// Minimum distance (from the origin) that the ray will hit. +//-------------------------------------------------------------------------------------------------- +double Ray::minimumDistance() const +{ + return m_minDistance; +} + + +//-------------------------------------------------------------------------------------------------- +/// Maximum distance (from the origin) that the ray will hit +//-------------------------------------------------------------------------------------------------- +double Ray::maximumDistance() const +{ + return m_maxDistance; +} + +} // namespace cvf diff --git a/VisualizationModules/LibGeometry/cvfRay.h b/VisualizationModules/LibGeometry/cvfRay.h index 0153d4ca8e..4bb008a8e3 100644 --- a/VisualizationModules/LibGeometry/cvfRay.h +++ b/VisualizationModules/LibGeometry/cvfRay.h @@ -47,6 +47,11 @@ public: void setDirection(const Vec3d& dir); const Vec3d& direction() const; + void setMinimumDistance(double distance); + double minimumDistance() const; + void setMaximumDistance(double distance); + double maximumDistance() const; + void transform(const Mat4d& matrix); const Ray getTransformed(const Mat4d& matrix) const; @@ -55,11 +60,16 @@ public: bool boxIntersect(const BoundingBox& box, Vec3d* intersectionPoint = NULL) const; bool planeIntersect(const Plane& plane, Vec3d* intersectionPoint = NULL) const; - String toString() const; + String debugString() const; private: - Vec3d m_origin; ///< Starting point of ray - Vec3d m_direction; ///< Vector specifying ray direction + Vec3d m_origin; ///< Starting point of ray + Vec3d m_direction; ///< Vector specifying ray direction + double m_minDistance; ///< Minimum distance for a hit + double m_maxDistance; ///< Maximum distance for a hit + double m_minDistanceSquared; + double m_maxDistanceSquared; + bool m_distanceLimitedRay; }; } diff --git a/VisualizationModules/LibGuiQt/cvfqtUtils.cpp b/VisualizationModules/LibGuiQt/cvfqtUtils.cpp index b827b8b768..439685ffbe 100644 --- a/VisualizationModules/LibGuiQt/cvfqtUtils.cpp +++ b/VisualizationModules/LibGuiQt/cvfqtUtils.cpp @@ -48,13 +48,13 @@ QString Utils::toQString(const cvf::String& ceeString) if (sizeof(wchar_t) == 2) { - const unsigned short* strPtr = reinterpret_cast(ceeString.ptr()); + const unsigned short* strPtr = reinterpret_cast(ceeString.c_str()); return QString::fromUtf16(strPtr); } else if (sizeof(wchar_t) == 4) { - const unsigned int* strPtr = reinterpret_cast(ceeString.ptr()); + const unsigned int* strPtr = reinterpret_cast(ceeString.c_str()); return QString::fromUcs4(strPtr); } diff --git a/VisualizationModules/LibRender/cvfCamera.cpp b/VisualizationModules/LibRender/cvfCamera.cpp index f84b08894a..6ea6a8ebc7 100644 --- a/VisualizationModules/LibRender/cvfCamera.cpp +++ b/VisualizationModules/LibRender/cvfCamera.cpp @@ -489,8 +489,11 @@ double Camera::aspectRatio() const /// This method calls Viewport::set() and then updates the projection matrix, as this is depending /// on the viewport dimensions. /// This method is usually used as a response to a Resize message from the window system +/// +/// The window coordinates (x,y) are in OpenGL style coordinates, which means a right handed +/// coordinate system with the origin in the lower left corner of the window. //-------------------------------------------------------------------------------------------------- -void Camera::setViewport(uint x, uint y, uint width, uint height) +void Camera::setViewport(int x, int y, uint width, uint height) { CVF_ASSERT(m_viewport.notNull()); m_viewport->set(x, y, width, height); @@ -528,22 +531,19 @@ const Viewport* Camera::viewport() const //-------------------------------------------------------------------------------------------------- /// Create a Ray from window coordinates /// -/// The coordinates (winCoordX & winCoordY) are assumed to be in the window coordinate system -/// where <0,0> if in the top left corner. + /// The window coordinates are in OpenGL style coordinates, which means a right handed + /// coordinate system with the origin in the lower left corner of the window. //-------------------------------------------------------------------------------------------------- -ref Camera::rayFromWinCoord(int winCoordX, int winCoordY) const +ref Camera::rayFromWindowCoordinates(int x, int y) const { - // Unproject works in OpenGL coord system with (0,0) in lower left corner, so flip the y-coordinate - winCoordY = static_cast(m_viewport->height()) - winCoordY; - Vec3d coord0(0, 0, 0); - if (!unproject(Vec3d(static_cast(winCoordX), static_cast(winCoordY), 0), &coord0)) + if (!unproject(Vec3d(static_cast(x), static_cast(y), 0), &coord0)) { return NULL; } Vec3d coord1(0, 0, 0); - if (!unproject(Vec3d(static_cast(winCoordX), static_cast(winCoordY), 1), &coord1)) + if (!unproject(Vec3d(static_cast(x), static_cast(y), 1), &coord1)) { return NULL; } @@ -563,22 +563,19 @@ ref Camera::rayFromWinCoord(int winCoordX, int winCoordY) const /// /// The plane will be constructed so that the specified line lies in the plane, and the plane /// normal will be pointing left when moving along the line from start to end. -/// The coordinates (winCoordStart & winCoordEnd) are assumed to be in the window coordinate system -/// where <0,0> is in the top left corner. +/// +/// The window coordinates are in OpenGL style coordinates, which means a right handed +/// coordinate system with the origin in the lower left corner of the window. //-------------------------------------------------------------------------------------------------- -ref Camera::planeFromLineWinCoord(Vec2i winCoordStart, Vec2i winCoordEnd) const +ref Camera::planeFromLineWindowCoordinates(Vec2i coordStart, Vec2i coordEnd) const { - // Unproject works in OpenGL coord system with (0,0) in lower left corner, so flip the y-coordinates - winCoordStart.y() = static_cast(m_viewport->height()) - winCoordStart.y(); - winCoordEnd.y() = static_cast(m_viewport->height()) - winCoordEnd.y(); - Vec3d s0(0, 0, 0); Vec3d e0(0, 0, 0); Vec3d e1(0, 0, 0); bool unprojOk = true; - unprojOk &= unproject(Vec3d(winCoordStart.x(), winCoordStart.y(), 0), &s0); - unprojOk &= unproject(Vec3d(winCoordEnd.x(), winCoordEnd.y(), 0), &e0); - unprojOk &= unproject(Vec3d(winCoordEnd.x(), winCoordEnd.y(), 1), &e1); + unprojOk &= unproject(Vec3d(coordStart.x(), coordStart.y(), 0), &s0); + unprojOk &= unproject(Vec3d(coordEnd.x(), coordEnd.y(), 0), &e0); + unprojOk &= unproject(Vec3d(coordEnd.x(), coordEnd.y(), 1), &e1); if (!unprojOk) { return NULL; @@ -770,7 +767,7 @@ bool Camera::unproject(const Vec3d& coord, Vec3d* out) const //-------------------------------------------------------------------------------------------------- bool Camera::project(const Vec3d& point, Vec3d* out) const { - return GeometryUtils::project(m_cachedProjectionMultViewMatrix, Vec2ui(m_viewport->x(), m_viewport->y()), Vec2ui(m_viewport->width(), m_viewport->height()), point, out); + return GeometryUtils::project(m_cachedProjectionMultViewMatrix, Vec2i(m_viewport->x(), m_viewport->y()), Vec2ui(m_viewport->width(), m_viewport->height()), point, out); } diff --git a/VisualizationModules/LibRender/cvfCamera.h b/VisualizationModules/LibRender/cvfCamera.h index b2e9f396b5..d00e364cf4 100644 --- a/VisualizationModules/LibRender/cvfCamera.h +++ b/VisualizationModules/LibRender/cvfCamera.h @@ -81,12 +81,12 @@ public: double frontPlanePixelHeight() const; double distanceWhereObjectProjectsToPixelExtent(double objectExtentWorld, double objectExtentPixels) const; - void setViewport(uint x, uint y, uint width, uint height); + void setViewport(int x, int y, uint width, uint height); Viewport* viewport(); const Viewport* viewport() const; - ref rayFromWinCoord(int winCoordX, int winCoordY) const; - ref planeFromLineWinCoord(Vec2i winCoordStart, Vec2i winCoordEnd) const; + ref rayFromWindowCoordinates(int x, int y) const; + ref planeFromLineWindowCoordinates(Vec2i coordStart, Vec2i coordEnd) const; bool unproject(const Vec3d& coord, Vec3d* out) const; bool project(const Vec3d& point, Vec3d* out) const; diff --git a/VisualizationModules/LibRender/cvfMatrixState.cpp b/VisualizationModules/LibRender/cvfMatrixState.cpp index 4e2b0bffb1..65edddc254 100644 --- a/VisualizationModules/LibRender/cvfMatrixState.cpp +++ b/VisualizationModules/LibRender/cvfMatrixState.cpp @@ -44,7 +44,7 @@ MatrixState::MatrixState(const Camera& camera) m_modelMatrix(), m_modelMatrixIsSet(false), m_viewProjectionMatrix(m_projectionMatrix*m_viewMatrix), - m_viewportPosition(static_cast(camera.viewport()->x()), static_cast(camera.viewport()->y())), + m_viewportPosition(camera.viewport()->x(), camera.viewport()->y()), m_viewportSize(static_cast(camera.viewport()->width()), static_cast(camera.viewport()->height())), m_pixelHeightAtUnitDistance(0.0f), m_versionTick(1) @@ -59,7 +59,7 @@ MatrixState::MatrixState(const Camera& camera) //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- -MatrixState::MatrixState(const Vec2ui& viewportPosition, const Vec2ui& viewportSize, const Mat4d& projectionMatrix, const Mat4d& viewMatrix) +MatrixState::MatrixState(const Vec2i& viewportPosition, const Vec2ui& viewportSize, const Mat4d& projectionMatrix, const Mat4d& viewMatrix) : m_projectionMatrix(projectionMatrix), m_viewMatrix(viewMatrix), m_modelMatrix(), @@ -295,7 +295,7 @@ float MatrixState::pixelHeightAtUnitDistance() const //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- -Vec2ui MatrixState::viewportPosition() const +Vec2i MatrixState::viewportPosition() const { return m_viewportPosition; } diff --git a/VisualizationModules/LibRender/cvfMatrixState.h b/VisualizationModules/LibRender/cvfMatrixState.h index 91979d5d6f..f7caa6a368 100644 --- a/VisualizationModules/LibRender/cvfMatrixState.h +++ b/VisualizationModules/LibRender/cvfMatrixState.h @@ -35,7 +35,7 @@ class MatrixState { public: MatrixState(const Camera& camera); - MatrixState(const Vec2ui& viewportPosition, const Vec2ui& viewportSize, const Mat4d& projectionMatrix, const Mat4d& viewMatrix); + MatrixState(const Vec2i& viewportPosition, const Vec2ui& viewportSize, const Mat4d& projectionMatrix, const Mat4d& viewMatrix); void setViewMatrix(const Mat4d& viewMatrix); @@ -56,7 +56,7 @@ public: Mat3f normalMatrix() const; float pixelHeightAtUnitDistance() const; - Vec2ui viewportPosition() const; + Vec2i viewportPosition() const; Vec2ui viewportSize() const; uint versionTick() const; @@ -71,7 +71,7 @@ private: bool m_modelMatrixIsSet; // Set to true when a model matrix is set, false when no model matrix is currently set Mat4f m_viewProjectionMatrix; // Combined view matrix and projection matrix - Vec2ui m_viewportPosition; // Position of the viewport + Vec2i m_viewportPosition; // Position of the viewport Vec2ui m_viewportSize; // Size of the viewport float m_pixelHeightAtUnitDistance;// Height of a pixel at unit distance (distance of 1.0 from camera) in world system. For perspective projections this value must be multiplied by the distance to the point in question diff --git a/VisualizationModules/LibRender/cvfOpenGLContextGroup.cpp b/VisualizationModules/LibRender/cvfOpenGLContextGroup.cpp index 7a02573ae9..ad6e99c802 100644 --- a/VisualizationModules/LibRender/cvfOpenGLContextGroup.cpp +++ b/VisualizationModules/LibRender/cvfOpenGLContextGroup.cpp @@ -27,6 +27,14 @@ #include +#ifdef WIN32 +#pragma warning (push) +#pragma warning (disable: 4668) +#include "glew/GL/wglew.h" +#pragma warning (pop) +#endif + + namespace cvf { @@ -46,7 +54,8 @@ namespace cvf { //-------------------------------------------------------------------------------------------------- OpenGLContextGroup::OpenGLContextGroup() : m_isInitialized(false), - m_glewContextStruct(NULL) + m_glewContextStruct(NULL), + m_wglewContextStruct(NULL) { m_resourceManager = new OpenGLResourceManager; m_logger = new Logger; @@ -116,6 +125,14 @@ bool OpenGLContextGroup::initializeContextGroup(OpenGLContext* currentContext) } configureCapablititesFromGLEW(currentContext); + +#ifdef WIN32 + if (!initializeWGLEW(currentContext)) + { + return false; + } +#endif + #endif m_isInitialized = true; @@ -138,8 +155,13 @@ void OpenGLContextGroup::uninitializeContextGroup() #ifdef CVF_USE_GLEW delete m_glewContextStruct; + +#ifdef WIN32 + delete m_wglewContextStruct; +#endif #endif m_glewContextStruct = NULL; + m_wglewContextStruct = NULL; m_isInitialized = false; } @@ -231,6 +253,45 @@ bool OpenGLContextGroup::initializeGLEW(OpenGLContext* currentContext) } +//-------------------------------------------------------------------------------------------------- +/// Initializes GLEW for this context group +/// +/// \warning The context passed in \a currentContext must be current! +//-------------------------------------------------------------------------------------------------- +bool OpenGLContextGroup::initializeWGLEW(OpenGLContext* currentContext) +{ + CVF_ASSERT(currentContext); + CVF_ASSERT(m_wglewContextStruct == NULL); + +#if defined(CVF_USE_GLEW) && defined(WIN32) + + // Since we're sometimes (when using Core OpenGL) seeing some OGL errors from GLEW, check before and after call to help find them + CVF_CHECK_OGL(currentContext); + + // Must allocate memory for struct first since glewInit() call below will try and retrieve it + WGLEWContextStruct* theContextStruct = new WGLEWContextStruct; + memset(theContextStruct, 0, sizeof(WGLEWContextStruct)); + GLenum err = wglewContextInit(theContextStruct); + if (err != GLEW_OK) + { + delete theContextStruct; + return false; + } + + m_wglewContextStruct = theContextStruct; + + CVF_CHECK_OGL(currentContext); + +#else + + CVF_FAIL_MSG("Not implemented"); + +#endif + + return true; +} + + //-------------------------------------------------------------------------------------------------- /// Configures the capabilities of this context group by querying GLEW /// @@ -374,5 +435,24 @@ GLEWContextStruct* OpenGLContextGroup::glewContextStruct() } -} // namespace cvf +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +WGLEWContextStruct* OpenGLContextGroup::wglewContextStruct() +{ +#if defined(CVF_USE_GLEW) && defined(WIN32) + CVF_TIGHT_ASSERT(this); + CVF_TIGHT_ASSERT(m_wglewContextStruct); + return m_wglewContextStruct; + +#else + + CVF_FAIL_MSG("Not implemented"); + return NULL; + +#endif +} + + +} // namespace cvf diff --git a/VisualizationModules/LibRender/cvfOpenGLContextGroup.h b/VisualizationModules/LibRender/cvfOpenGLContextGroup.h index 3b61704a56..8fd274288a 100644 --- a/VisualizationModules/LibRender/cvfOpenGLContextGroup.h +++ b/VisualizationModules/LibRender/cvfOpenGLContextGroup.h @@ -24,6 +24,7 @@ #include "cvfLogger.h" struct GLEWContextStruct; +struct WGLEWContextStruct; namespace cvf { @@ -53,12 +54,14 @@ public: OpenGLCapabilities* capabilities(); GLEWContextStruct* glewContextStruct(); + WGLEWContextStruct* wglewContextStruct(); private: bool initializeContextGroup(OpenGLContext* currentContext); void uninitializeContextGroup(); void contextAboutToBeShutdown(OpenGLContext* contextToShutdown); bool initializeGLEW(OpenGLContext* currentContext); + bool initializeWGLEW(OpenGLContext* currentContext); void configureCapablititesFromGLEW(OpenGLContext* currentContext); void addContext(OpenGLContext* contextToAdd); @@ -69,6 +72,7 @@ private: ref m_logger; ref m_capabilities; // Capabilities of the contexts in this group context GLEWContextStruct* m_glewContextStruct; // Pointer to the GLEW context struct + WGLEWContextStruct* m_wglewContextStruct; // Pointer to the GLEW context struct friend class OpenGLContext; }; @@ -76,5 +80,3 @@ private: } - - diff --git a/VisualizationModules/LibRender/cvfOverlayAxisCross.cpp b/VisualizationModules/LibRender/cvfOverlayAxisCross.cpp index 1665eb94c7..29aca5ac4f 100644 --- a/VisualizationModules/LibRender/cvfOverlayAxisCross.cpp +++ b/VisualizationModules/LibRender/cvfOverlayAxisCross.cpp @@ -140,7 +140,7 @@ void OverlayAxisCross::setSize(const Vec2ui& size) //-------------------------------------------------------------------------------------------------- /// Hardware rendering using shader programs //-------------------------------------------------------------------------------------------------- -void OverlayAxisCross::render(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size) +void OverlayAxisCross::render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size) { Mat4d viewMatrix = m_camera->viewMatrix(); render(oglContext, position, size, false, viewMatrix); @@ -150,7 +150,7 @@ void OverlayAxisCross::render(OpenGLContext* oglContext, const Vec2ui& position, //-------------------------------------------------------------------------------------------------- /// Software rendering //-------------------------------------------------------------------------------------------------- -void OverlayAxisCross::renderSoftware(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size) +void OverlayAxisCross::renderSoftware(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size) { Mat4d viewMatrix = m_camera->viewMatrix(); render(oglContext, position, size, true, viewMatrix); @@ -160,7 +160,7 @@ void OverlayAxisCross::renderSoftware(OpenGLContext* oglContext, const Vec2ui& p //-------------------------------------------------------------------------------------------------- /// Set up camera/viewport and render //-------------------------------------------------------------------------------------------------- -void OverlayAxisCross::render(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size, bool software, const Mat4d& viewMatrix) +void OverlayAxisCross::render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size, bool software, const Mat4d& viewMatrix) { if (size.x() <= 0 || size.y() <= 0) { diff --git a/VisualizationModules/LibRender/cvfOverlayAxisCross.h b/VisualizationModules/LibRender/cvfOverlayAxisCross.h index 5802dce182..a48eb08c8b 100644 --- a/VisualizationModules/LibRender/cvfOverlayAxisCross.h +++ b/VisualizationModules/LibRender/cvfOverlayAxisCross.h @@ -49,8 +49,8 @@ public: virtual Vec2ui maximumSize(); virtual Vec2ui minimumSize(); - virtual void render(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size); - virtual void renderSoftware(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size); + virtual void render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size); + virtual void renderSoftware(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size); void setSize(const Vec2ui& size); @@ -58,7 +58,7 @@ public: void setAxisLabelsColor(const Color3f& color); private: - void render(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size, bool software, const Mat4d& viewMatrix); + void render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size, bool software, const Mat4d& viewMatrix); void createAxisGeometry(bool software); void renderAxis(OpenGLContext* oglContext, const MatrixState& matrixState); void renderAxisImmediateMode(OpenGLContext* oglContext, const MatrixState& matrixState); diff --git a/VisualizationModules/LibRender/cvfOverlayColorLegend.cpp b/VisualizationModules/LibRender/cvfOverlayColorLegend.cpp index f8ea39cd7d..76821b25c1 100644 --- a/VisualizationModules/LibRender/cvfOverlayColorLegend.cpp +++ b/VisualizationModules/LibRender/cvfOverlayColorLegend.cpp @@ -198,7 +198,7 @@ String OverlayColorLegend::title() const //-------------------------------------------------------------------------------------------------- /// Hardware rendering using shader programs //-------------------------------------------------------------------------------------------------- -void OverlayColorLegend::render(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size) +void OverlayColorLegend::render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size) { render(oglContext, position, size, false); } @@ -207,7 +207,7 @@ void OverlayColorLegend::render(OpenGLContext* oglContext, const Vec2ui& positio //-------------------------------------------------------------------------------------------------- /// Software rendering using software //-------------------------------------------------------------------------------------------------- -void OverlayColorLegend::renderSoftware(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size) +void OverlayColorLegend::renderSoftware(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size) { render(oglContext, position, size, true); } @@ -216,21 +216,21 @@ void OverlayColorLegend::renderSoftware(OpenGLContext* oglContext, const Vec2ui& //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- -bool OverlayColorLegend::pick(uint oglXCoord, uint oglYCoord, const Vec2ui& position, const Vec2ui& size) +bool OverlayColorLegend::pick(int x, int y, const Vec2i& position, const Vec2ui& size) { - Rectui oglRect(position, size.x(), size.y()); + Recti oglRect(position, static_cast(size.x()), static_cast(size.y())); - OverlayColorLegendLayoutInfo layoutInViewPortCoords(oglRect.min(), Vec2ui(oglRect.width(), oglRect.height())); + OverlayColorLegendLayoutInfo layoutInViewPortCoords(oglRect.min(), Vec2ui(static_cast(oglRect.width()), static_cast(oglRect.height()))); layoutInfo(&layoutInViewPortCoords); - Vec2ui legendBarOrigin = oglRect.min(); + Vec2i legendBarOrigin = oglRect.min(); legendBarOrigin.x() += static_cast(layoutInViewPortCoords.legendRect.min().x()); legendBarOrigin.y() += static_cast(layoutInViewPortCoords.legendRect.min().y()); - Rectui legendBarRect = Rectui(legendBarOrigin, static_cast(layoutInViewPortCoords.legendRect.width()), static_cast(layoutInViewPortCoords.legendRect.height())); + Recti legendBarRect = Recti(legendBarOrigin, static_cast(layoutInViewPortCoords.legendRect.width()), static_cast(layoutInViewPortCoords.legendRect.height())); - if ((oglXCoord > legendBarRect.min().x()) && (oglXCoord < legendBarRect.max().x()) && - (oglYCoord > legendBarRect.min().y()) && (oglYCoord < legendBarRect.max().y())) + if ((x > legendBarRect.min().x()) && (x < legendBarRect.max().x()) && + (y > legendBarRect.min().y()) && (y < legendBarRect.max().y())) { return true; } @@ -242,7 +242,7 @@ bool OverlayColorLegend::pick(uint oglXCoord, uint oglYCoord, const Vec2ui& posi //-------------------------------------------------------------------------------------------------- /// Set up camera/viewport and render //-------------------------------------------------------------------------------------------------- -void OverlayColorLegend::render(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size, bool software) +void OverlayColorLegend::render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size, bool software) { if (size.x() <= 0 || size.y() <= 0) { diff --git a/VisualizationModules/LibRender/cvfOverlayColorLegend.h b/VisualizationModules/LibRender/cvfOverlayColorLegend.h index a13cad6ff3..38656ac030 100644 --- a/VisualizationModules/LibRender/cvfOverlayColorLegend.h +++ b/VisualizationModules/LibRender/cvfOverlayColorLegend.h @@ -40,7 +40,7 @@ class TextDrawer; //================================================================================================== struct OverlayColorLegendLayoutInfo { - OverlayColorLegendLayoutInfo(const Vec2ui& pos, const Vec2ui& setSize) + OverlayColorLegendLayoutInfo(const Vec2i& pos, const Vec2ui& setSize) { position = pos; size = setSize; @@ -56,7 +56,7 @@ struct OverlayColorLegendLayoutInfo ref tickPixelPos; - Vec2ui position; + Vec2i position; Vec2ui size; }; @@ -76,9 +76,9 @@ public: virtual Vec2ui maximumSize(); virtual Vec2ui minimumSize(); - virtual void render(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size); - virtual void renderSoftware(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size); - virtual bool pick(uint oglXCoord, uint oglYCoord, const Vec2ui& position, const Vec2ui& size); + virtual void render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size); + virtual void renderSoftware(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size); + virtual bool pick(int x, int y, const Vec2i& position, const Vec2ui& size); void configureLevels(const Color3ubArray& levelColors, const DoubleArray& tickValues); @@ -96,7 +96,7 @@ public: String title() const; protected: - void render(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size, bool software); + void render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size, bool software); virtual void renderLegend(OpenGLContext* oglContext, OverlayColorLegendLayoutInfo* layout, const MatrixState& matrixState); virtual void renderLegendImmediateMode(OpenGLContext* oglContext, OverlayColorLegendLayoutInfo* layout); virtual void setupTextDrawer(TextDrawer* textDrawer, OverlayColorLegendLayoutInfo* layout); diff --git a/VisualizationModules/LibRender/cvfOverlayImage.cpp b/VisualizationModules/LibRender/cvfOverlayImage.cpp index 66cd38cdc9..0bb7443fc8 100644 --- a/VisualizationModules/LibRender/cvfOverlayImage.cpp +++ b/VisualizationModules/LibRender/cvfOverlayImage.cpp @@ -111,7 +111,7 @@ cvf::Vec2ui OverlayImage::minimumSize() //-------------------------------------------------------------------------------------------------- /// Render using Shaders //-------------------------------------------------------------------------------------------------- -void OverlayImage::render(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size) +void OverlayImage::render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size) { render(oglContext, position, size, false); } @@ -120,7 +120,7 @@ void OverlayImage::render(OpenGLContext* oglContext, const Vec2ui& position, con //-------------------------------------------------------------------------------------------------- /// Render using Fixed Function //-------------------------------------------------------------------------------------------------- -void OverlayImage::renderSoftware(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size) +void OverlayImage::renderSoftware(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size) { render(oglContext, position, size, true); } @@ -129,7 +129,7 @@ void OverlayImage::renderSoftware(OpenGLContext* oglContext, const Vec2ui& posit //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- -void OverlayImage::render(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size, bool software) +void OverlayImage::render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size, bool software) { CVF_CALLSITE_OPENGL(oglContext); @@ -262,6 +262,12 @@ void OverlayImage::render(OpenGLContext* oglContext, const Vec2ui& position, con RenderStateBlending blend; blend.applyOpenGL(oglContext); } + + if (!software) + { + glDisableVertexAttribArray(ShaderProgram::VERTEX); + glDisableVertexAttribArray(ShaderProgram::TEX_COORD_2F_0); + } } diff --git a/VisualizationModules/LibRender/cvfOverlayImage.h b/VisualizationModules/LibRender/cvfOverlayImage.h index b56662224c..8a68e5274f 100644 --- a/VisualizationModules/LibRender/cvfOverlayImage.h +++ b/VisualizationModules/LibRender/cvfOverlayImage.h @@ -52,8 +52,8 @@ public: virtual Vec2ui maximumSize(); virtual Vec2ui minimumSize(); - virtual void render(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size); - virtual void renderSoftware(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size); + virtual void render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size); + virtual void renderSoftware(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size); void setImage(TextureImage* image); void setPixelSize(const Vec2ui& size); @@ -63,7 +63,7 @@ public: const TextureImage* image() const; private: - void render(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size, bool software); + void render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size, bool software); private: Vec2ui m_size; diff --git a/VisualizationModules/LibRender/cvfOverlayItem.cpp b/VisualizationModules/LibRender/cvfOverlayItem.cpp index 56697d7592..129f6eec8b 100644 --- a/VisualizationModules/LibRender/cvfOverlayItem.cpp +++ b/VisualizationModules/LibRender/cvfOverlayItem.cpp @@ -46,12 +46,12 @@ namespace cvf { //-------------------------------------------------------------------------------------------------- /// Do hit test on the overlay item. Base class only does a check //-------------------------------------------------------------------------------------------------- -bool OverlayItem::pick(uint oglXCoord, uint oglYCoord, const Vec2ui& position, const Vec2ui& size) +bool OverlayItem::pick(int x, int y, const Vec2i& position, const Vec2ui& size) { - Rectui oglRect(position, size.x(), size.y()); + Recti oglRect(position, static_cast(size.x()), static_cast(size.y())); - if ((oglXCoord > oglRect.min().x()) && (oglXCoord < oglRect.max().x()) && - (oglYCoord > oglRect.min().y()) && (oglYCoord < oglRect.max().y())) + if ((x > oglRect.min().x()) && (x < oglRect.max().x()) && + (y > oglRect.min().y()) && (y < oglRect.max().y())) { return true; } diff --git a/VisualizationModules/LibRender/cvfOverlayItem.h b/VisualizationModules/LibRender/cvfOverlayItem.h index 90c10bc7b3..d196c29e16 100644 --- a/VisualizationModules/LibRender/cvfOverlayItem.h +++ b/VisualizationModules/LibRender/cvfOverlayItem.h @@ -57,9 +57,9 @@ public: virtual Vec2ui maximumSize() = 0; // In Pixels virtual Vec2ui minimumSize() = 0; // In Pixels - virtual void render(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size) = 0; - virtual void renderSoftware(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size) = 0; - virtual bool pick(uint oglXCoord, uint oglYCoord, const Vec2ui& position, const Vec2ui& size); + virtual void render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size) = 0; + virtual void renderSoftware(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size) = 0; + virtual bool pick(int oglXCoord, int oglYCoord, const Vec2i& position, const Vec2ui& size); }; } diff --git a/VisualizationModules/LibRender/cvfOverlayNavigationCube.cpp b/VisualizationModules/LibRender/cvfOverlayNavigationCube.cpp index 54a4f0cb7a..8a0c6d9d2a 100644 --- a/VisualizationModules/LibRender/cvfOverlayNavigationCube.cpp +++ b/VisualizationModules/LibRender/cvfOverlayNavigationCube.cpp @@ -145,7 +145,7 @@ void OverlayNavigationCube::setSize(const Vec2ui& size) //-------------------------------------------------------------------------------------------------- /// Hardware rendering using shader programs //-------------------------------------------------------------------------------------------------- -void OverlayNavigationCube::render(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size) +void OverlayNavigationCube::render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size) { Mat4d viewMatrix = m_camera->viewMatrix(); render(oglContext, position, size, false, viewMatrix); @@ -155,7 +155,7 @@ void OverlayNavigationCube::render(OpenGLContext* oglContext, const Vec2ui& posi //-------------------------------------------------------------------------------------------------- /// Software rendering //-------------------------------------------------------------------------------------------------- -void OverlayNavigationCube::renderSoftware(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size) +void OverlayNavigationCube::renderSoftware(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size) { Mat4d viewMatrix = m_camera->viewMatrix(); render(oglContext, position, size, true, viewMatrix); @@ -165,7 +165,7 @@ void OverlayNavigationCube::renderSoftware(OpenGLContext* oglContext, const Vec2 //-------------------------------------------------------------------------------------------------- /// Set up camera/viewport and render //-------------------------------------------------------------------------------------------------- -void OverlayNavigationCube::render(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size, bool software, const Mat4d& viewMatrix) +void OverlayNavigationCube::render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size, bool software, const Mat4d& viewMatrix) { if (size.x() <= 0 || size.y() <= 0) { diff --git a/VisualizationModules/LibRender/cvfOverlayNavigationCube.h b/VisualizationModules/LibRender/cvfOverlayNavigationCube.h index 715014e062..e878ecf9ce 100644 --- a/VisualizationModules/LibRender/cvfOverlayNavigationCube.h +++ b/VisualizationModules/LibRender/cvfOverlayNavigationCube.h @@ -119,8 +119,8 @@ public: virtual Vec2ui maximumSize(); virtual Vec2ui minimumSize(); - virtual void render(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size); - virtual void renderSoftware(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size); + virtual void render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size); + virtual void renderSoftware(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size); void setSize(const Vec2ui& size); void updateHighlight(int winCoordX, int winCoordY); @@ -130,7 +130,7 @@ public: void setAxisLabelsColor(const Color3f& color); private: - void render(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size, bool software, const Mat4d& viewMatrix); + void render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size, bool software, const Mat4d& viewMatrix); void createAxisGeometry(bool software); void renderAxis(OpenGLContext* oglContext, const MatrixState& matrixState); void renderAxisImmediateMode(OpenGLContext* oglContext, const MatrixState& matrixState); diff --git a/VisualizationModules/LibRender/cvfOverlayScalarMapperLegend.cpp b/VisualizationModules/LibRender/cvfOverlayScalarMapperLegend.cpp index 9ebab2e176..93ea5c99a6 100644 --- a/VisualizationModules/LibRender/cvfOverlayScalarMapperLegend.cpp +++ b/VisualizationModules/LibRender/cvfOverlayScalarMapperLegend.cpp @@ -198,7 +198,7 @@ String OverlayScalarMapperLegend::title() const //-------------------------------------------------------------------------------------------------- /// Hardware rendering using shader programs //-------------------------------------------------------------------------------------------------- -void OverlayScalarMapperLegend::render(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size) +void OverlayScalarMapperLegend::render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size) { render(oglContext, position, size, false); } @@ -207,7 +207,7 @@ void OverlayScalarMapperLegend::render(OpenGLContext* oglContext, const Vec2ui& //-------------------------------------------------------------------------------------------------- /// Software rendering using software //-------------------------------------------------------------------------------------------------- -void OverlayScalarMapperLegend::renderSoftware(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size) +void OverlayScalarMapperLegend::renderSoftware(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size) { render(oglContext, position, size, true); } @@ -216,18 +216,18 @@ void OverlayScalarMapperLegend::renderSoftware(OpenGLContext* oglContext, const //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- -bool OverlayScalarMapperLegend::pick(uint oglXCoord, uint oglYCoord, const Vec2ui& position, const Vec2ui& size) +bool OverlayScalarMapperLegend::pick(int oglXCoord, int oglYCoord, const Vec2i& position, const Vec2ui& size) { - Rectui oglRect(position, size.x(), size.y()); + Recti oglRect(position, size.x(), size.y()); OverlayColorLegendLayoutInfo layoutInViewPortCoords(oglRect.min(), Vec2ui(oglRect.width(), oglRect.height())); layoutInfo(&layoutInViewPortCoords); - Vec2ui legendBarOrigin = oglRect.min(); + Vec2i legendBarOrigin = oglRect.min(); legendBarOrigin.x() += static_cast(layoutInViewPortCoords.legendRect.min().x()); legendBarOrigin.y() += static_cast(layoutInViewPortCoords.legendRect.min().y()); - Rectui legendBarRect = Rectui(legendBarOrigin, static_cast(layoutInViewPortCoords.legendRect.width()), static_cast(layoutInViewPortCoords.legendRect.height())); + Recti legendBarRect = Recti(legendBarOrigin, static_cast(layoutInViewPortCoords.legendRect.width()), static_cast(layoutInViewPortCoords.legendRect.height())); if ((oglXCoord > legendBarRect.min().x()) && (oglXCoord < legendBarRect.max().x()) && (oglYCoord > legendBarRect.min().y()) && (oglYCoord < legendBarRect.max().y())) @@ -242,7 +242,7 @@ bool OverlayScalarMapperLegend::pick(uint oglXCoord, uint oglYCoord, const Vec2u //-------------------------------------------------------------------------------------------------- /// Set up camera/viewport and render //-------------------------------------------------------------------------------------------------- -void OverlayScalarMapperLegend::render(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size, bool software) +void OverlayScalarMapperLegend::render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size, bool software) { if (size.x() <= 0 || size.y() <= 0) { diff --git a/VisualizationModules/LibRender/cvfOverlayScalarMapperLegend.h b/VisualizationModules/LibRender/cvfOverlayScalarMapperLegend.h index a2ded10631..4d077fea0d 100644 --- a/VisualizationModules/LibRender/cvfOverlayScalarMapperLegend.h +++ b/VisualizationModules/LibRender/cvfOverlayScalarMapperLegend.h @@ -50,9 +50,9 @@ public: virtual Vec2ui minimumSize(); void setScalarMapper(const ScalarMapper* scalarMapper); - virtual void render(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size); - virtual void renderSoftware(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size); - virtual bool pick(uint oglXCoord, uint oglYCoord, const Vec2ui& position, const Vec2ui& size); + virtual void render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size); + virtual void renderSoftware(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size); + virtual bool pick(int oglXCoord, int oglYCoord, const Vec2i& position, const Vec2ui& size); void setSizeHint(const Vec2ui& size); @@ -77,7 +77,7 @@ protected: //================================================================================================== struct OverlayColorLegendLayoutInfo { - OverlayColorLegendLayoutInfo(const Vec2ui& pos, const Vec2ui& setSize) + OverlayColorLegendLayoutInfo(const Vec2i& pos, const Vec2ui& setSize) { position = pos; size = setSize; @@ -93,12 +93,12 @@ protected: ref tickPixelPos; - Vec2ui position; + Vec2i position; Vec2ui size; }; - void render(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size, bool software); + void render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size, bool software); virtual void renderLegend(OpenGLContext* oglContext, OverlayColorLegendLayoutInfo* layout, const MatrixState& matrixState); virtual void renderLegendImmediateMode(OpenGLContext* oglContext, OverlayColorLegendLayoutInfo* layout); virtual void setupTextDrawer(TextDrawer* textDrawer, OverlayColorLegendLayoutInfo* layout); diff --git a/VisualizationModules/LibRender/cvfOverlayTextBox.cpp b/VisualizationModules/LibRender/cvfOverlayTextBox.cpp index 42597983fb..c436320f2a 100644 --- a/VisualizationModules/LibRender/cvfOverlayTextBox.cpp +++ b/VisualizationModules/LibRender/cvfOverlayTextBox.cpp @@ -104,7 +104,7 @@ cvf::Vec2ui OverlayTextBox::minimumSize() //-------------------------------------------------------------------------------------------------- /// Render using Shaders //-------------------------------------------------------------------------------------------------- -void OverlayTextBox::render(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size) +void OverlayTextBox::render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size) { render(oglContext, position, size, false); } @@ -113,7 +113,7 @@ void OverlayTextBox::render(OpenGLContext* oglContext, const Vec2ui& position, c //-------------------------------------------------------------------------------------------------- /// Render using Fixed Function //-------------------------------------------------------------------------------------------------- -void OverlayTextBox::renderSoftware(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size) +void OverlayTextBox::renderSoftware(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size) { render(oglContext, position, size, true); } @@ -122,7 +122,7 @@ void OverlayTextBox::renderSoftware(OpenGLContext* oglContext, const Vec2ui& pos //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- -void OverlayTextBox::render(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size, bool software) +void OverlayTextBox::render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size, bool software) { Mat4d ident; MatrixState matrixState(position, size, ident, ident); @@ -157,7 +157,7 @@ void OverlayTextBox::render(OpenGLContext* oglContext, const Vec2ui& position, c //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- -void OverlayTextBox::renderBackgroundAndBorder(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size, bool software) +void OverlayTextBox::renderBackgroundAndBorder(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size, bool software) { CVF_CALLSITE_OPENGL(oglContext); diff --git a/VisualizationModules/LibRender/cvfOverlayTextBox.h b/VisualizationModules/LibRender/cvfOverlayTextBox.h index 63bd41e10c..61725f7d30 100644 --- a/VisualizationModules/LibRender/cvfOverlayTextBox.h +++ b/VisualizationModules/LibRender/cvfOverlayTextBox.h @@ -44,8 +44,8 @@ public: virtual Vec2ui maximumSize(); virtual Vec2ui minimumSize(); - virtual void render(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size); - virtual void renderSoftware(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size); + virtual void render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size); + virtual void renderSoftware(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size); void setText(const String& text); void setPixelSize(const Vec2ui& size); @@ -66,8 +66,8 @@ public: private: - void render(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size, bool software); - void renderBackgroundAndBorder(OpenGLContext* oglContext, const Vec2ui& position, const Vec2ui& size, bool software); + void render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size, bool software); + void renderBackgroundAndBorder(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size, bool software); private: Vec2ui m_size; diff --git a/VisualizationModules/LibRender/cvfShaderProgram.cpp b/VisualizationModules/LibRender/cvfShaderProgram.cpp index 26bd7171e9..2ac80e90f1 100644 --- a/VisualizationModules/LibRender/cvfShaderProgram.cpp +++ b/VisualizationModules/LibRender/cvfShaderProgram.cpp @@ -748,12 +748,21 @@ void ShaderProgram::discoverActiveUniforms(OpenGLContext* oglContext) if (numCharsInName > 0) { - const char* uniformName = uniformNameBuffer.ptr(); - int location = glGetUniformLocation(m_oglRcProgram->oglId(), uniformName); + std::string uniformName = uniformNameBuffer.ptr(); + + // Added this code to fix a bug in the Nvidia drivers that reports arrays as xxx[0], like u_ecClipPlanes reported as u_ecClipPlanes[0] + size_t bracketPos = uniformName.find('['); + if (bracketPos != std::string::npos) + { + uniformName.resize(bracketPos); + } + + int location = glGetUniformLocation(m_oglRcProgram->oglId(), uniformName.c_str()); CVF_CHECK_OGL(oglContext); + FixedUniform fixedUniform; - if (ShaderProgram::mapUniformNameToFixedUniformEnum(uniformName, &fixedUniform)) + if (ShaderProgram::mapUniformNameToFixedUniformEnum(uniformName.c_str(), &fixedUniform)) { m_fixedUniformsMap[fixedUniform] = location; m_fixedUniformsNameLocationMap[uniformName] = location; diff --git a/VisualizationModules/LibRender/cvfShaderSourceProvider.cpp b/VisualizationModules/LibRender/cvfShaderSourceProvider.cpp index 253e2c32d8..ed3b82fbfe 100644 --- a/VisualizationModules/LibRender/cvfShaderSourceProvider.cpp +++ b/VisualizationModules/LibRender/cvfShaderSourceProvider.cpp @@ -125,7 +125,7 @@ void ShaderSourceProvider::addFileSearchDirectory(String directory) bool ShaderSourceProvider::loadFile(const String& fullFileName, CharArray* fileContents) { #ifdef WIN32 - std::ifstream file(fullFileName.ptr()); + std::ifstream file(fullFileName.c_str()); #else std::ifstream file(fullFileName.toUtf8().ptr()); #endif diff --git a/VisualizationModules/LibRender/cvfShaderSourceRepositoryFile.cpp b/VisualizationModules/LibRender/cvfShaderSourceRepositoryFile.cpp index beba3068b2..9a2b2543b2 100644 --- a/VisualizationModules/LibRender/cvfShaderSourceRepositoryFile.cpp +++ b/VisualizationModules/LibRender/cvfShaderSourceRepositoryFile.cpp @@ -53,7 +53,7 @@ bool ShaderSourceRepositoryFile::rawShaderSource(ShaderIdent shaderIdent, CharAr String fullFileName = fileNameFromIdent(shaderIdent); #ifdef WIN32 - std::ifstream file(fullFileName.ptr()); + std::ifstream file(fullFileName.c_str()); #else std::ifstream file(fullFileName.toUtf8().ptr()); #endif diff --git a/VisualizationModules/LibRender/cvfShaderSourceStrings.h b/VisualizationModules/LibRender/cvfShaderSourceStrings.h index bc82c4426d..dd0f33e580 100644 --- a/VisualizationModules/LibRender/cvfShaderSourceStrings.h +++ b/VisualizationModules/LibRender/cvfShaderSourceStrings.h @@ -1018,6 +1018,10 @@ static const char vs_Minimal_inl[] = " \n" "uniform mat4 cvfu_modelViewProjectionMatrix; \n" " \n" +"#ifdef CVF_CALC_CLIP_DISTANCES_IMPL \n" +"uniform mat4 cvfu_modelViewMatrix; \n" +"#endif \n" +" \n" "attribute vec4 cvfa_vertex; \n" " \n" "//-------------------------------------------------------------------------------------------------- \n" @@ -1027,6 +1031,11 @@ static const char vs_Minimal_inl[] = "{ \n" " gl_Position = cvfu_modelViewProjectionMatrix*cvfa_vertex; \n" " \n" +"#ifdef CVF_CALC_CLIP_DISTANCES_IMPL \n" +" vec3 ecPosition = (cvfu_modelViewMatrix * cvfa_vertex).xyz; \n" +" calcClipDistances(vec4(ecPosition, 1)); \n" +"#endif \n" +" \n" "#ifdef CVF_OPENGL_ES \n" " gl_PointSize = 1.0; \n" "#endif \n" @@ -1039,6 +1048,10 @@ static const char vs_Minimal_inl[] = static const char vs_MinimalTexture_inl[] = "uniform mat4 cvfu_modelViewProjectionMatrix; \n" " \n" +"#ifdef CVF_CALC_CLIP_DISTANCES_IMPL \n" +"uniform mat4 cvfu_modelViewMatrix; \n" +"#endif \n" +" \n" "attribute vec2 cvfa_texCoord; \n" "attribute vec4 cvfa_vertex; \n" " \n" @@ -1052,6 +1065,11 @@ static const char vs_MinimalTexture_inl[] = " v_texCoord = cvfa_texCoord; \n" " gl_Position = cvfu_modelViewProjectionMatrix * cvfa_vertex; \n" " \n" +"#ifdef CVF_CALC_CLIP_DISTANCES_IMPL \n" +" vec3 ecPosition = (cvfu_modelViewMatrix * cvfa_vertex).xyz; \n" +" calcClipDistances(vec4(ecPosition, 1)); \n" +"#endif \n" +" \n" "#ifdef CVF_OPENGL_ES \n" " gl_PointSize = 1.0; \n" "#endif \n" diff --git a/VisualizationModules/LibRender/cvfTextDrawer.cpp b/VisualizationModules/LibRender/cvfTextDrawer.cpp index 4a3295b2b0..ad3f7ed460 100644 --- a/VisualizationModules/LibRender/cvfTextDrawer.cpp +++ b/VisualizationModules/LibRender/cvfTextDrawer.cpp @@ -363,6 +363,8 @@ void TextDrawer::doRender2d(OpenGLContext* oglContext, const MatrixState& matrix if (softwareRendering) { #ifndef CVF_OPENGL_ES + glEnable(GL_COLOR_MATERIAL); + glDisable(GL_TEXTURE_2D); glColor4fv(m_backgroundColor.ptr()); glBegin(GL_TRIANGLE_FAN); glVertex3fv(v1); diff --git a/VisualizationModules/LibRender/cvfViewport.cpp b/VisualizationModules/LibRender/cvfViewport.cpp index 6dded35575..fdb6e9c99f 100644 --- a/VisualizationModules/LibRender/cvfViewport.cpp +++ b/VisualizationModules/LibRender/cvfViewport.cpp @@ -56,8 +56,11 @@ Viewport::Viewport() //-------------------------------------------------------------------------------------------------- /// Specify the position and dimensions of the viewport +/// +/// The window coordinates (x,y) are in OpenGL style coordinates, which means a right handed +/// coordinate system with the origin in the lower left corner of the window. //-------------------------------------------------------------------------------------------------- -void Viewport::set(uint x, uint y, uint width, uint height) +void Viewport::set(int x, int y, uint width, uint height) { m_x = x; m_y = y; @@ -84,7 +87,7 @@ void Viewport::setClearColor(Color4f color) //-------------------------------------------------------------------------------------------------- /// Get the x coordinate of the lower left corner of the viewport //-------------------------------------------------------------------------------------------------- -uint Viewport::x() const +int Viewport::x() const { return m_x; } @@ -93,7 +96,7 @@ uint Viewport::x() const //-------------------------------------------------------------------------------------------------- /// Get the y coordinate of the lower left corner of the viewport //-------------------------------------------------------------------------------------------------- -uint Viewport::y() const +int Viewport::y() const { return m_y; } @@ -245,7 +248,7 @@ void Viewport::applyOpenGL(OpenGLContext* oglContext, ClearMode clearMode) //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- -String Viewport::toString() const +String Viewport::debugString() const { String str = "Viewport: "; diff --git a/VisualizationModules/LibRender/cvfViewport.h b/VisualizationModules/LibRender/cvfViewport.h index af41bef850..b85899e8cb 100644 --- a/VisualizationModules/LibRender/cvfViewport.h +++ b/VisualizationModules/LibRender/cvfViewport.h @@ -52,10 +52,10 @@ public: public: Viewport(); - void set(uint x, uint y, uint width, uint height); + void set(int x, int y, uint width, uint height); - uint x() const; - uint y() const; + int x() const; + int y() const; uint width() const; uint height() const; double aspectRatio() const; @@ -65,16 +65,16 @@ public: void applyOpenGL(OpenGLContext* oglContext, ClearMode clearMode); - String toString() const; + String debugString() const; private: cvfGLbitfield clearFlagsOpenGL(ClearMode clearMode); private: - uint m_x; - uint m_y; - uint m_width; - uint m_height; + int m_x; + int m_y; + uint m_width; + uint m_height; Color4f m_clearColor; double m_clearDepth; diff --git a/VisualizationModules/LibRender/glsl/vs_Minimal.glsl b/VisualizationModules/LibRender/glsl/vs_Minimal.glsl index 46dcd21b99..b60a1ed6af 100644 --- a/VisualizationModules/LibRender/glsl/vs_Minimal.glsl +++ b/VisualizationModules/LibRender/glsl/vs_Minimal.glsl @@ -1,6 +1,10 @@ uniform mat4 cvfu_modelViewProjectionMatrix; +#ifdef CVF_CALC_CLIP_DISTANCES_IMPL +uniform mat4 cvfu_modelViewMatrix; +#endif + attribute vec4 cvfa_vertex; //-------------------------------------------------------------------------------------------------- @@ -10,6 +14,11 @@ void main () { gl_Position = cvfu_modelViewProjectionMatrix*cvfa_vertex; +#ifdef CVF_CALC_CLIP_DISTANCES_IMPL + vec3 ecPosition = (cvfu_modelViewMatrix * cvfa_vertex).xyz; + calcClipDistances(vec4(ecPosition, 1)); +#endif + #ifdef CVF_OPENGL_ES gl_PointSize = 1.0; #endif diff --git a/VisualizationModules/LibRender/glsl/vs_MinimalTexture.glsl b/VisualizationModules/LibRender/glsl/vs_MinimalTexture.glsl index 212c870f6a..c2e29dd7e7 100644 --- a/VisualizationModules/LibRender/glsl/vs_MinimalTexture.glsl +++ b/VisualizationModules/LibRender/glsl/vs_MinimalTexture.glsl @@ -1,5 +1,9 @@ uniform mat4 cvfu_modelViewProjectionMatrix; +#ifdef CVF_CALC_CLIP_DISTANCES_IMPL +uniform mat4 cvfu_modelViewMatrix; +#endif + attribute vec2 cvfa_texCoord; attribute vec4 cvfa_vertex; @@ -13,6 +17,11 @@ void main () v_texCoord = cvfa_texCoord; gl_Position = cvfu_modelViewProjectionMatrix * cvfa_vertex; +#ifdef CVF_CALC_CLIP_DISTANCES_IMPL + vec3 ecPosition = (cvfu_modelViewMatrix * cvfa_vertex).xyz; + calcClipDistances(vec4(ecPosition, 1)); +#endif + #ifdef CVF_OPENGL_ES gl_PointSize = 1.0; #endif diff --git a/VisualizationModules/LibViewing/cvfLocators.cpp b/VisualizationModules/LibViewing/cvfLocators.cpp index b69fa4b00c..85e42c33c5 100644 --- a/VisualizationModules/LibViewing/cvfLocators.cpp +++ b/VisualizationModules/LibViewing/cvfLocators.cpp @@ -79,12 +79,13 @@ Vec3d LocatorTranslateOnPlane::position() const //-------------------------------------------------------------------------------------------------- -/// +/// The window coordinates are in OpenGL style coordinates, which means a right handed +/// coordinate system with the origin in the lower left corner of the window. //-------------------------------------------------------------------------------------------------- -void LocatorTranslateOnPlane::start(int winCoordX, int winCoordY) +void LocatorTranslateOnPlane::start(int x, int y) { CVF_ASSERT(m_camera.notNull()); - ref ray = m_camera->rayFromWinCoord(winCoordX, winCoordY); + ref ray = m_camera->rayFromWindowCoordinates(x, y); Vec3d isect(0, 0, 0); ray->planeIntersect(m_plane, &isect); @@ -94,15 +95,16 @@ void LocatorTranslateOnPlane::start(int winCoordX, int winCoordY) //-------------------------------------------------------------------------------------------------- -/// +/// The window coordinates are in OpenGL style coordinates, which means a right handed +/// coordinate system with the origin in the lower left corner of the window. //-------------------------------------------------------------------------------------------------- -bool LocatorTranslateOnPlane::update(int winCoordX, int winCoordY) +bool LocatorTranslateOnPlane::update(int x, int y) { CVF_ASSERT(m_camera.notNull()); Vec3d oldPos = m_pos; - ref ray = m_camera->rayFromWinCoord(winCoordX, winCoordY); + ref ray = m_camera->rayFromWindowCoordinates(x, y); Vec3d isect(0, 0, 0); if (ray->planeIntersect(m_plane, &isect)) @@ -139,8 +141,8 @@ LocatorPanWalkRotate::LocatorPanWalkRotate(Camera* camera) : m_camera(camera), m_operation(PAN), m_pos(0, 0, 0), - m_lastWinPosX(0), - m_lastWinPosY(0) + m_lastPosX(0), + m_lastPosY(0) { CVF_ASSERT(camera); } @@ -183,31 +185,33 @@ Vec3d LocatorPanWalkRotate::position() const //-------------------------------------------------------------------------------------------------- -/// +/// The window coordinates are in OpenGL style coordinates, which means a right handed +/// coordinate system with the origin in the lower left corner of the window. //-------------------------------------------------------------------------------------------------- -void LocatorPanWalkRotate::start(int winCoordX, int winCoordY) +void LocatorPanWalkRotate::start(int x, int y) { - m_lastWinPosX = winCoordX; - m_lastWinPosY = winCoordY; + m_lastPosX = x; + m_lastPosY = y; } //-------------------------------------------------------------------------------------------------- -/// +/// The window coordinates are in OpenGL style coordinates, which means a right handed +/// coordinate system with the origin in the lower left corner of the window. //-------------------------------------------------------------------------------------------------- -bool LocatorPanWalkRotate::update(int winCoordX, int winCoordY) +bool LocatorPanWalkRotate::update(int x, int y) { CVF_ASSERT(m_camera.notNull()); - if (winCoordX == m_lastWinPosX && winCoordY == m_lastWinPosY) return false; + if (x == m_lastPosX && y == m_lastPosY) return false; const double vpPixSizeX = m_camera->viewport()->width(); const double vpPixSizeY = m_camera->viewport()->height(); if (vpPixSizeX <= 0 || vpPixSizeY <= 0) return false; // Normalized movement in screen plane - const double tx = (winCoordX - m_lastWinPosX)/vpPixSizeX; - const double ty = (winCoordY - m_lastWinPosY)/vpPixSizeY; + const double tx = (x - m_lastPosX)/vpPixSizeX; + const double ty = (y - m_lastPosY)/vpPixSizeY; Vec3d oldPos = m_pos; @@ -220,8 +224,8 @@ bool LocatorPanWalkRotate::update(int winCoordX, int winCoordY) updateWalk(ty); } - m_lastWinPosX = winCoordX; - m_lastWinPosY = winCoordY; + m_lastPosX = x; + m_lastPosY = y; if (m_pos == oldPos) { @@ -261,7 +265,7 @@ void LocatorPanWalkRotate::updatePan(double tx, double ty) const double nearPlane = m_camera->nearPlane(); Vec3d vX = camRight*((tx*vpWorldSizeX)/nearPlane)*camPointDist; - Vec3d vY = -camUp*((ty*vpWorldSizeY)/nearPlane)*camPointDist; + Vec3d vY = camUp*((ty*vpWorldSizeY)/nearPlane)*camPointDist; Vec3d translation = vX + vY; m_pos += translation; @@ -270,7 +274,7 @@ void LocatorPanWalkRotate::updatePan(double tx, double ty) else if (projType == Camera::ORTHO) { Vec3d vX = camRight*tx*vpWorldSizeX; - Vec3d vY = -camUp*ty*vpWorldSizeY; + Vec3d vY = camUp*ty*vpWorldSizeY; Vec3d translation = vX + vY; m_pos += translation; diff --git a/VisualizationModules/LibViewing/cvfLocators.h b/VisualizationModules/LibViewing/cvfLocators.h index 8f7fb734a2..1ccd5cccff 100644 --- a/VisualizationModules/LibViewing/cvfLocators.h +++ b/VisualizationModules/LibViewing/cvfLocators.h @@ -37,8 +37,8 @@ public: Locator() {}; virtual Vec3d position() const = 0; - virtual void start(int winCoordX, int winCoordY) = 0; - virtual bool update(int winCoordX, int winCoordY) = 0; + virtual void start(int x, int y) = 0; + virtual bool update(int x, int y) = 0; }; @@ -56,8 +56,8 @@ public: void setPosition(const Vec3d& position, const Vec3d& planeNormal); virtual Vec3d position() const; - virtual void start(int winCoordX, int winCoordY); - virtual bool update(int winCoordX, int winCoordY); + virtual void start(int x, int y); + virtual bool update(int x, int y); public: ref m_camera; @@ -90,8 +90,8 @@ public: void setOperation(Operation op); void setPosition(const Vec3d& position); virtual Vec3d position() const; - virtual void start(int winCoordX, int winCoordY); - virtual bool update(int winCoordX, int winCoordY); + virtual void start(int x, int y); + virtual bool update(int x, int y); private: void updatePan(double tx, double ty); @@ -101,8 +101,8 @@ private: ref m_camera; Operation m_operation; // Default operation is PAN Vec3d m_pos; - int m_lastWinPosX; - int m_lastWinPosY; + int m_lastPosX; + int m_lastPosY; }; diff --git a/VisualizationModules/LibViewing/cvfManipulatorTrackball.cpp b/VisualizationModules/LibViewing/cvfManipulatorTrackball.cpp index fb01d01eb1..c522ccd120 100644 --- a/VisualizationModules/LibViewing/cvfManipulatorTrackball.cpp +++ b/VisualizationModules/LibViewing/cvfManipulatorTrackball.cpp @@ -92,15 +92,16 @@ ManipulatorTrackball::NavigationType ManipulatorTrackball::activeNavigation() co //-------------------------------------------------------------------------------------------------- -/// +/// The window coordinates are in OpenGL style coordinates, which means a right handed +/// coordinate system with the origin in the lower left corner of the window. //-------------------------------------------------------------------------------------------------- -void ManipulatorTrackball::startNavigation(NavigationType navigationType, int winCoordX, int winCoordY) +void ManipulatorTrackball::startNavigation(NavigationType navigationType, int x, int y) { if (m_camera.isNull()) return; if (m_activeNavigation == navigationType) return; - m_lastPosX = winCoordX; - m_lastPosY = winCoordY; + m_lastPosX = x; + m_lastPosY = y; // Register camera's starting position for walk m_walkStartCameraPos = m_camera->position(); @@ -110,25 +111,26 @@ void ManipulatorTrackball::startNavigation(NavigationType navigationType, int wi //-------------------------------------------------------------------------------------------------- -/// +/// The window coordinates are in OpenGL style coordinates, which means a right handed +/// coordinate system with the origin in the lower left corner of the window. //-------------------------------------------------------------------------------------------------- -bool ManipulatorTrackball::updateNavigation(int winCoordX, int winCoordY) +bool ManipulatorTrackball::updateNavigation(int x, int y) { if (m_activeNavigation == PAN) { - return pan(winCoordX, winCoordY); + return pan(x, y); } else if (m_activeNavigation == WALK) { - return walk(winCoordX, winCoordY); + return walk(x, y); } else if (m_activeNavigation == ZOOM) { - return zoom(winCoordX, winCoordY); + return zoom(x, y); } else if (m_activeNavigation == ROTATE) { - return rotate(winCoordX, winCoordY); + return rotate(x, y); } return false; @@ -185,13 +187,13 @@ bool ManipulatorTrackball::pan(int posX, int posY) const double camRotPointDist = Math::abs(camDir*vDiff); Vec3d vX = camRight*((tx*vpWorldSizeX)/nearPlane)*camRotPointDist; - Vec3d vY = -camUp*((ty*vpWorldSizeY)/nearPlane)*camRotPointDist; + Vec3d vY = camUp*((ty*vpWorldSizeY)/nearPlane)*camRotPointDist; translation = vX + vY; } else if (projType == Camera::ORTHO) { Vec3d vX = camRight*tx*vpWorldSizeX; - Vec3d vY = -camUp*ty*vpWorldSizeY; + Vec3d vY = camUp*ty*vpWorldSizeY; translation = vX + vY; } @@ -226,7 +228,7 @@ bool ManipulatorTrackball::walk(int posX, int posY) // Should be a member variable, settable as a ratio of the model bounding box/sphere const double minWalkTargetDistance = 1.0; - const double ty = (posY - m_lastPosY)/vpPixSizeY; + const double ty = (m_lastPosY - posY)/vpPixSizeY; // Determine target distance to travel along camera direction // This is the distance that we will move the camera in response to a full (whole viewport) movement of the mouse @@ -261,7 +263,7 @@ bool ManipulatorTrackball::zoom(int posX, int posY) const double vpPixSizeY = m_camera->viewport()->height(); if (vpPixSizeY <= 0) return false; - const double ty = (posY - m_lastPosY)/vpPixSizeY; + const double ty = (m_lastPosY - posY)/vpPixSizeY; const double frustumHeight = m_camera->frontPlaneFrustumHeight(); @@ -312,17 +314,21 @@ bool ManipulatorTrackball::rotate(int posX, int posY) const double vpPixSizeY = m_camera->viewport()->height(); if (vpPixSizeX <= 0 || vpPixSizeY <= 0) return false; + const double vpPosX = posX - static_cast(m_camera->viewport()->x()); + const double vpPosY = posY - static_cast(m_camera->viewport()->y()); + const double vpLastPosX = m_lastPosX - static_cast(m_camera->viewport()->x()); + const double vpLastPosY = m_lastPosY - static_cast(m_camera->viewport()->y()); // Scale the new/last positions to the range [-1.0, 1.0] - double newPosX = 2.0*(posX/vpPixSizeX) - 1.0; - double newPosY = 2.0*(posY/vpPixSizeY) - 1.0; - double lastPosX = 2.0*(m_lastPosX/vpPixSizeX) - 1.0; - double lastPosY = 2.0*(m_lastPosY/vpPixSizeY) - 1.0; + double newPosX = 2.0*(vpPosX/vpPixSizeX) - 1.0; + double newPosY = 2.0*(vpPosY/vpPixSizeY) - 1.0; + double lastPosX = 2.0*(vpLastPosX/vpPixSizeX) - 1.0; + double lastPosY = 2.0*(vpLastPosY/vpPixSizeY) - 1.0; Mat4d viewMat = m_camera->viewMatrix(); // Compute rotation quaternion - Quatd rotQuat = trackballRotation(lastPosX, -lastPosY, newPosX, -newPosY, viewMat, m_rotateSensitivity); + Quatd rotQuat = trackballRotation(lastPosX, lastPosY, newPosX, newPosY, viewMat, m_rotateSensitivity); // Update navigation by modifying the view matrix Mat4d rotMatr = rotQuat.toMatrix4(); diff --git a/VisualizationModules/LibViewing/cvfManipulatorTrackball.h b/VisualizationModules/LibViewing/cvfManipulatorTrackball.h index 09522ae3f0..b444844050 100644 --- a/VisualizationModules/LibViewing/cvfManipulatorTrackball.h +++ b/VisualizationModules/LibViewing/cvfManipulatorTrackball.h @@ -54,8 +54,8 @@ public: void setView(const Vec3d& alongDirection, const Vec3d& upDirection); NavigationType activeNavigation() const; - void startNavigation(NavigationType navigationType, int winCoordX, int winCoordY); - bool updateNavigation(int winCoordX, int winCoordY); + void startNavigation(NavigationType navigationType, int x, int y); + bool updateNavigation(int x, int y); void endNavigation(); private: diff --git a/VisualizationModules/LibViewing/cvfPartHighlighter.cpp b/VisualizationModules/LibViewing/cvfPartHighlighter.cpp index 7d3f37cba0..3570c13617 100644 --- a/VisualizationModules/LibViewing/cvfPartHighlighter.cpp +++ b/VisualizationModules/LibViewing/cvfPartHighlighter.cpp @@ -38,6 +38,7 @@ #include "cvfRenderStateBlending.h" #include "cvfRenderStatePolygonMode.h" #include "cvfRenderStateLine.h" +#include "cvfClipPlaneSet.h" namespace cvf { @@ -69,12 +70,6 @@ PartHighlighter::PartHighlighter(Model* highlightModel, Camera* mainCamera) m_drawFbo = new FramebufferObject; m_drawFbo->attachColorTexture2d(0, selectedColorTexture.p()); - ShaderProgramGenerator spGen("DrawHighlightGeo", ShaderSourceProvider::instance()); - spGen.addVertexCode(ShaderSourceRepository::vs_Standard); - spGen.addFragmentCode(ShaderSourceRepository::src_Color); - spGen.addFragmentCode(ShaderSourceRepository::fs_Unlit); - ref shaderProg = spGen.generate(); - // Note that we clear alpha to 0 m_highlightCamera = new Camera; m_highlightCamera->viewport()->setClearColor(Color4f(Color3::GRAY, 0)); @@ -85,14 +80,7 @@ PartHighlighter::PartHighlighter(Model* highlightModel, Camera* mainCamera) m_drawRendering->setCamera(m_highlightCamera.p()); m_drawRendering->setScene(new Scene); m_drawRendering->scene()->addModel(m_highlightModel.p()); - - { - ref eff = new Effect; - eff->setShaderProgram(shaderProg.p()); - // Use magenta to detect if something isn't working as it should - eff->setUniform(new UniformFloat("u_color", Color4f(Color3::MAGENTA))); - m_drawRendering->setEffectOverride(eff.p()); - } + m_drawRendering->setRenderingName("PartHighlighter : Main 'solid' rendering (m_drawRendering)"); // Draw geometry again using lines to increase footprint of slim details bool growFootprintUsingLineDrawing = true; @@ -104,18 +92,11 @@ PartHighlighter::PartHighlighter(Model* highlightModel, Camera* mainCamera) m_drawRenderingLines->setScene(new Scene); m_drawRenderingLines->scene()->addModel(m_highlightModel.p()); m_drawRenderingLines->setClearMode(Viewport::DO_NOT_CLEAR); - - { - ref eff = new Effect; - eff->setShaderProgram(shaderProg.p()); - eff->setRenderState(new RenderStatePolygonMode(RenderStatePolygonMode::LINE)); - eff->setRenderState(new RenderStateLine(3)); - // Use cyan to detect if something isn't working as it should - eff->setUniform(new UniformFloat("u_color", Color4f(Color3::CYAN))); - m_drawRenderingLines->setEffectOverride(eff.p()); - } + m_drawRenderingLines->setRenderingName("PartHighlighter : Main 'solid' rendering (lines) (m_drawRenderingLines)"); } + configureOverrideEffects(false); + // Setup the blur helper // The sigma value her should be tuned to the line width used above // If sigma gets larger that the line width we will get artifacts during the blur pass @@ -141,6 +122,7 @@ PartHighlighter::PartHighlighter(Model* highlightModel, Camera* mainCamera) quadRenderGen.setUniform(m_highlightClrUniform.p()); m_mixRendering = quadRenderGen.generate(); m_mixRendering->setClearMode(Viewport::DO_NOT_CLEAR); + m_mixRendering->setRenderingName("PartHighlighter : Mix Rendering (m_mixRendering)"); } } @@ -205,14 +187,15 @@ void PartHighlighter::removeRenderingsFromSequence(RenderSequence* renderSequenc //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- -void PartHighlighter::resize(uint width, uint height) +void PartHighlighter::resize(int x, int y, uint width, uint height) { m_drawFbo->resizeAttachedBuffers(width, height); // Since draw and drawLines shares a camera, this call will set both m_drawRendering->camera()->setViewport(0, 0, width, height); - m_mixRendering->camera()->setViewport(0, 0, width, height); + // Mix rendering is the only "on-screen" rendering so here we do need to set the position of the viewport + m_mixRendering->camera()->setViewport(x, y, width, height); if (m_blur.notNull()) { @@ -239,6 +222,78 @@ void PartHighlighter::prepareForRedraw() } +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +void PartHighlighter::setClipPlaneSet(ClipPlaneSet* clipPlaneSet) +{ + m_drawRendering->removeAllGlobalDynamicUniformSets(); + + if (m_drawRenderingLines.notNull()) + { + m_drawRenderingLines->removeAllGlobalDynamicUniformSets(); + } + + if (clipPlaneSet) + { + m_drawRendering->addGlobalDynamicUniformSet(clipPlaneSet); + if (m_drawRenderingLines.notNull()) + { + m_drawRenderingLines->addGlobalDynamicUniformSet(clipPlaneSet); + } + + configureOverrideEffects(true); + } + else + { + configureOverrideEffects(false); + } +} + + +//-------------------------------------------------------------------------------------------------- +/// +//-------------------------------------------------------------------------------------------------- +void PartHighlighter::configureOverrideEffects(bool useClipping) +{ + ShaderProgramGenerator spGen("DrawHighlightGeo", ShaderSourceProvider::instance()); + + if (useClipping) + { + spGen.addVertexCode(cvf::ShaderSourceRepository::calcClipDistances); + spGen.addFragmentCode(cvf::ShaderSourceRepository::checkDiscard_ClipDistances); + } + + spGen.addVertexCode(ShaderSourceRepository::vs_Standard); + spGen.addFragmentCode(ShaderSourceRepository::src_Color); + spGen.addFragmentCode(ShaderSourceRepository::fs_Unlit); + + ref shaderProg = spGen.generate(); + + if (useClipping) + { + shaderProg->setDefaultUniform(new cvf::UniformInt( "u_clipPlaneCount", 0)); + shaderProg->setDefaultUniform(new cvf::UniformFloat("u_ecClipPlanes", cvf::Vec4f(0, 0, 1, 0))); + } + + ref eff = new Effect; + eff->setShaderProgram(shaderProg.p()); + // Use magenta to detect if something isn't working as it should + eff->setUniform(new UniformFloat("u_color", Color4f(Color3::MAGENTA))); + m_drawRendering->setEffectOverride(eff.p()); + + if (m_drawRenderingLines.notNull()) + { + ref eff = new Effect; + eff->setShaderProgram(shaderProg.p()); + eff->setRenderState(new RenderStatePolygonMode(RenderStatePolygonMode::LINE)); + eff->setRenderState(new RenderStateLine(3)); + // Use cyan to detect if something isn't working as it should + eff->setUniform(new UniformFloat("u_color", Color4f(Color3::CYAN))); + m_drawRenderingLines->setEffectOverride(eff.p()); + } +} + //================================================================================================== diff --git a/VisualizationModules/LibViewing/cvfPartHighlighter.h b/VisualizationModules/LibViewing/cvfPartHighlighter.h index 87d1b7c3f2..ea88af85d8 100644 --- a/VisualizationModules/LibViewing/cvfPartHighlighter.h +++ b/VisualizationModules/LibViewing/cvfPartHighlighter.h @@ -31,6 +31,7 @@ class Model; class Camera; class GaussianBlur; class UniformFloat; +class ClipPlaneSet; @@ -48,9 +49,14 @@ public: void addRenderingsToSequence(RenderSequence* renderSequence); void removeRenderingsFromSequence(RenderSequence* renderSequence); - void resize(uint width, uint height); + void resize(int x, int y, uint width, uint height); void prepareForRedraw(); + void setClipPlaneSet(ClipPlaneSet* clipPlaneSet); + +private: + void configureOverrideEffects(bool useClipping); + private: ref m_highlightModel; // Model containing the parts that should be highlighted ref m_highlightCamera; // Camera to use in the highlight rendering, need a separate camera as long as clear color is part of camera/viewport @@ -63,7 +69,6 @@ private: ref m_mixRendering; // Rendering used in final mix pass ref m_highlightClrUniform; // Uniform that controls the highlight color used in the mix rendering ref m_blur; // Blur helper - }; diff --git a/VisualizationModules/LibViewing/cvfRendering.cpp b/VisualizationModules/LibViewing/cvfRendering.cpp index 80ee9f92b2..b29e6cc711 100644 --- a/VisualizationModules/LibViewing/cvfRendering.cpp +++ b/VisualizationModules/LibViewing/cvfRendering.cpp @@ -159,7 +159,10 @@ void Rendering::render(OpenGLContext* oglContext) } // Update any transforms and bounding boxes if a transform tree is used - m_scene->updateTransformTree(m_camera.p()); + if (m_scene.notNull()) + { + m_scene->updateTransformTree(m_camera.p()); + } // Compute visible parts // ------------------------------------------------------------------------- @@ -294,15 +297,15 @@ void Rendering::renderOverlayItems(OpenGLContext* oglContext, bool useSoftwareRe for (it = itemRectMap.begin(); it != itemRectMap.end(); ++it) { OverlayItem* item = it->first; - Rectui rect = it->second; + Recti rect = it->second; if (useSoftwareRendering) { - item->renderSoftware(oglContext, rect.min(), Vec2ui(rect.width(), rect.height())); + item->renderSoftware(oglContext, rect.min(), Vec2ui(static_cast(rect.width()), static_cast(rect.height()))); } else { - item->render(oglContext, rect.min(), Vec2ui(rect.width(), rect.height())); + item->render(oglContext, rect.min(), Vec2ui(static_cast(rect.width()), static_cast(rect.height()))); } } } @@ -329,10 +332,11 @@ void Rendering::calculateOverlayItemLayout(OverlayItemRectMap* itemRectMap) //-------------------------------------------------------------------------------------------------- void Rendering::calculateOverlayItemLayout(OverlayItemRectMap* itemRectMap, OverlayItem::LayoutCorner corner, OverlayItem::LayoutDirection direction) { - const uint border = 3; - const Vec2ui vpSize = Vec2ui(m_camera->viewport()->width(), m_camera->viewport()->height()); + const int border = 3; + const Vec2i vpSize = Vec2i(static_cast(m_camera->viewport()->width()), static_cast(m_camera->viewport()->height())); + const Vec2i vpPos = Vec2i(m_camera->viewport()->x(), m_camera->viewport()->y()); - Vec2ui cursor(0,0); + Vec2i cursor(0,0); switch (corner) { case OverlayItem::TOP_LEFT: cursor.set(border, vpSize.y() - border); break; @@ -342,11 +346,13 @@ void Rendering::calculateOverlayItemLayout(OverlayItemRectMap* itemRectMap, Over default: cursor.set(border,border); } + cursor += vpPos; + // Adjust based on other already placed items OverlayItemRectMap::iterator it; for (it = itemRectMap->begin(); it != itemRectMap->end(); ++it) { - Rectui rect = it->second; + Recti rect = it->second; if (rect.contains(cursor) && (direction == OverlayItem::VERTICAL)) { @@ -371,7 +377,7 @@ void Rendering::calculateOverlayItemLayout(OverlayItemRectMap* itemRectMap, Over CVF_ASSERT(item.overlayItem.notNull()); // Find this position and size - Vec2ui position = cursor; + Vec2i position = cursor; Vec2ui size = item.overlayItem->sizeHint(); if ((corner == OverlayItem::TOP_RIGHT) || (corner == OverlayItem::BOTTOM_RIGHT)) { @@ -384,7 +390,7 @@ void Rendering::calculateOverlayItemLayout(OverlayItemRectMap* itemRectMap, Over } // Store the position in the map - Rectui rect(position.x(), position.y(), size.x(), size.y()); + Recti rect(position.x(), position.y(), static_cast(size.x()), static_cast(size.y())); (*itemRectMap)[item.overlayItem.p()] = rect; // Find next position, moving the cursor @@ -505,17 +511,17 @@ RenderQueueSorter* Rendering::renderQueueSorter() //-------------------------------------------------------------------------------------------------- /// Create a new RayIntersectSpec object based on this rendering and the specified coordinates /// -/// The coordinates (\a winCoordX & \a winCoordY) are assumed to be in the window coordinate system -/// where <0,0> if in the top left corner. +/// The window coordinates are in OpenGL style coordinates, which means a right handed +/// coordinate system with the origin in the lower left corner of the window. //-------------------------------------------------------------------------------------------------- -ref Rendering::createRayIntersectSpec(int winCoordX, int winCoordY) const +ref Rendering::rayIntersectSpecFromWindowCoordinates(int x, int y) const { if (m_scene.isNull() || m_camera.isNull()) { return NULL; } - ref ray = m_camera->rayFromWinCoord(winCoordX, winCoordY); + ref ray = m_camera->rayFromWindowCoordinates(x, y); if (ray.isNull()) { return NULL; @@ -670,7 +676,7 @@ void Rendering::addGlobalDynamicUniformSet(DynamicUniformSet* dynUniformSet) //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- -void Rendering::removeAllGlobalUniformSets() +void Rendering::removeAllGlobalDynamicUniformSets() { m_globalDynamicUniformSets.clear(); } @@ -877,12 +883,8 @@ const OverlayItem* Rendering::overlayItem(size_t index, OverlayItem::LayoutCorne //-------------------------------------------------------------------------------------------------- /// Get the the overlay item (if any) at the given cursor position //-------------------------------------------------------------------------------------------------- -OverlayItem* Rendering::overlayItemFromWinCoord(uint winCoordX, uint winCoordY) +OverlayItem* Rendering::overlayItemFromWindowCoordinates(int x, int y) { - // Overlay items are stored OpenGL coord system with (0,0) in lower left corner, so flip the y-coordinate - uint oglCoordX = winCoordX; - uint oglCoordY = static_cast(m_camera->viewport()->height()) - winCoordY; - OverlayItemRectMap itemRectMap; calculateOverlayItemLayout(&itemRectMap); @@ -890,9 +892,9 @@ OverlayItem* Rendering::overlayItemFromWinCoord(uint winCoordX, uint winCoordY) for (it = itemRectMap.begin(); it != itemRectMap.end(); ++it) { OverlayItem* item = it->first; - Rectui rect = it->second; + Recti rect = it->second; - if (item->pick(oglCoordX, oglCoordY, rect.min(), Vec2ui(rect.width(), rect.height()))) + if (item->pick(x, y, rect.min(), Vec2ui(static_cast(rect.width()), static_cast(rect.height())))) { return item; } @@ -933,7 +935,7 @@ void Rendering::removeAllOverlayItems() //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- -String Rendering::toString() const +String Rendering::debugString() const { String str = "Rendering: "; str += m_renderingName; diff --git a/VisualizationModules/LibViewing/cvfRendering.h b/VisualizationModules/LibViewing/cvfRendering.h index ca33795ff9..7061de66b8 100644 --- a/VisualizationModules/LibViewing/cvfRendering.h +++ b/VisualizationModules/LibViewing/cvfRendering.h @@ -79,7 +79,7 @@ public: FramebufferObject* targetFramebuffer(); void setTargetFramebuffer(FramebufferObject* framebuffer); - ref createRayIntersectSpec(int winCoordX, int winCoordY) const; + ref rayIntersectSpecFromWindowCoordinates(int x, int y) const; bool rayIntersect(RayIntersectSpec& rayIntersectSpec, HitItemCollection* hitItemCollection); BoundingBox boundingBox() const; @@ -97,7 +97,7 @@ public: void removeDynamicUniformSet(DynamicUniformSet* dynUniformSet); void removeAllDynamicUniformSets(); void addGlobalDynamicUniformSet(DynamicUniformSet* dynUniformSet); - void removeAllGlobalUniformSets(); + void removeAllGlobalDynamicUniformSets(); const PerformanceInfo& performanceInfo() const; void enablePerformanceTiming(bool enable); @@ -112,16 +112,16 @@ public: void addOverlayItem(OverlayItem* overlayItem, OverlayItem::LayoutCorner corner, OverlayItem::LayoutDirection direction); OverlayItem* overlayItem(size_t index, OverlayItem::LayoutCorner* corner, OverlayItem::LayoutDirection* direction); const OverlayItem* overlayItem(size_t index, OverlayItem::LayoutCorner* corner, OverlayItem::LayoutDirection* direction) const; - OverlayItem* overlayItemFromWinCoord(uint winCoordX, uint winCoordY); + OverlayItem* overlayItemFromWindowCoordinates(int x, int y); void removeOverlayItem(const OverlayItem* overlayItem); void removeAllOverlayItems(); - String toString() const; + String debugString() const; private: void renderOverlayItems(OpenGLContext* oglContext, bool useSoftwareRendering); - typedef std::map OverlayItemRectMap; + typedef std::map OverlayItemRectMap; void calculateOverlayItemLayout(OverlayItemRectMap* itemRectMap); void calculateOverlayItemLayout(OverlayItemRectMap* itemRectMap, OverlayItem::LayoutCorner corner, OverlayItem::LayoutDirection direction); diff --git a/VisualizationModules/LibViewing/cvfSingleQuadRenderingGenerator.cpp b/VisualizationModules/LibViewing/cvfSingleQuadRenderingGenerator.cpp index 3dad8a97b3..a145745f8d 100644 --- a/VisualizationModules/LibViewing/cvfSingleQuadRenderingGenerator.cpp +++ b/VisualizationModules/LibViewing/cvfSingleQuadRenderingGenerator.cpp @@ -29,6 +29,7 @@ #include "cvfShaderProgram.h" #include "cvfShaderProgramGenerator.h" #include "cvfRenderStateTextureBindings.h" +#include "cvfRenderStateDepth.h" namespace cvf { @@ -167,6 +168,7 @@ ref SingleQuadRenderingGenerator::generate() ref shaderProg = gen.generate(); eff->setShaderProgram(shaderProg.p()); + eff->setRenderState(new RenderStateDepth(true, RenderStateDepth::LESS, false)); uint rs; for (rs = 0; rs < m_renderStateSet.count(); rs++) diff --git a/cafViewer/cafCadNavigation.cpp b/cafViewer/cafCadNavigation.cpp index 41ce3681a3..8eb0d10ccd 100644 --- a/cafViewer/cafCadNavigation.cpp +++ b/cafViewer/cafCadNavigation.cpp @@ -49,23 +49,27 @@ bool caf::CadNavigation::handleInputEvent(QInputEvent* inputEvent) { if (! inputEvent) return false; bool isEventHandled = false; + switch (inputEvent->type()) { case QEvent::MouseButtonPress: { QMouseEvent * me = static_cast( inputEvent); + int translatedMousePosX = me->x(); + int translatedMousePosY = m_viewer->height() - me->y(); + if (me->button() == Qt::MidButton) { if (me->modifiers() & Qt::ShiftModifier) { - m_trackball->startNavigation(cvf::ManipulatorTrackball::PAN, me->x(), me->y()); + m_trackball->startNavigation(cvf::ManipulatorTrackball::PAN, translatedMousePosX, translatedMousePosY); m_isRotating = true; isEventHandled = true; } else if (me->modifiers() == Qt::NoModifier) { cvf::HitItemCollection hic; - bool hitSomething = m_viewer->rayPick(me->x(), me->y(), &hic); + bool hitSomething = m_viewer->rayPick(translatedMousePosX, translatedMousePosY, &hic); if (hitSomething) { @@ -78,7 +82,7 @@ bool caf::CadNavigation::handleInputEvent(QInputEvent* inputEvent) initializeRotationCenter(); } - m_trackball->startNavigation(cvf::ManipulatorTrackball::ROTATE, me->x(), me->y()); + m_trackball->startNavigation(cvf::ManipulatorTrackball::ROTATE, translatedMousePosX, translatedMousePosY); //m_viewer->setCursor(RICursors::get(RICursors::ROTATE)); m_isRotating = true; isEventHandled = true; @@ -107,9 +111,12 @@ bool caf::CadNavigation::handleInputEvent(QInputEvent* inputEvent) if (m_isRotCenterInitialized) { QMouseEvent * me = static_cast( inputEvent); + int translatedMousePosX = me->x(); + int translatedMousePosY = m_viewer->height() - me->y(); + if (m_isRotating) { - bool needRedraw = m_trackball->updateNavigation(me->x(), me->y()); + bool needRedraw = m_trackball->updateNavigation(translatedMousePosX, translatedMousePosY); if (needRedraw) { m_viewer->update(); @@ -126,12 +133,15 @@ bool caf::CadNavigation::handleInputEvent(QInputEvent* inputEvent) initializeRotationCenter(); if (m_isRotCenterInitialized) { - QWheelEvent* we = static_cast ( inputEvent); + QWheelEvent* we = static_cast(inputEvent); + int translatedMousePosX = we->x(); + int translatedMousePosY = m_viewer->height() - we->y(); + cvf::ref ray; if (we->delta() > 0) - ray = m_viewer->mainCamera()->rayFromWinCoord(we->x(), we->y()); + ray = m_viewer->mainCamera()->rayFromWindowCoordinates(translatedMousePosX, translatedMousePosY); else - ray = m_viewer->mainCamera()->rayFromWinCoord((int)(1.0*we->x()), (int)(1.0*we->y())); + ray = m_viewer->mainCamera()->rayFromWindowCoordinates((int)(1.0*translatedMousePosX), (int)(1.0*translatedMousePosY)); if (ray.notNull() && abs(we->delta()) > 0) { diff --git a/cafViewer/cafCeetronNavigation.cpp b/cafViewer/cafCeetronNavigation.cpp index a250185bb0..4b09a40da2 100644 --- a/cafViewer/cafCeetronNavigation.cpp +++ b/cafViewer/cafCeetronNavigation.cpp @@ -111,7 +111,7 @@ void caf::CeetronNavigation::mouseMoveEvent(QMouseEvent* event) if (!m_viewer->canRender()) return; initializeRotationCenter(); int posX = event->x(); - int posY = event->y(); + int posY = m_viewer->height() - event->y(); ManipulatorTrackball::NavigationType navType = getNavigationTypeFromMouseButtons(event->buttons()); if (navType != m_trackball->activeNavigation()) @@ -137,7 +137,7 @@ void caf::CeetronNavigation::mousePressEvent(QMouseEvent* event) if (!m_viewer->canRender()) return; initializeRotationCenter(); int posX = event->x(); - int posY = event->y(); + int posY = m_viewer->height() - event->y(); ManipulatorTrackball::NavigationType navType = getNavigationTypeFromMouseButtons(event->buttons()); m_trackball->startNavigation(navType, posX, posY); @@ -176,16 +176,18 @@ void caf::CeetronNavigation::wheelEvent(QWheelEvent* event) int navDelta = vpHeight/5; if (event->delta() < 0) navDelta *= -1; + int posY = m_viewer->height() - event->y(); + if (m_viewer->mainCamera()->projection() == cvf::Camera::PERSPECTIVE) { - m_trackball->startNavigation(ManipulatorTrackball::WALK, event->x(), event->y()); + m_trackball->startNavigation(ManipulatorTrackball::WALK, event->x(), posY); } else { - m_trackball->startNavigation(ManipulatorTrackball::ZOOM, event->x(), event->y()); + m_trackball->startNavigation(ManipulatorTrackball::ZOOM, event->x(), posY); } - m_trackball->updateNavigation(event->x(), event->y() - navDelta); + m_trackball->updateNavigation(event->x(), posY + navDelta); m_trackball->endNavigation(); m_viewer->update(); diff --git a/cafViewer/cafViewer.cpp b/cafViewer/cafViewer.cpp index 6c0d39b306..c85927cf75 100644 --- a/cafViewer/cafViewer.cpp +++ b/cafViewer/cafViewer.cpp @@ -324,8 +324,10 @@ bool caf::Viewer::rayPick(int winPosX, int winPosY, cvf::HitItemCollection* pick { CVF_ASSERT(m_mainRendering.notNull()); + int translatedMousePosX = winPosX; + int translatedMousePosY = height() - winPosY; - cvf::ref ris = m_mainRendering->createRayIntersectSpec(winPosX, winPosY); + cvf::ref ris = m_mainRendering->rayIntersectSpecFromWindowCoordinates(translatedMousePosX, translatedMousePosY); if (ris.notNull()) { bool retVal = m_mainRendering->rayIntersect(*ris, pickedPoints); @@ -545,9 +547,8 @@ void caf::Viewer::releaseOGlResourcesForCurrentFrame() { cvf::Scene* currentScene = m_renderingSequence->firstRendering()->scene(); makeCurrent(); - size_t modelCount = currentScene->modelCount(); - size_t i; - for (i = 0; i < modelCount; ++i) + cvf::uint modelCount = currentScene->modelCount(); + for (cvf::uint i = 0; i < modelCount; ++i) { cvf::Collection partCollection; currentScene->model(i)->allParts(&partCollection);