yyc12345/libcmo21
1
0
Fork 0
Code Activity

fix: fix VxMath part

Browse Source
This commit is contained in:
yyc12345
2026-01-25 11:30:11 +08:00
parent 09ca976fd9
commit bdb920e83a
11 changed files with 869 additions and 496 deletions
Download Patch File Download Diff File Expand all files Collapse all files

317
.clang-format Normal file
View File

@@ -0,0 +1,317 @@
# yaml-language-server: $schema=https://json.schemastore.org/clang-format.json
---
Language: Cpp
AccessModifierOffset: -4
AlignAfterOpenBracket: Align
AlignArrayOfStructures: None
AlignConsecutiveAssignments:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
AlignFunctionPointers: false
PadOperators: false
AlignConsecutiveBitFields:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
AlignFunctionPointers: false
PadOperators: false
AlignConsecutiveDeclarations:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
AlignFunctionPointers: false
PadOperators: false
AlignConsecutiveMacros:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
AlignFunctionPointers: false
PadOperators: false
AlignConsecutiveShortCaseStatements:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCaseArrows: false
AlignCaseColons: false
AlignConsecutiveTableGenBreakingDAGArgColons:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
AlignFunctionPointers: false
PadOperators: false
AlignConsecutiveTableGenCondOperatorColons:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
AlignFunctionPointers: false
PadOperators: false
AlignConsecutiveTableGenDefinitionColons:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
AlignFunctionPointers: false
PadOperators: false
AlignEscapedNewlines: DontAlign
AlignOperands: Align
AlignTrailingComments:
Kind: Always
OverEmptyLines: 0
AllowAllArgumentsOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowBreakBeforeNoexceptSpecifier: Never
AllowShortBlocksOnASingleLine: Never
AllowShortCaseExpressionOnASingleLine: true
AllowShortCaseLabelsOnASingleLine: false
AllowShortCompoundRequirementOnASingleLine: true
AllowShortEnumsOnASingleLine: true
AllowShortFunctionsOnASingleLine: Inline
AllowShortIfStatementsOnASingleLine: AllIfsAndElse
AllowShortLambdasOnASingleLine: All
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakBeforeMultilineStrings: false
AttributeMacros:
- __capability
BinPackArguments: false
BinPackParameters: false
BitFieldColonSpacing: Both
BraceWrapping:
AfterCaseLabel: false
AfterClass: false
AfterControlStatement: Never
AfterEnum: false
AfterExternBlock: false
AfterFunction: false
AfterNamespace: false
AfterObjCDeclaration: false
AfterStruct: false
AfterUnion: false
BeforeCatch: false
BeforeElse: false
BeforeLambdaBody: false
BeforeWhile: false
IndentBraces: false
SplitEmptyFunction: false
SplitEmptyRecord: false
SplitEmptyNamespace: false
BreakAdjacentStringLiterals: true
BreakAfterAttributes: Leave
BreakAfterJavaFieldAnnotations: false
BreakAfterReturnType: None
BreakArrays: true
BreakBeforeBinaryOperators: All
BreakBeforeConceptDeclarations: Always
BreakBeforeBraces: Attach
BreakBeforeInlineASMColon: OnlyMultiline
BreakBeforeTernaryOperators: true
BreakConstructorInitializers: AfterColon
BreakFunctionDefinitionParameters: false
BreakInheritanceList: BeforeColon
BreakStringLiterals: false
BreakTemplateDeclarations: Yes
ColumnLimit: 140
CommentPragmas: '^ IWYU pragma:'
CompactNamespaces: false
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4
Cpp11BracedListStyle: true
DerivePointerAlignment: true
DisableFormat: false
EmptyLineAfterAccessModifier: Never
EmptyLineBeforeAccessModifier: LogicalBlock
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: true
ForEachMacros:
- forever
- foreach
- Q_FOREACH
- BOOST_FOREACH
IfMacros:
- KJ_IF_MAYBE
IncludeBlocks: Preserve
IncludeCategories:
- Regex: '^<Q.*'
Priority: 200
SortPriority: 200
CaseSensitive: true
IncludeIsMainRegex: '(Test)?$'
IncludeIsMainSourceRegex: ''
IndentAccessModifiers: false
IndentCaseBlocks: false
IndentCaseLabels: true
IndentExternBlock: AfterExternBlock
IndentGotoLabels: true
IndentPPDirectives: None
IndentRequiresClause: true
IndentWidth: 4
IndentWrappedFunctionNames: false
InsertBraces: false
InsertNewlineAtEOF: false
InsertTrailingCommas: None
IntegerLiteralSeparator:
Binary: 0
BinaryMinDigits: 0
Decimal: 0
DecimalMinDigits: 0
Hex: 0
HexMinDigits: 0
JavaScriptQuotes: Leave
JavaScriptWrapImports: true
KeepEmptyLines:
AtEndOfFile: false
AtStartOfBlock: false
AtStartOfFile: false
LambdaBodyIndentation: Signature
LineEnding: DeriveLF
MacroBlockBegin: ''
MacroBlockEnd: ''
MainIncludeChar: Quote
MaxEmptyLinesToKeep: 1
NamespaceIndentation: All
ObjCBinPackProtocolList: Auto
ObjCBlockIndentWidth: 4
ObjCBreakBeforeNestedBlockParam: true
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
PackConstructorInitializers: BinPack
PenaltyBreakAssignment: 150
PenaltyBreakBeforeFirstCallParameter: 300
PenaltyBreakComment: 500
PenaltyBreakFirstLessLess: 400
PenaltyBreakOpenParenthesis: 0
PenaltyBreakScopeResolution: 500
PenaltyBreakString: 600
PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 50
PenaltyIndentedWhitespace: 0
PenaltyReturnTypeOnItsOwnLine: 300
PointerAlignment: Right
PPIndentWidth: -1
QualifierAlignment: Leave
ReferenceAlignment: Pointer
ReflowComments: false
RemoveBracesLLVM: false
RemoveParentheses: Leave
RemoveSemicolon: false
RequiresClausePosition: OwnLine
RequiresExpressionIndentation: OuterScope
SeparateDefinitionBlocks: Leave
ShortNamespaceLines: 1
SkipMacroDefinitionBody: false
SortIncludes: Never
SortJavaStaticImport: Before
SortUsingDeclarations: Lexicographic
SpaceAfterCStyleCast: true
SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: false
SpaceAroundPointerQualifiers: Default
SpaceBeforeAssignmentOperators: true
SpaceBeforeCaseColon: false
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeJsonColon: false
SpaceBeforeParens: ControlStatements
SpaceBeforeParensOptions:
AfterControlStatements: true
AfterForeachMacros: true
AfterFunctionDefinitionName: false
AfterFunctionDeclarationName: false
AfterIfMacros: true
AfterOverloadedOperator: false
AfterPlacementOperator: true
AfterRequiresInClause: false
AfterRequiresInExpression: false
BeforeNonEmptyParentheses: false
SpaceBeforeRangeBasedForLoopColon: true
SpaceBeforeSquareBrackets: false
SpaceInEmptyBlock: false
SpacesBeforeTrailingComments: 1
SpacesInAngles: Never
SpacesInContainerLiterals: false
SpacesInLineCommentPrefix:
Minimum: 1
Maximum: -1
SpacesInParens: Never
SpacesInParensOptions:
ExceptDoubleParentheses: false
InCStyleCasts: false
InConditionalStatements: false
InEmptyParentheses: false
Other: false
SpacesInSquareBrackets: false
Standard: Auto
StatementAttributeLikeMacros:
- Q_EMIT
- emit
StatementMacros:
- Q_UNUSED
- QT_REQUIRE_VERSION
- Q_CLASSINFO
- Q_ENUM
- Q_ENUM_NS
- Q_FLAG
- Q_FLAG_NS
- Q_GADGET
- Q_GADGET_EXPORT
- Q_INTERFACES
- Q_LOGGING_CATEGORY
- Q_MOC_INCLUDE
- Q_NAMESPACE
- Q_NAMESPACE_EXPORT
- Q_OBJECT
- Q_PROPERTY
- Q_REVISION
- Q_DISABLE_COPY
- Q_DISABLE_COPY_MOVE
- Q_SET_OBJECT_NAME
- QT_BEGIN_NAMESPACE
- QT_END_NAMESPACE
- QML_ADDED_IN_MINOR_VERSION
- QML_ANONYMOUS
- QML_ATTACHED
- QML_DECLARE_TYPE
- QML_DECLARE_TYPEINFO
- QML_ELEMENT
- QML_EXTENDED
- QML_EXTENDED_NAMESPACE
- QML_EXTRA_VERSION
- QML_FOREIGN
- QML_FOREIGN_NAMESPACE
- QML_IMPLEMENTS_INTERFACES
- QML_INTERFACE
- QML_NAMED_ELEMENT
- QML_REMOVED_IN_MINOR_VERSION
- QML_SINGLETON
- QML_UNAVAILABLE
- QML_UNCREATABLE
- QML_VALUE_TYPE
- YYCC_DELETE_COPY
- YYCC_DELETE_MOVE
- YYCC_DELETE_COPY_MOVE
- YYCC_DEFAULT_COPY
- YYCC_DEFAULT_MOVE
- YYCC_DEFAULT_COPY_MOVE
- YYCC_DECL_COPY
- YYCC_DECL_MOVE
- YYCC_DECL_COPY_MOVE
TableGenBreakInsideDAGArg: DontBreak
TabWidth: 4
UseTab: Never
VerilogBreakBetweenInstancePorts: true
WhitespaceSensitiveMacros:
- BOOST_PP_STRINGIZE
- CF_SWIFT_NAME
- NS_SWIFT_NAME
- PP_STRINGIZE
- STRINGIZE
...

