Harlinn.Windows is a collection of libraries that serve as a big part of the runtime we use at work. A few of the libraries are my own; but most are well-known open source libraries.
The downloads were last updated on the 26th of January, 2022. Information about what has changed can be found at the end of this article.
If you have problems downloading the full code archive as a single zip-file, all of the files below provides the download as a multi-part zip-file:
Note: If you download the individual files, extract the contents of each file into one directory and then use 7zip or WinZip to extract them.
Github
I have also created a Github repository, Harlinn.Windows, that provides access to the code. The code in the repository currently compiles with Visual Studio 17.11.0 (as of 16th of August 2024). Earlier, some files where missing from the repository, and this has now been resolved. The version of the solution in the github repository has many updates and additions compared to the version provided with this article. The solution on Github currently contains 625 projects.
Overview
This article describes Harlinn.Windows, a Visual Studio 2022 solution.
Before you can build the solution, please read the build instructions and configure your environment accordingly.
This solution is for 64-bit, x64, builds only.
Introduction
Harlinn.Windows is a collection of libraries that I have put together that serves as a big part of the runtime we use at work. A few are my own; but most are; more or less, well-known open source libraries.
There are currently 521 projects in the solution, and this article provides a high-level overview of what's inside.
Why Did I Not Use cmake and vcpkg?
This is a good question, and initially I tried to do just that, but there were some snags:
- The size of the release build, using vcpkg, for grpc.lib was 325 MB; while the size of the release build of Harlinn.grpc.dll is just 3.7 MB. Currently, the combined size of all the native DLLs created for a release build of the solution is 108 MB.
- Some packages relied on different versions of the same package, including their own private copy of a package.
- Some packages were compiled with /sdl on, while others were not. I prefer to turn /sdl and /GS off for release builds, and on for debug builds. This may not be as significant as it used to, but you still get better performance when turning /sdl and /GS off.
- Many packages will not compile with:
- The /std:c++latest option, which enables all currently implemented compiler and standard library features proposed for the next draft standard, as well as some in-progress and experimental features.
- Many packages creates static libraries, not DLLs.
Don't get me wrong; I think CMake and vcpkg are great tools, but putting everything into a single solution makes it easier, at least for me, to understand how everything is tied together.
Why put Harlinn in Front of Every DLL Name?
To avoid naming conflicts. I own the harlinn.com domain, so it is unlikely that anybody would, by accident, put Harlinn in front of the name of their DLL.
What About the Unit Tests?
A few of those are included, but still just a fraction of those available for the original packages.
In particular, I've included all unit tests, that can be expected to compile on Windows, for:
- Abseil - 4430 tests pass, 26 fails, and 12 tests are disabled
- boringssl
crypto_test - 910 tests pass, 0 fails, and 0 tests are disabledssl_test - 330 tests pass, 0 fails, and 0 tests are disabled
- gRPC - the tests are implemented as 94 separate executables, using multiple approaches to testing. I think that the tests pass; but I am not certain, since much of the validation was performed manually.
- bullet - 31 tests pass, 0 fails, and 0 tests are disabled
- gdal - 84 tests pass, 0 fails, and 0 tests are disabled
-
skia - A fair number of the tests works, about 1500 of them, but then the test program terminates.
As far as I have been able to determine, this seems to be related to the test code.
I've also created a fair number of tests for my own projects:
Harlinn.Common.Core.Tests: 1175Harlinn.Windows.Tests: 271Harlinn.OCI.Tests: 49Harlinn.ODBC.Tests: 9Harlinn.Timeseries.Tests: 10Harlinn.Julia.Tests: 11Harlinn.Common.Config.Tests: 34
All tests can be found under the Tests folder.
What About the Examples?
So far, I've included 190 example projects.
All examples can be found under the Examples and DotNet\Examples folders.
How Stable Is This?
This is a snapshot of the solution, and while most things seems to work, there are bound to be some snags. The most common problem will be a function or variable that is not exported from a DLL, and there are probably other bugs too. Some, probably, created by yours truly.
Still, with this solution, you can now:
-
Use Open GL ES to create graphical applications on top of DirectX 3D:
-
Create nice 2D effects:
-
Create animated 3D visualizations:
-
Learn a lot about some of the most widely used open source packages available, using Visual Studio 2022 and C++.
Harlinn.Common.Core
Harlinn.Common.Core is a library packaged as a DLL that provides functionality that is useful for most Windows C++ projects.
Dependencies
- The boost C++ libraries
Other 3rd Party Code included in Harlinn.Common.Core
The Harlinn.Common.Core library contains code from a number of libraries:
- The {fmt} library, version 8.0.1, by Victor Zverovich
- The xxHash library, version 0.8.1
- The CRC-32C (Castagnoli) for C++ library
- The xxhash_cx library
About char, wchar_t, signed char and unsigned char
The library tries to treat char and wchar_t as types used for the sole purpose of representing character data, while signed char and unsigned char are expected to represent signed and unsigned 8-bit integers, respectively.
Normally, this is not much of a problem, but consider:
constexpr char buffer1[] = { 1,2,3 };
constexpr unsigned char buffer2[] = { 1,2,3 };
constexpr char buffer3[] = "hello";
constexpr int buffer4[] = { 1,2,3 };
constexpr wchar_t_ buffer5[] = { 1,2,3 };
constexpr wchar_t_ buffer6[] = L"hello";
constexpr auto length1 = LengthOf( buffer1 );
constexpr auto length2 = LengthOf( buffer2 );
constexpr auto length3 = LengthOf( buffer3 );
constexpr auto length4 = LengthOf( buffer4 );
constexpr auto length5 = LengthOf( buffer5 );
constexpr auto length6 = LengthOf( buffer6 );
LengthOf expects buffer1 and buffer5 to be zero-terminated; but since they are not, the compiler will not be able to evaluate LengthOf( buffer1 ) and LengthOf( buffer5 ). LengthOf( buffer3 ) and LengthOf( buffer6 ) evaluate to 5, while LengthOf( buffer2 ) and LengthOf( buffer4 ) evaluate to 3.
The code in HCCPersistent.h, which is used by the code in HCCLogger.h, relies on this, eliminating a significant number of calls to strlen and wcslen at runtime.
Main Header Files
- HCC7BitEncoding.h: provides
constexpr support for 7-bit encoded values. -
HCCActiveObject.h: provides:
-
HCCApplication.h: provides:
-
class Application:
Every program needs to create one, and only one, instance of this class, or a class derived from this class.
int main( int argc, char* argv[], char* envp[] )
{
Harlinn::Common::Core::ApplicationOptions options;
options.Load( );
Harlinn::Common::Core::Application application( options );
application.Start( );
int result = foo( );
application.Stop( );
return result;
}
Currently this configures, starts and stops the logging back-end on behalf of the program.
-
HCCArray.h: provides:
-
template<typename T, size_t N> ArrayEx:
A template derived from std::array that supports constexpr concatenation using operator +.
-
template<typename T, size_t N> class Array:
An alternative to std::array that supports constexpr concatenation using operator +.
-
template<size_t N> class ByteArray:
A template that supports constexpr serialization of binary data.
-
template<size_t N, bool networkByteOrder = false, bool use7BitEncodedSize = true> class ArrayReader:
A template that implements constexpr deserialization of data.
-
template<size_t N, bool networkByteOrder = false, bool use7BitEncodedSize = true> class ArrayWriter:
A template that implements constexpr serialization of data.
- HCCBinaryReader.h: provides:
BinaryReaderBase:
template<typename Derived,
bool networkByteOrder,
bool use7BitEncodedSize>
class BinaryReaderBase
A template that can be used to deserialize binary data.BufferedBinaryReader:
template<typename StreamT,
size_t BufferSizeValue,
bool networkByteOrder = false,
bool use7BitEncodedSize = true>
class BufferedBinaryReader
A template that can be used to deserialize binary data from a stream using an internal buffer.BinaryReader:
template< IO::StreamReader StreamT,
bool networkByteOrder = false,
bool use7BitEncodedSize = true >
class BinaryReader
A template that can be used to deserialize binary data from a stream.
- HCCBinaryWriter.h: provides:
BinaryWriterBase:
template<typename Derived,
bool networkByteOrder,
bool use7BitEncodedSize>
class BinaryWriterBase
A template that can be used to serialize binary data.BufferedBinaryWriter:
template<IO::StreamWriter StreamWriterT,
size_t BufferSizeValue,
bool networkByteOrder = false,
bool use7BitEncodedSize = true >
class BufferedBinaryWriter
A template that can be used to serialize binary data to a stream using an internal buffer.
BinaryWriter:
template<IO::StreamWriter StreamT,
bool networkByteOrder = false,
bool use7BitEncodedSize = true>
class BinaryWriter
A template that can be used to serialize binary data to a stream.
- HCCBuffer.h: provides
Blocks::Stream a block oriented memory stream. - HCCCom.h: provides:
class Unknown: A wrapper for the IUnknown interfacetemplate<typename T> class UnknownPtr: A generic smart pointer for COM interfacestemplate< class InterfaceType > class IUnknownImplementation: An implementation of the IUnknown interface
- HCCConverters.h: provides various overloads of:
template <typename ResultType, typename ArgumentType>
inline ResultType ConvertTo( ArgumentType arg )
implementing efficient and 'safe' conversion between basic data types.
- HCCCRC.h: provides a few ways of calculating the CRC value for data
- HCCCrypto.h: provides functionality for working with certificates
- HCCCurrency.h: declares the
Currency class - HCCDateTime.h: provides functionality for handling date and time, declares:
class TimeSpanclass DateTimeclass Stopwatch
- HCCEnvironment.h: provides easy access to system information
- HCCEse.h: provides C++ classes for working with the Extensible Storage Engine
- HCCException.h: provides a wide range of exception classes
- HCCGuid.h: functionality for working with UUIDs/GUIDs, declares
class Guid - HCCHandle.h: declares
template<typename DerivedT, typename HandleT> class Handle - HCCHTTP.h: provides C++ classes for working with the HTTP Server API
- HCCIO.h: provides file, directory, and stream I/O related C++ classes
- HCCIOContext.h: declares:
class Context: uses a thread-pool to process asynchronous I/O for an I/O completion portclass ContextHandler: An instance of the Context class delegates the work for a particular OS handle to the Process override implemented for a class derived from ContextHandler.template<typename DerivedT> FileHandler: A template derived from ContextHandler used to perform file related asynchronous I/Oclass FileRequest: Base class for file related asynchronous I/O requestsclass ReadFileRequest: Represents an asynchronous file read requestclass WriteFileRequest: Represents an asynchronous file write requestclass FileDispatcher: Derived from FileHandler, broadcasts I/O completion events to callbacks attached to boost::signals2::signal<> handlers
-
HCCLib.h: provides a number of useful functions:
ByteSwap:
template<typename T>
requires IsInteger<std::remove_cvref_t<T>>
inline constexpr T ByteSwap( T value )
Swaps the bytes of the argument, which must be some type of integer. Performs this operation, if possible, at compile-time. If the operation must be performed at runtime, the implementation will call _byteswap_ushort, _byteswap_ulong, _byteswap_uint64, or just return the argument; based on the byte size of the argument type. ByteSwap for float, double and enums are implemented as:
template<typename T>
requires (IsFloatingPoint<std::remove_cvref_t<T>> ||
std::is_enum_v<std::remove_cvref_t<T>> )
inline constexpr T ByteSwap( const T value ) noexcept
{
using Type = std::remove_cvref_t<T>;
using UIntType = MakeUnsigned<Type>;
std::bit_cast<Type>( ByteSwap( std::bit_cast<UIntType>( value ) ) );
}
-
BitMask:
template<size_t N>
struct BitMask
{
using type = ...
static constexpr type value = ...;
};
BitMask::type: is the type of the smallest unsigned integer capable of holding a bit-mask of N bits, where N <= 64.
BitMask::value: is the value of the bit-mask with the N lowest bits set to 1.
LengthOf: returns the number of elements in an array, length of a char or wchar_t zero-terminated string, or the number of elements in a container.template<typename T> inline int Compare( T v1, T v2 ) noexcept: compares two arguments of the same basic type, returning < 0 if the first value is considered to be less than the second; 0 if they are considered equal, and otherwise > 0. For char or wchar_t zero-terminated strings, nullptr is considered equal to a string with 0 length.AreNearlyEqual:
template<typename T>
requires std::is_floating_point_v<T>
constexpr bool AreNearlyEqual( T a, T b,
T smallNumber = static_cast<T>( 0.0001 ) ) noexcept
returns true if the absolute value of the difference between a and b is less than smallNumber.class XXH64Hasher: use this class to incrementally generate a hash value from multiple inputs.IsPowerOfTwo: returns true if an integer is a power of 2.NextPowerOfTwo: returns the next higher value, that is a power of 2, greater than the argument.
- HCCLMDB.h: declares a set of C++ classes for working with LMDB based on 3rdParty\Harlinn.LMDB
- HCCLogger.h: logger implementation
- HCCLogging.h: preprocessor macros used for logging
-
HCCMath.h: constexpr math, namespace: Harlinn::Common::Core::Math
IsSameValue:
constexpr bool IsSameValue( double x, double y ) noexcept;
constexpr bool IsSameValue( float x, float y ) noexcept;
Returns true if x and y holds the same value, even if they hold NaN values.IsZero:
constexpr bool IsZero( double x ) noexcept;
constexpr bool IsZero( float x ) noexcept;
Returns true if x is 0.0 or -0.0.
-
signum:
template< typename T>
requires IsUnsignedInteger<std::remove_cvref_t<T>> ||
IsBoolean<std::remove_cvref_t<T>>
inline constexpr T signum( T val ) noexcept;
template< typename T>
requires IsSignedInteger<std::remove_cvref_t<T>>
inline constexpr T signum( T val ) noexcept;
template< typename T>
requires IsFloatingPoint<std::remove_cvref_t<T>>
inline constexpr T signum( T val ) noexcept;
Indicates the sign of val, returning -1, 0, or +1.
Deg2Rad:
template< typename T>
requires IsFloatingPoint<std::remove_cvref_t<T>>
inline constexpr std::remove_cvref_t<T> Deg2Rad( T angleInDegrees ) noexcept;
Convert angleInDegrees from degrees to radians.Rad2Deg:
template< typename T>
requires IsFloatingPoint<std::remove_cvref_t<T>>
inline constexpr std::remove_cvref_t<T> Rad2Deg( T angleInRadians ) noexcept;
Convert angleInRadians from radians to degrees.
NextAfter:
inline constexpr double NextAfter( double x, double y ) noexcept;
inline constexpr double NextAfter( float x, float y ) noexcept;
Returns the next representable value of x in the direction of y.
NextDown:
template<typename T>
requires IsFloatingPoint<T>
inline constexpr std::remove_cvref_t<T> NextDown( T x ) noexcept;
Returns the next representable value of x in the direction of negative infinity.
NextUp:
template<typename T>
requires IsFloatingPoint<T>
inline constexpr std::remove_cvref_t<T> NextUp( T x ) noexcept;
Returns the next representable value of x in the direction of positive infinity.
-
IsNaN:
template<typename T>
requires IsInteger<T>
constexpr inline bool IsNaN( T val ) noexcept;
template<typename T>
requires IsFloatingPoint<T>
constexpr inline bool IsNaN( T val ) noexcept;
Returns true if val is NaN.
-
IsInf:
template<typename T>
requires IsInteger<T>
constexpr inline bool IsInf( T val ) noexcept;
template<typename T>
requires IsFloatingPoint<T>
constexpr inline bool IsInf( T val ) noexcept;
Returns true if val is infinite.
-
Abs:
template<typename T>
requires IsSignedInteger<T>
constexpr inline std::remove_cvref_t<T> Abs( T val ) noexcept;
template<typename T>
requires IsUnsignedInteger<T>
constexpr inline std::remove_cvref_t<T> Abs( T val ) noexcept;
template<typename T>
requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Abs( T val ) noexcept;
Returns the absolute value of val.
-
SignBit:
template<typename T>
requires IsSignedInteger<T>
constexpr inline bool SignBit( T val ) noexcept;
template<typename T>
requires IsUnsignedInteger<T>
constexpr inline bool SignBit( T val ) noexcept;
template<typename T>
requires IsFloatingPoint<T>
constexpr inline bool SignBit( T val ) noexcept;
Returns true if the value of the sign of val is negative, otherwise false.
-
FRExp:
template<typename T>
requires IsInteger<T>
constexpr inline std::pair<double,int> FRExp( T val ) noexcept;
template<typename T>
requires IsFloatingPoint<T>
constexpr inline std::pair<double,int> FRExp( T val ) noexcept;
template<typename T>
requires IsInteger<T>
constexpr inline double FRExp( T val, int* exp ) noexcept;
template<typename T>
requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> FRExp( T val, int* exp ) noexcept;
template<typename T>
requires IsInteger<T>
constexpr inline double FRExp( T val, int& exp ) noexcept;
template<typename T>
requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> FRExp( T val, int& exp ) noexcept;
Return (result,exp) such that result has a magnitude in the interval [1/2, 1) or 0, and val is equal to result * 2exp.
-
ModF:
template<typename T>
requires IsFloatingPoint<T>
constexpr inline std::pair<std::remove_cvref_t<T>,
std::remove_cvref_t<T>> ModF( T val ) noexcept;
template<typename T>
requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> ModF( T val, T* integerPart ) noexcept;
template<typename T>
requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> ModF( T val, T& integerPart ) noexcept;
Return a std::pair<T,T> of the fractional and integral parts of a number. Both parts have the same sign as the argument.
-
Min:
template<typename T>
requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Min( T first, T second ) noexcept;
template<typename T>
requires IsInteger<T>
constexpr inline std::remove_cvref_t<T> Min( T first, T second ) noexcept;
Returns the smaller of the argument values.
-
Max:
template<typename T>
requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Max( T first, T second ) noexcept;
template<typename T>
requires IsInteger<T>
constexpr inline std::remove_cvref_t<T> Max( T first, T second ) noexcept;
Returns the greater of the argument values.
-
Trunc:
template<typename T>
requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Trunc( T val ) noexcept;
template<typename T>
requires IsInteger<T>
constexpr inline std::remove_cvref_t<T> Trunc( T val ) noexcept;
Returns the nearest integral value of the same type as val whose absolute value is less than or equal to the absolute value of val.
-
Floor:
template<typename T>
requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Floor( T val ) noexcept;
template<typename T>
requires IsInteger<T>
constexpr inline std::remove_cvref_t<T> Floor( T val ) noexcept;
Returns the nearest integral value of the same type as val that is less than or equal to val.
-
Ceil:
template<typename T>
requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Ceil( T val ) noexcept;
template<typename T>
requires IsInteger<T>
constexpr inline std::remove_cvref_t<T> Ceil( T val ) noexcept;
Returns the nearest integral value of the same type as val that is greater than or equal to val.
-
Round:
template<typename T>
requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Round( T val ) noexcept;
template<typename T>
requires IsInteger<T>
constexpr inline std::remove_cvref_t<T> Round( T val ) noexcept;
Returns val rounded to the nearest integral value.
-
Clamp:
template<typename T>
requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T>
Clamp( T val, T minimumValue, T maximumValue ) noexcept;
template<typename T>
requires ( IsInteger<T> )
constexpr inline std::remove_cvref_t<T>
Clamp( T val, T minimumValue, T maximumValue ) noexcept;
If val compares less than minimumValue, returns minimumValue; otherwise if maximumValue compares less than val, returns maximumValue; otherwise returns val.
Lerp:
template<typename T, typename U>
requires ( ( IsInteger<T> || IsFloatingPoint<T> ) &&
( IsInteger<U> || IsFloatingPoint<U> ) )
constexpr inline std::conditional_t<IsFloatingPoint<T>, T,
std::conditional_t<IsFloatingPoint<U>, U, T>> Lerp( T a, T b, U t ) noexcept;
Computes the linear interpolation between a and b for the parameter t (or extrapolation, when t is outside the range [0,1]).CopySign:
template<typename T>
requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T>
CopySign( T magnitude, T signValue ) noexcept;
Returns a value with the magnitude of magnitude and the sign of signValue.
ScaleByN:
inline constexpr double ScaleByN( double x, int n ) noexcept;
inline constexpr double ScaleByN( float x, int n ) noexcept;
Multiplies a floating point value x by FLT_RADIX raised to power n.
FMod:
inline constexpr double FMod( double x, double y ) noexcept;
inline constexpr float FMod( float x, float y ) noexcept;
Computes the floating-point remainder of the division operation x/y.
Exp:
template<typename T>
requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Exp( T x ) noexcept;
Computes e (Euler's number, 2.7182818)) raised to the given power of x.
Hypot:
template<typename T>
requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Hypot( T x, T y ) noexcept;
Computes the hypotenuse.
Log:
template<typename T>
requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Log( T x ) noexcept;
Computes the natural (base e)) logarithm of x.
Log2:
template<typename T>
requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Log2( T x ) noexcept;
Computes the base 2 logarithm of x.
Log10:
template<typename T>
requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Log10( T x ) noexcept;
Computes the base 10 logarithm of x.
Sin:
template<typename T>
requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Sin( T x ) noexcept;
Computes the sine of x, where x is in radians.
ASin:
template<typename T>
requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> ASin( T x ) noexcept;
Computes the inverse sine of x, in radians.
Cos:
template<typename T>
requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Cos( T x ) noexcept;
Computes cosine of x, where x is in radians.
ACos:
template<typename T>
requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> ACos( T x ) noexcept;
Computes the inverse cosine of x, with the result in radians.
Tan:
template<typename T>
requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> Tan( T x ) noexcept;
Computes tangent of x, where x is in radians.
-
ATan, ATan2:
template<typename T>
requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> ATan( T x ) noexcept;
template<typename T>
requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> ATan( T x, T y ) noexcept
template<typename T>
requires IsFloatingPoint<T>
constexpr inline std::remove_cvref_t<T> ATan2( T x, T y ) noexcept
Compute the inverse tangent of y or y/x, respectively.
SinCos:
template<typename T>
requires IsFloatingPoint<T>
inline constexpr void SinCos( T x, T& sinResult, T& cosResult ) noexcept;
Simultaneously compute the sine and cosine of x, where x is in radians.
- HCCObj.h: provides wrapper C++ classes for a wide range of Windows COM interfaces.
- HCCObjBase.h: provides wrapper C++ classes for central Windows COM interfaces.
- HCCObservable.h: declares
template<typename DerivedT> class Observable and a couple macros that can be used to implement observable properties. - HCCPersistent.h: provides a flexible and efficient serialization and deserialization mechanism.
- HCCPersistentDecoder.h: provides a generic decoder for data serialized using the mechanism provided in HCCPersistent.h.
- HCCPipe.h: Synchronous and synchronous I/O using named pipes.
- HCCProcess.h: classes for working with Windows processes.
- HCCPropSys.h: classes for working with the (Windows Property System)[https://docs.microsoft.com/en-us/windows/win32/api/_properties/]
- HCCReference.h: support for intrusive reference counted objects.
- HCCSecurity.h: classes for working with Windows Security and identity
- HCCShell.h: classes for working with the Windows Shell API).
- HCCSocket.h: Synchronous and synchronous I/O using sockets.
- HCCSync.h: classes for working with synchronization.
- HCCThread.h: classes for working with threads.
- HCCTraits.h: useful meta programming features.
- HCCTuple.h: yet another tuple implementation.
- HCCVariant.h: provides functionality for working with the VARIANT structure.
- HCCVector.h: yet another vector implementation.
- HCCXml.h: classes for working with the MSXML SDK).
Harlinn.Windows
Harlinn.Windows provides functionality for developing user interfaces in C++.
It is used to implement 73 of the examples.
Main Header Files
- HWDXGI.h: provides support for the DirectX Graphics Infrastructure API.
- HWGraphicsD3D12.h: provides support for the Direct3D 12 API.
- HWGraphics.h: provides support for the Direct2D API.
- HWDWrite.h: provides support for the DirectWrite API.
- HWImaging.h: provides support for the Windows Imaging Component API
- HWHandles.h: provides support for the Windows GDI API.
- HWControl.h: provides support for working with Windows Controls
- HWMessage.h: provides the
Message class, a simple abstraction for the MSG structure - HWMenu.h: provides support for working with Windows Menus.
- HWForm.h: provides support for working with top level Windows Controls using the
Form class. - HWApplication.h: provides an
Application class and a MessageLoop class. - HWDXApplication.h: declares some
Direct3D 12 utility classes:
- class DXMessageLoop: The render/message loop.
- class DXContext: Initializes and manages interaction with the
D3D12Device, the DXGI::SwapChain3, the D3D12GraphicsCommandList, and the few other objects required for interaction with the Direct3D 12 API. - class DXApplication: Derived from
Windows::Application, tailored for developing Direct3D 12 using Windows::Form.
- HWStdCtrls.h: provides a number of classes for working with standard Windows controls. The provided functionality is, unfortunately, quite limited.
- HWFileDialog.h: provides support for the
Open and Save As functionality from the Common Dialog Box Library. - HWEnvironment.h: provides easy access to system information.
- HWSkia.h: provides support for creating Skia based applications.
- HWImGui.h: provides support for creating Dear ImGui based applications.
HWControl.h, HWMessage.h, HWMenu.h, HWForm.h, HWApplication.h, HWStdCtrls.h, HWFileDialog.h, HWSkia.h are meant to be used together, while HWDXGI.h, HWGraphicsD3D12.h, HWGraphics.h, HWImaging.h and HWHandles.h can be used on their own.
These days, I often use the slightly modified version of Dear ImGui and ImPlot located under 3rdParty\Harlinn.ImGui to create user interfaces for my Harlinn\:\:Windows\:\:Form based applications.
#include "HWDXApplication.h"
#include "HWImGui.h"
#include "HWmenu.h"
#include "HWstdctrls.h"
#include <iostream>
using namespace Harlinn;
int main()
{
try
{
Windows::ApplicationOptions applicationOptions;
applicationOptions.Load( );
Windows::ImGui::Application application( applicationOptions );
application.Start( );
Windows::ImGui::Form form;
form.SetText( L"ImGui & ImPlot Demo" );
bool showImGuiDemoWindow = true;
bool showImPlotDemoWindow = true;
bool showAnotherWindow = false;
form.OnRender.connect( [&showImGuiDemoWindow,&showImPlotDemoWindow,
&showAnotherWindow]( Windows::ImGui::Form* sender )
{
if ( showImGuiDemoWindow )
{
ImGui::ShowDemoWindow( &showImGuiDemoWindow );
}
if ( showImPlotDemoWindow )
{
ImPlot::ShowDemoWindow( &showImPlotDemoWindow );
}
} );
auto result = application.Run( form );
application.Stop( );
return result;
}
catch ( std::exception& exc )
{
std::cout << exc.what( ) << std::endl;
}
catch ( ... )
{
std::cout << "Unknown exception" << std::endl;
}
return 0;
}
Harlinn.OCI
Harlinn.OCI provides high performance access to the Oracle RDBMS using the Oracle OCI API.
Harlinn.ODBC
Harlinn.ODBC provides high performance access to database servers and engines through the ODBC API.
Harlinn.Common.Config
This library implements an in-memory hierarchical storage suitable for handling configuration information.
Harlinn.Julia
This library provides easy access to Julia.
3rd Party Libraries
This solution contains a few useful C and C++ libraries located under the 3rdParty folder.
Header only libraries are contained within ''Static library (.lib)'' projects, everything else creates a DLL.
All C++ code compiles using /std:c++latest and /Zc:__cplusplus
Version: 20210324.2
Description
Abseil is an open source collection of C++ libraries drawn from the most fundamental pieces of Google’s internal code-base. These libraries are the nuts-and-bolts that underpin almost everything Google runs. Bits and pieces of these APIs are embedded in most of our open source projects, and Abseil aims to bring them together into one comprehensive project. Abseil encompasses the most basic building blocks of Google’s code-base: code that is production-tested and will be fully maintained for years to come.
Projects
Harlinn.abseil- Tests\3rdParty\abseil\abseil_test
The abseil_test contains the unit tests for the Harlinn.abseil project
Version: master as of 2021.08.26
Description
Libaec provides fast lossless compression of 1 up to 32 bit wide signed or unsigned integers (samples).
Project: Harlinn.aec
Version: master as of 2021.09.20
Description
The goal of ANGLE is to allow users of multiple operating systems to seamlessly run WebGL and other OpenGL ES content by translating OpenGL ES API calls to one of the hardware-supported APIs available for that platform. ANGLE currently provides translation from OpenGL ES 2.0, 3.0 and 3.1 to Vulkan, desktop OpenGL, OpenGL ES, Direct3D 9, and Direct3D 11.
Projects
Harlinn.angleHarlinn.angle-eglHarlinn.angle-glHarlinn.angle-glesv1Harlinn.angle-glesv2Harlinn.angle-openclHarlinn.angle-util
Version: 3.1.2
Description
AV1 Codec Library
Project: Harlinn.aom
Version: 10.6.x
Description
Armadillo is a high quality linear algebra library (matrix maths) for the C++ language, aiming towards a good balance between speed and ease of use
Provides high-level syntax and functionality deliberately similar to Matlab
Useful for algorithm development directly in C++, or quick conversion of research code into production environments
Provides efficient classes for vectors, matrices and cubes; dense and sparse matrices are supported
Integer, floating point and complex numbers are supported
A sophisticated expression evaluator (based on template meta-programming) automatically combines several operations to increase speed and efficiency
Various matrix decompositions (eigen, SVD, QR, etc) are provided through integration with LAPACK, or one of its high performance drop-in replacements (eg. MKL or OpenBLAS)
Can automatically use OpenMP multi-threading (parallelisation) to speed up computationally expensive operations
Distributed under the permissive Apache 2.0 license, useful for both open-source and proprietary (closed-source) software
Can be used for machine learning, pattern recognition, computer vision, signal processing, bioinformatics, statistics, finance, etc
Project: Harlinn.armadillo
Version: 2.0.rc8
Description
Base64 encoding and decoding with c++.
Project: Harlinn.base64
Version: master as of 2021.09.20
Description
BoringSSL is a fork of OpenSSL that is designed to meet Google's needs.
Projects
Harlinn.boringssl- Tests\3rdParty\boringssl\crypto_test
- Tests\3rdParty\boringssl\ssl_test
Version: master as of 2021.08.04
Description
Brotli is a generic-purpose lossless compression algorithm that compresses data using a combination of a modern variant of the LZ77 algorithm, Huffman coding and 2nd order context modeling, with a compression ratio comparable to the best currently available general-purpose compression methods. It is similar in speed with deflate but offers more dense compression.
Project: Harlinn.brotli
Version: 3.21
Description
Real-time collision detection and multi-physics simulation for VR, games, visual effects, robotics, machine learning etc.
Project: Harlinn.bullet
Version: from bullet 3.21
Description
Selectively Damped Least Squares for Inverse Kinematics.
Project: Harlinn.BussIK
Version: 1.0.8
Description
bzip2 is a freely available, patent free (see below), high-quality data compressor. It typically compresses files to within 10% to 15% of the best available techniques (the PPM family of statistical compressors), whilst being around twice as fast at compression and six times faster at decompression.
Project: Harlinn.bzip2
Version: 1.17.0
Description
c-ares is a C library for asynchronous DNS requests (including name resolves)
Project: Harlinn.c-ares
Version: 4.0.0
Description
CFITSIO is a library of C and Fortran subroutines for reading and writing data files in FITS (Flexible Image Transport System) data format. CFITSIO provides simple high-level routines for reading and writing FITS files that insulate the programmer from the internal complexities of the FITS format. CFITSIO also provides many advanced features for manipulating and filtering the information in FITS files.
Project: Harlinn.cfitsio
Version: 1.04
Description
crnlib is a lossy texture compression library for developers that ship content using the DXT1/5/N or 3DC compressed color/normal map/cubemap mipmapped texture formats.
It can compress mipmapped 2D textures, normal maps, and cubemaps to approx. 1-1.25 bits/texel, and normal maps to 1.75-2 bits/texel. The actual bitrate depends on the complexity of the texture itself, the specified quality factor/target bitrate, and ultimately on the desired quality needed for a particular texture.
Project: Harlinn.crnlib
Version: 1.41.1
Description
Provides a mechanism for writing cross platform socket code. This library was originally written to only support blocking TCP sockets. Over the years it has been extended to support UDP and RAW sockets as well.
Project: Harlinn.clsocket
Version: 0.2.2
Description
CrossGuid is a minimal, cross platform, C++ GUID library. It uses the best native GUID/UUID generator on the given platform and has a generic class for parsing, stringifying, and comparing IDs. The guid generation technique is determined by your platform.
Project: Harlinn.crossguid
Version: 7.78.0
Description
libcurl is a free and easy-to-use client-side URL transfer library, supporting DICT, FILE, FTP, FTPS, GOPHER, GOPHERS, HTTP, HTTPS, IMAP, IMAPS, LDAP, LDAPS, MQTT, POP3, POP3S, RTMP, RTMPS, RTSP, SCP, SFTP, SMB, SMBS, SMTP, SMTPS, TELNET and TFTP. libcurl supports SSL certificates, HTTP POST, HTTP PUT, FTP uploading, HTTP form based upload, proxies, HTTP/2, HTTP/3, cookies, user+password authentication (Basic, Digest, NTLM, Negotiate, Kerberos), file transfer resume, http proxy tunneling and more!
Project: Harlinn.curl
Version: 2.0.0-development (2021-07-26)
Description
Easy to integrate memory allocation library for Direct3D 12
Project: Harlinn.d3d12allocator
Version: 1.8
Description
libdeflate is a library for fast, whole-buffer DEFLATE-based compression and decompression
Project: Harlinn.deflate
Version: 1.5.1
Description
The DNG SDK provides support for reading and writing DNG files as well as for converting DNG data to a format that is easily displayed or processed by imaging applications.
Project: Harlinn.dngsdk
Version: main as of 2021.09.27
Description
Effcee is a C++ library for stateful pattern matching of strings, inspired by LLVM's FileCheck command.
Project: Harlinn.effcee
Version: 3.4.0
Description
Eigen is a C++ template library for linear algebra: matrices, vectors, numerical solvers, and related algorithms.
Project: Harlinn.Eigen
Version: 1.3.17
Description
ENet's purpose is to provide a relatively thin, simple and robust network communication layer on top of UDP (User Datagram Protocol). The primary feature it provides is optional reliable, in-order delivery of packets.
Project: Harlinn.enet
Version: 2.4.1
Description
This is Expat, a C library for parsing XML, started by James Clark in 1997. Expat is a stream-oriented XML parser. This means that you register handlers with the parser before starting the parse. These handlers are called when the parser discovers the associated structures in the document being parsed. A start tag is an example of the kind of structures for which you may register handlers.
Project: Harlinn.expat
Version: 2.0.0
Description
FlatBuffers is an efficient cross platform serialization library for C++, C#, C, Go, Java, Kotlin, JavaScript, Lobster, Lua, TypeScript, PHP, Python, Rust and Swift. It was originally created at Google for game development and other performance-critical applications.
Project: Harlinn.flatbuffers
Version: 2.11.0
Description
FreeType is a freely available software library to render fonts.
It is written in C, designed to be small, efficient, highly customizable, and portable while capable of producing high-quality output (glyph images) of most vector and bitmap font formats.
Project: Harlinn.freetype
Version: 3.4.0
Description
GDAL is a translator library for raster and vector geospatial data formats that is released under an X/MIT style Open Source License by the Open Source Geospatial Foundation. As a library, it presents a single raster abstract data model and single vector abstract data model to the calling application for all supported formats.
Project: Harlinn.gdal
Version: 3.4.0
Description
GEOS is a C/C++ library for spatial computational geometry of the sort generally used by “geographic information systems” software.
Project: Harlinn.geos
Version: 2.2.2
Description
Gflags, the commandline flags library used within Google, differs from other libraries, such as getopt(), in that flag definitions can be scattered around the source code, and not just listed in one place such as main(). In practice, this means that a single source-code file will define and use flags that are meaningful to that file. Any application that links in that file will get the flags, and the gflags library will automatically handle that flag appropriately.
There's significant gain in flexibility, and ease of code reuse, due to this technique.
Project: Harlinn.gflags
Version: 5.2.1
Project: Harlinn.gif
Description
giflib is a library for reading and writing gif images.
Version: generated by glad 0.1.35 on Sun Dec 26 15:01:04 2021
Description
GLSC2, OpenGL, OpenGL ES loader generated by glad 0.1.35 on Sun Dec 26 15:01:04 2021 using the Multi-Language GL/GLES/EGL/GLX/WGL Loader-Generator based on the official specs.
Project: Harlinn.glad
Version: 3.3.4
Description
GLFW is an Open Source, multi-platform library for OpenGL, OpenGL ES and Vulkan development on the desktop. It provides a simple API for creating windows, contexts and surfaces, receiving input and events.
Project: Harlinn.glfw
Version: 2020.07.28
Description
Reference Validator and GLSL/ESSL -> AST Front End
An OpenGL GLSL and OpenGL|ES GLSL (ESSL) front-end for reference validation and translation of GLSL/ESSL into an internal abstract syntax tree (AST).
HLSL -> AST Front End
An HLSL front-end for translation of an approximation of HLSL to glslang's AST form.
AST -> SPIR-V Back End
Translates glslang's AST to the Khronos-specified SPIR-V intermediate language.
Reflector
An API for getting reflection information from the AST, reflection types/variables/etc. from the HLL source (not the SPIR-V).
Project: Harlinn.glslang
Version: 1.41.1
Description
gRPC is a modern open source high performance Remote Procedure Call (RPC) framework that can run in any environment. It can efficiently connect services in and across data centers with pluggable support for load balancing, tracing, health checking and authentication. It is also applicable in last mile of distributed computing to connect devices, mobile applications and browsers to backend services.
Projects
Harlinn.grpcHarlinn.grpc-compiler- Tools\3rdParty\grpc\gen_hpack_tables
- Tools\3rdParty\grpc\grpc_cpp_plugin
- Tools\3rdParty\grpc\grpc_csharp_plugin
- Tools\3rdParty\grpc\grpc_node_plugin
- Tools\3rdParty\grpc\grpc_objective_c_plugin
- Tools\3rdParty\grpc\grpc_php_plugin
- Tools\3rdParty\grpc\grpc_python_plugin
- Tools\3rdParty\grpc\grpc_ruby_plugin
- Tests\3rdParty\gRPC\core\address_utils\grpc_test_core_address_utils_parse_address_test
- Tests\3rdParty\gRPC\core\address_utils\grpc_test_core_address_utils_parse_address_with_named_scope_id_test
- Tests\3rdParty\gRPC\core\address_utils\grpc_test_core_address_utils_sockaddr_utils_test
- Tests\3rdParty\gRPC\core\avl\grpc_test_avl_avl_test
- Tests\3rdParty\gRPC\core\backoff\grpc_test_backoff_backoff_test
- Tests\3rdParty\gRPC\core\bad_client\grpc_test_bad_client_badreq
- Tests\3rdParty\gRPC\core\bad_client\grpc_test_bad_client_bad_streaming_id
- Tests\3rdParty\gRPC\core\bad_client\grpc_test_bad_client_connection_prefix
- Tests\3rdParty\gRPC\core\bad_client\grpc_test_bad_client_duplicate_header
- Tests\3rdParty\gRPC\core\bad_client\grpc_test_bad_client_headers
- Tests\3rdParty\gRPC\core\bad_client\grpc_test_bad_client_head_of_line_blocking
- Tests\3rdParty\gRPC\core\bad_client\grpc_test_bad_client_initial_settings_frame
- Tests\3rdParty\gRPC\core\bad_client\grpc_test_bad_client_large_metadata
- Tests\3rdParty\gRPC\core\bad_client\grpc_test_bad_client_out_of_bounds
- Tests\3rdParty\gRPC\core\bad_client\grpc_test_bad_client_server_registered_method
- Tests\3rdParty\gRPC\core\bad_client\grpc_test_bad_client_simple_request
- Tests\3rdParty\gRPC\core\bad_client\grpc_test_bad_client_unknown_frame
- Tests\3rdParty\gRPC\core\bad_client\grpc_test_bad_client_window_overflow
- Tests\3rdParty\gRPC\core\bad_connection\grpc_test_bad_connection_close_fd_test
- Tests\3rdParty\gRPC\core\bad_ssl\grpc_test_bad_ssl_alpn_server_test
- Tests\3rdParty\gRPC\core\bad_ssl\grpc_test_bad_ssl_bad_ssl_test
- Tests\3rdParty\gRPC\core\bad_ssl\grpc_test_bad_ssl_cert_server_test
- Tests\3rdParty\gRPC\core\channel\grpc_test_channel_channel_args_test
- Tests\3rdParty\gRPC\core\channel\grpc_test_channel_channel_stack_builder_test
- Tests\3rdParty\gRPC\core\channel\grpc_test_channel_channel_stack_test
- Tests\3rdParty\gRPC\core\channel\grpc_test_channel_channel_trace_test
- Tests\3rdParty\gRPC\core\channel\grpc_test_core_channelz_registry_test
- Tests\3rdParty\gRPC\core\channel\grpc_test_core_channelz_test
- Tests\3rdParty\gRPC\core\channel\grpc_test_core_channel_status_util_test
- Tests\3rdParty\gRPC\core\channel\grpc_test_core_minimal_stack_is_minimal_test
- Tests\3rdParty\gRPC\core\client_channel\grpc_test_core_client_channel_certificate_provider_registry_test
- Tests\3rdParty\gRPC\core\client_channel\grpc_test_core_client_channel_retry_throttle_test
- Tests\3rdParty\gRPC\core\client_channel\grpc_test_core_client_channel_service_config_test
- Tests\3rdParty\gRPC\core\client_channel\resolvers\dns_resolver_connectivity_test
- Tests\3rdParty\gRPC\core\client_channel\resolvers\dns_resolver_cooldown_test
- Tests\3rdParty\gRPC\core\client_channel\resolvers\grpc_test_dns_resolver_test
- Tests\3rdParty\gRPC\core\client_channel\resolvers\grpc_test_fake_resolver_test
- Tests\3rdParty\gRPC\core\client_channel\resolvers\grpc_test_sockaddr_resolver_test
- Tests\3rdParty\gRPC\core\compression\grpc_test_core_compression_algorithm_test
- Tests\3rdParty\gRPC\core\compression\grpc_test_core_compression_compression_test
- Tests\3rdParty\gRPC\core\compression\grpc_test_core_compression_message_compress_test
- Tests\3rdParty\gRPC\core\compression\grpc_test_core_compression_stream_compression_test
- Tests\3rdParty\gRPC\core\config\grpc_test_core_config_core_configuration_test
- Tests\3rdParty\gRPC\core\debug\grpc_test_core_debug_stats_test
- Tests\3rdParty\gRPC\core\event_engine\grpc_test_core_event_engine_endpoint_config_test
- Tests\3rdParty\gRPC\core\fling\fling_client
- Tests\3rdParty\gRPC\core\fling\fling_server
- Tests\3rdParty\gRPC\core\fling\grpc_test_core_fling_fling_stream_test
- Tests\3rdParty\gRPC\core\fling\grpc_test_core_fling_fling_test
- Tests\3rdParty\gRPC\core\gpr\grpc_test_core_gpr_alloc_test
- Tests\3rdParty\gRPC\core\gpr\grpc_test_core_gpr_arena_test
- Tests\3rdParty\gRPC\core\gpr\grpc_test_core_gpr_cpu_test
- Tests\3rdParty\gRPC\core\gpr\grpc_test_core_gpr_env_test
- Tests\3rdParty\gRPC\core\gpr\grpc_test_core_gpr_log_test
- Tests\3rdParty\gRPC\core\gpr\grpc_test_core_gpr_murmur_hash_test
- Tests\3rdParty\gRPC\core\gpr\grpc_test_core_gpr_spinlock_test
- Tests\3rdParty\gRPC\core\gpr\grpc_test_core_gpr_string_test
- Tests\3rdParty\gRPC\core\gpr\grpc_test_core_gpr_sync_test
- Tests\3rdParty\gRPC\core\gpr\grpc_test_core_gpr_time_test
- Tests\3rdParty\gRPC\core\gpr\grpc_test_core_gpr_tls_test
- Tests\3rdParty\gRPC\core\gpr\grpc_test_core_gpr_useful_test
- Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_bitset_test
- Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_capture_test
- Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_dual_ref_counted_test
- Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_examine_stack_test
- Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_fork_test
- Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_global_config_env_test
- Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_global_config_test
- Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_host_port_test
- Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_manual_constructor_test
- Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_match_test
- Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_mpscq_test
- Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_orphanable_test
- Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_overload_test
- Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_ref_counted_ptr_test
- Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_ref_counted_test
- Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_status_helper_test
- Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_stat_test
- Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_table_test
- Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_thd_test
- Tests\3rdParty\gRPC\core\gprpp\grpc_test_core_gprpp_time_util_test
- Tests\3rdParty\gRPC\core\iomgr\grpc_test_core_iomgr_combiner_test
- Tests\3rdParty\gRPC\core\iomgr\grpc_test_core_iomgr_endpoint_pair_test
- Tests\3rdParty\gRPC\core\iomgr\grpc_test_core_iomgr_error_test
- Tests\3rdParty\gRPC\core\iomgr\grpc_test_core_iomgr_grpc_ipv6_loopback_available_test
- Tests\3rdParty\gRPC\core\iomgr\grpc_test_core_iomgr_load_file_test
- Tests\3rdParty\gRPC\core\iomgr\grpc_test_core_iomgr_mpmcqueue_test
- Tests\3rdParty\gRPC\core\iomgr\grpc_test_core_iomgr_pollset_windows_starvation_test
- Tests\3rdParty\gRPC\core\iomgr\grpc_test_core_iomgr_resolve_address_test
- Tests\3rdParty\gRPC\core\iomgr\grpc_test_core_iomgr_resource_quota_test
- Tests\3rdParty\gRPC\core\iomgr\grpc_test_core_iomgr_threadpool_test
- Tests\3rdParty\gRPC\core\iomgr\grpc_test_core_iomgr_timer_heap_test
- Tests\3rdParty\gRPC\core\iomgr\grpc_test_core_iomgr_timer_list_test
- Tests\3rdParty\gRPC\core\iomgr\grpc_test_core_iomgr_time_averaged_stats_test
- Tests\3rdParty\gRPC\grpc_test_core_util
Version: 1.2.1
Description
Libgta, a library that reads and writes GTA files.
Project: Harlinn.gta
Version: 1.11.0
Description
GoogleTest is Google’s C++ testing and mocking framework.
Project: Harlinn.gtest
Version: from bullet 3.21
Description
A C++ GUI library.
Project: Harlinn.gwen
Version: 3.0.0
Description
HarfBuzz is a text shaping library. Using the HarfBuzz library allows programs to convert a sequence of Unicode input into properly formatted and positioned glyph output—for any writing system and language.
Project: Harlinn.harfbuzz
Version: 4.2.15
Description
The Hierarchical Data Format, or HDF, is a multiobject file format for sharing scientific data in a distributed environment. HDF was created at the National Center for Supercomputing Applications, and is now developed and maintained by The HDF Group, to serve the needs of diverse groups of scientists working on projects in various fields
Project: Harlinn.hdf4
Version: 1.12.1
Description
The HDF Group is the developer of HDF5®, a high-performance software library and data format that has been adopted across multiple industries and has become a de facto standard in scientific and research communities.
Project: Harlinn.hdf5
Version: 0.14.2
Description
Highway is a C++ library for SIMD (Single Instruction, Multiple Data), i.e. applying the same operation to multiple 'lanes' using a single CPU instruction.
Project: Harlinn.highway
Version: master as of 2021.08.18
Description
Imath is a basic, light-weight, and efficient C++ representation of 2D and 3D vectors and matrices and other simple but useful mathematical objects, functions, and data types common in computer graphics applications, including the “half” 16-bit floating-point type.
Project: Harlinn.imath
Version: master as of 2021.07.14
Description: Packages Dear ImGui and ImPlot as a single DLL.
Description 'Dear ImGui':
Dear ImGui is a bloat-free graphical user interface library for C++. It outputs optimized vertex buffers that you can render anytime in your 3D-pipeline enabled application.
Description 'ImPlot':
ImPlot is an immediate mode, GPU accelerated plotting library for Dear ImGui. It aims to provide a first-class API that ImGui fans will love. ImPlot is well suited for visualizing program data in real-time or creating interactive plots, and requires minimal code to integrate.
Project: Harlinn.ImGui
Version: 2.0.33
Description
JasPer Image Processing/Coding Tool Kit
Project: Harlinn.jasper
Version: 9d
Description
IJG is an informal group that writes and distributes a widely used free library for JPEG image compression.
Project: Harlinn.jpeg
Version: 2.1.1
Description
libjpeg-turbo is a JPEG image codec that uses SIMD instructions (MMX, SSE2, AVX2, Neon, AltiVec) to accelerate baseline JPEG compression and decompression on x86, x86-64, Arm, and PowerPC systems, as well as progressive JPEG compression on x86 and x86-64 systems. On such systems, libjpeg-turbo is generally 2-6x as fast as libjpeg, all else being equal. On other types of systems, libjpeg-turbo can still outperform libjpeg by a significant amount, by virtue of its highly-optimized Huffman coding routines. In many cases, the performance of libjpeg-turbo rivals that of proprietary high-speed JPEG codecs.
libjpeg-turbo implements both the traditional libjpeg API as well as the less powerful but more straightforward TurboJPEG API. libjpeg-turbo also features colorspace extensions that allow it to compress from/decompress to 32-bit and big-endian pixel buffers (RGBX, XBGR, etc.), as well as a full-featured Java interface.
Project: Harlinn.jpeg-turbo
Version: master as of 2021.08.01
Description
A JSON implementation in C.
Project: Harlinn.json-c
Version: 1.9.4
Description
JsonCpp is a C++ library that allows manipulating JSON values, including serialization and deserialization to and from strings. It can also preserve existing comment in unserialization/serialization steps, making it a convenient format to store user input files.
Project: Harlinn.jsoncpp
Version: 0.6.1
Description
A reference implementation of JPEG XL (encoder and decoder), called libjxl.
Project: Harlinn.jxl
Version: 1.3.0
Description
This is Google's reference implementation of OGC KML 2.2.
Projects
Harlinn.kmlbaseHarlinn.kmlconvenienceHarlinn.kmldomHarlinn.kmlengineHarlinn.kmlregionatorHarlinn.kmlxsd
Version: 2.12
Description
Little CMS intends to be an OPEN SOURCE small-footprint color management engine, with special focus on accuracy and performance. It uses the International Color Consortium standard (ICC), which is the modern standard when regarding to color management. The ICC specification is widely used and is referred to in many International and other de-facto standards. It was approved as an International Standard, ISO 15076-1, in 2005.
Project: Harlinn.lcms2
Version: 3.0
Description
LERC is an open-source image or raster format which supports rapid encoding and decoding for any pixel type (not just RGB or Byte).
Project: Harlinn.Lerc
Version: 1.0.8
Description
libde265 is an open source implementation of the h.265 video codec. It is written from scratch and has a plain C API to enable a simple integration into other software.
libde265 supports WPP and tile-based multithreading and includes SSE optimizations. The decoder includes all features of the Main profile and correctly decodes almost all conformance streams
Project: Harlinn.libde265
Version: 1.3.2
Description
FLAC is an Open Source lossless audio codec
Project: Harlinn.libflac
Version: 1.12.0
Description
libheif is an ISO/IEC 23008-12:2017 HEIF and AVIF (AV1 Image File Format) file format decoder and encoder.
HEIF and AVIF are new image file formats employing HEVC (h.265) or AV1 image coding, respectively, for the best compression ratios currently possible.
Project: Harlinn.libheif
Version: 5.2.5
Description
LZMA Utils is an attempt to provide LZMA compression to POSIX-like systems. The idea is to have a gzip-like command line tool and a zlib-like library, which would make it easy to adapt the new compression technology to existing applications.
Project: Harlinn.liblzma
Version: 1.2.1
Description
This is a simple set of C functions to read AES SOFA files, if they contain HRTFs stored according to the AES69-2015 standard.
Project: Harlinn.libmysofa
Version: 1.3.5
Description
Ogg is a multimedia container format, and the native file and stream format for the Xiph.org multimedia codecs.
Project: Harlinn.libogg
Version: 3.16
Description
LIBSVM is an integrated software for support vector classification, (C-SVC, nu-SVC), regression (epsilon-SVR, nu-SVR) and distribution estimation (one-class SVM). It supports multi-class classification.
Project: Harlinn.libsvm
Version: 2.2.0
Description
VMAF is a perceptual video quality assessment algorithm developed by Netflix.
Project: Harlinn.libvmaf
Version: 2.9.12
Description
Libxml2 is the XML C parser and toolkit developed for the Gnome project.
Project: Harlinn.libxml2
Version: 0.9.70
Description
An ultra-fast, ultra-compact, crash-proof, key-value, embedded data store
Project: Harlinn.LMDB
Version: 20200215
Description
LodePNG is a PNG image decoder and encoder, all in one, no dependency or linkage to zlib or libpng required.
Project: Harlinn.lodepng
Version: 1.9.3
Description
LZ4 is lossless compression algorithm, providing compression speed > 500 MB/s per core, scalable with multi-cores CPU. It features an extremely fast decoder, with speed in multiple GB/s per core, typically reaching RAM speed limits on multi-core systems.
Project: Harlinn.lz4
Version: 21.03
Description
LZMA / LZMA2 are default and general compression methods of 7z format in the 7-Zip program. LZMA provides a high compression ratio and fast decompression, so it is very suitable for embedded applications.
Project: Harlinn.lzma
Version: 0.8.1
Description
Mesh Data Abstraction Library.
Project: Harlinn.mdal
Version: 1.1
Description
This package enables to extract files from a .zip archive file.
Project: Harlinn.minizip
Version: TBD - this project is currently just a placeholder
Project: Harlinn.netcdf-c
Version: develop as of 2021.08.16
Description
JSON for Modern C++
Project: Harlinn.nlohmann-json
Version: 1.21.1
Description
OpenAL Soft is an LGPL-licensed, cross-platform, software implementation of the OpenAL 3D audio API.
OpenAL provides capabilities for playing audio in a virtual 3D environment. Distance attenuation, doppler shift, and directional sound emitters are among the features handled by the API.
Project: Harlinn.openal-soft
Version: 0.4.0
Description
OpenCensus is a toolkit for collecting application performance and behavior data. It currently includes an API for tracing and stats.
Project: Harlinn.opencensus
Version: master as of 2021.08.18
Description
OpenEXR provides the specification and reference implementation of the EXR file format, the professional-grade image storage format of the motion picture industry.
The purpose of EXR format is to accurately and efficiently represent high-dynamic-range scene-linear image data and associated metadata, with strong support for multi-part, multi-channel use cases.
Projects
Harlinn.iexHarlinn.ilmthreadHarlinn.openexrHarlinn.openexrcoreHarlinn.openexrutil
Version: 4.1.1
Description
OpenFYBA is the source code release of the FYBA library, distributed by the National Mapping Authority of Norway (Statens kartverk) to read and write files in the National geodata standard format SOSI.
Project: Harlinn.openfyba
Version: master as of 2021.09.24
Description
The Preview Image Extractor (PIEX) is designed to find and extract the largest JPEG compressed preview image contained in a RAW file.
Project: Harlinn.piex
Version: 1.6.37
Description
libpng is the official PNG reference library. It supports almost all PNG features, is extensible, and has been extensively tested for over 23 years.
Project: Harlinn.png
Version: 8.1.0
Description
PROJ is a generic coordinate transformation software that transforms geospatial coordinates from one coordinate reference system (CRS) to another. This includes cartographic projections as well as geodetic transformations.
Project: Harlinn.proj
Version: 3.17.3
Description
Protocol buffers are Google's language-neutral, platform-neutral, extensible mechanism for serializing structured data – think XML, but smaller, faster, and simpler. You define how you want your data to be structured once, then you can use special generated source code to easily write and read your structured data to and from a variety of data streams and using a variety of languages.
Projects
Harlinn.protobuf- Tools\3rdParty\protobuf\protoc
Version: 3.0.0
Description
Also known as "pthreads-win32", POSIX Threads for Windows implements a large subset of the threads related API from the Single Unix Specification Version 3.
Conformance and quality are high priorities of this mature library. Development began in 1998 and has continued with numerous significant professional contributions.
Project: Harlinn.pthreads4w
Version: 0.35.0
Description
Qpid Proton is a high-performance, lightweight messaging library. It can be used in the widest range of messaging applications, including brokers, client libraries, routers, bridges, proxies, and more. Proton makes it trivial to integrate with the AMQP 1.0 ecosystem from any platform, environment, or language.
Projects
Harlinn.qpid-protonHarlinn.qpid-proton-cpp
Version: master as of 2021.09.26
Description
A fast JSON parser/generator for C++ with both SAX/DOM style API.
Project: Harlinn.RapidJSON
Version: 2021-09-01
Description
RE2 was designed and implemented with an explicit goal of being able to handle regular expressions from untrusted users without risk. One of its primary guarantees is that the match time is linear in the length of the input string. It was also written with production concerns in mind: the parser, the compiler and the execution engines limit their memory usage by working within a configurable budget – failing gracefully when exhausted – and they avoid stack overflow by eschewing recursion.
Project: Harlinn.re2
Version: 6.26.1
Description
RocksDB is a storage engine with key/value interface, where keys and values are arbitrary byte streams. It is a C++ library. It was developed at Facebook based on LevelDB and provides backwards-compatible support for LevelDB APIs.
RocksDB supports various storage hardware, with fast flash as the initial focus. It uses a Log Structured Database Engine for storage, is written entirely in C++
Project: Harlinn.rocksdb
Version: 5.1.3
Description
Scintilla is a free source code editing component. It comes with complete source code and a license that permits use in any free project or commercial product.
As well as features found in standard text editing components, Scintilla includes features especially useful when editing and debugging source code. These include support for syntax styling, error indicators, code completion and call tips. The selection margin can contain markers like those used in debuggers to indicate breakpoints and the current line. Styling choices are more open than with many editors, allowing the use of proportional fonts, bold and italics, multiple foreground and background colours and multiple fonts.
Project: Harlinn.scintilla
Version: 2.0.16
Description
Simple DirectMedia Layer is a cross-platform development library designed to provide low level access to audio, keyboard, mouse, joystick, and graphics hardware via OpenGL and Direct3D.
Project: Harlinn.SDL2
Version: 2.5.1
Description
SFML provides a simple interface to the various components of your PC, to ease the development of games and multimedia applications. It is composed of five modules: system, window, graphics, audio and network.
Projects
Harlinn.sfml-audioHarlinn.sfml-graphicsHarlinn.sfml-networkHarlinn.sfml-systemHarlinn.sfml-window
Version: master as of 2021.09.11
Description
sjpeg is a simple encoding library for encoding baseline JPEG files.
Project: Harlinn.sjpeg
Version: main as of 2021.09.12
Description: Skia Color Management
Project: Harlinn.skcms
Version: 0.31
Description
Skia is an open source 2D graphics library which provides common APIs that work across a variety of hardware and software platforms. It serves as the graphics engine for Google Chrome and Chrome OS, Android, Flutter, Mozilla Firefox and Firefox OS, and many other products.
Projects
Harlinn.skia- Tools\3rdParty\Skia\skslc
Version: master as of 2021.08.02
Description
Snappy is a compression/decompression library. It does not aim for maximum compression, or compatibility with any other compression library; instead, it aims for very high speeds and reasonable compression. For instance, compared to the fastest mode of zlib, Snappy is an order of magnitude faster for most inputs, but the resulting compressed files are anywhere from 20% to 100% bigger.
Project: Harlinn.snappy
Version: Version used for MoltenVK 1.1.5 release
Description
SPIRV-Cross is a tool designed for parsing and converting SPIR-V to other shader languages.
Project: Harlinn.spirv-cross
Version: 1.5.4
Description: The header files from https://github.com/KhronosGroup/SPIRV-Headers
Project: Harlinn.spirv-headers
Version: 2021.3
Description
The project includes an assembler, binary module parser, disassembler, validator, and optimizer for SPIR-V.
Project: Harlinn.spirv-tools
Version: 3.36.0
Description
SQLite is a C-language library that implements a small, fast, self-contained, high-reliability, full-featured, SQL database engine.
Projects
Harlinn.SQLite3- Tools\3rdParty\SQLite3\sqlite3
Version: master as of 2021.09.10
Description
Small, easy-to-integrate, portable libraries which are usable from C and/or C++
Project: Harlinn.stb
Version: 5.2.2
Description
SuperLU is a general purpose library for the direct solution of large, sparse, nonsymmetric systems of linear equations.
Project: Harlinn.superlu
Version: 4.3.0
Description
This software provides support for the Tag Image File Format (TIFF), a widely used format for storing image data.
Project: Harlinn.tiff
Version: master as of 2021.06.07
Description
TinyXML-2 is a simple, small, efficient, C++ XML parser that can be easily integrated into other programs.
Project: Harlinn.tinyxml2
Version: master as of 2021.10.21
Description
μpb (often written 'upb') is a small protobuf implementation written in C.
Projects
Harlinn.upb- Tools\3rdParty\upb\protoc-gen-upb
- Tools\3rdParty\upb\protoc-gen-upbdefs
Version: 0.9.5
Description
uriparser is a strictly RFC 3986 compliant URI parsing and handling library written in C89 ("ANSI C").
Project: Harlinn.uriparser
Version: 1.3.7
Description
Vorbis is a general purpose audio and music encoding format contemporary to MPEG-4's AAC and TwinVQ, the next generation beyond MPEG audio layer 3.
Project: Harlinn.vorbis
Version: main as of 2021.09.21
Description
Vulkan header files
Project: Harlinn.vulkan
Version: 2.3.0
Description
The Vulkan® Memory Allocator (VMA) library provides a simple and easy to integrate API to help you allocate memory for Vulkan® buffer and image storage.
Project: Harlinn.vulkanmemoryallocator
Version: main as of 2021.09.08
Description
The WebM Project is dedicated to developing a high-quality, open video format for the web that's freely available to everyone.
Project: Harlinn.webm
Version: main as of 2021.09.08
Description
WebP is a modern image format that provides superior lossless and lossy compression for images on the web. Using WebP, webmasters and web developers can create smaller, richer images that make the web faster.
Project: Harlinn.webp
Version: 3.2.3
Description
Xerces-C++ is a validating XML parser written in a portable subset of C++. Xerces-C++ makes it easy to give your application the ability to read and write XML data.
Project: Harlinn.xerces-c
Version: 6.0.0
Description
The XMP Toolkit allows you to integrate XMP functionality into your product or solution.
Project: Harlinn.xmptoolkitsdk
Version: main as of 2021-09-07
Description
libyuv is an open source project that includes YUV scaling and conversion functionality.
Project: Harlinn.yuv
Version: 1.2.11
Description
zlib is designed to be a free, general-purpose, legally unencumbered -- that is, not covered by any patents -- lossless data-compression library for use on virtually any computer hardware and operating system.
Project: Harlinn.zlib
Version: develop as of 2021.05.08
Description
zlib data compression library for the next generation systems
Project: Harlinn.zlibng
Version: dev as of 2021.08.04
Description
Zstandard, or zstd as short version, is a fast lossless compression algorithm, targeting real-time compression scenarios at zlib-level and better compression ratios.
Project: Harlinn.zstd
2022.01.26
- Improved the tests for
BitVector (BitVectorTests.cpp) in Harlinn.Common.Core.Tests
2022.01.25
- Added functionality to
template<typename VectorT> BitVector
- Implemented
template<typename T> void append( const T* bits, size_t bitCount ) - Implemented
template<typename VectorU> void append( const BitVector<VectorU>& other )
- Added unit more tests for
BitVector to BitVectorTests.cpp in Harlinn.Common.Core.Tests
2022.01.24
- Added functionality to
template<typename VectorT> BitVector
- Implemented
BitVector operator~( ) const - Implemented
template<typename VectorU> void And( const BitVector<VectorU>& other ) - Implemented
template<typename VectorU> void Or( const BitVector<VectorU>& other ) - Implemented
template<typename VectorU> void Xor( const BitVector<VectorU>& other ) - Implemented
template<typename VectorU> BitVector& operator &= ( const BitVector<VectorU>& other ) - Implemented
template<typename VectorU> BitVector& operator |= ( const BitVector<VectorU>& other ) - Implemented
template<typename VectorU> BitVector& operator ^= ( const BitVector<VectorU>& other ) - Implemented
bool all( ) const noexcept - Implemented
bool none( ) const noexcept - Implemented
bool any( ) const
- Added unit more tests for
BitVector to BitVectorTests.cpp in Harlinn.Common.Core.Tests
2022.01.23
- Added functionality to
template<typename VectorT> BitVector
- Implemented
explicit operator bool( ) const noexcept - Implemented
constexpr bool empty( ) const noexcept - Implemented
BitVector constructors - Implemented
operator & ( const BitVector<VectorT>& lhs, const BitVector<VectorU>& rhs ) - Implemented
operator | ( const BitVector<VectorT>& lhs, const BitVector<VectorU>& rhs ) - Implemented
operator ^ ( const BitVector<VectorT>& lhs, const BitVector<VectorU>& rhs )
- Added unit more tests for
BitVector to BitVectorTests.cpp in Harlinn.Common.Core.Tests
2022.01.22
- Added functionality to
template<typename VectorT> BitVector
- Implemented
void resize( size_t newSize, bool value = false ) - Implemented
void emplace_back( bool value ) - Implemented
void push_back( bool value ) - Implemented
template<size_t N> void append( const Bits<N> values ) - Implemented
template<typename T> void append( const T value, size_t bitCount = sizeof(T) * BitsPerByte ) - Implemented
void flip( ) noexcept - Implemented
constexpr size_t capacity( ) const noexcept - Implemented
void reserve( size_t numberOfBits ) - Implemented
void clear( ) - Implemented
void swap( BitVector& other ) noexcept - Implemented
BitVector::reference - Implemented
reference operator[]( size_t index ) noexcept - Implemented
bool operator[]( size_t index ) const noexcept - Implemented
bool test( size_t index ) const noexcept - Implemented
template<typename VectorU> bool EqualTo( const BitVector<VectorU>& other ) const noexcept - Implemented
template<typename VectorU> bool operator == ( const BitVector<VectorU>& other ) const noexcept - Implemented
template<typename VectorU> bool operator != ( const BitVector<VectorU>& other ) const noexcept - Implemented
word_type* data( ) noexcept - Implemented
const word_type* data( ) const noexcept - Implemented
constexpr size_t size( ) const noexcept - Implemented
constexpr size_t DataSize( ) const noexcept - Implemented
const VectorType& Vector( ) const noexcept
2022.01.21
- Improved the implementation of
template<size_t bitCount> Bits
- Performance improvements for
template<size_t bitCount> Bits::reference
2022.01.20
- Added more unit tests for
template<size_t bitCount> Bits to BitsTests.cpp in Harlinn.Common.Core.Tests - Added more performance tests for
template<size_t bitCount> Bits to BitsOperations.cpp in HCCMathPerfTest01
2022.01.19
- Added more unit tests for
template<size_t bitCount> Bits to BitsTests.cpp in Harlinn.Common.Core.Tests
2022.01.18
- Fixed a bug in
template<size_t N> struct BitMask, which caused an overflow in the calculation of the bit-mask for N=8, N=16, N=32 and N=64 (HCCLib.h) - Implemented
template<size_t bitCount> Bits - Added unit tests for
template<size_t bitCount> Bits (BitsTests.cpp) to Harlinn.Common.Core.Tests - Added performance tests for
template<size_t bitCount> Bits (BitsOperations.cpp) to HCCMathPerfTest01
2022.01.17
- Added new header HCCBits.h
- Added
template<size_t bitCount> Bits
Like template< std::size_t N > class bitset this template implements a fixed size container for bits.
This template uses the smallest unsigned integer capable of holding bitCount number of bits to hold its value. It implements an API similar to std::bitset. Since it uses an unsigned integer to store the bits, bitCount has to be less or equal to 64. This also makes most operations significantly faster than the same operation on a std::bitset. My primary use for this template is to parse a binary, fixed size, bit-mask received over the network.
- Added
template<typename VectorT> BitVector
Like template<class Allocator> class vector<bool, Allocator> this template implements a variable sized container for bits, but with an API that is similar to template<size_t bitCount> Bits. Unlike std::vector<bool>, BitVector lets me specify the container used to store the bits, which must be a std::vector like container of some integer type. My primary use for this template is to parse a binary, variable sized, bit-mask received over the network. The idea is to be able to use boost::container::small_vector to store the bit-mask, and avoid dynamic memory allocation for, perhaps, 99% of the received bit-masks.
- Fixed a bug in
FileSystemEntriesBase::Read( )
2022.01.16
- Fixed bug in the declaration of the WideStringType concept in HCCTraits.h
- Finished initial/minimal implementation of the classes in HCCwbem.h
- Added initial implementation of missing wrappers for common COM interfaces:
- Added
ServiceProvider to HCCObj.h
2022.01.15
- Added initial implementation of missing wrappers for common COM interfaces:
- Added
OleLink to HCCObj.h - Added
OleItemContainer to HCCObj.h - Added
OleInPlaceUIWindow to HCCObj.h - Added
OleInPlaceActiveObject to HCCObj.h - Added
OleInPlaceFrame to HCCObj.h - Added
Continue to HCCObj.h - Added
DropSource to HCCObj.h - Added
DropTarget to HCCObj.h - Added
DropSourceNotify to HCCObj.h - Added
EnterpriseDropTarget to HCCObj.h - Added
CreateTypeInfo to HCCObj.h - Added
CreateTypeInfo2 to HCCObj.h - Added
CreateTypeLib to HCCObj.h - Added
CreateTypeLib2 to HCCObj.h - Added
TypeInfo2 to HCCObj.h - Added
TypeChangeEvents to HCCObj.h - Added
TypeFactory to HCCObj.h - Added
TypeMarshal to HCCObj.h - Added
RecordInfo to HCCObj.h - Added
ErrorLog to HCCObj.h - Added
TypeLibRegistrationReader to HCCObj.h - Added
TypeLibRegistration to HCCObj.h - Added
ClassFactory2 to HCCObj.h - Added
ProvideClassInfo2 to HCCObj.h - Added
ProvideMultipleClassInfo to HCCObj.h - Added
OleControl to HCCObj.h - Added
OleControlSite to HCCObj.h - Added
PropertyPage to HCCObj.h - Added
PropertyPage2 to HCCObj.h - Added
PropertyPageSite to HCCObj.h - Added
PropertyNotifySink to HCCObj.h - Added
SpecifyPropertyPages to HCCObj.h - Added
PersistMemory to HCCObj.h - Added
PersistStreamInit to HCCObj.h - Added
PersistPropertyBag to HCCObj.h - Added
SimpleFrameSite to HCCObj.h - Added
Font to HCCObj.h - Added
Picture to HCCObj.h - Added
Picture2 to HCCObj.h - Added
FontEventsDisp to HCCObj.h - Added
FontDisp to HCCObj.h - Added
PictureDisp to HCCObj.h - Added
OleInPlaceObject to HCCObj.h - Added
OleInPlaceObjectWindowless to HCCObj.h - Added
OleInPlaceSite to HCCObj.h - Added
OleInPlaceSiteEx to HCCObj.h - Added
OleInPlaceSiteWindowless to HCCObj.h - Added
ViewObject to HCCObj.h - Added
ViewObject2 to HCCObj.h - Added
ViewObjectEx to HCCObj.h - Added
OleUndoUnit to HCCObj.h - Added
OleParentUndoUnit to HCCObj.h - Added
EnumOleUndoUnits to HCCObj.h - Added
OleUndoManager to HCCObj.h - Added
PointerInactive to HCCObj.h - Added
ObjectWithSite to HCCObj.h - Added
PerPropertyBrowsing to HCCObj.h - Added
PropertyBag to HCCObj.h - Added
PropertyBag2 to HCCObj.h - Added
PersistPropertyBag2 to HCCObj.h - Added
AdviseSinkEx to HCCObj.h - Added
QuickActivate to HCCObj.h
2022.01.14
- Added
template<...> class ObjectBase to HCCComImpl.h - Added
template<...> class Interfaces to HCCComImpl.h - Added ComInterfacesTests.cpp to Harlinn.Common.Core.Tests verifying that
QueryInterface works for, currently, more than 1000 different COM interfaces. - Added ComImplTests.cpp to Harlinn.Common.Core.Tests verifying that
class ObjectImpl : public Com::ObjectBase<ObjectImpl, IEnumString, IEnumVARIANT>
{
int value_ = 0;
public:
virtual HRESULT __stdcall Next( ULONG celt, LPOLESTR* rgelt, ULONG* pceltFetched ) override;
virtual HRESULT __stdcall Next( ULONG celt, VARIANT* rgVar, ULONG* pCeltFetched ) override;
virtual HRESULT __stdcall Skip( ULONG celt ) override;
virtual HRESULT __stdcall Reset( ) override;
virtual HRESULT __stdcall Clone( IEnumString** ppenum ) override;
virtual HRESULT STDMETHODCALLTYPE Clone( IEnumVARIANT** ppEnum ) override;
};
is a valid implementation of a COM object that implements both IEnumString and IEnumVARIANT.
Demonstrating an implementation that is significantly simpler than alternative COM implementation frameworks.
2022.01.13
- Added HCCComImpl.h to Harlinn.Common.Core: Classes used to implement COM objects.
- Added HCCComInterfaces.h to Harlinn.Common.Core:
struct Interface : std::false_type
template<typename ...InterfaceTypes>
{
};
With specializations for many common COM interfaces derived from:
template<>
struct Interface<IUnknown> : std::true_type
{
using InterfaceType = IUnknown;
template<typename DerivedInterfaceType>
static void* QueryInterface( const Guid& interfaceId, const DerivedInterfaceType* impl )
{
if ( interfaceId == __uuidof( InterfaceType ) )
{
auto* result = static_cast<InterfaceType*>( const_cast<DerivedInterfaceType*>( impl ) );
return result;
}
else
{
return nullptr;
}
}
};
Specializations for interfaces derived from IUnknown are the implemented using this macro:
#define HCC_COM_DEFINE_INTERFACE( Itf, BaseItf ) \
template<> \
struct Interface<Itf> : Interface<BaseItf> \
{ \
using Base = Interface<BaseItf>; \
using InterfaceType = Itf; \
template<typename DerivedInterfaceType> \
static void* QueryInterface( const Guid& interfaceId, const DerivedInterfaceType* impl ) \
{ \
if ( interfaceId == __uuidof( InterfaceType ) ) \
{ \
auto* result = static_cast<InterfaceType*>( const_cast<DerivedInterfaceType*>( impl ) ); \
return result; \
} \
else \
{ \
return Base::QueryInterface<DerivedInterfaceType>( interfaceId, impl ); \
} \
} \
}
Which is then used to implement specializations of Interface<...> for COM interfaces like this:
HCC_COM_DEFINE_INTERFACE( IEnumString, IUnknown );
HCC_COM_DEFINE_INTERFACE( IClassFactory, IUnknown );
HCC_COM_DEFINE_INTERFACE( ISequentialStream, IUnknown );
HCC_COM_DEFINE_INTERFACE( IStream, ISequentialStream );
HCC_COM_DEFINE_INTERFACE( IPersist, IUnknown );
HCC_COM_DEFINE_INTERFACE( IPersistStream, IPersist );
HCC_COM_DEFINE_INTERFACE( IEnumMoniker, IUnknown );
HCC_COM_DEFINE_INTERFACE( IMoniker, IPersistStream );
.
.
.
2022.01.11
- Reimplemented IUnknownImplementation; fixing, among other things, a nasty bug in QueryInterface,
- Continued reimplementing the support for Direct2D in HWGraphics.h, rewriting the follwing classes/templates in the Harlinn::Windows::Graphics namespace:
- CommandSink2
- GdiMetafile1
- GdiMetafileSink1
- SpriteBatch
- DeviceContext3
- Device3
- Factory4
- CommandSink3
- SvgGlyphStyle
- DeviceContext4
- Device4
- Factory5
- CommandSink4
- ColorContext1
- SvgAttribute
- SvgPaint
- SvgStrokeDashArray
- SvgPointCollection
- SvgPathData
- SvgElement
- SvgDocument
- DeviceContext5
- Device5
- Factory6
- CommandSink5
- DeviceContext6
- Device6
- Factory7
2022.01.10
- Continued reimplementing the support for Direct2D in HWGraphics.h, rewriting the follwing classes/templates in the Harlinn::Windows::Graphics namespace:
- Device
- Factory1
- Multithread
- GeometryRealization
- DeviceContext1
- Device1
- Factory2
- CommandSink1
- InkStyle
- Ink
- GradientMesh
- ImageSource
- ImageSourceFromWic
- TransformedImageSource
- LookupTable3D
- DeviceContext2
- Device2
- Factory3
2022.01.09
- Continued reimplementing the support for Direct2D in HWGraphics.h, rewriting the follwing classes/templates in the Harlinn::Windows::Graphics namespace:
- DeviceContextRenderTarget
- Factory
- GdiMetafileSink
- ID2D1GdiMetafileSinkImplementationBase
- GdiMetafile
- CommandSink
- ID2D1CommandSinkImplementationBase
- CommandList
- PrintControl
- ImageBrush
- BitmapBrush1
- StrokeStyle1
- PathGeometry1
- Properties
- Effect
- Bitmap1
- GradientStopCollection1
- DrawingStateBlock1
- DeviceContext
2022.01.08
- Moved support for DirectWrite out of HWGraphics.h and out of the Harlinn::Windows::Graphics namespace and into HWDWrite.h and into the Harlinn::Windows::DirectWrite namespace.
- Reimplemented the support for Direct2D in HWGraphics.h, rewriting the follwing classes/templates in the Harlinn::Windows::Graphics namespace:
- Resource
- Image
- ColorContext
- Bitmap
- GradientStopCollection
- Brush
- BitmapBrush
- SolidColorBrush
- LinearGradientBrush
- RadialGradientBrush
- StrokeStyle
- Geometry
- RectangleGeometry
- RoundedRectangleGeometry
- EllipseGeometry
- GeometryGroup
- TransformedGeometry
- SimplifiedGeometrySink
- ID2D1SimplifiedGeometrySinkImplementationBase
- GeometrySink
- ID2D1GeometrySinkImplementationBase
- TessellationSink
- ID2D1TessellationSinkImplementationBase
- PathGeometry
- Mesh
- Layer
- DrawingStateBlock
- RenderTarget
- BitmapRenderTarget
- ControlRenderTarget
- GdiInteropRenderTarget
This rewrite provides better documentation, improved error handling, improved support for working with raw COM interfaces, and an improved API compared to the API I created back in 2012.
2022.01.06/07
- Added new classes to Tools\WMI\CIMTool
- Renderable
- TreeNode
- Command
- CommandManager
- Window
- MenuItem
- SubMenuItem
- Menu
- ClassObjectNode
- NamespaceNode
- Connection
- ConnectionManager
- ExplorerWindow
- PropertiesWindow
- FileMenu
- EditMenu
- ViewMenu
- MainMenuBar
- Main
2022.01.05
- Added new project Tools\WMI\CIMTool - A tool for exploring Windows Management Instrumentation (WMI) API implemented using ImGui.
2022.01.04
- Added new project Examples\Core\WMI\HCCExampleSimpleWMIClient
- Added new project Examples\Core\WMI\HCCExampleSimpleAsyncWMIClient
2022.01.03
- Added more classes for interfacing with the Windows Management Instrumentation (WMI) API
- WbemMethodSignature
- WbemMethod
2022.01.02
- Added classes for interfacing with the Windows Management Instrumentation (WMI) API
- WbemProperty
- WbemClassObject
- WbemObjectAccess
- WbemQualifierSet
- WbemServices
- WbemLocator
- WbemObjectSink
- EnumWbemClassObject
- WbemCallResult
- WbemContext
- UnsecuredApartment
- WbemUnsecuredApartment
- WbemStatusCodeText
- WbemBackupRestore
- WbemBackupRestoreEx
- WbemRefresher
- WbemHiPerfEnum
- WbemConfigureRefresher
- WbemObjectSinkEx
- WbemShutdown
- WbemObjectTextSrc
- MofCompiler
- WbemPropertyProvider
- WbemUnboundObjectSink
- WbemEventProvider
- WbemEventProviderQuerySink
- WbemEventProviderSecurity
- WbemEventConsumerProvider
- WbemProviderInitSink
- WbemProviderInit
- WbemHiPerfProvider
- WbemDecoupledRegistrar
- WbemProviderIdentity
- WbemDecoupledBasicEventProvider
- WbemEventSink
- WbemTransport
- WbemLevel1Login
- WbemConnectorLogin
- WbemAddressResolution
- WbemClientTransport
- WbemClientConnectionTransport
- WbemConstructClassObject
2022.01.01
- Added classes for interfacing with the Windows Location API
- LocationReport
- LatLongReport
- CivicAddressReport
- Location
- LocationPower
- DefaultLocation
- DispLatLongReport
- DispCivicAddressReport
- LocationReportFactory
- LatLongReportFactory
- CivicAddressReportFactory
- Added classes for interfacing with the Windows sensor API
- WpdSerializer
- PortableDeviceValues
- PortableDeviceKeyCollection
- PortableDevicePropVariantCollection
- PortableDeviceValuesCollection
- SensorManager
- LocationPermissions
- SensorCollection
- Sensor
- SensorDataReport
- SensorManagerEvents
- SensorEvents
- SensorManagerEventSinkBase
- SensorManagerEventSink
- SensorEventSinkBase
- SensorEventSink
2021.12.29
- Added classes for serial port device I/O to Harlinn.Common.Core
- DeviceControlBlock
- CommConfig
- SerialPort
- SerialPorts
- CommDeviceStream
- CommDeviceRequest
- ReadCommDeviceRequest
- WriteCommDeviceRequest
- CommDeviceHandler
- CommDeviceDispatcher
- Added several backends to Harlinn.ImGui: DirectX 9 through 11: OpenGL 2 and 3; and Vulkan.
2021.12.28
- Updated Harlinn.ImGui to Docking branch after merge of master at version 1.86 and ImPlot to version 0.12
- Build fixes, rebuilding the entire solution for both Debug and release.
- Fixed missing exports from Harlinn.tiff while building Harlinn.gdal
2021.12.27
- Added new project Examples\3rdParty\bullet\BulletBasicDemo
- Added bullet\examples\Importers to 3rdParty\Harlinn.bullet
- Added bullet\examples\OpenGLWindow to 3rdParty\Harlinn.bullet
- Added bullet\examples\Importers to 3rdParty\Harlinn.bullet
- Added bullet\Extras\Serialize to 3rdParty\Harlinn.bullet
- Added bullet\Extras\InverseDynamics to 3rdParty\Harlinn.bullet
- Added bullet\Extras\HACD to 3rdParty\Harlinn.bullet
- Added bullet\Extras\GIMPACTUtils to 3rdParty\Harlinn.bullet
- Added bullet\Extras\ConvexDecomposition to 3rdParty\Harlinn.bullet
- Added new project 3rdParty\Harlinn.rtmidi
- Added new project 3rdParty\Harlinn.gwen
- Added new project 3rdParty\Harlinn.enet
- Added new project 3rdParty\Harlinn.crossguid
- Added new project 3rdParty\Harlinn.base64
- Added new project Tools\3rdParty\lua\luac
- Added new project Tools\3rdParty\lua\lua
- Added new project 3rdParty\Harlinn.lua
- Added new project 3rdParty\Harlinn.clsocket
2021.12.26
- Added new project 3rdParty\Harlinn.BussIK
- Added new project 3rdParty\Harlinn.glad
2021.12.23
- Added 31 tests to Tests\3rdParty\bullet\Harlinn.bullet.tests
- Added new project Tests\3rdParty\bullet\Harlinn.bullet.tests
2021.12.22
- Added new project 3rdParty\Harlinn.Eigen
2021.12.21
- Added new project 3rdParty\Harlinn.bullet
- Added new project 3rdParty\Harlinn.tinyobjloader
- Added new project Examples\3rdParty\flatbuffers\FlatbuffersGreeterClient
- Added new project Examples\3rdParty\flatbuffers\FlatbuffersGreeterServer
- Added new project Tools\3rdParty\flatbuffers\flatc
- Added new project 3rdParty\Harlinn.flatbuffers
2021.12.20
- Updated Harlinn.Julia, required Julia version is now 1.7
- Added new project Tools\3rdParty\proj\projinfo
- Added new project Tools\3rdParty\proj\gie
- Added new project Tools\3rdParty\proj\proj
- Added new project Tools\3rdParty\proj\geod
- Added new project Tools\3rdParty\proj\cs2cs
- Added new project Tools\3rdParty\proj\projsync
- Added new project Tools\3rdParty\proj\cct
2021.12.19
- Added new project Examples\3rdParty\rocksdb\RocksDBOptimisticTransactionExample
- Added new project Examples\3rdParty\rocksdb\RocksDBCompactionFilterExample
- Added new project Examples\3rdParty\rocksdb\RocksDBCompactFilesExample
- Added new project Examples\3rdParty\rocksdb\RocksDBColumnFamiliesExample
- Added new project Tools\3rdParty\rocksdb\rocksdb_dump
- Added new project Tools\3rdParty\rocksdb\rocksdb_undump
- Added new project Tools\3rdParty\rocksdb\write_stress
- Added new project Tools\3rdParty\rocksdb\trace_analyzer
- Added new project Tools\3rdParty\rocksdb\sst_dump
- Added new project Tools\3rdParty\rocksdb\io_tracer_parser
2021.12.18
- Added new project Tools\3rdParty\rocksdb\db_sanity_test
- Added new project Tools\3rdParty\rocksdb\db_repl_stress
- Added new project Tools\3rdParty\rocksdb\db_bench
- Added new project Tools\3rdParty\rocksdb\ldb
- Added new project Examples\3rdParty\rocksdb\RocksDBSimpleExample2
- Modified 3rdParty\Harlinn.rocksdb so that the Harlinn.rocksdb.dll now exports the C++ API.
2021.12.17
- Added new project Examples\3rdParty\rocksdb\RocksDBSimpleExample
- Added new project Tools\3rdParty\rocksdb\blob_dump
- Added new project Tools\3rdParty\rocksdb\cache_bench
- Upgraded 3rdParty\Harlinn.rocksdb to rocksdb 6.26.1
- Added 5 tests to Tools\3rdParty\gdal\gdal_tests, for a total of 84 tests
2021.12.16
- Added 79 tests to Tools\3rdParty\gdal\gdal_tests
- Added gdal runtime datafiles to Share\gdal
- Added proj runtime datafiles to Share\proj
2021.12.15
- Added new project Harlinn.Java - A thin wrapper around the Java Native Interface. Locates jvm.dll dynamically.
2021.12.14
- Added new project Tools\3rdParty\gdal\gdal_tests
- Upgraded 3rdParty\Harlinn.jxl to libjxl 0.6.1
- Upgraded 3rdParty\Harlinn.gdal to gdal 3.4
- Upgraded 3rdParty\Harlinn.tiff with modifications from gdal 3.4
- Added new project Tools\3rdParty\gdal\dumpoverviews
- Added new project Tools\3rdParty\gdal\gdal_contour
- Added new project Tools\3rdParty\gdal\gdal_create
- Added new project Tools\3rdParty\gdal\gdal_grid
- Added new project Tools\3rdParty\gdal\gdal_rasterize
- Added new project Tools\3rdParty\gdal\gdal_translate
- Added new project Tools\3rdParty\gdal\gdal_viewshed
- Added new project Tools\3rdParty\gdal\gdal2ogr
- Added new project Tools\3rdParty\gdal\gdaladdo
- Added new project Tools\3rdParty\gdal\gdalasyncread
- Added new project Tools\3rdParty\gdal\gdalbuildvrt
- Added new project Tools\3rdParty\gdal\gdaldem
- Added new project Tools\3rdParty\gdal\gdalenhance
- Added new project Tools\3rdParty\gdal\gdalflattenmask
- Added new project Tools\3rdParty\gdal\gdalinfo
- Added new project Tools\3rdParty\gdal\gdallocationinfo
- Added new project Tools\3rdParty\gdal\gdalmanage
- Added new project Tools\3rdParty\gdal\gdalmdiminfo
- Added new project Tools\3rdParty\gdal\gdalmultidimtranslate
- Added new project Tools\3rdParty\gdal\gdalsrsinfo
- Added new project Tools\3rdParty\gdal\gdaltindex
- Added new project Tools\3rdParty\gdal\gdaltorture
- Added new project Tools\3rdParty\gdal\gdaltransform
- Added new project Tools\3rdParty\gdal\gdalwarp
- Added new project Tools\3rdParty\gdal\gnmanalyse
- Added new project Tools\3rdParty\gdal\gnmmanage
- Added new project Tools\3rdParty\gdal\nearblack
- Added new project Tools\3rdParty\gdal\ogr2ogr
- Added new project Tools\3rdParty\gdal\ogrinfo
- Added new project Tools\3rdParty\gdal\ogrlineref
- Added new project Tools\3rdParty\gdal\ogrtindex
2021.12.12
- Added new project Tests\3rdParty\skia\skia_test. A fair number of the tests works, about 1500 of them, but then the test program terminates. As far as I have been able to determine, this seems to be related to the test code.
- Changed the build of 3rdParty\Harlinn.skia to support Vulkan, Open GL and DirectX 3D. Temporarily removed support for 3rdParty\Harlinn.Angle in 3rdParty\Harlinn.skia.