2
Assets/CodeGen/VectorGen/VxTypes.hpp.jinja
View File

@@ -10,7 +10,7 @@ struct {{ sname }} {
{{ sname }}({{- shared.argument_list_builder(svars) -}}); {{ sname }}({{- shared.argument_list_builder(svars) -}});
{#- Default copy ctor, move ctor, copy assigner, move assigner #} {#- Default copy ctor, move ctor, copy assigner, move assigner #}
YYCC_DEFAULT_COPY_MOVE({{ sname }}); YYCC_DEFAULT_COPY_MOVE({{ sname }})
{#- Offset operator #} {#- Offset operator #}
CKFLOAT& operator[](size_t i); CKFLOAT& operator[](size_t i);

50
LibCmo/LibCmo/CK2/CKBitmapData.cpp
View File

@@ -159,14 +159,14 @@ namespace LibCmo::CK2 {
if (!canSaveAlpha) { if (!canSaveAlpha) {
// prepare alpha list // prepare alpha list
CKDWORD pixelCount = slot->GetPixelCount(); CKDWORD pixelCount = slot->GetPixelCount();
std::unique_ptr<CKBYTE[]> alphabuf(new CKBYTE[pixelCount * VxMath::VxImageDescEx::ColorFactorSize]); std::unique_ptr<CKBYTE[]> alphabuf(new CKBYTE[pixelCount * VxMath::VxImageDescEx::FACTOR_SIZE]);
VxMath::VxCopyStructure( VxMath::VxCopyStructure(
pixelCount, pixelCount,
alphabuf.get(), alphabuf.get(),
VxMath::VxImageDescEx::ColorFactorSize, VxMath::VxImageDescEx::FACTOR_SIZE,
VxMath::VxImageDescEx::ColorFactorSize, VxMath::VxImageDescEx::FACTOR_SIZE,
slot->GetImage() + 3 * VxMath::VxImageDescEx::ColorFactorSize, // move to A factor slot->GetImage() + 3 * VxMath::VxImageDescEx::FACTOR_SIZE, // move to A factor
VxMath::VxImageDescEx::PixelSize VxMath::VxImageDescEx::PIXEL_SIZE
); );
// check whether alpha are the same value // check whether alpha are the same value
@@ -174,9 +174,9 @@ namespace LibCmo::CK2 {
CKDWORD sameAlpha = 0; CKDWORD sameAlpha = 0;
for (CKDWORD i = 0; i < pixelCount; ++i) { for (CKDWORD i = 0; i < pixelCount; ++i) {
if (i == 0) { if (i == 0) {
sameAlpha = static_cast<CKDWORD>(alphabuf[i * VxMath::VxImageDescEx::ColorFactorSize]); sameAlpha = static_cast<CKDWORD>(alphabuf[i * VxMath::VxImageDescEx::FACTOR_SIZE]);
} else { } else {
if (sameAlpha != static_cast<CKDWORD>(alphabuf[i * VxMath::VxImageDescEx::ColorFactorSize])) { if (sameAlpha != static_cast<CKDWORD>(alphabuf[i * VxMath::VxImageDescEx::FACTOR_SIZE])) {
isSameAlpha = false; isSameAlpha = false;
break; break;
} }
@@ -192,7 +192,7 @@ namespace LibCmo::CK2 {
if (isSameAlpha) { if (isSameAlpha) {
chk->WriteStruct(sameAlpha); chk->WriteStruct(sameAlpha);
} else { } else {
chk->WriteBuffer(alphabuf.get(), pixelCount * VxMath::VxImageDescEx::ColorFactorSize); chk->WriteBuffer(alphabuf.get(), pixelCount * VxMath::VxImageDescEx::FACTOR_SIZE);
} }
// free alphabuf // free alphabuf
@@ -240,7 +240,7 @@ namespace LibCmo::CK2 {
// create 4 channel buf // create 4 channel buf
// we always write alpha channel data. // we always write alpha channel data.
CKDWORD pixelCount = slot->GetPixelCount(); CKDWORD pixelCount = slot->GetPixelCount();
CKDWORD bufSize = pixelCount * VxMath::VxImageDescEx::ColorFactorSize; CKDWORD bufSize = pixelCount * VxMath::VxImageDescEx::FACTOR_SIZE;
std::unique_ptr<CKBYTE[]> redbuf(new CKBYTE[bufSize]); std::unique_ptr<CKBYTE[]> redbuf(new CKBYTE[bufSize]);
std::unique_ptr<CKBYTE[]> greenbuf(new CKBYTE[bufSize]); std::unique_ptr<CKBYTE[]> greenbuf(new CKBYTE[bufSize]);
std::unique_ptr<CKBYTE[]> bluebuf(new CKBYTE[bufSize]); std::unique_ptr<CKBYTE[]> bluebuf(new CKBYTE[bufSize]);
@@ -251,37 +251,37 @@ namespace LibCmo::CK2 {
VxMath::VxCopyStructure( VxMath::VxCopyStructure(
pixelCount, pixelCount,
alphabuf.get(), alphabuf.get(),
VxMath::VxImageDescEx::ColorFactorSize, VxMath::VxImageDescEx::FACTOR_SIZE,
VxMath::VxImageDescEx::ColorFactorSize, VxMath::VxImageDescEx::FACTOR_SIZE,
slot->GetImage() + (3 * VxMath::VxImageDescEx::ColorFactorSize), slot->GetImage() + (3 * VxMath::VxImageDescEx::FACTOR_SIZE),
VxMath::VxImageDescEx::PixelSize VxMath::VxImageDescEx::PIXEL_SIZE
); );
// copy r // copy r
VxMath::VxCopyStructure( VxMath::VxCopyStructure(
pixelCount, pixelCount,
redbuf.get(), redbuf.get(),
VxMath::VxImageDescEx::ColorFactorSize, VxMath::VxImageDescEx::FACTOR_SIZE,
VxMath::VxImageDescEx::ColorFactorSize, VxMath::VxImageDescEx::FACTOR_SIZE,
slot->GetImage() + (2 * VxMath::VxImageDescEx::ColorFactorSize), slot->GetImage() + (2 * VxMath::VxImageDescEx::FACTOR_SIZE),
VxMath::VxImageDescEx::PixelSize VxMath::VxImageDescEx::PIXEL_SIZE
); );
// copy g // copy g
VxMath::VxCopyStructure( VxMath::VxCopyStructure(
pixelCount, pixelCount,
greenbuf.get(), greenbuf.get(),
VxMath::VxImageDescEx::ColorFactorSize, VxMath::VxImageDescEx::FACTOR_SIZE,
VxMath::VxImageDescEx::ColorFactorSize, VxMath::VxImageDescEx::FACTOR_SIZE,
slot->GetImage() + (1 * VxMath::VxImageDescEx::ColorFactorSize), slot->GetImage() + (1 * VxMath::VxImageDescEx::FACTOR_SIZE),
VxMath::VxImageDescEx::PixelSize VxMath::VxImageDescEx::PIXEL_SIZE
); );
// copy b // copy b
VxMath::VxCopyStructure( VxMath::VxCopyStructure(
pixelCount, pixelCount,
bluebuf.get(), bluebuf.get(),
VxMath::VxImageDescEx::ColorFactorSize, VxMath::VxImageDescEx::FACTOR_SIZE,
VxMath::VxImageDescEx::ColorFactorSize, VxMath::VxImageDescEx::FACTOR_SIZE,
slot->GetImage() + (0 * VxMath::VxImageDescEx::ColorFactorSize), slot->GetImage() + (0 * VxMath::VxImageDescEx::FACTOR_SIZE),
VxMath::VxImageDescEx::PixelSize VxMath::VxImageDescEx::PIXEL_SIZE
); );
// write 4 buf // write 4 buf

2
LibCmo/LibCmo/CK2/CKGlobals.cpp
View File

@@ -1,5 +1,5 @@
#include "../VTUtils.hpp" #include "../VTUtils.hpp"
#if YYCC_OS == YYCC_OS_WINDOWS #if defined(YYCC_OS_WINDOWS)
#define ZLIB_WINAPI #define ZLIB_WINAPI
#endif #endif
#include <zconf.h> #include <zconf.h>

68
LibCmo/LibCmo/CK2/DataHandlers/CKBitmapHandler.cpp
View File

@@ -16,7 +16,7 @@ namespace LibCmo::CK2::DataHandlers {
*/ */
// MARK: for std-image size, we use `n * CKSizeof(CKBYTE)` to calc offset. // MARK: for std-image size, we use `n * CKSizeof(CKBYTE)` to calc offset.
// for virtools size, we use `VxMath::VxImageDescEx::ColorFactorSize` and `VxMath::VxImageDescEx::PixelSize` to calc offset. // for virtools size, we use `VxMath::VxImageDescEx::FACTOR_SIZE` and `VxMath::VxImageDescEx::PIXEL_SIZE` to calc offset.
static void ABGRToARGB(CKDWORD count, const void* _abgr, void* _argb) { static void ABGRToARGB(CKDWORD count, const void* _abgr, void* _argb) {
const CKBYTE* abgr = static_cast<const CKBYTE*>(_abgr); const CKBYTE* abgr = static_cast<const CKBYTE*>(_abgr);
@@ -24,36 +24,36 @@ namespace LibCmo::CK2::DataHandlers {
// copy R // copy R
VxMath::VxCopyStructure( VxMath::VxCopyStructure(
count, count,
argb + (2u * VxMath::VxImageDescEx::ColorFactorSize), argb + (2u * VxMath::VxImageDescEx::FACTOR_SIZE),
VxMath::VxImageDescEx::PixelSize, VxMath::VxImageDescEx::PIXEL_SIZE,
VxMath::VxImageDescEx::ColorFactorSize, VxMath::VxImageDescEx::FACTOR_SIZE,
abgr + (0u * CKSizeof(CKBYTE)), abgr + (0u * CKSizeof(CKBYTE)),
4u * CKSizeof(CKBYTE) 4u * CKSizeof(CKBYTE)
); );
// copy G // copy G
VxMath::VxCopyStructure( VxMath::VxCopyStructure(
count, count,
argb + (1u * VxMath::VxImageDescEx::ColorFactorSize), argb + (1u * VxMath::VxImageDescEx::FACTOR_SIZE),
VxMath::VxImageDescEx::PixelSize, VxMath::VxImageDescEx::PIXEL_SIZE,
VxMath::VxImageDescEx::ColorFactorSize, VxMath::VxImageDescEx::FACTOR_SIZE,
abgr + (1u * CKSizeof(CKBYTE)), abgr + (1u * CKSizeof(CKBYTE)),
4u * CKSizeof(CKBYTE) 4u * CKSizeof(CKBYTE)
); );
// copy B // copy B
VxMath::VxCopyStructure( VxMath::VxCopyStructure(
count, count,
argb + (0u * VxMath::VxImageDescEx::ColorFactorSize), argb + (0u * VxMath::VxImageDescEx::FACTOR_SIZE),
VxMath::VxImageDescEx::PixelSize, VxMath::VxImageDescEx::PIXEL_SIZE,
VxMath::VxImageDescEx::ColorFactorSize, VxMath::VxImageDescEx::FACTOR_SIZE,
abgr + (2u * CKSizeof(CKBYTE)), abgr + (2u * CKSizeof(CKBYTE)),
4u * CKSizeof(CKBYTE) 4u * CKSizeof(CKBYTE)
); );
// copy A // copy A
VxMath::VxCopyStructure( VxMath::VxCopyStructure(
count, count,
argb + (3u * VxMath::VxImageDescEx::ColorFactorSize), argb + (3u * VxMath::VxImageDescEx::FACTOR_SIZE),
VxMath::VxImageDescEx::PixelSize, VxMath::VxImageDescEx::PIXEL_SIZE,
VxMath::VxImageDescEx::ColorFactorSize, VxMath::VxImageDescEx::FACTOR_SIZE,
abgr + (3u * CKSizeof(CKBYTE)), abgr + (3u * CKSizeof(CKBYTE)),
4u * CKSizeof(CKBYTE) 4u * CKSizeof(CKBYTE)
); );
@@ -67,36 +67,36 @@ namespace LibCmo::CK2::DataHandlers {
count, count,
abgr + (0u * CKSizeof(CKBYTE)), abgr + (0u * CKSizeof(CKBYTE)),
4u * CKSizeof(CKBYTE), 4u * CKSizeof(CKBYTE),
VxMath::VxImageDescEx::ColorFactorSize, VxMath::VxImageDescEx::FACTOR_SIZE,
argb + (2u * VxMath::VxImageDescEx::ColorFactorSize), argb + (2u * VxMath::VxImageDescEx::FACTOR_SIZE),
VxMath::VxImageDescEx::PixelSize VxMath::VxImageDescEx::PIXEL_SIZE
); );
// copy G // copy G
VxMath::VxCopyStructure( VxMath::VxCopyStructure(
count, count,
abgr + (1u * CKSizeof(CKBYTE)), abgr + (1u * CKSizeof(CKBYTE)),
4u * CKSizeof(CKBYTE), 4u * CKSizeof(CKBYTE),
VxMath::VxImageDescEx::ColorFactorSize, VxMath::VxImageDescEx::FACTOR_SIZE,
argb + (1u * VxMath::VxImageDescEx::ColorFactorSize), argb + (1u * VxMath::VxImageDescEx::FACTOR_SIZE),
VxMath::VxImageDescEx::PixelSize VxMath::VxImageDescEx::PIXEL_SIZE
); );
// copy B // copy B
VxMath::VxCopyStructure( VxMath::VxCopyStructure(
count, count,
abgr + (2u * CKSizeof(CKBYTE)), abgr + (2u * CKSizeof(CKBYTE)),
4u * CKSizeof(CKBYTE), 4u * CKSizeof(CKBYTE),
VxMath::VxImageDescEx::ColorFactorSize, VxMath::VxImageDescEx::FACTOR_SIZE,
argb + (0u * VxMath::VxImageDescEx::ColorFactorSize), argb + (0u * VxMath::VxImageDescEx::FACTOR_SIZE),
VxMath::VxImageDescEx::PixelSize VxMath::VxImageDescEx::PIXEL_SIZE
); );
// copy A // copy A
VxMath::VxCopyStructure( VxMath::VxCopyStructure(
count, count,
abgr + (3u * CKSizeof(CKBYTE)), abgr + (3u * CKSizeof(CKBYTE)),
4u * CKSizeof(CKBYTE), 4u * CKSizeof(CKBYTE),
VxMath::VxImageDescEx::ColorFactorSize, VxMath::VxImageDescEx::FACTOR_SIZE,
argb + (3u * VxMath::VxImageDescEx::ColorFactorSize), argb + (3u * VxMath::VxImageDescEx::FACTOR_SIZE),
VxMath::VxImageDescEx::PixelSize VxMath::VxImageDescEx::PIXEL_SIZE
); );
} }
@@ -108,27 +108,27 @@ namespace LibCmo::CK2::DataHandlers {
count, count,
bgr + (0u * CKSizeof(CKBYTE)), bgr + (0u * CKSizeof(CKBYTE)),
3u * CKSizeof(CKBYTE), 3u * CKSizeof(CKBYTE),
VxMath::VxImageDescEx::ColorFactorSize, VxMath::VxImageDescEx::FACTOR_SIZE,
argb + (2u * VxMath::VxImageDescEx::ColorFactorSize), argb + (2u * VxMath::VxImageDescEx::FACTOR_SIZE),
VxMath::VxImageDescEx::PixelSize VxMath::VxImageDescEx::PIXEL_SIZE
); );
// copy G // copy G
VxMath::VxCopyStructure( VxMath::VxCopyStructure(
count, count,
bgr + (1u * CKSizeof(CKBYTE)), bgr + (1u * CKSizeof(CKBYTE)),
3u * CKSizeof(CKBYTE), 3u * CKSizeof(CKBYTE),
VxMath::VxImageDescEx::ColorFactorSize, VxMath::VxImageDescEx::FACTOR_SIZE,
argb + (1u * VxMath::VxImageDescEx::ColorFactorSize), argb + (1u * VxMath::VxImageDescEx::FACTOR_SIZE),
VxMath::VxImageDescEx::PixelSize VxMath::VxImageDescEx::PIXEL_SIZE
); );
// copy B // copy B
VxMath::VxCopyStructure( VxMath::VxCopyStructure(
count, count,
bgr + (2u * CKSizeof(CKBYTE)), bgr + (2u * CKSizeof(CKBYTE)),
3u * CKSizeof(CKBYTE), 3u * CKSizeof(CKBYTE),
VxMath::VxImageDescEx::ColorFactorSize, VxMath::VxImageDescEx::FACTOR_SIZE,
argb + (0u * VxMath::VxImageDescEx::ColorFactorSize), argb + (0u * VxMath::VxImageDescEx::FACTOR_SIZE),
VxMath::VxImageDescEx::PixelSize VxMath::VxImageDescEx::PIXEL_SIZE
); );
// skip A factor // skip A factor
} }

2
LibCmo/LibCmo/CK2/ObjImpls/CKTexture.cpp
View File

@@ -169,7 +169,7 @@ namespace LibCmo::CK2::ObjImpls {
props.m_Format.Flags = static_cast<CKDWORD>(VxMath::VX_PIXELFORMAT::_32_ARGB8888); props.m_Format.Flags = static_cast<CKDWORD>(VxMath::VX_PIXELFORMAT::_32_ARGB8888);
props.m_Format.Width = m_ImageHost.GetWidth(); props.m_Format.Width = m_ImageHost.GetWidth();
props.m_Format.Height = m_ImageHost.GetHeight(); props.m_Format.Height = m_ImageHost.GetHeight();
props.m_Format.BytesPerLine = VxMath::VxImageDescEx::PixelSize * props.m_Format.Width; props.m_Format.BytesPerLine = VxMath::VxImageDescEx::PIXEL_SIZE * props.m_Format.Width;
props.m_Format.BitsPerPixel = 32; props.m_Format.BitsPerPixel = 32;
props.m_Format.RedMask = 0x00FF0000; props.m_Format.RedMask = 0x00FF0000;

2
LibCmo/LibCmo/VxMath/VxMath.cpp
View File

@@ -63,7 +63,7 @@ namespace LibCmo::VxMath {
// copy and swap data by line // copy and swap data by line
CKDWORD height = dst->GetHeight(), CKDWORD height = dst->GetHeight(),
rowsize = VxImageDescEx::PixelSize * dst->GetWidth(); rowsize = VxImageDescEx::PIXEL_SIZE * dst->GetWidth();
for (CKDWORD row = 0; row < height; ++row) { for (CKDWORD row = 0; row < height; ++row) {
std::memcpy( std::memcpy(
dst->GetMutableImage() + (row * rowsize), dst->GetMutableImage() + (row * rowsize),

37
LibCmo/LibCmo/VxMath/VxMemoryMappedFile.cpp
View File

@@ -1,11 +1,16 @@
#include "VxMemoryMappedFile.hpp" #include "VxMemoryMappedFile.hpp"
#include "../VTEncoding.hpp" #include <yycc/num/safe_cast.hpp>
#if defined(YYCC_OS_WINDOWS)
#include <yycc/encoding/windows.hpp>
#else
#include <yycc/string/reinterpret.hpp>
#endif
namespace LibCmo::VxMath { namespace LibCmo::VxMath {
VxMemoryMappedFile::VxMemoryMappedFile(CKSTRING u8_filepath) : VxMemoryMappedFile::VxMemoryMappedFile(CKSTRING u8_filepath) :
// Initialize members // Initialize members
#if YYCC_OS == YYCC_OS_WINDOWS #if defined(YYCC_OS_WINDOWS)
// Initialize Windows specific. // Initialize Windows specific.
m_hFile(NULL), m_hFileMapping(NULL), m_hFileMapView(NULL), m_hFile(NULL), m_hFileMapping(NULL), m_hFileMapView(NULL),
m_dwFileSize(), m_dwFileSize(),
@@ -22,12 +27,12 @@ namespace LibCmo::VxMath {
m_szFilePath = u8_filepath; m_szFilePath = u8_filepath;
// Do real mapping work according to different platform. // Do real mapping work according to different platform.
#if YYCC_OS == YYCC_OS_WINDOWS #if defined(YYCC_OS_WINDOWS)
// Parse file name to wchar_t // Parse file name to wchar_t
std::wstring w_filename; auto rv_w_filename = yycc::encoding::windows::to_wchar(m_szFilePath);
if (!YYCC::EncodingHelper::UTF8ToWchar(m_szFilePath, w_filename)) if (!rv_w_filename.has_value()) return;
return; std::wstring w_filename = std::move(rv_w_filename.value());
// Open file // Open file
this->m_hFile = ::CreateFileW( this->m_hFile = ::CreateFileW(
@@ -80,12 +85,12 @@ namespace LibCmo::VxMath {
} }
// Set base address // Set base address
m_pMemoryMappedFileBase = m_hFileMapView; m_pMemoryMappedFileBase = m_hFileMapView;
#else #else
// create file // create file
// we do not need provide mode_t, because is served for new created file. // we do not need provide mode_t, because is served for new created file.
// we are opening a existed file. // we are opening a existed file.
this->m_hFile = open(YYCC::EncodingHelper::ToOrdinary(m_szFilePath.c_str()), O_RDONLY); this->m_hFile = open(yycc::string::reinterpret::as_ordinary(m_szFilePath.c_str()), O_RDONLY);
if (m_hFile == -1) { if (m_hFile == -1) {
return; return;
} }
@@ -98,13 +103,15 @@ namespace LibCmo::VxMath {
close(m_hFile); close(m_hFile);
return; return;
} }
// Setup size and check its range // Setup size with checking its range
this->m_offFileSize = sb.st_size; this->m_offFileSize = sb.st_size;
if (this->m_offFileSize > static_cast<off_t>(std::numeric_limits<CKDWORD>::max())) { auto rv_cbFile = yycc::num::safe_cast::try_to<CKDWORD>(this->m_offFileSize);
close(m_hFile); if (rv_cbFile.has_value()) {
return; this->m_cbFile = rv_cbFile.value();
} else {
close(m_hFile);
return;
} }
m_cbFile = static_cast<CKDWORD>(this->m_offFileSize);
// map file // map file
this->m_pFileAddr = mmap( this->m_pFileAddr = mmap(
@@ -120,7 +127,7 @@ namespace LibCmo::VxMath {
return; return;
} }
// set base address // set base address
m_pMemoryMappedFileBase = m_pFileAddr; this->m_pMemoryMappedFileBase = m_pFileAddr;
#endif #endif
@@ -135,7 +142,7 @@ namespace LibCmo::VxMath {
m_cbFile = 0; m_cbFile = 0;
m_pMemoryMappedFileBase = nullptr; m_pMemoryMappedFileBase = nullptr;
#if YYCC_OS == YYCC_OS_WINDOWS #if defined(YYCC_OS_WINDOWS)
UnmapViewOfFile(this->m_hFileMapView); UnmapViewOfFile(this->m_hFileMapView);
CloseHandle(m_hFileMapping); CloseHandle(m_hFileMapping);
CloseHandle(m_hFile); CloseHandle(m_hFile);

11
LibCmo/LibCmo/VxMath/VxMemoryMappedFile.hpp
View File

@@ -1,10 +1,11 @@
#pragma once #pragma once
#include "../VTInternal.hpp" #include "../VTInternal.hpp"
#if YYCC_OS == YYCC_OS_WINDOWS #include <yycc/macro/class_copy_move.hpp>
#include <YYCC/WinImportPrefix.hpp> #if defined(YYCC_OS_WINDOWS)
#include <yycc/windows/import_guard_head.hpp>
#include <Windows.h> #include <Windows.h>
#include <YYCC/WinImportSuffix.hpp> #include <yycc/windows/import_guard_tail.hpp>
#else #else
#include <sys/mman.h> #include <sys/mman.h>
#include <sys/stat.h> #include <sys/stat.h>
@@ -24,7 +25,7 @@ namespace LibCmo::VxMath {
*/ */
class VxMemoryMappedFile { class VxMemoryMappedFile {
private: private:
#if YYCC_OS == YYCC_OS_WINDOWS #if defined(YYCC_OS_WINDOWS)
HANDLE m_hFile; HANDLE m_hFile;
LARGE_INTEGER m_dwFileSize; LARGE_INTEGER m_dwFileSize;
HANDLE m_hFileMapping; HANDLE m_hFileMapping;
@@ -48,7 +49,7 @@ namespace LibCmo::VxMath {
*/ */
VxMemoryMappedFile(CKSTRING u8_filepath); VxMemoryMappedFile(CKSTRING u8_filepath);
~VxMemoryMappedFile(); ~VxMemoryMappedFile();
YYCC_DEL_CLS_COPY_MOVE(VxMemoryMappedFile); YYCC_DELETE_COPY_MOVE(VxMemoryMappedFile)
/** /**
* @brief Returns a pointer to the mapped memory buffer. * @brief Returns a pointer to the mapped memory buffer.

742
LibCmo/LibCmo/VxMath/VxTypes.cpp
View File

@@ -5,378 +5,422 @@ namespace LibCmo::VxMath {
#pragma region VxVector2 #pragma region VxVector2
VxVector2::VxVector2() :x(0.0f), y(0.0f) {} VxVector2::VxVector2() : x(0.0f), y(0.0f) {}
VxVector2::VxVector2(CKFLOAT _x, CKFLOAT _y) : x(_x), y(_y) {} VxVector2::VxVector2(CKFLOAT _x, CKFLOAT _y) : x(_x), y(_y) {}
CKFLOAT& VxVector2::operator[](size_t i) { CKFLOAT& VxVector2::operator[](size_t i) {
switch (i) { switch (i) {
case 0: return x; case 0:
case 1: return y; return x;
default: throw LogicException("Invalid index for VxVector2::operator[]."); case 1:
} return y;
} default:
const CKFLOAT& VxVector2::operator[](size_t i) const { throw LogicException("Invalid index for VxVector2::operator[].");
switch (i) { }
case 0: return x; }
case 1: return y; const CKFLOAT& VxVector2::operator[](size_t i) const {
default: throw LogicException("Invalid index for VxVector2::operator[]."); switch (i) {
} case 0:
} return x;
bool VxVector2::operator==(const VxVector2& rhs) const { case 1:
return (x == rhs.x && y == rhs.y); return y;
} default:
auto VxVector2::operator<=>(const VxVector2& rhs) const { throw LogicException("Invalid index for VxVector2::operator[].");
if (auto cmp = x <=> rhs.x; cmp != 0) return cmp; }
return y <=> rhs.y; }
} bool VxVector2::operator==(const VxVector2& rhs) const {
VxVector2 VxVector2::operator+() const { return (x == rhs.x && y == rhs.y);
return *this; }
} std::partial_ordering VxVector2::operator<=>(const VxVector2& rhs) const {
VxVector2 VxVector2::operator-() const { if (auto cmp = x <=> rhs.x; cmp != 0) return cmp;
return VxVector2(-x, -y); return y <=> rhs.y;
} }
VxVector2& VxVector2::operator+=(const VxVector2& rhs) { VxVector2 VxVector2::operator+() const {
x += rhs.x; return *this;
y += rhs.y; }
return *this; VxVector2 VxVector2::operator-() const {
} return VxVector2(-x, -y);
VxVector2 operator+(const VxVector2& lhs, const VxVector2& rhs) { }
return VxVector2(lhs.x + rhs.x, lhs.y + rhs.y); VxVector2& VxVector2::operator+=(const VxVector2& rhs) {
} x += rhs.x;
VxVector2& VxVector2::operator-=(const VxVector2& rhs) { y += rhs.y;
x -= rhs.x; return *this;
y -= rhs.y; }
return *this; VxVector2 operator+(const VxVector2& lhs, const VxVector2& rhs) {
} return VxVector2(lhs.x + rhs.x, lhs.y + rhs.y);
VxVector2 operator-(const VxVector2& lhs, const VxVector2& rhs) { }
return VxVector2(lhs.x - rhs.x, lhs.y - rhs.y); VxVector2& VxVector2::operator-=(const VxVector2& rhs) {
} x -= rhs.x;
VxVector2& VxVector2::operator*=(CKFLOAT rhs) { y -= rhs.y;
x *= rhs; return *this;
y *= rhs; }
return *this; VxVector2 operator-(const VxVector2& lhs, const VxVector2& rhs) {
} return VxVector2(lhs.x - rhs.x, lhs.y - rhs.y);
VxVector2 operator*(const VxVector2& lhs, CKFLOAT rhs) { }
return VxVector2(lhs.x * rhs, lhs.y * rhs); VxVector2& VxVector2::operator*=(CKFLOAT rhs) {
} x *= rhs;
VxVector2 operator*(CKFLOAT lhs, const VxVector2& rhs) { y *= rhs;
return VxVector2(lhs * rhs.x, lhs * rhs.y); return *this;
} }
CKFLOAT operator*(const VxVector2& lhs, const VxVector2& rhs) { VxVector2 operator*(const VxVector2& lhs, CKFLOAT rhs) {
return (lhs.x * rhs.x + lhs.y * rhs.y); return VxVector2(lhs.x * rhs, lhs.y * rhs);
} }
VxVector2& VxVector2::operator/=(CKFLOAT rhs) { VxVector2 operator*(CKFLOAT lhs, const VxVector2& rhs) {
if (rhs == 0.0f) return *this; return VxVector2(lhs * rhs.x, lhs * rhs.y);
x /= rhs; }
y /= rhs; CKFLOAT operator*(const VxVector2& lhs, const VxVector2& rhs) {
return *this; return (lhs.x * rhs.x + lhs.y * rhs.y);
} }
VxVector2 operator/(const VxVector2& lhs, CKFLOAT rhs) { VxVector2& VxVector2::operator/=(CKFLOAT rhs) {
if (rhs == 0.0f) return VxVector2(); if (rhs == 0.0f) return *this;
else return VxVector2(lhs.x / rhs, lhs.y / rhs); x /= rhs;
} y /= rhs;
CKFLOAT VxVector2::SquaredLength() const { return *this;
return (x * x + y * y); }
} VxVector2 operator/(const VxVector2& lhs, CKFLOAT rhs) {
CKFLOAT VxVector2::Length() const { if (rhs == 0.0f) return VxVector2();
return std::sqrt(SquaredLength()); else return VxVector2(lhs.x / rhs, lhs.y / rhs);
} }
void VxVector2::Normalized() { CKFLOAT VxVector2::SquaredLength() const {
CKFLOAT len = Length(); return (x * x + y * y);
if (len == 0.0f) return; }
x /= len; CKFLOAT VxVector2::Length() const {
y /= len; return std::sqrt(SquaredLength());
} }
VxVector2 VxVector2::Normalize() const { void VxVector2::Normalized() {
CKFLOAT len = Length(); CKFLOAT len = Length();
if (len == 0.0f) return VxVector2(); if (len == 0.0f) return;
else return VxVector2(x / len, y / len); x /= len;
} y /= len;
}
VxVector2 VxVector2::Normalize() const {
CKFLOAT len = Length();
if (len == 0.0f) return VxVector2();
else return VxVector2(x / len, y / len);
}
/* ===== BEGIN USER CUSTOM ===== */ /* ===== BEGIN USER CUSTOM ===== */
/* ===== END USER CUSTOM ===== */ /* ===== END USER CUSTOM ===== */
#pragma endregion #pragma endregion
#pragma region VxVector3 #pragma region VxVector3
VxVector3::VxVector3() :x(0.0f), y(0.0f), z(0.0f) {} VxVector3::VxVector3() : x(0.0f), y(0.0f), z(0.0f) {}
VxVector3::VxVector3(CKFLOAT _x, CKFLOAT _y, CKFLOAT _z) : x(_x), y(_y), z(_z) {} VxVector3::VxVector3(CKFLOAT _x, CKFLOAT _y, CKFLOAT _z) : x(_x), y(_y), z(_z) {}
CKFLOAT& VxVector3::operator[](size_t i) { CKFLOAT& VxVector3::operator[](size_t i) {
switch (i) { switch (i) {
case 0: return x; case 0:
case 1: return y; return x;
case 2: return z; case 1:
default: throw LogicException("Invalid index for VxVector3::operator[]."); return y;
} case 2:
} return z;
const CKFLOAT& VxVector3::operator[](size_t i) const { default:
switch (i) { throw LogicException("Invalid index for VxVector3::operator[].");
case 0: return x; }
case 1: return y; }
case 2: return z; const CKFLOAT& VxVector3::operator[](size_t i) const {
default: throw LogicException("Invalid index for VxVector3::operator[]."); switch (i) {
} case 0:
} return x;
bool VxVector3::operator==(const VxVector3& rhs) const { case 1:
return (x == rhs.x && y == rhs.y && z == rhs.z); return y;
} case 2:
auto VxVector3::operator<=>(const VxVector3& rhs) const { return z;
if (auto cmp = x <=> rhs.x; cmp != 0) return cmp; default:
if (auto cmp = y <=> rhs.y; cmp != 0) return cmp; throw LogicException("Invalid index for VxVector3::operator[].");
return z <=> rhs.z; }
} }
VxVector3 VxVector3::operator+() const { bool VxVector3::operator==(const VxVector3& rhs) const {
return *this; return (x == rhs.x && y == rhs.y && z == rhs.z);
} }
VxVector3 VxVector3::operator-() const { std::partial_ordering VxVector3::operator<=>(const VxVector3& rhs) const {
return VxVector3(-x, -y, -z); if (auto cmp = x <=> rhs.x; cmp != 0) return cmp;
} if (auto cmp = y <=> rhs.y; cmp != 0) return cmp;
VxVector3& VxVector3::operator+=(const VxVector3& rhs) { return z <=> rhs.z;
x += rhs.x; }
y += rhs.y; VxVector3 VxVector3::operator+() const {
z += rhs.z; return *this;
return *this; }
} VxVector3 VxVector3::operator-() const {
VxVector3 operator+(const VxVector3& lhs, const VxVector3& rhs) { return VxVector3(-x, -y, -z);
return VxVector3(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z); }
} VxVector3& VxVector3::operator+=(const VxVector3& rhs) {
VxVector3& VxVector3::operator-=(const VxVector3& rhs) { x += rhs.x;
x -= rhs.x; y += rhs.y;
y -= rhs.y; z += rhs.z;
z -= rhs.z; return *this;
return *this; }
} VxVector3 operator+(const VxVector3& lhs, const VxVector3& rhs) {
VxVector3 operator-(const VxVector3& lhs, const VxVector3& rhs) { return VxVector3(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z);
return VxVector3(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z); }
} VxVector3& VxVector3::operator-=(const VxVector3& rhs) {
VxVector3& VxVector3::operator*=(CKFLOAT rhs) { x -= rhs.x;
x *= rhs; y -= rhs.y;
y *= rhs; z -= rhs.z;
z *= rhs; return *this;
return *this; }
} VxVector3 operator-(const VxVector3& lhs, const VxVector3& rhs) {
VxVector3 operator*(const VxVector3& lhs, CKFLOAT rhs) { return VxVector3(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z);
return VxVector3(lhs.x * rhs, lhs.y * rhs, lhs.z * rhs); }
} VxVector3& VxVector3::operator*=(CKFLOAT rhs) {
VxVector3 operator*(CKFLOAT lhs, const VxVector3& rhs) { x *= rhs;
return VxVector3(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z); y *= rhs;
} z *= rhs;
CKFLOAT operator*(const VxVector3& lhs, const VxVector3& rhs) { return *this;
return (lhs.x * rhs.x + lhs.y * rhs.y + lhs.z * rhs.z); }
} VxVector3 operator*(const VxVector3& lhs, CKFLOAT rhs) {
VxVector3& VxVector3::operator/=(CKFLOAT rhs) { return VxVector3(lhs.x * rhs, lhs.y * rhs, lhs.z * rhs);
if (rhs == 0.0f) return *this; }
x /= rhs; VxVector3 operator*(CKFLOAT lhs, const VxVector3& rhs) {
y /= rhs; return VxVector3(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z);
z /= rhs; }
return *this; CKFLOAT operator*(const VxVector3& lhs, const VxVector3& rhs) {
} return (lhs.x * rhs.x + lhs.y * rhs.y + lhs.z * rhs.z);
VxVector3 operator/(const VxVector3& lhs, CKFLOAT rhs) { }
if (rhs == 0.0f) return VxVector3(); VxVector3& VxVector3::operator/=(CKFLOAT rhs) {
else return VxVector3(lhs.x / rhs, lhs.y / rhs, lhs.z / rhs); if (rhs == 0.0f) return *this;
} x /= rhs;
CKFLOAT VxVector3::SquaredLength() const { y /= rhs;
return (x * x + y * y + z * z); z /= rhs;
} return *this;
CKFLOAT VxVector3::Length() const { }
return std::sqrt(SquaredLength()); VxVector3 operator/(const VxVector3& lhs, CKFLOAT rhs) {
} if (rhs == 0.0f) return VxVector3();
void VxVector3::Normalized() { else return VxVector3(lhs.x / rhs, lhs.y / rhs, lhs.z / rhs);
CKFLOAT len = Length(); }
if (len == 0.0f) return; CKFLOAT VxVector3::SquaredLength() const {
x /= len; return (x * x + y * y + z * z);
y /= len; }
z /= len; CKFLOAT VxVector3::Length() const {
} return std::sqrt(SquaredLength());
VxVector3 VxVector3::Normalize() const { }
CKFLOAT len = Length(); void VxVector3::Normalized() {
if (len == 0.0f) return VxVector3(); CKFLOAT len = Length();
else return VxVector3(x / len, y / len, z / len); if (len == 0.0f) return;
} x /= len;
y /= len;
z /= len;
}
VxVector3 VxVector3::Normalize() const {
CKFLOAT len = Length();
if (len == 0.0f) return VxVector3();
else return VxVector3(x / len, y / len, z / len);
}
/* ===== BEGIN USER CUSTOM ===== */ /* ===== BEGIN USER CUSTOM ===== */
/* ===== END USER CUSTOM ===== */ /* ===== END USER CUSTOM ===== */
#pragma endregion #pragma endregion
#pragma region VxVector4 #pragma region VxVector4
VxVector4::VxVector4() :x(0.0f), y(0.0f), z(0.0f), w(0.0f) {} VxVector4::VxVector4() : x(0.0f), y(0.0f), z(0.0f), w(0.0f) {}
VxVector4::VxVector4(CKFLOAT _x, CKFLOAT _y, CKFLOAT _z, CKFLOAT _w) : x(_x), y(_y), z(_z), w(_w) {} VxVector4::VxVector4(CKFLOAT _x, CKFLOAT _y, CKFLOAT _z, CKFLOAT _w) : x(_x), y(_y), z(_z), w(_w) {}
CKFLOAT& VxVector4::operator[](size_t i) { CKFLOAT& VxVector4::operator[](size_t i) {
switch (i) { switch (i) {
case 0: return x; case 0:
case 1: return y; return x;
case 2: return z; case 1:
case 3: return w; return y;
default: throw LogicException("Invalid index for VxVector4::operator[]."); case 2:
} return z;
} case 3:
const CKFLOAT& VxVector4::operator[](size_t i) const { return w;
switch (i) { default:
case 0: return x; throw LogicException("Invalid index for VxVector4::operator[].");
case 1: return y; }
case 2: return z; }
case 3: return w; const CKFLOAT& VxVector4::operator[](size_t i) const {
default: throw LogicException("Invalid index for VxVector4::operator[]."); switch (i) {
} case 0:
} return x;
bool VxVector4::operator==(const VxVector4& rhs) const { case 1:
return (x == rhs.x && y == rhs.y && z == rhs.z && w == rhs.w); return y;
} case 2:
auto VxVector4::operator<=>(const VxVector4& rhs) const { return z;
if (auto cmp = x <=> rhs.x; cmp != 0) return cmp; case 3:
if (auto cmp = y <=> rhs.y; cmp != 0) return cmp; return w;
if (auto cmp = z <=> rhs.z; cmp != 0) return cmp; default:
return w <=> rhs.w; throw LogicException("Invalid index for VxVector4::operator[].");
} }
VxVector4 VxVector4::operator+() const { }
return *this; bool VxVector4::operator==(const VxVector4& rhs) const {
} return (x == rhs.x && y == rhs.y && z == rhs.z && w == rhs.w);
VxVector4 VxVector4::operator-() const { }
return VxVector4(-x, -y, -z, -w); std::partial_ordering VxVector4::operator<=>(const VxVector4& rhs) const {
} if (auto cmp = x <=> rhs.x; cmp != 0) return cmp;
VxVector4& VxVector4::operator+=(const VxVector4& rhs) { if (auto cmp = y <=> rhs.y; cmp != 0) return cmp;
x += rhs.x; if (auto cmp = z <=> rhs.z; cmp != 0) return cmp;
y += rhs.y; return w <=> rhs.w;
z += rhs.z; }
w += rhs.w; VxVector4 VxVector4::operator+() const {
return *this; return *this;
} }
VxVector4 operator+(const VxVector4& lhs, const VxVector4& rhs) { VxVector4 VxVector4::operator-() const {
return VxVector4(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z, lhs.w + rhs.w); return VxVector4(-x, -y, -z, -w);
} }
VxVector4& VxVector4::operator-=(const VxVector4& rhs) { VxVector4& VxVector4::operator+=(const VxVector4& rhs) {
x -= rhs.x; x += rhs.x;
y -= rhs.y; y += rhs.y;
z -= rhs.z; z += rhs.z;
w -= rhs.w; w += rhs.w;
return *this; return *this;
} }
VxVector4 operator-(const VxVector4& lhs, const VxVector4& rhs) { VxVector4 operator+(const VxVector4& lhs, const VxVector4& rhs) {
return VxVector4(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z, lhs.w - rhs.w); return VxVector4(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z, lhs.w + rhs.w);
} }
VxVector4& VxVector4::operator*=(CKFLOAT rhs) { VxVector4& VxVector4::operator-=(const VxVector4& rhs) {
x *= rhs; x -= rhs.x;
y *= rhs; y -= rhs.y;
z *= rhs; z -= rhs.z;
w *= rhs; w -= rhs.w;
return *this; return *this;
} }
VxVector4 operator*(const VxVector4& lhs, CKFLOAT rhs) { VxVector4 operator-(const VxVector4& lhs, const VxVector4& rhs) {
return VxVector4(lhs.x * rhs, lhs.y * rhs, lhs.z * rhs, lhs.w * rhs); return VxVector4(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z, lhs.w - rhs.w);
} }
VxVector4 operator*(CKFLOAT lhs, const VxVector4& rhs) { VxVector4& VxVector4::operator*=(CKFLOAT rhs) {
return VxVector4(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z, lhs * rhs.w); x *= rhs;
} y *= rhs;
CKFLOAT operator*(const VxVector4& lhs, const VxVector4& rhs) { z *= rhs;
return (lhs.x * rhs.x + lhs.y * rhs.y + lhs.z * rhs.z + lhs.w * rhs.w); w *= rhs;
} return *this;
VxVector4& VxVector4::operator/=(CKFLOAT rhs) { }
if (rhs == 0.0f) return *this; VxVector4 operator*(const VxVector4& lhs, CKFLOAT rhs) {
x /= rhs; return VxVector4(lhs.x * rhs, lhs.y * rhs, lhs.z * rhs, lhs.w * rhs);
y /= rhs; }
z /= rhs; VxVector4 operator*(CKFLOAT lhs, const VxVector4& rhs) {
w /= rhs; return VxVector4(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z, lhs * rhs.w);
return *this; }
} CKFLOAT operator*(const VxVector4& lhs, const VxVector4& rhs) {
VxVector4 operator/(const VxVector4& lhs, CKFLOAT rhs) { return (lhs.x * rhs.x + lhs.y * rhs.y + lhs.z * rhs.z + lhs.w * rhs.w);
if (rhs == 0.0f) return VxVector4(); }
else return VxVector4(lhs.x / rhs, lhs.y / rhs, lhs.z / rhs, lhs.w / rhs); VxVector4& VxVector4::operator/=(CKFLOAT rhs) {
} if (rhs == 0.0f) return *this;
CKFLOAT VxVector4::SquaredLength() const { x /= rhs;
return (x * x + y * y + z * z + w * w); y /= rhs;
} z /= rhs;
CKFLOAT VxVector4::Length() const { w /= rhs;
return std::sqrt(SquaredLength()); return *this;
} }
void VxVector4::Normalized() { VxVector4 operator/(const VxVector4& lhs, CKFLOAT rhs) {
CKFLOAT len = Length(); if (rhs == 0.0f) return VxVector4();
if (len == 0.0f) return; else return VxVector4(lhs.x / rhs, lhs.y / rhs, lhs.z / rhs, lhs.w / rhs);
x /= len; }
y /= len; CKFLOAT VxVector4::SquaredLength() const {
z /= len; return (x * x + y * y + z * z + w * w);
w /= len; }
} CKFLOAT VxVector4::Length() const {
VxVector4 VxVector4::Normalize() const { return std::sqrt(SquaredLength());
CKFLOAT len = Length(); }
if (len == 0.0f) return VxVector4(); void VxVector4::Normalized() {
else return VxVector4(x / len, y / len, z / len, w / len); CKFLOAT len = Length();
} if (len == 0.0f) return;
x /= len;
y /= len;
z /= len;
w /= len;
}
VxVector4 VxVector4::Normalize() const {
CKFLOAT len = Length();
if (len == 0.0f) return VxVector4();
else return VxVector4(x / len, y / len, z / len, w / len);
}
/* ===== BEGIN USER CUSTOM ===== */ /* ===== BEGIN USER CUSTOM ===== */
/* ===== END USER CUSTOM ===== */ /* ===== END USER CUSTOM ===== */
#pragma endregion #pragma endregion
#pragma region VxQuaternion #pragma region VxQuaternion
VxQuaternion::VxQuaternion() :x(0.0f), y(0.0f), z(0.0f), w(1.0f) {} // SET YOUR CUSTOM INIT VxQuaternion::VxQuaternion() : x(0.0f), y(0.0f), z(0.0f), w(0.0f) {} // SET YOUR CUSTOM INIT
VxQuaternion::VxQuaternion(CKFLOAT _x, CKFLOAT _y, CKFLOAT _z, CKFLOAT _w) : x(_x), y(_y), z(_z), w(_w) {} VxQuaternion::VxQuaternion(CKFLOAT _x, CKFLOAT _y, CKFLOAT _z, CKFLOAT _w) : x(_x), y(_y), z(_z), w(_w) {}
CKFLOAT& VxQuaternion::operator[](size_t i) { CKFLOAT& VxQuaternion::operator[](size_t i) {
switch (i) { switch (i) {
case 0: return x; case 0:
case 1: return y; return x;
case 2: return z; case 1:
case 3: return w; return y;
default: throw LogicException("Invalid index for VxQuaternion::operator[]."); case 2:
} return z;
} case 3:
const CKFLOAT& VxQuaternion::operator[](size_t i) const { return w;
switch (i) { default:
case 0: return x; throw LogicException("Invalid index for VxQuaternion::operator[].");
case 1: return y; }
case 2: return z; }
case 3: return w; const CKFLOAT& VxQuaternion::operator[](size_t i) const {
default: throw LogicException("Invalid index for VxQuaternion::operator[]."); switch (i) {
} case 0:
} return x;
bool VxQuaternion::operator==(const VxQuaternion& rhs) const { case 1:
return (x == rhs.x && y == rhs.y && z == rhs.z && w == rhs.w); return y;
} case 2:
auto VxQuaternion::operator<=>(const VxQuaternion& rhs) const { return z;
if (auto cmp = x <=> rhs.x; cmp != 0) return cmp; case 3:
if (auto cmp = y <=> rhs.y; cmp != 0) return cmp; return w;
if (auto cmp = z <=> rhs.z; cmp != 0) return cmp; default:
return w <=> rhs.w; throw LogicException("Invalid index for VxQuaternion::operator[].");
} }
}
bool VxQuaternion::operator==(const VxQuaternion& rhs) const {
return (x == rhs.x && y == rhs.y && z == rhs.z && w == rhs.w);
}
std::partial_ordering VxQuaternion::operator<=>(const VxQuaternion& rhs) const {
if (auto cmp = x <=> rhs.x; cmp != 0) return cmp;
if (auto cmp = y <=> rhs.y; cmp != 0) return cmp;
if (auto cmp = z <=> rhs.z; cmp != 0) return cmp;
return w <=> rhs.w;
}
/* ===== BEGIN USER CUSTOM ===== */ /* ===== BEGIN USER CUSTOM ===== */
/* ===== END USER CUSTOM ===== */ /* ===== END USER CUSTOM ===== */
#pragma endregion #pragma endregion
#pragma region VxColor #pragma region VxColor
VxColor::VxColor() :r(0.0f), g(0.0f), b(0.0f), a(1.0f) {} // SET YOUR CUSTOM INIT VxColor::VxColor() : r(0.0f), g(0.0f), b(0.0f), a(0.0f) {} // SET YOUR CUSTOM INIT
VxColor::VxColor(CKFLOAT _r, CKFLOAT _g, CKFLOAT _b, CKFLOAT _a) : r(_r), g(_g), b(_b), a(_a) {} VxColor::VxColor(CKFLOAT _r, CKFLOAT _g, CKFLOAT _b, CKFLOAT _a) : r(_r), g(_g), b(_b), a(_a) {}
CKFLOAT& VxColor::operator[](size_t i) { CKFLOAT& VxColor::operator[](size_t i) {
switch (i) { switch (i) {
case 0: return r; case 0:
case 1: return g; return r;
case 2: return b; case 1:
case 3: return a; return g;
default: throw LogicException("Invalid index for VxColor::operator[]."); case 2:
} return b;
} case 3:
const CKFLOAT& VxColor::operator[](size_t i) const { return a;
switch (i) { default:
case 0: return r; throw LogicException("Invalid index for VxColor::operator[].");
case 1: return g; }
case 2: return b; }
case 3: return a; const CKFLOAT& VxColor::operator[](size_t i) const {
default: throw LogicException("Invalid index for VxColor::operator[]."); switch (i) {
} case 0:
} return r;
bool VxColor::operator==(const VxColor& rhs) const { case 1:
return (r == rhs.r && g == rhs.g && b == rhs.b && a == rhs.a); return g;
} case 2:
auto VxColor::operator<=>(const VxColor& rhs) const { return b;
if (auto cmp = r <=> rhs.r; cmp != 0) return cmp; case 3:
if (auto cmp = g <=> rhs.g; cmp != 0) return cmp; return a;
if (auto cmp = b <=> rhs.b; cmp != 0) return cmp; default:
return a <=> rhs.a; throw LogicException("Invalid index for VxColor::operator[].");
} }
}
bool VxColor::operator==(const VxColor& rhs) const {
return (r == rhs.r && g == rhs.g && b == rhs.b && a == rhs.a);
}
std::partial_ordering VxColor::operator<=>(const VxColor& rhs) const {
if (auto cmp = r <=> rhs.r; cmp != 0) return cmp;
if (auto cmp = g <=> rhs.g; cmp != 0) return cmp;
if (auto cmp = b <=> rhs.b; cmp != 0) return cmp;
return a <=> rhs.a;
}
/* ===== BEGIN USER CUSTOM ===== */ /* ===== BEGIN USER CUSTOM ===== */
VxColor::VxColor(CKDWORD argb) { FromARGB(argb); } VxColor::VxColor(CKDWORD argb) { FromARGB(argb); }
@@ -427,7 +471,7 @@ namespace LibCmo::VxMath {
bool VxMatrix::operator==(const VxMatrix& rhs) const { bool VxMatrix::operator==(const VxMatrix& rhs) const {
return ((*this)[0] == rhs[0] && (*this)[1] == rhs[1] && (*this)[2] == rhs[2] && (*this)[3] == rhs[3]); return ((*this)[0] == rhs[0] && (*this)[1] == rhs[1] && (*this)[2] == rhs[2] && (*this)[3] == rhs[3]);
} }
auto VxMatrix::operator<=>(const VxMatrix& rhs) const { std::partial_ordering VxMatrix::operator<=>(const VxMatrix& rhs) const {
if (auto cmp = (*this)[0] <=> rhs[0]; cmp != 0) return cmp; if (auto cmp = (*this)[0] <=> rhs[0]; cmp != 0) return cmp;
if (auto cmp = (*this)[1] <=> rhs[1]; cmp != 0) return cmp; if (auto cmp = (*this)[1] <=> rhs[1]; cmp != 0) return cmp;
if (auto cmp = (*this)[2] <=> rhs[2]; cmp != 0) return cmp; if (auto cmp = (*this)[2] <=> rhs[2]; cmp != 0) return cmp;

132
LibCmo/LibCmo/VxMath/VxTypes.hpp
View File

@@ -2,11 +2,13 @@
#include "../VTUtils.hpp" #include "../VTUtils.hpp"
#include "../CK2/CKTypes.hpp" #include "../CK2/CKTypes.hpp"
#include <yycc/macro/class_copy_move.hpp>
#include "VxEnums.hpp" #include "VxEnums.hpp"
#include <string> #include <string>
#include <vector> #include <vector>
#include <cstring> #include <cstring>
#include <cinttypes> #include <cinttypes>
#include <compare>
/** /**
* @brief The VxMath part of LibCmo. * @brief The VxMath part of LibCmo.
@@ -33,11 +35,11 @@ namespace LibCmo::VxMath {
CKFLOAT x, y; CKFLOAT x, y;
VxVector2(); VxVector2();
VxVector2(CKFLOAT _x, CKFLOAT _y); VxVector2(CKFLOAT _x, CKFLOAT _y);
YYCC_DEF_CLS_COPY_MOVE(VxVector2); YYCC_DEFAULT_COPY_MOVE(VxVector2)
CKFLOAT& operator[](size_t i); CKFLOAT& operator[](size_t i);
const CKFLOAT& operator[](size_t i) const; const CKFLOAT& operator[](size_t i) const;
bool operator==(const VxVector2& rhs) const; bool operator==(const VxVector2& rhs) const;
auto operator<=>(const VxVector2& rhs) const; std::partial_ordering operator<=>(const VxVector2& rhs) const;
VxVector2 operator+() const; VxVector2 operator+() const;
VxVector2 operator-() const; VxVector2 operator-() const;
VxVector2& operator+=(const VxVector2& rhs); VxVector2& operator+=(const VxVector2& rhs);
@@ -59,6 +61,7 @@ namespace LibCmo::VxMath {
/* ===== END USER CUSTOM ===== */ /* ===== END USER CUSTOM ===== */
}; };
/** /**
* @brief The representation of a Vector in 3 dimensions * @brief The representation of a Vector in 3 dimensions
* @remarks In original Virtools SDK, it was named VxVector. * @remarks In original Virtools SDK, it was named VxVector.
@@ -67,11 +70,11 @@ namespace LibCmo::VxMath {
CKFLOAT x, y, z; CKFLOAT x, y, z;
VxVector3(); VxVector3();
VxVector3(CKFLOAT _x, CKFLOAT _y, CKFLOAT _z); VxVector3(CKFLOAT _x, CKFLOAT _y, CKFLOAT _z);
YYCC_DEF_CLS_COPY_MOVE(VxVector3); YYCC_DEFAULT_COPY_MOVE(VxVector3)
CKFLOAT& operator[](size_t i); CKFLOAT& operator[](size_t i);
const CKFLOAT& operator[](size_t i) const; const CKFLOAT& operator[](size_t i) const;
bool operator==(const VxVector3& rhs) const; bool operator==(const VxVector3& rhs) const;
auto operator<=>(const VxVector3& rhs) const; std::partial_ordering operator<=>(const VxVector3& rhs) const;
VxVector3 operator+() const; VxVector3 operator+() const;
VxVector3 operator-() const; VxVector3 operator-() const;
VxVector3& operator+=(const VxVector3& rhs); VxVector3& operator+=(const VxVector3& rhs);
@@ -101,35 +104,35 @@ namespace LibCmo::VxMath {
* @remarks In original Virtools SDK, it was named VxVector4. Not changed. * @remarks In original Virtools SDK, it was named VxVector4. Not changed.
* @see VxVector3 * @see VxVector3
*/ */
struct VxVector4 { struct VxVector4 {
CKFLOAT x, y, z, w; CKFLOAT x, y, z, w;
VxVector4(); VxVector4();
VxVector4(CKFLOAT _x, CKFLOAT _y, CKFLOAT _z, CKFLOAT _w); VxVector4(CKFLOAT _x, CKFLOAT _y, CKFLOAT _z, CKFLOAT _w);
YYCC_DEF_CLS_COPY_MOVE(VxVector4); YYCC_DEFAULT_COPY_MOVE(VxVector4)
CKFLOAT& operator[](size_t i); CKFLOAT& operator[](size_t i);
const CKFLOAT& operator[](size_t i) const; const CKFLOAT& operator[](size_t i) const;
bool operator==(const VxVector4& rhs) const; bool operator==(const VxVector4& rhs) const;
auto operator<=>(const VxVector4& rhs) const; std::partial_ordering operator<=>(const VxVector4& rhs) const;
VxVector4 operator+() const; VxVector4 operator+() const;
VxVector4 operator-() const; VxVector4 operator-() const;
VxVector4& operator+=(const VxVector4& rhs); VxVector4& operator+=(const VxVector4& rhs);
friend VxVector4 operator+(const VxVector4& lhs, const VxVector4& rhs); friend VxVector4 operator+(const VxVector4& lhs, const VxVector4& rhs);
VxVector4& operator-=(const VxVector4& rhs); VxVector4& operator-=(const VxVector4& rhs);
friend VxVector4 operator-(const VxVector4& lhs, const VxVector4& rhs); friend VxVector4 operator-(const VxVector4& lhs, const VxVector4& rhs);
VxVector4& operator*=(CKFLOAT rhs); VxVector4& operator*=(CKFLOAT rhs);
friend VxVector4 operator*(const VxVector4& lhs, CKFLOAT rhs); friend VxVector4 operator*(const VxVector4& lhs, CKFLOAT rhs);
friend VxVector4 operator*(CKFLOAT lhs, const VxVector4& rhs); friend VxVector4 operator*(CKFLOAT lhs, const VxVector4& rhs);
friend CKFLOAT operator*(const VxVector4& lhs, const VxVector4& rhs); friend CKFLOAT operator*(const VxVector4& lhs, const VxVector4& rhs);
VxVector4& operator/=(CKFLOAT rhs); VxVector4& operator/=(CKFLOAT rhs);
friend VxVector4 operator/(const VxVector4& lhs, CKFLOAT rhs); friend VxVector4 operator/(const VxVector4& lhs, CKFLOAT rhs);
CKFLOAT SquaredLength() const; CKFLOAT SquaredLength() const;
CKFLOAT Length() const; CKFLOAT Length() const;
void Normalized(); void Normalized();
VxVector4 Normalize() const; VxVector4 Normalize() const;
/* ===== BEGIN USER CUSTOM ===== */ /* ===== BEGIN USER CUSTOM ===== */
/* ===== END USER CUSTOM ===== */ /* ===== END USER CUSTOM ===== */
}; };
/** /**
* @brief The representation of a quaternion. * @brief The representation of a quaternion.
@@ -140,19 +143,19 @@ namespace LibCmo::VxMath {
* Quaternions can be converted to VxMatrix or Euler Angles. * Quaternions can be converted to VxMatrix or Euler Angles.
* @see VxMatrix, VxVector3 * @see VxMatrix, VxVector3
*/ */
struct VxQuaternion { struct VxQuaternion {
CKFLOAT x, y, z, w; CKFLOAT x, y, z, w;
VxQuaternion(); VxQuaternion();
VxQuaternion(CKFLOAT _x, CKFLOAT _y, CKFLOAT _z, CKFLOAT _w); VxQuaternion(CKFLOAT _x, CKFLOAT _y, CKFLOAT _z, CKFLOAT _w);
YYCC_DEF_CLS_COPY_MOVE(VxQuaternion); YYCC_DEFAULT_COPY_MOVE(VxQuaternion)
CKFLOAT& operator[](size_t i); CKFLOAT& operator[](size_t i);
const CKFLOAT& operator[](size_t i) const; const CKFLOAT& operator[](size_t i) const;
bool operator==(const VxQuaternion& rhs) const; bool operator==(const VxQuaternion& rhs) const;
auto operator<=>(const VxQuaternion& rhs) const; std::partial_ordering operator<=>(const VxQuaternion& rhs) const;
/* ===== BEGIN USER CUSTOM ===== */ /* ===== BEGIN USER CUSTOM ===== */
/* ===== END USER CUSTOM ===== */ /* ===== END USER CUSTOM ===== */
}; };
/** /**
* @brief The representation of a color through 4 floats. * @brief The representation of a color through 4 floats.
@@ -162,15 +165,15 @@ namespace LibCmo::VxMath {
* *
* Most methods are used to construct a VxColor or to convert it to a 32 bit ARGB format. * Most methods are used to construct a VxColor or to convert it to a 32 bit ARGB format.
*/ */
struct VxColor { struct VxColor {
CKFLOAT r, g, b, a; CKFLOAT r, g, b, a;
VxColor(); VxColor();
VxColor(CKFLOAT _r, CKFLOAT _g, CKFLOAT _b, CKFLOAT _a); VxColor(CKFLOAT _r, CKFLOAT _g, CKFLOAT _b, CKFLOAT _a);
YYCC_DEF_CLS_COPY_MOVE(VxColor); YYCC_DEFAULT_COPY_MOVE(VxColor)
CKFLOAT& operator[](size_t i); CKFLOAT& operator[](size_t i);
const CKFLOAT& operator[](size_t i) const; const CKFLOAT& operator[](size_t i) const;
bool operator==(const VxColor& rhs) const; bool operator==(const VxColor& rhs) const;
auto operator<=>(const VxColor& rhs) const; std::partial_ordering operator<=>(const VxColor& rhs) const;
/* ===== BEGIN USER CUSTOM ===== */ /* ===== BEGIN USER CUSTOM ===== */
VxColor(CKDWORD argb); VxColor(CKDWORD argb);
@@ -193,11 +196,11 @@ namespace LibCmo::VxMath {
public: public:
VxMatrix(); VxMatrix();
VxMatrix(CKFLOAT m[4][4]); VxMatrix(CKFLOAT m[4][4]);
YYCC_DEF_CLS_COPY_MOVE(VxMatrix); YYCC_DEFAULT_COPY_MOVE(VxMatrix)
VxVector4& operator[](size_t i); VxVector4& operator[](size_t i);
const VxVector4& operator[](size_t i) const; const VxVector4& operator[](size_t i) const;
bool operator==(const VxMatrix& rhs) const; bool operator==(const VxMatrix& rhs) const;
auto operator<=>(const VxMatrix& rhs) const; std::partial_ordering operator<=>(const VxMatrix& rhs) const;
/* ===== BEGIN USER CUSTOM ===== */ /* ===== BEGIN USER CUSTOM ===== */
void Clear(); void Clear();
@@ -300,7 +303,8 @@ namespace LibCmo::VxMath {
* @brief Structure for storage of strided data. * @brief Structure for storage of strided data.
* @tparam _Ty The data pointer type this class stored. * @tparam _Ty The data pointer type this class stored.
*/ */
template<class _Ty, std::enable_if_t<std::is_pointer_v<_Ty>, int> = 0> template<class T>
requires std::is_pointer_v<T>
class VxStridedData { class VxStridedData {
public: public:
/** /**
@@ -310,7 +314,7 @@ namespace LibCmo::VxMath {
* If you set stride to the size of underlying type of pointer, * If you set stride to the size of underlying type of pointer,
* this class will degenerate to the visitor of a plain data array. * this class will degenerate to the visitor of a plain data array.
*/ */
VxStridedData(_Ty ptr, CKDWORD stride) : VxStridedData(T ptr, CKDWORD stride) :
m_Ptr(reinterpret_cast<CKBYTE*>(ptr)), m_Ptr(reinterpret_cast<CKBYTE*>(ptr)),
m_Stride(stride) {} m_Stride(stride) {}
~VxStridedData() {} ~VxStridedData() {}
@@ -320,8 +324,8 @@ namespace LibCmo::VxMath {
* @param[in] idx N-th * @param[in] idx N-th
* @return The pointer to n-th data. * @return The pointer to n-th data.
*/ */
_Ty operator[](size_t idx) { T operator[](size_t idx) {
return reinterpret_cast<_Ty>(m_Ptr + (m_Stride * idx)); return reinterpret_cast<T>(m_Ptr + (m_Stride * idx));
} }
private: private:
@@ -340,8 +344,8 @@ namespace LibCmo::VxMath {
*/ */
class VxImageDescEx { class VxImageDescEx {
public: public:
static constexpr CKDWORD ColorFactorSize = 1u; /**< Single color factor (one of ARGB) occpied size in byte. */ static constexpr CKDWORD FACTOR_SIZE = 1u; /**< Single color factor (one of ARGB) occpied size in byte. */
static constexpr CKDWORD PixelSize = ColorFactorSize * 4u; /**< Single pixel occpied size in byte. */ static constexpr CKDWORD PIXEL_SIZE = FACTOR_SIZE * 4u; /**< Single pixel occpied size in byte. */
public: public:
/** /**
* @brief Create a blank (invalid) image. * @brief Create a blank (invalid) image.
@@ -364,7 +368,7 @@ namespace LibCmo::VxMath {
CreateImage(rhs.m_Width, rhs.m_Height, rhs.m_Image); CreateImage(rhs.m_Width, rhs.m_Height, rhs.m_Image);
} }
} }
VxImageDescEx(VxImageDescEx&& rhs) : VxImageDescEx(VxImageDescEx&& rhs) noexcept :
m_Width(rhs.m_Width), m_Height(rhs.m_Height), m_Image(rhs.m_Image) { m_Width(rhs.m_Width), m_Height(rhs.m_Height), m_Image(rhs.m_Image) {
// move image // move image
rhs.m_Height = 0; rhs.m_Height = 0;
@@ -382,7 +386,7 @@ namespace LibCmo::VxMath {
return *this; return *this;
} }
VxImageDescEx& operator=(VxImageDescEx&& rhs) { VxImageDescEx& operator=(VxImageDescEx&& rhs) noexcept {
FreeImage(); FreeImage();
m_Height = rhs.m_Height; m_Height = rhs.m_Height;
@@ -444,7 +448,7 @@ namespace LibCmo::VxMath {
* Basically it is image width * height * (single pixel size). * Basically it is image width * height * (single pixel size).
*/ */
CKDWORD GetImageSize() const { CKDWORD GetImageSize() const {
return static_cast<CKDWORD>(PixelSize * m_Width * m_Height); return static_cast<CKDWORD>(PIXEL_SIZE * m_Width * m_Height);
} }
/** /**
* @brief Get a constant pointer to image in memory unit for viewing. * @brief Get a constant pointer to image in memory unit for viewing.