WebKit Bugzilla
Attachment 357602 Details for
Bug 192355
: [WHLSL] Add a handwritten parser
Home
|
New
|
Browse
|
Search
|
[?]
|
Reports
|
Requests
|
Help
|
New Account
|
Log In
Remember
[x]
|
Forgot Password
Login:
[x]
[patch]
Patch
file.txt (text/plain), 4.08 MB, created by
Myles C. Maxfield
on 2018-12-18 13:21:08 PST
(
hide
)
Description:
Patch
Filename:
MIME Type:
Creator:
Myles C. Maxfield
Created:
2018-12-18 13:21:08 PST
Size:
4.08 MB
patch
obsolete
>commit 87386260918d2f400bc6b1ffb223aecfb29ddd2a >Author: Myles C. Maxfield <mmaxfield@apple.com> >Date: Mon Dec 17 21:38:36 2018 -0800 > > WIP > >diff --git a/LayoutTests/ChangeLog b/LayoutTests/ChangeLog >index 7684fdcd825..a81a51336c0 100644 >--- a/LayoutTests/ChangeLog >+++ b/LayoutTests/ChangeLog >@@ -1,3 +1,13 @@ >+2018-12-17 Myles C. Maxfield <mmaxfield@apple.com> >+ >+ [WHLSL] Add a handwritten parser >+ https://bugs.webkit.org/show_bug.cgi?id=192355 >+ >+ Reviewed by NOBODY (OOPS!). >+ >+ * webgpu/WHLSL/parse-expected.txt: Added. >+ * webgpu/WHLSL/parse.html: Added. >+ > 2018-12-17 Eric Carlson <eric.carlson@apple.com> > > [MediaStream] A stream's first video frame should be rendered >diff --git a/LayoutTests/webgpu/WHLSL/parse-expected.txt b/LayoutTests/webgpu/WHLSL/parse-expected.txt >new file mode 100644 >index 00000000000..a290b5aaa28 >--- /dev/null >+++ b/LayoutTests/webgpu/WHLSL/parse-expected.txt >@@ -0,0 +1,6 @@ >+PASS shaderModule is defined. >+PASS shaderModule is non-null. >+PASS successfullyParsed is true >+ >+TEST COMPLETE >+ >diff --git a/LayoutTests/webgpu/WHLSL/parse.html b/LayoutTests/webgpu/WHLSL/parse.html >new file mode 100644 >index 00000000000..f75a43a5c79 >--- /dev/null >+++ b/LayoutTests/webgpu/WHLSL/parse.html >@@ -0,0 +1,19 @@ >+<!DOCTYPE html> >+<html> >+<head> >+<script src="../../resources/js-test-pre.js"></script> >+</head> >+<body> >+<script> >+let shaderSource = ""; >+let shaderModule; >+window.webgpu.requestAdapter({}).then(function(adapter) { >+ let device = adapter.createDevice(); >+ shaderModule = device.createShaderModule({ code: shaderSource, isWHLSL: true }); >+ shouldBeDefined("shaderModule"); >+ shouldBeNonNull("shaderModule"); >+}); >+</script> >+<script src="../../resources/js-test-post.js"></script> >+</body> >+</html> >diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog >index 6ff69a5dcce..3266f38ccf9 100644 >--- a/Source/WebCore/ChangeLog >+++ b/Source/WebCore/ChangeLog >@@ -1,3 +1,305 @@ >+2018-12-17 Myles C. Maxfield <mmaxfield@apple.com> >+ >+ [WHLSL] Add a handwritten parser >+ https://bugs.webkit.org/show_bug.cgi?id=192355 >+ >+ Reviewed by NOBODY (OOPS!). >+ >+ Test: webgpu/WHLSL/parse.html >+ >+ * DerivedSources.make: >+ * Modules/webgpu/WHLSL/AST/WHLSLASTAnonymousVariableDeclaration.h: Copied from Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::AnonymousVariableDeclaration::AnonymousVariableDeclaration): >+ (WebCore::WHLSL::AST::AnonymousVariableDeclaration::origin const): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTArrayReferenceType.h: Copied from Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::ArrayReferenceType::ArrayReferenceType): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTArrayType.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::ArrayType::ArrayType): >+ (WebCore::WHLSL::AST::ArrayType::numElements const): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTAssignmentExpression.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::AssignmentExpression::AssignmentExpression): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTBaseFunctionAttribute.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::BaseFunctionAttribute::BaseFunctionAttribute): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTBaseSemantic.h: Copied from Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::BaseSemantic::BaseSemantic): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTBlock.h: Copied from Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::Block::Block): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTBooleanLiteral.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::BooleanLiteral::BooleanLiteral): >+ (WebCore::WHLSL::AST::BooleanLiteral::value const): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTBreak.h: Copied from Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::Break::Break): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTBuiltInSemantic.h: Copied from Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::BuiltInSemantic::BuiltInSemantic): >+ (WebCore::WHLSL::AST::BuiltInSemantic::variable const): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTCallExpression.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::CallExpression::CallExpression): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTCommaExpression.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::CommaExpression::CommaExpression): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTConstantExpression.h: Copied from Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h. >+ * Modules/webgpu/WHLSL/AST/WHLSLASTConstantExpressionEnumerationMemberReference.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::ConstantExpressionEnumerationMemberReference::ConstantExpressionEnumerationMemberReference): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTContinue.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::Continue::Continue): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTDereferenceExpression.h: Copied from Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::DereferenceExpression::DereferenceExpression): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTDoWhileLoop.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::DoWhileLoop::DoWhileLoop): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTDotExpression.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::DotExpression::DotExpression): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTEffectfulExpressionStatement.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::EffectfulExpressionStatement::EffectfulExpressionStatement): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTEnumerationDefinition.h: Copied from Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::EnumerationDefinition::EnumerationDefinition): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTEnumerationMember.h: Copied from Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::EnumerationMember::EnumerationMember): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTExpression.h: Copied from Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::Expression::Expression): >+ (WebCore::WHLSL::AST::Expression::origin const): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTFallthrough.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::Fallthrough::Fallthrough): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTFloatLiteral.h: Copied from Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::FloatLiteral::FloatLiteral): >+ (WebCore::WHLSL::AST::FloatLiteral::value const): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTForLoop.h: Copied from Source/WebCore/platform/graphics/gpu/cocoa/GPUShaderModuleMetal.mm. >+ (WebCore::WHLSL::AST::ForLoop::ForLoop): >+ (WebCore::WHLSL::AST::ForLoop::~ForLoop): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTFunctionAttribute.h: Copied from Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h. >+ * Modules/webgpu/WHLSL/AST/WHLSLASTFunctionDeclaration.h: Added. >+ (WebCore::WHLSL::AST::FunctionDeclaration::FunctionDeclaration): >+ (WebCore::WHLSL::AST::FunctionDeclaration::takeOrigin): >+ (WebCore::WHLSL::AST::FunctionDeclaration::takeAttributeBlock): >+ (WebCore::WHLSL::AST::FunctionDeclaration::takeEntryPointType): >+ (WebCore::WHLSL::AST::FunctionDeclaration::takeType): >+ (WebCore::WHLSL::AST::FunctionDeclaration::takeName): >+ (WebCore::WHLSL::AST::FunctionDeclaration::takeParameters): >+ (WebCore::WHLSL::AST::FunctionDeclaration::takeSemantic): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTFunctionDefinition.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::FunctionDefinition::FunctionDefinition): >+ (WebCore::WHLSL::AST::FunctionDefinition::restricted const): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTIfStatement.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::IfStatement::IfStatement): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTIndexExpression.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::IndexExpression::IndexExpression): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTIntegerLiteral.h: Copied from Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::IntegerLiteral::IntegerLiteral): >+ (WebCore::WHLSL::AST::IntegerLiteral::value const): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTLogicalExpression.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::LogicalExpression::LogicalExpression): >+ (WebCore::WHLSL::AST::LogicalExpression::type const): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTLogicalNotExpression.h: Copied from Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::LogicalNotExpression::LogicalNotExpression): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTMakeArrayReferenceExpression.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::MakeArrayReferenceExpression::MakeArrayReferenceExpression): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTMakePointerExpression.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::MakePointerExpression::MakePointerExpression): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTNativeFunctionDeclaration.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::NativeFunctionDeclaration::NativeFunctionDeclaration): >+ (WebCore::WHLSL::AST::NativeFunctionDeclaration::restricted const): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTNativeTypeDeclaration.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::NativeTypeDeclaration::NativeTypeDeclaration): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTNode.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ * Modules/webgpu/WHLSL/AST/WHLSLASTNullLiteral.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::NullLiteral::NullLiteral): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTNumThreadsFunctionAttribute.h: Copied from Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::NumThreadsFunctionAttribute::NumThreadsFunctionAttribute): >+ (WebCore::WHLSL::AST::NumThreadsFunctionAttribute::width const): >+ (WebCore::WHLSL::AST::NumThreadsFunctionAttribute::height const): >+ (WebCore::WHLSL::AST::NumThreadsFunctionAttribute::depth const): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTParameter.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::Parameter::Parameter): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTPointerType.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::PointerType::PointerType): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTPropertyAccessExpression.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::PropertyAccessExpression::PropertyAccessExpression): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTQualifier.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ * Modules/webgpu/WHLSL/AST/WHLSLASTReadModifyWriteExpression.h: Added. >+ (WebCore::WHLSL::AST::ReadModifyWriteExpression::ReadModifyWriteExpression): >+ (WebCore::WHLSL::AST::ReadModifyWriteExpression::setNewValueExpression): >+ (WebCore::WHLSL::AST::ReadModifyWriteExpression::setResultExpression): >+ (WebCore::WHLSL::AST::ReadModifyWriteExpression::oldVariableReference): >+ (WebCore::WHLSL::AST::ReadModifyWriteExpression::newVariableReference): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTReferenceType.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::ReferenceType::ReferenceType): >+ (WebCore::WHLSL::AST::ReferenceType::origin const): >+ (WebCore::WHLSL::AST::ReferenceType::addressSpace const): >+ (WebCore::WHLSL::AST::ReferenceType::elementType const): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTResourceSemantic.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::ResourceSemantic::ResourceSemantic): >+ (WebCore::WHLSL::AST::ResourceSemantic::mode const): >+ (WebCore::WHLSL::AST::ResourceSemantic::index const): >+ (WebCore::WHLSL::AST::ResourceSemantic::space const): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTReturn.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::Return::Return): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTSemantic.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ * Modules/webgpu/WHLSL/AST/WHLSLASTSpecializationConstantSemantic.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::SpecializationConstantSemantic::SpecializationConstantSemantic): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTStageInOutSemantic.h: Copied from Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::StageInOutSemantic::StageInOutSemantic): >+ (WebCore::WHLSL::AST::StageInOutSemantic::index const): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTStatement.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::Statement::Statement): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTStructureDefinition.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::StructureDefinition::StructureDefinition): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTStructureElement.h: Copied from Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::StructureElement::StructureElement): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTSwitchCase.h: Copied from Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::SwitchCase::SwitchCase): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTSwitchStatement.h: Copied from Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::SwitchStatement::SwitchStatement): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTTernaryExpression.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::TernaryExpression::TernaryExpression): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTTrap.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::Trap::Trap): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTType.h: Copied from Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h. >+ * Modules/webgpu/WHLSL/AST/WHLSLASTTypeArgument.h: Copied from Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h. >+ * Modules/webgpu/WHLSL/AST/WHLSLASTTypeDefinition.h: Copied from Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::TypeDefinition::TypeDefinition): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTTypeReference.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::TypeReference::TypeReference): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTUnsignedIntegerLiteral.h: Copied from Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::UnsignedIntegerLiteral::UnsignedIntegerLiteral): >+ (WebCore::WHLSL::AST::UnsignedIntegerLiteral::value const): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTValue.h: Copied from Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::Value::Value): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTVariableDeclaration.h: Copied from Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::VariableDeclaration::VariableDeclaration): >+ (WebCore::WHLSL::AST::VariableDeclaration::origin const): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTVariableDeclarationsStatement.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::VariableDeclarationsStatement::VariableDeclarationsStatement): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTVariableReference.h: Copied from Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::VariableReference::VariableReference): >+ (WebCore::WHLSL::AST::VariableReference::wrap): >+ * Modules/webgpu/WHLSL/AST/WHLSLASTWhileLoop.h: Copied from Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h. >+ (WebCore::WHLSL::AST::WhileLoop::WhileLoop): >+ * Modules/webgpu/WHLSL/WHLSLLexer.cpp: Added. >+ (WebCore::WHLSL::Lexer::recognizeKeyword): >+ (WebCore::WHLSL::Lexer::consumeTokenFromStream): >+ (WebCore::WHLSL::Lexer::skipWhitespaceAndComments): >+ (WebCore::WHLSL::isWhitespace): >+ (WebCore::WHLSL::isNewline): >+ (WebCore::WHLSL::Lexer::skipWhitespace): >+ (WebCore::WHLSL::Lexer::skipLineComment): >+ (WebCore::WHLSL::Lexer::skipLongComment): >+ (WebCore::WHLSL::Lexer::coreDecimalIntLiteral const): >+ (WebCore::WHLSL::Lexer::decimalIntLiteral const): >+ (WebCore::WHLSL::Lexer::decimalUintLiteral const): >+ (WebCore::WHLSL::isHexadecimalCharacter): >+ (WebCore::WHLSL::Lexer::coreHexadecimalIntLiteral const): >+ (WebCore::WHLSL::Lexer::hexadecimalIntLiteral const): >+ (WebCore::WHLSL::Lexer::hexadecimalUintLiteral const): >+ (WebCore::WHLSL::Lexer::intLiteral const): >+ (WebCore::WHLSL::Lexer::uintLiteral const): >+ (WebCore::WHLSL::Lexer::digit const): >+ (WebCore::WHLSL::Lexer::digitStar const): >+ (WebCore::WHLSL::Lexer::character const): >+ (WebCore::WHLSL::Lexer::coreFloatLiteralType1 const): >+ (WebCore::WHLSL::Lexer::coreFloatLiteral const): >+ (WebCore::WHLSL::Lexer::floatLiteral const): >+ (WebCore::WHLSL::Lexer::validIdentifier const): >+ (WebCore::WHLSL::Lexer::identifier const): >+ (WebCore::WHLSL::Lexer::operatorName const): >+ * Modules/webgpu/WHLSL/WHLSLLexer.h: Added. >+ (WebCore::WHLSL::Lexer::Lexer): >+ (WebCore::WHLSL::Lexer::consumeToken): >+ (WebCore::WHLSL::Lexer::unconsumeToken): >+ (WebCore::WHLSL::Lexer::state const): >+ (WebCore::WHLSL::Lexer::setState): >+ (WebCore::WHLSL::Lexer::isFullyConsumed const): >+ (WebCore::WHLSL::Lexer::string const): >+ (WebCore::WHLSL::Lexer::anyCharacter const): >+ * Modules/webgpu/WHLSL/WHLSLParser.cpp: Added. >+ (WebCore::WHLSL::Parser::Parser): >+ (WebCore::WHLSL::Parser::parse): >+ (WebCore::WHLSL::Parser::peek): >+ (WebCore::WHLSL::Parser::tryType): >+ (WebCore::WHLSL::Parser::tryTypes): >+ (WebCore::WHLSL::Parser::consumeType): >+ (WebCore::WHLSL::Parser::consumeTypes): >+ (WebCore::WHLSL::digitValue): >+ (WebCore::WHLSL::intLiteralToInt): >+ (WebCore::WHLSL::uintLiteralToUint): >+ (WebCore::WHLSL::floatLiteralToFloat): >+ (WebCore::WHLSL::Parser::consumeIntegralLiteral): >+ (WebCore::WHLSL::Parser::consumeNonNegativeIntegralLiteral): >+ (WebCore::WHLSL::recognizeSimpleUnsignedInteger): >+ (WebCore::WHLSL::Parser::parseConstantExpression): >+ (WebCore::WHLSL::Parser::parseTypeArgument): >+ (WebCore::WHLSL::Parser::parseTypeArguments): >+ (WebCore::WHLSL::Parser::parseTypeSuffixAbbreviated): >+ (WebCore::WHLSL::Parser::parseTypeSuffixNonAbbreviated): >+ (WebCore::WHLSL::Parser::parseAddressSpaceType): >+ (WebCore::WHLSL::Parser::parseNonAddressSpaceType): >+ (WebCore::WHLSL::Parser::parseType): >+ (WebCore::WHLSL::Parser::parseTypeDefinition): >+ (WebCore::WHLSL::Parser::parseBuiltInSemantic): >+ (WebCore::WHLSL::Parser::parseResourceSemantic): >+ (WebCore::WHLSL::Parser::parseSpecializationConstantSemantic): >+ (WebCore::WHLSL::Parser::parseStageInOutSemantic): >+ (WebCore::WHLSL::Parser::parseSemantic): >+ (WebCore::WHLSL::Parser::parseQualifiers): >+ (WebCore::WHLSL::Parser::parseStructureElement): >+ (WebCore::WHLSL::Parser::parseStructureDefinition): >+ (WebCore::WHLSL::Parser::parseEnumerationDefinition): >+ (WebCore::WHLSL::Parser::parseEnumerationMember): >+ (WebCore::WHLSL::Parser::parseNativeTypeDeclaration): >+ (WebCore::WHLSL::Parser::parseNumThreadsFunctionAttribute): >+ (WebCore::WHLSL::Parser::parseAttributeBlock): >+ (WebCore::WHLSL::Parser::parseParameter): >+ (WebCore::WHLSL::Parser::parseParameters): >+ (WebCore::WHLSL::Parser::parseFunctionDefinition): >+ (WebCore::WHLSL::Parser::parseEntryPointFunctionDeclaration): >+ (WebCore::WHLSL::Parser::parseRegularFunctionDeclaration): >+ (WebCore::WHLSL::Parser::parseOperatorFunctionDeclaration): >+ (WebCore::WHLSL::Parser::parseFunctionDeclaration): >+ (WebCore::WHLSL::Parser::parseNativeFunctionDeclaration): >+ (WebCore::WHLSL::Parser::parseBlock): >+ (WebCore::WHLSL::Parser::parseBlockBody): >+ (WebCore::WHLSL::Parser::parseIfStatement): >+ (WebCore::WHLSL::Parser::parseSwitchStatement): >+ (WebCore::WHLSL::Parser::parseSwitchCase): >+ (WebCore::WHLSL::Parser::parseForLoop): >+ (WebCore::WHLSL::Parser::parseWhileLoop): >+ (WebCore::WHLSL::Parser::parseDoWhileLoop): >+ (WebCore::WHLSL::Parser::parseVariableDeclaration): >+ (WebCore::WHLSL::Parser::parseVariableDeclarations): >+ (WebCore::WHLSL::Parser::parseStatement): >+ (WebCore::WHLSL::Parser::parseEffectfulExpression): >+ (WebCore::WHLSL::Parser::parseEffectfulAssignment): >+ (WebCore::WHLSL::Parser::parseEffectfulPrefix): >+ (WebCore::WHLSL::Parser::parseEffectfulSuffix): >+ (WebCore::WHLSL::Parser::parseLimitedSuffixOperator): >+ (WebCore::WHLSL::Parser::parseSuffixOperator): >+ (WebCore::WHLSL::Parser::parseExpression): >+ (WebCore::WHLSL::Parser::parseTernaryConditional): >+ (WebCore::WHLSL::Parser::parseAssignment): >+ (WebCore::WHLSL::Parser::parsePossibleTernaryConditional): >+ (WebCore::WHLSL::Parser::parsePossibleLogicalBinaryOperation): >+ (WebCore::WHLSL::Parser::parsePossibleRelationalBinaryOperation): >+ (WebCore::WHLSL::Parser::parsePossibleShift): >+ (WebCore::WHLSL::Parser::parsePossibleAdd): >+ (WebCore::WHLSL::Parser::parsePossibleMultiply): >+ (WebCore::WHLSL::Parser::parsePossiblePrefix): >+ (WebCore::WHLSL::Parser::parsePossibleSuffix): >+ (WebCore::WHLSL::Parser::parseCallExpression): >+ (WebCore::WHLSL::Parser::parseTerm): >+ * Modules/webgpu/WHLSL/WHLSLParser.h: Added. >+ (WebCore::WHLSL::Parser::backtrackingScope): >+ (WebCore::WHLSL::Parser::SuffixExpression::SuffixExpression): >+ (WebCore::WHLSL::Parser::SuffixExpression::operator bool const): >+ * Modules/webgpu/WHLSL/WHLSLProgram.h: Added. >+ (WebCore::WHLSL::Program::append): >+ * Modules/webgpu/WHLSL/WHLSLStandardLibrary.txt: Added. >+ * Modules/webgpu/WebGPUDevice.cpp: >+ (WebCore::WebGPUDevice::createShaderModule const): >+ * Modules/webgpu/WebGPUShaderModuleDescriptor.h: >+ * Modules/webgpu/WebGPUShaderModuleDescriptor.idl: >+ * Sources.txt: >+ * WebCore.xcodeproj/project.pbxproj: >+ * platform/graphics/gpu/GPUShaderModuleDescriptor.h: >+ * platform/graphics/gpu/cocoa/GPUShaderModuleMetal.mm: >+ (WebCore::GPUShaderModule::create): >+ > 2018-12-17 Eric Carlson <eric.carlson@apple.com> > > [MediaStream] A stream's first video frame should be rendered >diff --git a/Source/WebCore/DerivedSources.make b/Source/WebCore/DerivedSources.make >index 321bd439a5e..3ed4258e315 100644 >--- a/Source/WebCore/DerivedSources.make >+++ b/Source/WebCore/DerivedSources.make >@@ -1594,6 +1594,15 @@ $(GENERATE_SETTINGS_PATTERNS) : $(WebCore)/Scripts/GenerateSettings.rb $(GENERAT > > # -------- > >+# WHLSL Standard Library >+ >+all : WHLSLStandardLibrary.cpp >+ >+WHLSLStandardLibrary.cpp : $(JavaScriptCore_SCRIPTS_DIR)/xxd.pl $(WebCore)/Modules/webgpu/WHLSL/WHLSLStandardLibrary.txt >+ $(PERL) $(JavaScriptCore_SCRIPTS_DIR)/xxd.pl WHLSLStandardLibrary $(WebCore)/Modules/webgpu/WHLSL/WHLSLStandardLibrary.txt WHLSLStandardLibrary.h >+ >+# -------- >+ > # Common generator things > > COMMON_BINDINGS_SCRIPTS = \ >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTAnonymousVariableDeclaration.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTAnonymousVariableDeclaration.h >new file mode 100644 >index 00000000000..fbb9fccc455 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTAnonymousVariableDeclaration.h >@@ -0,0 +1,63 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTValue.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class AnonymousVariableDeclaration : public Value { >+public: >+ AnonymousVariableDeclaration(Lexer::Token&& origin) >+ : m_origin(WTFMove(origin)) >+ { >+ } >+ >+ virtual ~AnonymousVariableDeclaration() = default; >+ >+ AnonymousVariableDeclaration(const AnonymousVariableDeclaration&) = delete; >+ AnonymousVariableDeclaration(AnonymousVariableDeclaration&&) = default; >+ >+ Lexer::Token origin() const { return m_origin; } >+ >+private: >+ Lexer::Token m_origin; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTArrayReferenceType.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTArrayReferenceType.h >new file mode 100644 >index 00000000000..2397868353f >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTArrayReferenceType.h >@@ -0,0 +1,66 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTReferenceType.h" >+#include "WHLSLLexer.h" >+#include <wtf/text/WTFString.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class ArrayReferenceType : public ReferenceType { >+public: >+ ArrayReferenceType(Lexer::Token&& origin, String&& addressSpace, std::unique_ptr<Type>&& elementType) >+ : ReferenceType(WTFMove(origin), WTFMove(addressSpace), WTFMove(elementType)) >+ { >+ } >+ >+ virtual ~ArrayReferenceType() = default; >+ >+ ArrayReferenceType(const ArrayReferenceType&) = delete; >+ ArrayReferenceType(ArrayReferenceType&&) = default; >+ >+ std::unique_ptr<Type> clone() const override >+ { >+ return std::make_unique<ArrayReferenceType>(Lexer::Token(origin()), String(addressSpace()), elementType()->clone()); >+ } >+ >+private: >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTArrayType.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTArrayType.h >new file mode 100644 >index 00000000000..bf388fb8f6b >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTArrayType.h >@@ -0,0 +1,74 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTType.h" >+#include "WHLSLASTTypeArgument.h" >+#include "WHLSLLexer.h" >+#include <wtf/text/WTFString.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class ArrayType : public Type { >+public: >+ ArrayType(Lexer::Token&& origin, std::unique_ptr<Type>&& elementType, unsigned numElements) >+ : m_origin(WTFMove(origin)) >+ , m_elementType(WTFMove(elementType)) >+ , m_numElements(numElements) >+ { >+ } >+ >+ virtual ~ArrayType() = default; >+ >+ ArrayType(const ArrayType&) = delete; >+ ArrayType(ArrayType&&) = default; >+ >+ unsigned numElements() const { return m_numElements; } >+ >+ std::unique_ptr<Type> clone() const override >+ { >+ return std::make_unique<ArrayType>(Lexer::Token(m_origin), m_elementType->clone(), m_numElements); >+ } >+ >+private: >+ Lexer::Token m_origin; >+ std::unique_ptr<Type> m_elementType; >+ unsigned m_numElements; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTAssignmentExpression.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTAssignmentExpression.h >new file mode 100644 >index 00000000000..c66c6dc35ec >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTAssignmentExpression.h >@@ -0,0 +1,64 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTExpression.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class AssignmentExpression : public Expression { >+public: >+ AssignmentExpression(Lexer::Token&& origin, std::unique_ptr<Expression>&& left, std::unique_ptr<Expression>&& right) >+ : Expression(WTFMove(origin)) >+ , m_left(WTFMove(left)) >+ , m_right(WTFMove(right)) >+ { >+ } >+ >+ virtual ~AssignmentExpression() = default; >+ >+ AssignmentExpression(const AssignmentExpression&) = delete; >+ AssignmentExpression(AssignmentExpression&&) = default; >+ >+private: >+ std::unique_ptr<Expression> m_left; >+ std::unique_ptr<Expression> m_right; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTBaseFunctionAttribute.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTBaseFunctionAttribute.h >new file mode 100644 >index 00000000000..69c6511c82b >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTBaseFunctionAttribute.h >@@ -0,0 +1,61 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTNode.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class BaseFunctionAttribute : public Node { >+public: >+ BaseFunctionAttribute(Lexer::Token&& origin) >+ : m_origin(WTFMove(origin)) >+ { >+ } >+ >+ virtual ~BaseFunctionAttribute() = default; >+ >+ BaseFunctionAttribute(const BaseFunctionAttribute&) = delete; >+ BaseFunctionAttribute(BaseFunctionAttribute&&) = default; >+ >+private: >+ Lexer::Token m_origin; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTBaseSemantic.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTBaseSemantic.h >new file mode 100644 >index 00000000000..44feceee9b7 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTBaseSemantic.h >@@ -0,0 +1,61 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTNode.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class BaseSemantic : public Node { >+public: >+ BaseSemantic(Lexer::Token&& origin) >+ : m_origin(WTFMove(origin)) >+ { >+ } >+ >+ virtual ~BaseSemantic() = default; >+ >+ BaseSemantic(const BaseSemantic&) = delete; >+ BaseSemantic(BaseSemantic&&) = default; >+ >+private: >+ Lexer::Token m_origin; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTBlock.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTBlock.h >new file mode 100644 >index 00000000000..8b73f7f04c4 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTBlock.h >@@ -0,0 +1,63 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTStatement.h" >+#include "WHLSLLexer.h" >+#include <wtf/Vector.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class Block : public Statement { >+public: >+ Block(Lexer::Token&& origin, Vector<std::unique_ptr<Statement>>&& statements) >+ : Statement(WTFMove(origin)) >+ , m_statements(WTFMove(statements)) >+ { >+ } >+ >+ virtual ~Block() = default; >+ >+ Block(const Block&) = delete; >+ Block(Block&&) = default; >+ >+private: >+ Vector<std::unique_ptr<Statement>> m_statements; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTBooleanLiteral.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTBooleanLiteral.h >new file mode 100644 >index 00000000000..0c3ba78652e >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTBooleanLiteral.h >@@ -0,0 +1,64 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTExpression.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class BooleanLiteral : public Expression { >+public: >+ BooleanLiteral(Lexer::Token&& origin, bool value) >+ : Expression(WTFMove(origin)) >+ , m_value(value) >+ { >+ } >+ >+ virtual ~BooleanLiteral() = default; >+ >+ explicit BooleanLiteral(const BooleanLiteral&) = default; >+ BooleanLiteral(BooleanLiteral&&) = default; >+ >+ bool value() const { return m_value; } >+ >+private: >+ bool m_value; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTBreak.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTBreak.h >new file mode 100644 >index 00000000000..7c2b10ac727 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTBreak.h >@@ -0,0 +1,60 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTStatement.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class Break : public Statement { >+public: >+ Break(Lexer::Token&& origin) >+ : Statement(WTFMove(origin)) >+ { >+ } >+ >+ virtual ~Break() = default; >+ >+ Break(const Break&) = delete; >+ Break(Break&&) = default; >+ >+private: >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTBuiltInSemantic.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTBuiltInSemantic.h >new file mode 100644 >index 00000000000..ee4012b3042 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTBuiltInSemantic.h >@@ -0,0 +1,83 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTBaseSemantic.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class BuiltInSemantic : public BaseSemantic { >+public: >+ enum class Variable { >+ SVInstanceID, >+ SVVertexID, >+ PSize, >+ SVPosition, >+ SVIsFrontFace, >+ SVSampleIndex, >+ SVInnerCoverage, >+ SVTarget, >+ SVDepth, >+ SVCoverage, >+ SVDispatchThreadID, >+ SVGroupID, >+ SVGroupIndex, >+ SVGroupThreadID >+ }; >+ >+ BuiltInSemantic(Lexer::Token&& origin, Variable variable, std::optional<unsigned>&& targetIndex = std::nullopt) >+ : BaseSemantic(WTFMove(origin)) >+ , m_variable(variable) >+ , m_targetIndex(WTFMove(targetIndex)) >+ { >+ } >+ >+ virtual ~BuiltInSemantic() = default; >+ >+ BuiltInSemantic(const BuiltInSemantic&) = delete; >+ BuiltInSemantic(BuiltInSemantic&&) = default; >+ >+ Variable variable() const { return m_variable; } >+ >+private: >+ Variable m_variable; >+ std::optional<unsigned> m_targetIndex; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTCallExpression.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTCallExpression.h >new file mode 100644 >index 00000000000..68af89ead85 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTCallExpression.h >@@ -0,0 +1,64 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTExpression.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class CallExpression : public Expression { >+public: >+ CallExpression(Lexer::Token&& origin, String&& name, Vector<std::unique_ptr<Expression>>&& arguments) >+ : Expression(WTFMove(origin)) >+ , m_name(WTFMove(name)) >+ , m_arguments(WTFMove(arguments)) >+ { >+ } >+ >+ virtual ~CallExpression() = default; >+ >+ CallExpression(const CallExpression&) = delete; >+ CallExpression(CallExpression&&) = default; >+ >+private: >+ String m_name; >+ Vector<std::unique_ptr<Expression>> m_arguments; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTCommaExpression.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTCommaExpression.h >new file mode 100644 >index 00000000000..77bf3dcf50b >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTCommaExpression.h >@@ -0,0 +1,63 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTExpression.h" >+#include "WHLSLLexer.h" >+#include <wtf/Vector.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class CommaExpression : public Expression { >+public: >+ CommaExpression(Lexer::Token&& origin, Vector<std::unique_ptr<Expression>>&& list) >+ : Expression(WTFMove(origin)) >+ , m_list(WTFMove(list)) >+ { >+ } >+ >+ virtual ~CommaExpression() = default; >+ >+ CommaExpression(const CommaExpression&) = delete; >+ CommaExpression(CommaExpression&&) = default; >+ >+private: >+ Vector<std::unique_ptr<Expression>> m_list; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTConstantExpression.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTConstantExpression.h >new file mode 100644 >index 00000000000..8c7d7d060cd >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTConstantExpression.h >@@ -0,0 +1,59 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTBooleanLiteral.h" >+#include "WHLSLASTConstantExpressionEnumerationMemberReference.h" >+#include "WHLSLASTFloatLiteral.h" >+#include "WHLSLASTIntegerLiteral.h" >+#include "WHLSLASTNullLiteral.h" >+#include "WHLSLASTUnsignedIntegerLiteral.h" >+#include <wtf/Variant.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+typedef Variant< >+ IntegerLiteral, >+ UnsignedIntegerLiteral, >+ FloatLiteral, >+ NullLiteral, >+ BooleanLiteral, >+ ConstantExpressionEnumerationMemberReference >+ > ConstantExpression; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTConstantExpressionEnumerationMemberReference.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTConstantExpressionEnumerationMemberReference.h >new file mode 100644 >index 00000000000..2c24a98b2ca >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTConstantExpressionEnumerationMemberReference.h >@@ -0,0 +1,65 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLLexer.h" >+#include <wtf/text/WTFString.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class ConstantExpressionEnumerationMemberReference : public Node { >+public: >+ ConstantExpressionEnumerationMemberReference(Lexer::Token&& origin, String&& left, String&& right) >+ : m_origin(WTFMove(origin)) >+ , m_left(WTFMove(left)) >+ , m_right(WTFMove(right)) >+ { >+ } >+ >+ virtual ~ConstantExpressionEnumerationMemberReference() = default; >+ >+ explicit ConstantExpressionEnumerationMemberReference(const ConstantExpressionEnumerationMemberReference&) = default; >+ ConstantExpressionEnumerationMemberReference(ConstantExpressionEnumerationMemberReference&&) = default; >+ >+private: >+ Lexer::Token m_origin; >+ String m_left; >+ String m_right; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTContinue.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTContinue.h >new file mode 100644 >index 00000000000..1681024e813 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTContinue.h >@@ -0,0 +1,60 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTStatement.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class Continue : public Statement { >+public: >+ Continue(Lexer::Token&& origin) >+ : Statement(WTFMove(origin)) >+ { >+ } >+ >+ virtual ~Continue() = default; >+ >+ Continue(const Continue&) = delete; >+ Continue(Continue&&) = default; >+ >+private: >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTDereferenceExpression.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTDereferenceExpression.h >new file mode 100644 >index 00000000000..2d2f1717805 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTDereferenceExpression.h >@@ -0,0 +1,62 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTExpression.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class DereferenceExpression : public Expression { >+public: >+ DereferenceExpression(Lexer::Token&& origin, std::unique_ptr<Expression>&& pointer) >+ : Expression(WTFMove(origin)) >+ , m_pointer(WTFMove(pointer)) >+ { >+ } >+ >+ virtual ~DereferenceExpression() = default; >+ >+ DereferenceExpression(const DereferenceExpression&) = delete; >+ DereferenceExpression(DereferenceExpression&&) = default; >+ >+private: >+ std::unique_ptr<Expression> m_pointer; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTDoWhileLoop.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTDoWhileLoop.h >new file mode 100644 >index 00000000000..6cc69c27fea >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTDoWhileLoop.h >@@ -0,0 +1,65 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTExpression.h" >+#include "WHLSLASTStatement.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class DoWhileLoop : public Statement { >+public: >+ DoWhileLoop(Lexer::Token&& origin, std::unique_ptr<Statement>&& body, std::unique_ptr<Expression>&& conditional) >+ : Statement(WTFMove(origin)) >+ , m_body(WTFMove(body)) >+ , m_conditional(WTFMove(conditional)) >+ { >+ } >+ >+ virtual ~DoWhileLoop() = default; >+ >+ DoWhileLoop(const DoWhileLoop&) = delete; >+ DoWhileLoop(DoWhileLoop&&) = default; >+ >+private: >+ std::unique_ptr<Statement> m_body; >+ std::unique_ptr<Expression> m_conditional; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTDotExpression.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTDotExpression.h >new file mode 100644 >index 00000000000..3ecafa2cb2c >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTDotExpression.h >@@ -0,0 +1,62 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTPropertyAccessExpression.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class DotExpression : public PropertyAccessExpression { >+public: >+ DotExpression(Lexer::Token&& origin, std::unique_ptr<Expression>&& base, String&& fieldName) >+ : PropertyAccessExpression(WTFMove(origin), WTFMove(base)) >+ , m_fieldName(WTFMove(fieldName)) >+ { >+ } >+ >+ virtual ~DotExpression() = default; >+ >+ DotExpression(const DotExpression&) = delete; >+ DotExpression(DotExpression&&) = default; >+ >+private: >+ String m_fieldName; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTEffectfulExpressionStatement.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTEffectfulExpressionStatement.h >new file mode 100644 >index 00000000000..fd9aa730804 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTEffectfulExpressionStatement.h >@@ -0,0 +1,63 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTExpression.h" >+#include "WHLSLASTStatement.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class EffectfulExpressionStatement : public Statement { >+public: >+ EffectfulExpressionStatement(std::unique_ptr<Expression>&& effectfulExpression) >+ : Statement(Lexer::Token(effectfulExpression->origin())) >+ , m_effectfulExpression(WTFMove(effectfulExpression)) >+ { >+ } >+ >+ virtual ~EffectfulExpressionStatement() = default; >+ >+ EffectfulExpressionStatement(const EffectfulExpressionStatement&) = delete; >+ EffectfulExpressionStatement(EffectfulExpressionStatement&&) = default; >+ >+private: >+ std::unique_ptr<Expression> m_effectfulExpression; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTEnumerationDefinition.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTEnumerationDefinition.h >new file mode 100644 >index 00000000000..d607f662076 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTEnumerationDefinition.h >@@ -0,0 +1,76 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTEnumerationMember.h" >+#include "WHLSLASTType.h" >+#include "WHLSLLexer.h" >+#include <wtf/Vector.h> >+#include <wtf/text/WTFString.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class EnumerationDefinition : public Type { >+public: >+ EnumerationDefinition(Lexer::Token&& origin, String&& name, std::unique_ptr<Type>&& type, Vector<EnumerationMember> members) >+ : m_origin(WTFMove(origin)) >+ , m_name(WTFMove(name)) >+ , m_type(WTFMove(type)) >+ , m_members(WTFMove(members)) >+ { >+ } >+ >+ virtual ~EnumerationDefinition() = default; >+ >+ EnumerationDefinition(const EnumerationDefinition&) = delete; >+ EnumerationDefinition(EnumerationDefinition&&) = default; >+ >+ std::unique_ptr<Type> clone() const override >+ { >+ ASSERT_NOT_REACHED(); >+ return nullptr; >+ } >+ >+private: >+ Lexer::Token m_origin; >+ String m_name; >+ std::unique_ptr<Type> m_type; >+ Vector<EnumerationMember> m_members; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTEnumerationMember.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTEnumerationMember.h >new file mode 100644 >index 00000000000..1ec91eabe9f >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTEnumerationMember.h >@@ -0,0 +1,68 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTConstantExpression.h" >+#include "WHLSLASTNode.h" >+#include "WHLSLLexer.h" >+#include <wtf/Optional.h> >+#include <wtf/text/WTFString.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class EnumerationMember : public Node { >+public: >+ EnumerationMember(Lexer::Token&& origin, String&& name, std::optional<ConstantExpression>&& value = std::nullopt) >+ : m_origin(WTFMove(origin)) >+ , m_name(WTFMove(name)) >+ , m_value(WTFMove(value)) >+ { >+ } >+ >+ virtual ~EnumerationMember() = default; >+ >+ EnumerationMember(const EnumerationMember&) = delete; >+ EnumerationMember(EnumerationMember&&) = default; >+ >+private: >+ Lexer::Token m_origin; >+ String m_name; >+ std::optional<ConstantExpression> m_value; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTExpression.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTExpression.h >new file mode 100644 >index 00000000000..82680321a31 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTExpression.h >@@ -0,0 +1,63 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTValue.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class Expression : public Value { >+public: >+ Expression(Lexer::Token&& origin) >+ : m_origin(WTFMove(origin)) >+ { >+ } >+ >+ virtual ~Expression() = default; >+ >+ explicit Expression(const Expression&) = default; >+ Expression(Expression&&) = default; >+ >+ Lexer::Token origin() const { return m_origin; } >+ >+private: >+ Lexer::Token m_origin; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTFallthrough.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTFallthrough.h >new file mode 100644 >index 00000000000..f7e3bb50186 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTFallthrough.h >@@ -0,0 +1,60 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTStatement.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class Fallthrough : public Statement { >+public: >+ Fallthrough(Lexer::Token&& origin) >+ : Statement(WTFMove(origin)) >+ { >+ } >+ >+ virtual ~Fallthrough() = default; >+ >+ Fallthrough(const Fallthrough&) = delete; >+ Fallthrough(Fallthrough&&) = default; >+ >+private: >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTFloatLiteral.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTFloatLiteral.h >new file mode 100644 >index 00000000000..e450bd27289 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTFloatLiteral.h >@@ -0,0 +1,64 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTExpression.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class FloatLiteral : public Expression { >+public: >+ FloatLiteral(Lexer::Token&& origin, float value) >+ : Expression(WTFMove(origin)) >+ , m_value(value) >+ { >+ } >+ >+ virtual ~FloatLiteral() = default; >+ >+ explicit FloatLiteral(const FloatLiteral&) = default; >+ FloatLiteral(FloatLiteral&&) = default; >+ >+ float value() const { return m_value; } >+ >+private: >+ float m_value; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTForLoop.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTForLoop.h >new file mode 100644 >index 00000000000..22606384764 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTForLoop.h >@@ -0,0 +1,74 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTExpression.h" >+#include "WHLSLASTStatement.h" >+#include "WHLSLASTVariableDeclarationsStatement.h" >+#include "WHLSLLexer.h" >+#include <wtf/Variant.h> >+#include <wtf/Vector.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class ForLoop : public Statement { >+public: >+ ForLoop(Lexer::Token&& origin, Variant<VariableDeclarationsStatement, std::unique_ptr<Expression>>&& initialization, std::unique_ptr<Expression>&& condition, std::unique_ptr<Expression>&& increment, std::unique_ptr<Statement>&& body) >+ : Statement(WTFMove(origin)) >+ , m_initialization(WTFMove(initialization)) >+ , m_condition(WTFMove(condition)) >+ , m_increment(WTFMove(increment)) >+ , m_body(WTFMove(body)) >+ { >+ } >+ >+ virtual ~ForLoop() >+ { >+ } >+ >+ ForLoop(const ForLoop&) = delete; >+ ForLoop(ForLoop&&) = default; >+ >+private: >+ Variant<VariableDeclarationsStatement, std::unique_ptr<Expression>> m_initialization; >+ std::unique_ptr<Expression> m_condition; // nullable >+ std::unique_ptr<Expression> m_increment; // nullable >+ std::unique_ptr<Statement> m_body; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTFunctionAttribute.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTFunctionAttribute.h >new file mode 100644 >index 00000000000..ec2dff4d606 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTFunctionAttribute.h >@@ -0,0 +1,49 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTNumThreadsFunctionAttribute.h" >+#include <wtf/Variant.h> >+#include <wtf/Vector.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+typedef Variant<NumThreadsFunctionAttribute> FunctionAttribute; >+typedef Vector<FunctionAttribute> AttributeBlock; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTFunctionDeclaration.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTFunctionDeclaration.h >new file mode 100644 >index 00000000000..ff78c4d8b9a >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTFunctionDeclaration.h >@@ -0,0 +1,92 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTFunctionAttribute.h" >+#include "WHLSLASTNode.h" >+#include "WHLSLASTParameter.h" >+#include "WHLSLASTSemantic.h" >+#include "WHLSLASTType.h" >+#include "WHLSLLexer.h" >+#include <wtf/text/WTFString.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class FunctionDeclaration : public Node { >+public: >+ enum class EntryPointType { >+ Vertex, >+ Fragment, >+ Compute >+ }; >+ >+ FunctionDeclaration(Lexer::Token&& origin, AttributeBlock&& attributeBlock, std::optional<EntryPointType> entryPointType, std::unique_ptr<AST::Type>&& type, String&& name, Parameters&& parameters, std::optional<AST::Semantic>&& semantic) >+ : m_origin(WTFMove(origin)) >+ , m_attributeBlock(WTFMove(attributeBlock)) >+ , m_entryPointType(entryPointType) >+ , m_type(WTFMove(type)) >+ , m_name(WTFMove(name)) >+ , m_parameters(WTFMove(parameters)) >+ , m_semantic(WTFMove(semantic)) >+ { >+ } >+ >+ virtual ~FunctionDeclaration() = default; >+ >+ FunctionDeclaration(const FunctionDeclaration&) = delete; >+ FunctionDeclaration(FunctionDeclaration&&) = default; >+ >+ Lexer::Token&& takeOrigin() { return WTFMove(m_origin); } >+ AttributeBlock&& takeAttributeBlock() { return WTFMove(m_attributeBlock); } >+ std::optional<EntryPointType>&& takeEntryPointType() { return WTFMove(m_entryPointType); } >+ std::unique_ptr<AST::Type>&& takeType() { return WTFMove(m_type); } >+ String&& takeName() { return WTFMove(m_name); } >+ Parameters&& takeParameters() { return WTFMove(m_parameters); } >+ std::optional<AST::Semantic>&& takeSemantic() { return WTFMove(m_semantic); } >+ >+private: >+ Lexer::Token m_origin; >+ AttributeBlock m_attributeBlock; >+ std::optional<EntryPointType> m_entryPointType; >+ std::unique_ptr<AST::Type> m_type; >+ String m_name; >+ Parameters m_parameters; >+ std::optional<AST::Semantic> m_semantic; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTFunctionDefinition.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTFunctionDefinition.h >new file mode 100644 >index 00000000000..8d7209a6c7f >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTFunctionDefinition.h >@@ -0,0 +1,66 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTBlock.h" >+#include "WHLSLASTFunctionDeclaration.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class FunctionDefinition : public FunctionDeclaration { >+public: >+ FunctionDefinition(FunctionDeclaration&& functionDeclaration, Block&& block, bool restricted) >+ : FunctionDeclaration(WTFMove(functionDeclaration)) >+ , m_block(WTFMove(block)) >+ , m_restricted(restricted) >+ { >+ } >+ >+ virtual ~FunctionDefinition() = default; >+ >+ FunctionDefinition(const FunctionDefinition&) = delete; >+ FunctionDefinition(FunctionDefinition&&) = default; >+ >+ bool restricted() const { return m_restricted; } >+ >+private: >+ Block m_block; >+ bool m_restricted; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTIfStatement.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTIfStatement.h >new file mode 100644 >index 00000000000..18131e443b3 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTIfStatement.h >@@ -0,0 +1,67 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTExpression.h" >+#include "WHLSLASTStatement.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class IfStatement : public Statement { >+public: >+ IfStatement(Lexer::Token&& origin, std::unique_ptr<Expression>&& conditional, std::unique_ptr<Statement>&& body, std::unique_ptr<Statement>&& elseBody) >+ : Statement(WTFMove(origin)) >+ , m_conditional(WTFMove(conditional)) >+ , m_body(WTFMove(body)) >+ , m_elseBody(WTFMove(elseBody)) >+ { >+ } >+ >+ virtual ~IfStatement() = default; >+ >+ IfStatement(const IfStatement&) = delete; >+ IfStatement(IfStatement&&) = default; >+ >+private: >+ std::unique_ptr<Expression> m_conditional; >+ std::unique_ptr<Statement> m_body; >+ std::unique_ptr<Statement> m_elseBody; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTIndexExpression.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTIndexExpression.h >new file mode 100644 >index 00000000000..0412fa0fdc9 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTIndexExpression.h >@@ -0,0 +1,62 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTPropertyAccessExpression.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class IndexExpression : public PropertyAccessExpression { >+public: >+ IndexExpression(Lexer::Token&& origin, std::unique_ptr<Expression>&& base, std::unique_ptr<Expression>&& index) >+ : PropertyAccessExpression(WTFMove(origin), WTFMove(base)) >+ , m_index(WTFMove(index)) >+ { >+ } >+ >+ virtual ~IndexExpression() = default; >+ >+ IndexExpression(const IndexExpression&) = delete; >+ IndexExpression(IndexExpression&&) = default; >+ >+private: >+ std::unique_ptr<Expression> m_index; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTIntegerLiteral.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTIntegerLiteral.h >new file mode 100644 >index 00000000000..d6b51d18fce >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTIntegerLiteral.h >@@ -0,0 +1,64 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTExpression.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class IntegerLiteral : public Expression { >+public: >+ IntegerLiteral(Lexer::Token&& origin, int value) >+ : Expression(WTFMove(origin)) >+ , m_value(value) >+ { >+ } >+ >+ virtual ~IntegerLiteral() = default; >+ >+ explicit IntegerLiteral(const IntegerLiteral&) = default; >+ IntegerLiteral(IntegerLiteral&&) = default; >+ >+ int value() const { return m_value; } >+ >+private: >+ int m_value; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTLogicalExpression.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTLogicalExpression.h >new file mode 100644 >index 00000000000..77beb1e3b91 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTLogicalExpression.h >@@ -0,0 +1,73 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTExpression.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class LogicalExpression : public Expression { >+public: >+ enum class Type { >+ And, >+ Or >+ }; >+ >+ LogicalExpression(Lexer::Token&& origin, Type type, std::unique_ptr<Expression>&& left, std::unique_ptr<Expression>&& right) >+ : Expression(WTFMove(origin)) >+ , m_type(type) >+ , m_left(WTFMove(left)) >+ , m_right(WTFMove(right)) >+ { >+ } >+ >+ virtual ~LogicalExpression() = default; >+ >+ LogicalExpression(const LogicalExpression&) = delete; >+ LogicalExpression(LogicalExpression&&) = default; >+ >+ Type type() const { return m_type; } >+ >+private: >+ Type m_type; >+ std::unique_ptr<Expression> m_left; >+ std::unique_ptr<Expression> m_right; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTLogicalNotExpression.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTLogicalNotExpression.h >new file mode 100644 >index 00000000000..8c93d885761 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTLogicalNotExpression.h >@@ -0,0 +1,62 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTExpression.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class LogicalNotExpression : public Expression { >+public: >+ LogicalNotExpression(Lexer::Token&& origin, std::unique_ptr<Expression>&& operand) >+ : Expression(WTFMove(origin)) >+ , m_operand(WTFMove(operand)) >+ { >+ } >+ >+ virtual ~LogicalNotExpression() = default; >+ >+ LogicalNotExpression(const LogicalNotExpression&) = delete; >+ LogicalNotExpression(LogicalNotExpression&&) = default; >+ >+private: >+ std::unique_ptr<Expression> m_operand; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTMakeArrayReferenceExpression.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTMakeArrayReferenceExpression.h >new file mode 100644 >index 00000000000..10f8206e88a >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTMakeArrayReferenceExpression.h >@@ -0,0 +1,62 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTExpression.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class MakeArrayReferenceExpression : public Expression { >+public: >+ MakeArrayReferenceExpression(Lexer::Token&& origin, std::unique_ptr<Expression>&& lValue) >+ : Expression(WTFMove(origin)) >+ , m_lValue(WTFMove(lValue)) >+ { >+ } >+ >+ virtual ~MakeArrayReferenceExpression() = default; >+ >+ MakeArrayReferenceExpression(const MakeArrayReferenceExpression&) = delete; >+ MakeArrayReferenceExpression(MakeArrayReferenceExpression&&) = default; >+ >+private: >+ std::unique_ptr<Expression> m_lValue; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTMakePointerExpression.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTMakePointerExpression.h >new file mode 100644 >index 00000000000..69fa9240e10 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTMakePointerExpression.h >@@ -0,0 +1,62 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTExpression.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class MakePointerExpression : public Expression { >+public: >+ MakePointerExpression(Lexer::Token&& origin, std::unique_ptr<Expression>&& lValue) >+ : Expression(WTFMove(origin)) >+ , m_lValue(WTFMove(lValue)) >+ { >+ } >+ >+ virtual ~MakePointerExpression() = default; >+ >+ MakePointerExpression(const MakePointerExpression&) = delete; >+ MakePointerExpression(MakePointerExpression&&) = default; >+ >+private: >+ std::unique_ptr<Expression> m_lValue; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTNativeFunctionDeclaration.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTNativeFunctionDeclaration.h >new file mode 100644 >index 00000000000..1a7ea684d0f >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTNativeFunctionDeclaration.h >@@ -0,0 +1,63 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTFunctionDeclaration.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class NativeFunctionDeclaration : public FunctionDeclaration { >+public: >+ NativeFunctionDeclaration(Lexer::Token&& origin, AttributeBlock&& attributeBlock, std::optional<EntryPointType> entryPointType, std::unique_ptr<AST::Type>&& type, String&& name, Parameters&& parameters, std::optional<AST::Semantic>&& semantic, bool restricted) >+ : FunctionDeclaration(WTFMove(origin), WTFMove(attributeBlock), WTFMove(entryPointType), WTFMove(type), WTFMove(name), WTFMove(parameters), WTFMove(semantic)) >+ , m_restricted(restricted) >+ { >+ } >+ >+ virtual ~NativeFunctionDeclaration() = default; >+ >+ NativeFunctionDeclaration(const NativeFunctionDeclaration&) = delete; >+ NativeFunctionDeclaration(NativeFunctionDeclaration&&) = default; >+ >+ bool restricted() const { return m_restricted; } >+ >+private: >+ bool m_restricted; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTNativeTypeDeclaration.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTNativeTypeDeclaration.h >new file mode 100644 >index 00000000000..83f954393c5 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTNativeTypeDeclaration.h >@@ -0,0 +1,73 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTType.h" >+#include "WHLSLASTTypeArgument.h" >+#include "WHLSLLexer.h" >+#include <wtf/text/WTFString.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class NativeTypeDeclaration : public Type { >+public: >+ NativeTypeDeclaration(Lexer::Token&& origin, String&& name, TypeArguments&& typeArguments) >+ : m_origin(WTFMove(origin)) >+ , m_name(WTFMove(name)) >+ , m_typeArguments(WTFMove(typeArguments)) >+ { >+ } >+ >+ virtual ~NativeTypeDeclaration() = default; >+ >+ NativeTypeDeclaration(const NativeTypeDeclaration&) = delete; >+ NativeTypeDeclaration(NativeTypeDeclaration&&) = default; >+ >+ std::unique_ptr<Type> clone() const override >+ { >+ ASSERT_NOT_REACHED(); >+ return nullptr; >+ } >+ >+private: >+ Lexer::Token m_origin; >+ String m_name; >+ TypeArguments m_typeArguments; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTNode.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTNode.h >new file mode 100644 >index 00000000000..f6c4f0060c0 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTNode.h >@@ -0,0 +1,54 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class Node { >+public: >+ Node() = default; >+ >+ virtual ~Node() = default; >+ >+ explicit Node(const Node&) = default; >+ Node(Node&&) = default; >+ >+private: >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTNullLiteral.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTNullLiteral.h >new file mode 100644 >index 00000000000..5ba7f687e83 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTNullLiteral.h >@@ -0,0 +1,60 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTExpression.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class NullLiteral : public Expression { >+public: >+ NullLiteral(Lexer::Token&& origin) >+ : Expression(WTFMove(origin)) >+ { >+ } >+ >+ virtual ~NullLiteral() = default; >+ >+ explicit NullLiteral(const NullLiteral&) = default; >+ NullLiteral(NullLiteral&&) = default; >+ >+private: >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTNumThreadsFunctionAttribute.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTNumThreadsFunctionAttribute.h >new file mode 100644 >index 00000000000..eb1681d22a6 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTNumThreadsFunctionAttribute.h >@@ -0,0 +1,69 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTBaseFunctionAttribute.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class NumThreadsFunctionAttribute : public BaseFunctionAttribute { >+public: >+ NumThreadsFunctionAttribute(Lexer::Token&& origin, unsigned width, unsigned height, unsigned depth) >+ : BaseFunctionAttribute(WTFMove(origin)) >+ , m_width(width) >+ , m_height(height) >+ , m_depth(depth) >+ { >+ } >+ >+ virtual ~NumThreadsFunctionAttribute() = default; >+ >+ NumThreadsFunctionAttribute(const NumThreadsFunctionAttribute&) = delete; >+ NumThreadsFunctionAttribute(NumThreadsFunctionAttribute&&) = default; >+ >+ unsigned width() const { return m_width; } >+ unsigned height() const { return m_height; } >+ unsigned depth() const { return m_depth; } >+ >+private: >+ unsigned m_width; >+ unsigned m_height; >+ unsigned m_depth; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTParameter.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTParameter.h >new file mode 100644 >index 00000000000..6b919fa5753 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTParameter.h >@@ -0,0 +1,76 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTQualifier.h" >+#include "WHLSLASTSemantic.h" >+#include "WHLSLASTType.h" >+#include "WHLSLASTValue.h" >+#include "WHLSLLexer.h" >+#include <wtf/Vector.h> >+#include <wtf/text/WTFString.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class Parameter : public Value { >+public: >+ Parameter(Lexer::Token&& origin, Qualifiers&& qualifiers, std::unique_ptr<AST::Type>&& type, std::optional<String>&& name, std::optional<AST::Semantic>&& semantic) >+ : m_origin(WTFMove(origin)) >+ , m_qualifiers(WTFMove(qualifiers)) >+ , m_type(WTFMove(type)) >+ , m_name(WTFMove(name)) >+ , m_semantic(WTFMove(semantic)) >+ { >+ } >+ >+ virtual ~Parameter() = default; >+ >+ Parameter(const Parameter&) = delete; >+ Parameter(Parameter&&) = default; >+ >+private: >+ Lexer::Token m_origin; >+ Qualifiers m_qualifiers; >+ std::unique_ptr<AST::Type> m_type; >+ std::optional<String> m_name; >+ std::optional<AST::Semantic> m_semantic; >+}; >+ >+typedef Vector<Parameter> Parameters; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTPointerType.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTPointerType.h >new file mode 100644 >index 00000000000..4d4bf5cacf5 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTPointerType.h >@@ -0,0 +1,66 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTReferenceType.h" >+#include "WHLSLLexer.h" >+#include <wtf/text/WTFString.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class PointerType : public ReferenceType { >+public: >+ PointerType(Lexer::Token&& origin, String&& addressSpace, std::unique_ptr<Type> elementType) >+ : ReferenceType(WTFMove(origin), WTFMove(addressSpace), WTFMove(elementType)) >+ { >+ } >+ >+ virtual ~PointerType() = default; >+ >+ PointerType(const PointerType&) = delete; >+ PointerType(PointerType&&) = default; >+ >+ std::unique_ptr<Type> clone() const override >+ { >+ return std::make_unique<PointerType>(Lexer::Token(origin()), String(addressSpace()), elementType()->clone()); >+ } >+ >+private: >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTPropertyAccessExpression.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTPropertyAccessExpression.h >new file mode 100644 >index 00000000000..f12b3b28a21 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTPropertyAccessExpression.h >@@ -0,0 +1,62 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTExpression.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class PropertyAccessExpression : public Expression { >+public: >+ PropertyAccessExpression(Lexer::Token&& origin, std::unique_ptr<Expression>&& base) >+ : Expression(WTFMove(origin)) >+ , m_base(WTFMove(base)) >+ { >+ } >+ >+ virtual ~PropertyAccessExpression() = default; >+ >+ PropertyAccessExpression(const PropertyAccessExpression&) = delete; >+ PropertyAccessExpression(PropertyAccessExpression&&) = default; >+ >+private: >+ std::unique_ptr<Expression> m_base; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTQualifier.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTQualifier.h >new file mode 100644 >index 00000000000..57fda540729 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTQualifier.h >@@ -0,0 +1,57 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTType.h" >+#include "WHLSLLexer.h" >+#include <wtf/Vector.h> >+#include <wtf/text/WTFString.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+enum class Qualifier { >+ Nointerpolation, >+ Noperspective, >+ Uniform, >+ Centroid, >+ Sample >+}; >+ >+typedef Vector<Qualifier> Qualifiers; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTReadModifyWriteExpression.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTReadModifyWriteExpression.h >new file mode 100644 >index 00000000000..3f27e6a3c2c >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTReadModifyWriteExpression.h >@@ -0,0 +1,101 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTAnonymousVariableDeclaration.h" >+#include "WHLSLASTExpression.h" >+#include "WHLSLASTVariableReference.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+/* >+ * 1. Evaluate m_lValue >+ * 2. Assign the result to m_oldValue >+ * 3. Evaluate m_newValueExpression >+ * 4. Assign the result to m_newValue >+ * 5. Assign the result to m_lValue >+ * 6. Evaluate m_resultExpression >+ * 7. Return the result >+ */ >+class ReadModifyWriteExpression : public Expression { >+public: >+ ReadModifyWriteExpression(Lexer::Token&& origin, std::unique_ptr<Expression> lValue) >+ : Expression(Lexer::Token(origin)) >+ , m_lValue(WTFMove(lValue)) >+ , m_oldValue(Lexer::Token(origin)) >+ , m_newValue(WTFMove(origin)) >+ { >+ } >+ >+ virtual ~ReadModifyWriteExpression() = default; >+ >+ ReadModifyWriteExpression(const ReadModifyWriteExpression&) = delete; >+ ReadModifyWriteExpression(ReadModifyWriteExpression&&) = default; >+ >+ void setNewValueExpression(std::unique_ptr<Expression>&& newValueExpression) >+ { >+ m_newValueExpression = WTFMove(newValueExpression); >+ } >+ >+ void setResultExpression(std::unique_ptr<Expression>&& resultExpression) >+ { >+ m_resultExpression = WTFMove(resultExpression); >+ } >+ >+ std::unique_ptr<VariableReference> oldVariableReference() >+ { >+ // The only reason we don't get use-after-frees is the fact that every instance of ReadModifyWriteExpression is allocated on the heap. >+ return std::make_unique<VariableReference>(VariableReference::wrap(m_oldValue)); >+ } >+ >+ std::unique_ptr<VariableReference> newVariableReference() >+ { >+ // The only reason we don't get use-after-frees is the fact that every instance of ReadModifyWriteExpression is allocated on the heap. >+ return std::make_unique<VariableReference>(VariableReference::wrap(m_newValue)); >+ } >+ >+private: >+ std::unique_ptr<Expression> m_lValue; >+ AnonymousVariableDeclaration m_oldValue; >+ AnonymousVariableDeclaration m_newValue; >+ std::unique_ptr<Expression> m_newValueExpression; >+ std::unique_ptr<Expression> m_resultExpression; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTReferenceType.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTReferenceType.h >new file mode 100644 >index 00000000000..701bbb1ba57 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTReferenceType.h >@@ -0,0 +1,71 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTType.h" >+#include "WHLSLLexer.h" >+#include <wtf/text/WTFString.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class ReferenceType : public Type { >+public: >+ ReferenceType(Lexer::Token&& origin, String&& addressSpace, std::unique_ptr<Type>&& elementType) >+ : m_origin(WTFMove(origin)) >+ , m_addressSpace(WTFMove(addressSpace)) >+ , m_elementType(WTFMove(elementType)) >+ { >+ } >+ >+ virtual ~ReferenceType() = default; >+ >+ ReferenceType(const ReferenceType&) = delete; >+ ReferenceType(ReferenceType&&) = default; >+ >+protected: >+ const Lexer::Token& origin() const { return m_origin; } >+ const String& addressSpace() const { return m_addressSpace; } >+ const std::unique_ptr<Type>& elementType() const { return m_elementType; } >+ >+private: >+ Lexer::Token m_origin; >+ String m_addressSpace; >+ std::unique_ptr<Type> m_elementType; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTResourceSemantic.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTResourceSemantic.h >new file mode 100644 >index 00000000000..811cece3486 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTResourceSemantic.h >@@ -0,0 +1,77 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTBaseSemantic.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class ResourceSemantic : public BaseSemantic { >+public: >+ enum class Mode { >+ UnorderedAccessView, >+ Texture, >+ Buffer, >+ Sampler >+ }; >+ >+ ResourceSemantic(Lexer::Token&& origin, Mode mode, unsigned index, unsigned space) >+ : BaseSemantic(WTFMove(origin)) >+ , m_mode(mode) >+ , m_index(index) >+ , m_space(space) >+ { >+ } >+ >+ virtual ~ResourceSemantic() = default; >+ >+ ResourceSemantic(const ResourceSemantic&) = delete; >+ ResourceSemantic(ResourceSemantic&&) = default; >+ >+ Mode mode() const { return m_mode; } >+ unsigned index() const { return m_index; } >+ unsigned space() const { return m_space; } >+ >+private: >+ Mode m_mode; >+ unsigned m_index; >+ unsigned m_space; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTReturn.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTReturn.h >new file mode 100644 >index 00000000000..10d786fcec6 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTReturn.h >@@ -0,0 +1,63 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTExpression.h" >+#include "WHLSLASTStatement.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class Return : public Statement { >+public: >+ Return(Lexer::Token&& origin, std::unique_ptr<Expression>&& value) >+ : Statement(WTFMove(origin)) >+ , m_value(WTFMove(value)) >+ { >+ } >+ >+ virtual ~Return() = default; >+ >+ Return(const Return&) = delete; >+ Return(Return&&) = default; >+ >+private: >+ std::unique_ptr<Expression> m_value; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTSemantic.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTSemantic.h >new file mode 100644 >index 00000000000..67c0f9ca97c >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTSemantic.h >@@ -0,0 +1,50 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTBuiltInSemantic.h" >+#include "WHLSLASTResourceSemantic.h" >+#include "WHLSLASTSpecializationConstantSemantic.h" >+#include "WHLSLASTStageInOutSemantic.h" >+#include <wtf/Variant.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+typedef Variant<BuiltInSemantic, ResourceSemantic, SpecializationConstantSemantic, StageInOutSemantic> Semantic; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTSpecializationConstantSemantic.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTSpecializationConstantSemantic.h >new file mode 100644 >index 00000000000..07d9498c55f >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTSpecializationConstantSemantic.h >@@ -0,0 +1,60 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTBaseSemantic.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class SpecializationConstantSemantic : public BaseSemantic { >+public: >+ SpecializationConstantSemantic(Lexer::Token&& origin) >+ : BaseSemantic(WTFMove(origin)) >+ { >+ } >+ >+ virtual ~SpecializationConstantSemantic() = default; >+ >+ SpecializationConstantSemantic(const SpecializationConstantSemantic&) = delete; >+ SpecializationConstantSemantic(SpecializationConstantSemantic&&) = default; >+ >+private: >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTStageInOutSemantic.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTStageInOutSemantic.h >new file mode 100644 >index 00000000000..5be924a7309 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTStageInOutSemantic.h >@@ -0,0 +1,64 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTBaseSemantic.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class StageInOutSemantic : public BaseSemantic { >+public: >+ StageInOutSemantic(Lexer::Token&& origin, unsigned index) >+ : BaseSemantic(WTFMove(origin)) >+ , m_index(index) >+ { >+ } >+ >+ virtual ~StageInOutSemantic() = default; >+ >+ StageInOutSemantic(const StageInOutSemantic&) = delete; >+ StageInOutSemantic(StageInOutSemantic&&) = default; >+ >+ unsigned index() const { return m_index; } >+ >+private: >+ unsigned m_index; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTStatement.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTStatement.h >new file mode 100644 >index 00000000000..2686edff4d6 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTStatement.h >@@ -0,0 +1,61 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTValue.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class Statement : public Value { >+public: >+ Statement(Lexer::Token&& origin) >+ : m_origin(WTFMove(origin)) >+ { >+ } >+ >+ virtual ~Statement() = default; >+ >+ Statement(const Statement&) = delete; >+ Statement(Statement&&) = default; >+ >+private: >+ Lexer::Token m_origin; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTStructureDefinition.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTStructureDefinition.h >new file mode 100644 >index 00000000000..0a8f4a4cc3b >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTStructureDefinition.h >@@ -0,0 +1,74 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTStructureElement.h" >+#include "WHLSLASTType.h" >+#include "WHLSLLexer.h" >+#include <wtf/Vector.h> >+#include <wtf/text/WTFString.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class StructureDefinition : public Type { >+public: >+ StructureDefinition(Lexer::Token&& origin, String&& name, StructureElements&& structureElements) >+ : m_origin(WTFMove(origin)) >+ , m_name(WTFMove(name)) >+ , m_structureElements(WTFMove(structureElements)) >+ { >+ } >+ >+ virtual ~StructureDefinition() = default; >+ >+ StructureDefinition(const StructureDefinition&) = delete; >+ StructureDefinition(StructureDefinition&&) = default; >+ >+ std::unique_ptr<Type> clone() const override >+ { >+ ASSERT_NOT_REACHED(); >+ return nullptr; >+ } >+ >+private: >+ Lexer::Token m_origin; >+ String m_name; >+ StructureElements m_structureElements; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTStructureElement.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTStructureElement.h >new file mode 100644 >index 00000000000..fc59990f120 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTStructureElement.h >@@ -0,0 +1,74 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTNode.h" >+#include "WHLSLASTQualifier.h" >+#include "WHLSLASTSemantic.h" >+#include "WHLSLASTType.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class StructureElement : public Node { >+public: >+ StructureElement(Lexer::Token&& origin, Qualifiers&& qualifiers, std::unique_ptr<Type>&& type, String&& name, std::optional<Semantic> semantic) >+ : m_origin(WTFMove(origin)) >+ , m_qualifiers(WTFMove(qualifiers)) >+ , m_type(WTFMove(type)) >+ , m_name(WTFMove(name)) >+ , m_semantic(WTFMove(semantic)) >+ { >+ } >+ >+ virtual ~StructureElement() = default; >+ >+ StructureElement(const StructureElement&) = delete; >+ StructureElement(StructureElement&&) = default; >+ >+private: >+ Lexer::Token m_origin; >+ Qualifiers m_qualifiers; >+ std::unique_ptr<Type> m_type; >+ String m_name; >+ std::optional<Semantic> m_semantic; >+}; >+ >+typedef Vector<StructureElement> StructureElements; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTSwitchCase.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTSwitchCase.h >new file mode 100644 >index 00000000000..b44d0ecf74e >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTSwitchCase.h >@@ -0,0 +1,67 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTBlock.h" >+#include "WHLSLASTConstantExpression.h" >+#include "WHLSLASTStatement.h" >+#include "WHLSLLexer.h" >+#include <wtf/Optional.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class SwitchCase : public Statement { >+public: >+ SwitchCase(Lexer::Token&& origin, std::optional<ConstantExpression>&& value, Block&& block) >+ : Statement(WTFMove(origin)) >+ , m_value(WTFMove(value)) >+ , m_block(WTFMove(block)) >+ { >+ } >+ >+ virtual ~SwitchCase() = default; >+ >+ SwitchCase(const SwitchCase&) = delete; >+ SwitchCase(SwitchCase&&) = default; >+ >+private: >+ std::optional<ConstantExpression> m_value; >+ Block m_block; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTSwitchStatement.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTSwitchStatement.h >new file mode 100644 >index 00000000000..736ef116848 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTSwitchStatement.h >@@ -0,0 +1,66 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTExpression.h" >+#include "WHLSLASTStatement.h" >+#include "WHLSLASTSwitchCase.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class SwitchStatement : public Statement { >+public: >+ SwitchStatement(Lexer::Token&& origin, std::unique_ptr<Expression>&& value, Vector<SwitchCase>&& switchCases) >+ : Statement(WTFMove(origin)) >+ , m_value(WTFMove(value)) >+ , m_switchCases(WTFMove(switchCases)) >+ { >+ } >+ >+ virtual ~SwitchStatement() = default; >+ >+ SwitchStatement(const SwitchStatement&) = delete; >+ SwitchStatement(SwitchStatement&&) = default; >+ >+private: >+ std::unique_ptr<Expression> m_value; >+ Vector<SwitchCase> m_switchCases; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTTernaryExpression.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTTernaryExpression.h >new file mode 100644 >index 00000000000..cbfb5968a6d >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTTernaryExpression.h >@@ -0,0 +1,66 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTExpression.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class TernaryExpression : public Expression { >+public: >+ TernaryExpression(Lexer::Token&& origin, std::unique_ptr<Expression>&& predicate, std::unique_ptr<Expression>&& bodyExpression, std::unique_ptr<Expression>&& elseExpression) >+ : Expression(WTFMove(origin)) >+ , m_predicate(WTFMove(predicate)) >+ , m_bodyExpression(WTFMove(bodyExpression)) >+ , m_elseExpression(WTFMove(elseExpression)) >+ { >+ } >+ >+ virtual ~TernaryExpression() = default; >+ >+ TernaryExpression(const TernaryExpression&) = delete; >+ TernaryExpression(TernaryExpression&&) = default; >+ >+private: >+ std::unique_ptr<Expression> m_predicate; >+ std::unique_ptr<Expression> m_bodyExpression; >+ std::unique_ptr<Expression> m_elseExpression; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTTrap.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTTrap.h >new file mode 100644 >index 00000000000..577714b2596 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTTrap.h >@@ -0,0 +1,60 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTStatement.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class Trap : public Statement { >+public: >+ Trap(Lexer::Token&& origin) >+ : Statement(WTFMove(origin)) >+ { >+ } >+ >+ virtual ~Trap() = default; >+ >+ Trap(const Trap&) = delete; >+ Trap(Trap&&) = default; >+ >+private: >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTType.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTType.h >new file mode 100644 >index 00000000000..df6ecec669b >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTType.h >@@ -0,0 +1,58 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTNode.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class Type : public Node { >+public: >+ Type() = default; >+ >+ virtual ~Type() = default; >+ >+ Type(const Type&) = delete; >+ Type(Type&&) = default; >+ >+ virtual std::unique_ptr<Type> clone() const = 0; >+ >+private: >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTTypeArgument.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTTypeArgument.h >new file mode 100644 >index 00000000000..a416896ad4a >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTTypeArgument.h >@@ -0,0 +1,51 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTConstantExpression.h" >+#include "WHLSLLexer.h" >+#include <wtf/Variant.h> >+#include <wtf/Vector.h> >+#include <wtf/text/StringView.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+typedef Variant<ConstantExpression, String> TypeArgument; >+typedef Vector<TypeArgument> TypeArguments; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTTypeDefinition.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTTypeDefinition.h >new file mode 100644 >index 00000000000..f72c6b6a03d >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTTypeDefinition.h >@@ -0,0 +1,73 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTNode.h" >+#include "WHLSLASTType.h" >+#include "WHLSLLexer.h" >+#include <wtf/text/WTFString.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class TypeDefinition : public Type { >+public: >+ TypeDefinition(Lexer::Token&& origin, String&& name, std::unique_ptr<AST::Type>&& type) >+ : m_origin(WTFMove(origin)) >+ , m_name(WTFMove(name)) >+ , m_type(WTFMove(type)) >+ { >+ } >+ >+ virtual ~TypeDefinition() = default; >+ >+ TypeDefinition(const TypeDefinition&) = delete; >+ TypeDefinition(TypeDefinition&&) = default; >+ >+ std::unique_ptr<Type> clone() const override >+ { >+ ASSERT_NOT_REACHED(); >+ return nullptr; >+ } >+ >+private: >+ Lexer::Token m_origin; >+ String m_name; >+ std::unique_ptr<AST::Type> m_type; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTTypeReference.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTTypeReference.h >new file mode 100644 >index 00000000000..6bbab389950 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTTypeReference.h >@@ -0,0 +1,72 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTType.h" >+#include "WHLSLASTTypeArgument.h" >+#include "WHLSLLexer.h" >+#include <wtf/text/WTFString.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class TypeReference : public Type { >+public: >+ TypeReference(Lexer::Token&& origin, String&& name, TypeArguments&& typeArguments) >+ : m_origin(WTFMove(origin)) >+ , m_name(WTFMove(name)) >+ , m_typeArguments(WTFMove(typeArguments)) >+ { >+ } >+ >+ virtual ~TypeReference() = default; >+ >+ TypeReference(const TypeReference&) = delete; >+ TypeReference(TypeReference&&) = default; >+ >+ std::unique_ptr<Type> clone() const override >+ { >+ return std::make_unique<TypeReference>(Lexer::Token(m_origin), String(m_name), TypeArguments(m_typeArguments)); >+ } >+ >+private: >+ Lexer::Token m_origin; >+ String m_name; >+ TypeArguments m_typeArguments; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTUnsignedIntegerLiteral.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTUnsignedIntegerLiteral.h >new file mode 100644 >index 00000000000..67b9c22793a >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTUnsignedIntegerLiteral.h >@@ -0,0 +1,64 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTExpression.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class UnsignedIntegerLiteral : public Expression { >+public: >+ UnsignedIntegerLiteral(Lexer::Token&& origin, unsigned value) >+ : Expression(WTFMove(origin)) >+ , m_value(value) >+ { >+ } >+ >+ virtual ~UnsignedIntegerLiteral() = default; >+ >+ explicit UnsignedIntegerLiteral(const UnsignedIntegerLiteral&) = default; >+ UnsignedIntegerLiteral(UnsignedIntegerLiteral&&) = default; >+ >+ unsigned value() const { return m_value; } >+ >+private: >+ unsigned m_value; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTValue.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTValue.h >new file mode 100644 >index 00000000000..bc7067eff72 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTValue.h >@@ -0,0 +1,58 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTNode.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class Value : public Node { >+public: >+ Value() >+ { >+ } >+ >+ virtual ~Value() = default; >+ >+ explicit Value(const Value&) = default; >+ Value(Value&&) = default; >+ >+private: >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTVariableDeclaration.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTVariableDeclaration.h >new file mode 100644 >index 00000000000..1a9c81ace34 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTVariableDeclaration.h >@@ -0,0 +1,79 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTExpression.h" >+#include "WHLSLASTQualifier.h" >+#include "WHLSLASTSemantic.h" >+#include "WHLSLASTType.h" >+#include "WHLSLASTValue.h" >+#include "WHLSLLexer.h" >+#include <wtf/Vector.h> >+#include <wtf/text/WTFString.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class VariableDeclaration : public Value { >+public: >+ VariableDeclaration(Lexer::Token&& origin, Qualifiers&& qualifiers, std::unique_ptr<AST::Type>&& type, String&& name, std::optional<Semantic>&& semantic, std::unique_ptr<Expression>&& initializer) >+ : m_origin(WTFMove(origin)) >+ , m_qualifiers(WTFMove(qualifiers)) >+ , m_type(WTFMove(type)) >+ , m_name(WTFMove(name)) >+ , m_semantic(WTFMove(semantic)) >+ , m_initializer(WTFMove(initializer)) >+ { >+ } >+ >+ virtual ~VariableDeclaration() = default; >+ >+ VariableDeclaration(const VariableDeclaration&) = delete; >+ VariableDeclaration(VariableDeclaration&&) = default; >+ >+ Lexer::Token origin() const { return m_origin; } >+ >+private: >+ Lexer::Token m_origin; >+ Qualifiers m_qualifiers; >+ std::unique_ptr<AST::Type> m_type; >+ String m_name; >+ std::optional<Semantic> m_semantic; >+ std::unique_ptr<Expression> m_initializer; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTVariableDeclarationsStatement.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTVariableDeclarationsStatement.h >new file mode 100644 >index 00000000000..30be3f45b98 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTVariableDeclarationsStatement.h >@@ -0,0 +1,64 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTStatement.h" >+#include "WHLSLASTVariableDeclaration.h" >+#include "WHLSLLexer.h" >+#include <wtf/Vector.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class VariableDeclarationsStatement : public Statement { >+public: >+ VariableDeclarationsStatement(Lexer::Token&& origin, Vector<VariableDeclaration>&& variableDeclarations) >+ : Statement(WTFMove(origin)) >+ , m_variableDeclarations(WTFMove(variableDeclarations)) >+ { >+ } >+ >+ virtual ~VariableDeclarationsStatement() = default; >+ >+ VariableDeclarationsStatement(const VariableDeclarationsStatement&) = delete; >+ VariableDeclarationsStatement(VariableDeclarationsStatement&&) = default; >+ >+private: >+ Vector<VariableDeclaration>&& m_variableDeclarations; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTVariableReference.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTVariableReference.h >new file mode 100644 >index 00000000000..33b6fc61d5f >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTVariableReference.h >@@ -0,0 +1,85 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTAnonymousVariableDeclaration.h" >+#include "WHLSLASTExpression.h" >+#include "WHLSLASTVariableDeclaration.h" >+#include "WHLSLLexer.h" >+#include <wtf/text/WTFString.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class VariableReference : public Expression { >+public: >+ VariableReference(Lexer::Token&& origin, String&& name) >+ : Expression(WTFMove(origin)) >+ , m_name(WTFMove(name)) >+ { >+ } >+ >+ virtual ~VariableReference() = default; >+ >+ VariableReference(const VariableReference&) = delete; >+ VariableReference(VariableReference&&) = default; >+ >+ static VariableReference wrap(VariableDeclaration& variableDeclaration) >+ { >+ VariableReference result(Lexer::Token(variableDeclaration.origin())); >+ result.m_variable = { &variableDeclaration }; >+ return result; >+ } >+ >+ static VariableReference wrap(AnonymousVariableDeclaration& anonymousVariableDeclaration) >+ { >+ VariableReference result(Lexer::Token(anonymousVariableDeclaration.origin())); >+ result.m_variable = { &anonymousVariableDeclaration }; >+ return result; >+ } >+ >+private: >+ VariableReference(Lexer::Token&& origin) >+ : Expression(WTFMove(origin)) >+ { >+ } >+ >+ String m_name; >+ std::optional<Variant<VariableDeclaration*, AnonymousVariableDeclaration*>> m_variable; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTWhileLoop.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTWhileLoop.h >new file mode 100644 >index 00000000000..8aea2c1b2d9 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLASTWhileLoop.h >@@ -0,0 +1,65 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTExpression.h" >+#include "WHLSLASTStatement.h" >+#include "WHLSLLexer.h" >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+namespace AST { >+ >+class WhileLoop : public Statement { >+public: >+ WhileLoop(Lexer::Token&& origin, std::unique_ptr<Expression>&& conditional, std::unique_ptr<Statement>&& body) >+ : Statement(WTFMove(origin)) >+ , m_conditional(WTFMove(conditional)) >+ , m_body(WTFMove(body)) >+ { >+ } >+ >+ virtual ~WhileLoop() = default; >+ >+ WhileLoop(const WhileLoop&) = delete; >+ WhileLoop(WhileLoop&&) = default; >+ >+private: >+ std::unique_ptr<Expression> m_conditional; >+ std::unique_ptr<Statement> m_body; >+}; >+ >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLLexer.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLLexer.cpp >new file mode 100644 >index 00000000000..15bccf38fea >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLLexer.cpp >@@ -0,0 +1,830 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "config.h" >+#include "WHLSLLexer.h" >+ >+#include <wtf/Optional.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+const char* Lexer::Token::typeName(Type type) >+{ >+ switch (type) { >+ case Type::IntLiteral: >+ return "int literal"; >+ case Type::UintLiteral: >+ return "uint literal"; >+ case Type::FloatLiteral: >+ return "float literal"; >+ case Type::Struct: >+ return "struct"; >+ case Type::Typedef: >+ return "typedef"; >+ case Type::Enum: >+ return "enum"; >+ case Type::Operator: >+ return "operator"; >+ case Type::If: >+ return "if"; >+ case Type::Else: >+ return "else"; >+ case Type::Continue: >+ return "continue"; >+ case Type::Break: >+ return "break"; >+ case Type::Switch: >+ return "switch"; >+ case Type::Case: >+ return "case"; >+ case Type::Default: >+ return "default"; >+ case Type::Fallthrough: >+ return "fallthrough"; >+ case Type::For: >+ return "for"; >+ case Type::While: >+ return "while"; >+ case Type::Do: >+ return "do"; >+ case Type::Return: >+ return "return"; >+ case Type::Trap: >+ return "trap"; >+ case Type::Null: >+ return "null"; >+ case Type::True: >+ return "true"; >+ case Type::False: >+ return "false"; >+ case Type::Constant: >+ return "constant"; >+ case Type::Device: >+ return "device"; >+ case Type::Threadgroup: >+ return "threadgroup"; >+ case Type::Thread: >+ return "thread"; >+ case Type::Space: >+ return "space"; >+ case Type::Vertex: >+ return "vertex"; >+ case Type::Fragment: >+ return "fragment"; >+ case Type::Compute: >+ return "compute"; >+ case Type::NumThreads: >+ return "numthreads"; >+ case Type::SVInstanceID: >+ return "SV_InstanceID"; >+ case Type::SVVertexID: >+ return "SV_VertexID"; >+ case Type::PSize: >+ return "PSIZE"; >+ case Type::SVPosition: >+ return "SV_Position"; >+ case Type::SVIsFrontFace: >+ return "SV_IsFrontFace"; >+ case Type::SVSampleIndex: >+ return "SV_SampleIndex"; >+ case Type::SVInnerCoverage: >+ return "SV_InnerCoverage"; >+ case Type::SVTarget: >+ return "SV_Target"; >+ case Type::SVDepth: >+ return "SV_Depth"; >+ case Type::SVCoverage: >+ return "SV_Coverage"; >+ case Type::SVDispatchThreadID: >+ return "SV_DispatchThreadID"; >+ case Type::SVGroupID: >+ return "SV_GroupID"; >+ case Type::SVGroupIndex: >+ return "SV_GroupIndex"; >+ case Type::SVGroupThreadID: >+ return "SV_GroupThreadID"; >+ case Type::Attribute: >+ return "SV_Attribute"; >+ case Type::Register: >+ return "register"; >+ case Type::Specialized: >+ return "specialized"; >+ case Type::Native: >+ return "native"; >+ case Type::Restricted: >+ return "restricted"; >+ case Type::Underscore: >+ return "_"; >+ case Type::Auto: >+ return "auto"; >+ case Type::Protocol: >+ return "protocol"; >+ case Type::Const: >+ return "const"; >+ case Type::Static: >+ return "static"; >+ case Type::Qualifier: >+ return "qualifier"; >+ case Type::Identifier: >+ return "identifier"; >+ case Type::OperatorName: >+ return "operator name"; >+ case Type::EqualsSign: >+ return "="; >+ case Type::Semicolon: >+ return ";"; >+ case Type::LeftCurlyBracket: >+ return "{"; >+ case Type::RightCurlyBracket: >+ return "}"; >+ case Type::Colon: >+ return ":"; >+ case Type::Comma: >+ return ","; >+ case Type::LeftParenthesis: >+ return "("; >+ case Type::RightParenthesis: >+ return ")"; >+ case Type::SquareBracketPair: >+ return "[]"; >+ case Type::LeftSquareBracket: >+ return "["; >+ case Type::RightSquareBracket: >+ return "]"; >+ case Type::Star: >+ return "*"; >+ case Type::LessThanSign: >+ return "<"; >+ case Type::GreaterThanSign: >+ return ">"; >+ case Type::FullStop: >+ return "."; >+ case Type::PlusEquals: >+ return "+="; >+ case Type::MinusEquals: >+ return "-="; >+ case Type::TimesEquals: >+ return "*="; >+ case Type::DivideEquals: >+ return "/="; >+ case Type::ModEquals: >+ return "%="; >+ case Type::XorEquals: >+ return "^="; >+ case Type::AndEquals: >+ return "&="; >+ case Type::OrEquals: >+ return "|="; >+ case Type::RightShiftEquals: >+ return ">>="; >+ case Type::LeftShiftEquals: >+ return "<<="; >+ case Type::PlusPlus: >+ return "++"; >+ case Type::MinusMinus: >+ return "--"; >+ case Type::Arrow: >+ return "->"; >+ case Type::QuestionMark: >+ return "?"; >+ case Type::OrOr: >+ return "||"; >+ case Type::AndAnd: >+ return "&&"; >+ case Type::Or: >+ return "|"; >+ case Type::Xor: >+ return "^"; >+ case Type::And: >+ return "&"; >+ case Type::LessThanOrEqualTo: >+ return "<="; >+ case Type::GreaterThanOrEqualTo: >+ return ">="; >+ case Type::EqualComparison: >+ return "=="; >+ case Type::NotEqual: >+ return "!="; >+ case Type::RightShift: >+ return ">>"; >+ case Type::LeftShift: >+ return "<<"; >+ case Type::Plus: >+ return "+"; >+ case Type::Minus: >+ return "-"; >+ case Type::Divide: >+ return "/"; >+ case Type::Mod: >+ return "%"; >+ case Type::Tilde: >+ return "~"; >+ case Type::ExclamationPoint: >+ return "!"; >+ case Type::At: >+ return "@"; >+ } >+} >+ >+auto Lexer::recognizeKeyword(unsigned end) -> std::optional<Token::Type> >+{ >+ auto substring = m_stringView.substring(m_offset, end - m_offset); >+ if (substring == "struct") >+ return Token::Type::Struct; >+ if (substring == "typedef") >+ return Token::Type::Typedef; >+ if (substring == "enum") >+ return Token::Type::Enum; >+ if (substring == "operator") >+ return Token::Type::Operator; >+ if (substring == "if") >+ return Token::Type::If; >+ if (substring == "else") >+ return Token::Type::Else; >+ if (substring == "continue") >+ return Token::Type::Continue; >+ if (substring == "break") >+ return Token::Type::Break; >+ if (substring == "switch") >+ return Token::Type::Switch; >+ if (substring == "case") >+ return Token::Type::Case; >+ if (substring == "default") >+ return Token::Type::Default; >+ if (substring == "fallthrough") >+ return Token::Type::Fallthrough; >+ if (substring == "for") >+ return Token::Type::For; >+ if (substring == "while") >+ return Token::Type::While; >+ if (substring == "do") >+ return Token::Type::Do; >+ if (substring == "return") >+ return Token::Type::Return; >+ if (substring == "trap") >+ return Token::Type::Trap; >+ if (substring == "null") >+ return Token::Type::Null; >+ if (substring == "true") >+ return Token::Type::True; >+ if (substring == "false") >+ return Token::Type::False; >+ if (substring == "constant") >+ return Token::Type::Constant; >+ if (substring == "device") >+ return Token::Type::Device; >+ if (substring == "threadgroup") >+ return Token::Type::Threadgroup; >+ if (substring == "thread") >+ return Token::Type::Thread; >+ if (substring == "space") >+ return Token::Type::Space; >+ if (substring == "vertex") >+ return Token::Type::Vertex; >+ if (substring == "fragment") >+ return Token::Type::Fragment; >+ if (substring == "compute") >+ return Token::Type::Compute; >+ if (substring == "numthreads") >+ return Token::Type::NumThreads; >+ if (substring == "SV_InstanceID") >+ return Token::Type::SVInstanceID; >+ if (substring == "SV_VertexID") >+ return Token::Type::SVVertexID; >+ if (substring == "PSIZE") >+ return Token::Type::PSize; >+ if (substring == "SV_Position") >+ return Token::Type::SVPosition; >+ if (substring == "SV_IsFrontFace") >+ return Token::Type::SVIsFrontFace; >+ if (substring == "SV_SampleIndex") >+ return Token::Type::SVSampleIndex; >+ if (substring == "SV_InnerCoverage") >+ return Token::Type::SVInnerCoverage; >+ if (substring == "SV_Target") >+ return Token::Type::SVTarget; >+ if (substring == "SV_Depth") >+ return Token::Type::SVDepth; >+ if (substring == "SV_Coverage") >+ return Token::Type::SVCoverage; >+ if (substring == "SV_DispatchThreadID") >+ return Token::Type::SVDispatchThreadID; >+ if (substring == "SV_GroupID") >+ return Token::Type::SVGroupID; >+ if (substring == "SV_GroupIndex") >+ return Token::Type::SVGroupIndex; >+ if (substring == "SV_GroupThreadID") >+ return Token::Type::SVGroupThreadID; >+ if (substring == "attribute") >+ return Token::Type::Attribute; >+ if (substring == "register") >+ return Token::Type::Register; >+ if (substring == "specialized") >+ return Token::Type::Specialized; >+ if (substring == "native") >+ return Token::Type::Native; >+ if (substring == "restricted") >+ return Token::Type::Restricted; >+ if (substring == "_") >+ return Token::Type::Underscore; >+ if (substring == "auto") >+ return Token::Type::Auto; >+ if (substring == "protocol") >+ return Token::Type::Protocol; >+ if (substring == "const") >+ return Token::Type::Const; >+ if (substring == "static") >+ return Token::Type::Static; >+ if (substring == "nointerpolation") >+ return Token::Type::Qualifier; >+ if (substring == "noperspective") >+ return Token::Type::Qualifier; >+ if (substring == "uniform") >+ return Token::Type::Qualifier; >+ if (substring == "centroid") >+ return Token::Type::Qualifier; >+ if (substring == "sample") >+ return Token::Type::Qualifier; >+ return std::nullopt; >+} >+ >+auto Lexer::consumeTokenFromStream() -> std::optional<Token> >+{ >+ auto prepare = [&](unsigned newOffset, Token::Type type) -> std::optional<Token> { >+ auto oldOffset = m_offset; >+ m_offset = newOffset; >+ skipWhitespaceAndComments(); >+ return {{ m_stringView.substring(oldOffset, newOffset - oldOffset), m_lineNumber, type }}; >+ }; >+ >+ if (auto newOffset = floatLiteral(m_offset)) >+ return prepare(*newOffset, Token::Type::FloatLiteral); >+ if (auto newOffset = uintLiteral(m_offset)) >+ return prepare(*newOffset, Token::Type::UintLiteral); >+ if (auto newOffset = intLiteral(m_offset)) >+ return prepare(*newOffset, Token::Type::IntLiteral); >+ if (auto newOffset = operatorName(m_offset)) >+ return prepare(*newOffset, Token::Type::OperatorName); >+ if (auto newOffset = identifier(m_offset)) { >+ if (auto result = recognizeKeyword(*newOffset)) >+ return prepare(*newOffset, *result); >+ return prepare(*newOffset, Token::Type::Identifier); >+ } >+ // Sorted by length, so longer matches are preferable to shorter matches. >+ if (auto newOffset = string(">>=", m_offset)) >+ return prepare(*newOffset, Token::Type::RightShiftEquals); >+ if (auto newOffset = string("<<=", m_offset)) >+ return prepare(*newOffset, Token::Type::LeftShiftEquals); >+ if (auto newOffset = string("+=", m_offset)) >+ return prepare(*newOffset, Token::Type::PlusEquals); >+ if (auto newOffset = string("-=", m_offset)) >+ return prepare(*newOffset, Token::Type::MinusEquals); >+ if (auto newOffset = string("*=", m_offset)) >+ return prepare(*newOffset, Token::Type::TimesEquals); >+ if (auto newOffset = string("/=", m_offset)) >+ return prepare(*newOffset, Token::Type::DivideEquals); >+ if (auto newOffset = string("%=", m_offset)) >+ return prepare(*newOffset, Token::Type::ModEquals); >+ if (auto newOffset = string("^=", m_offset)) >+ return prepare(*newOffset, Token::Type::XorEquals); >+ if (auto newOffset = string("&=", m_offset)) >+ return prepare(*newOffset, Token::Type::AndEquals); >+ if (auto newOffset = string("|=", m_offset)) >+ return prepare(*newOffset, Token::Type::OrEquals); >+ if (auto newOffset = string("++", m_offset)) >+ return prepare(*newOffset, Token::Type::PlusPlus); >+ if (auto newOffset = string("--", m_offset)) >+ return prepare(*newOffset, Token::Type::MinusMinus); >+ if (auto newOffset = string("->", m_offset)) >+ return prepare(*newOffset, Token::Type::Arrow); >+ if (auto newOffset = string("[]", m_offset)) >+ return prepare(*newOffset, Token::Type::SquareBracketPair); >+ if (auto newOffset = string("||", m_offset)) >+ return prepare(*newOffset, Token::Type::OrOr); >+ if (auto newOffset = string("&&", m_offset)) >+ return prepare(*newOffset, Token::Type::AndAnd); >+ if (auto newOffset = string("<=", m_offset)) >+ return prepare(*newOffset, Token::Type::LessThanOrEqualTo); >+ if (auto newOffset = string(">=", m_offset)) >+ return prepare(*newOffset, Token::Type::GreaterThanOrEqualTo); >+ if (auto newOffset = string("==", m_offset)) >+ return prepare(*newOffset, Token::Type::EqualComparison); >+ if (auto newOffset = string("!=", m_offset)) >+ return prepare(*newOffset, Token::Type::NotEqual); >+ if (auto newOffset = string(">>", m_offset)) >+ return prepare(*newOffset, Token::Type::RightShift); >+ if (auto newOffset = string("<<", m_offset)) >+ return prepare(*newOffset, Token::Type::LeftShift); >+ if (auto newOffset = character('=', m_offset)) >+ return prepare(*newOffset, Token::Type::EqualsSign); >+ if (auto newOffset = character(';', m_offset)) >+ return prepare(*newOffset, Token::Type::Semicolon); >+ if (auto newOffset = character('{', m_offset)) >+ return prepare(*newOffset, Token::Type::LeftCurlyBracket); >+ if (auto newOffset = character('}', m_offset)) >+ return prepare(*newOffset, Token::Type::RightCurlyBracket); >+ if (auto newOffset = character(':', m_offset)) >+ return prepare(*newOffset, Token::Type::Colon); >+ if (auto newOffset = character(',', m_offset)) >+ return prepare(*newOffset, Token::Type::Comma); >+ if (auto newOffset = character('(', m_offset)) >+ return prepare(*newOffset, Token::Type::LeftParenthesis); >+ if (auto newOffset = character(')', m_offset)) >+ return prepare(*newOffset, Token::Type::RightParenthesis); >+ if (auto newOffset = character('[', m_offset)) >+ return prepare(*newOffset, Token::Type::LeftSquareBracket); >+ if (auto newOffset = character(']', m_offset)) >+ return prepare(*newOffset, Token::Type::RightSquareBracket); >+ if (auto newOffset = character('*', m_offset)) >+ return prepare(*newOffset, Token::Type::Star); >+ if (auto newOffset = character('<', m_offset)) >+ return prepare(*newOffset, Token::Type::LessThanSign); >+ if (auto newOffset = character('>', m_offset)) >+ return prepare(*newOffset, Token::Type::GreaterThanSign); >+ if (auto newOffset = character('.', m_offset)) >+ return prepare(*newOffset, Token::Type::FullStop); >+ if (auto newOffset = character('?', m_offset)) >+ return prepare(*newOffset, Token::Type::QuestionMark); >+ if (auto newOffset = character('|', m_offset)) >+ return prepare(*newOffset, Token::Type::Or); >+ if (auto newOffset = character('^', m_offset)) >+ return prepare(*newOffset, Token::Type::Xor); >+ if (auto newOffset = character('&', m_offset)) >+ return prepare(*newOffset, Token::Type::And); >+ if (auto newOffset = character('+', m_offset)) >+ return prepare(*newOffset, Token::Type::Plus); >+ if (auto newOffset = character('-', m_offset)) >+ return prepare(*newOffset, Token::Type::Minus); >+ if (auto newOffset = character('/', m_offset)) >+ return prepare(*newOffset, Token::Type::Divide); >+ if (auto newOffset = character('%', m_offset)) >+ return prepare(*newOffset, Token::Type::Mod); >+ if (auto newOffset = character('~', m_offset)) >+ return prepare(*newOffset, Token::Type::Tilde); >+ if (auto newOffset = character('!', m_offset)) >+ return prepare(*newOffset, Token::Type::ExclamationPoint); >+ if (auto newOffset = character('@', m_offset)) >+ return prepare(*newOffset, Token::Type::At); >+ >+ return std::nullopt; >+} >+ >+void Lexer::skipWhitespaceAndComments() >+{ >+ unsigned savedOffset; >+ do { >+ savedOffset = m_offset; >+ skipWhitespace(); >+ skipLineComment(); >+ skipLongComment(); >+ } while (savedOffset != m_offset); >+} >+ >+static inline bool isWhitespace(UChar codeUnit) >+{ >+ switch (codeUnit) { >+ case ' ': >+ case '\t': >+ case '\r': >+ case '\n': >+ return true; >+ default: >+ return false; >+ } >+} >+ >+static inline bool isNewline(UChar codeUnit) >+{ >+ switch (codeUnit) { >+ case '\r': >+ case '\n': >+ return true; >+ default: >+ return false; >+ } >+} >+ >+// We can take advantage of two properties of Unicode: >+// 1. The consitutent UTF-16 code units for all non-BMP code points are surrogates, >+// which means we'll never see a false match. If we see a BMP code unit, we >+// really have a BMP code point. >+// 2. Everything we're looking for is in BMP >+ >+void Lexer::skipWhitespace() >+{ >+ for ( ; m_offset < m_stringView.length() && isWhitespace(m_stringView[m_offset]); ++m_offset) { >+ if (m_stringView[m_offset] == '\r' && m_offset + 1 < m_stringView.length() && m_stringView[m_offset + 1] == '\n') { >+ ++m_offset; >+ ++m_lineNumber; >+ } else if (isNewline(m_stringView[m_offset])) >+ ++m_lineNumber; >+ } >+} >+ >+void Lexer::skipLineComment() >+{ >+ if (m_offset + 1 >= m_stringView.length() || m_stringView[m_offset] != '/' || m_stringView[m_offset + 1] != '/') >+ return; >+ >+ m_offset += 2; >+ for ( ; m_offset < m_stringView.length() && !isNewline(m_stringView[m_offset]); ++m_offset) { } >+} >+ >+void Lexer::skipLongComment() >+{ >+ if (m_offset + 1 >= m_stringView.length() || m_stringView[m_offset] != '/' || m_stringView[m_offset + 1] != '*') >+ return; >+ >+ m_offset += 2; >+ do { >+ for ( ; m_offset < m_stringView.length() && m_stringView[m_offset] != '*'; ++m_offset) { >+ if (m_stringView[m_offset] == '\r' && m_offset + 1 < m_stringView.length() && m_stringView[m_offset + 1] == '\n') { >+ ++m_offset; >+ ++m_lineNumber; >+ } else if (isNewline(m_stringView[m_offset])) >+ ++m_lineNumber; >+ } >+ if (m_offset < m_stringView.length()) >+ ++m_offset; >+ if (m_offset < m_stringView.length() && m_stringView[m_offset] == '/') { >+ ++m_offset; >+ break; >+ } >+ } while (m_offset < m_stringView.length()); >+} >+ >+// Regular expression are unnecessary; we shouldn't need to compile them. >+ >+std::optional<unsigned> Lexer::coreDecimalIntLiteral(unsigned offset) const >+{ >+ if (offset >= m_stringView.length()) >+ return std::nullopt; >+ if (m_stringView[offset] == '0') >+ return offset + 1; >+ if (m_stringView[offset] >= '1' && m_stringView[offset] <= '9') { >+ ++offset; >+ for ( ; offset < m_stringView.length() && m_stringView[offset] >= '0' && m_stringView[offset] <= '9'; ++offset) { >+ } >+ return offset; >+ } >+ return std::nullopt; >+} >+ >+std::optional<unsigned> Lexer::decimalIntLiteral(unsigned offset) const >+{ >+ if (offset < m_stringView.length() && m_stringView[offset] == '-') >+ ++offset; >+ return coreDecimalIntLiteral(offset); >+} >+ >+std::optional<unsigned> Lexer::decimalUintLiteral(unsigned offset) const >+{ >+ auto result = coreDecimalIntLiteral(offset); >+ if (!result) >+ return std::nullopt; >+ if (*result < m_stringView.length() && m_stringView[*result] == 'u') >+ return *result + 1; >+ return std::nullopt; >+} >+ >+static inline bool isHexadecimalCharacter(UChar character) >+{ >+ return (character >= '0' && character <= '9') >+ || (character >= 'a' && character <= 'f') >+ || (character >= 'A' && character <= 'F'); >+} >+ >+std::optional<unsigned> Lexer::coreHexadecimalIntLiteral(unsigned offset) const >+{ >+ if (offset + 1 >= m_stringView.length() || m_stringView[offset] != '0' || m_stringView[offset + 1] != 'x') >+ return std::nullopt; >+ >+ offset += 2; >+ if (offset >= m_stringView.length() || !isHexadecimalCharacter(m_stringView[offset])) >+ return std::nullopt; >+ ++offset; >+ for ( ; offset < m_stringView.length() && isHexadecimalCharacter(m_stringView[offset]); ++offset) { >+ } >+ return offset; >+} >+ >+std::optional<unsigned> Lexer::hexadecimalIntLiteral(unsigned offset) const >+{ >+ if (offset < m_stringView.length() && m_stringView[offset] == '-') >+ ++offset; >+ return coreHexadecimalIntLiteral(offset); >+} >+ >+std::optional<unsigned> Lexer::hexadecimalUintLiteral(unsigned offset) const >+{ >+ auto result = coreHexadecimalIntLiteral(offset); >+ if (!result) >+ return std::nullopt; >+ if (*result < m_stringView.length() && m_stringView[*result] == 'u') >+ return *result + 1; >+ return std::nullopt; >+} >+ >+std::optional<unsigned> Lexer::intLiteral(unsigned offset) const >+{ >+ if (auto result = decimalIntLiteral(offset)) >+ return result; >+ if (auto result = hexadecimalIntLiteral(offset)) >+ return result; >+ return std::nullopt; >+} >+ >+std::optional<unsigned> Lexer::uintLiteral(unsigned offset) const >+{ >+ if (auto result = decimalUintLiteral(offset)) >+ return result; >+ if (auto result = hexadecimalUintLiteral(offset)) >+ return result; >+ return std::nullopt; >+} >+ >+std::optional<unsigned> Lexer::digit(unsigned offset) const >+{ >+ if (offset < m_stringView.length() && m_stringView[offset] >= '0' && m_stringView[offset] <= '9') >+ return offset + 1; >+ return std::nullopt; >+} >+ >+unsigned Lexer::digitStar(unsigned offset) const >+{ >+ while (true) { >+ auto result = digit(offset); >+ if (!result) >+ return offset; >+ offset = *result; >+ } >+} >+ >+std::optional<unsigned> Lexer::character(char character, unsigned offset) const >+{ >+ if (offset < m_stringView.length() && m_stringView[offset] == character) >+ return offset + 1; >+ return std::nullopt; >+} >+ >+std::optional<unsigned> Lexer::coreFloatLiteralType1(unsigned offset) const >+{ >+ auto result = digit(offset); >+ if (!result) >+ return std::nullopt; >+ auto result2 = digitStar(*result); >+ auto result3 = character('.', result2); >+ if (!result3) >+ return std::nullopt; >+ return digitStar(*result3); >+} >+ >+std::optional<unsigned> Lexer::coreFloatLiteral(unsigned offset) const >+{ >+ if (auto type1 = coreFloatLiteralType1(offset)) >+ return type1; >+ auto result = digitStar(offset); >+ auto result2 = character('.', result); >+ if (!result2) >+ return std::nullopt; >+ auto result3 = digit(*result2); >+ if (!result3) >+ return std::nullopt; >+ return digitStar(*result3); >+} >+ >+std::optional<unsigned> Lexer::floatLiteral(unsigned offset) const >+{ >+ if (offset < m_stringView.length() && m_stringView[offset] == '-') >+ ++offset; >+ auto result = coreFloatLiteral(offset); >+ if (!result) >+ return std::nullopt; >+ offset = *result; >+ if (offset < m_stringView.length() && m_stringView[offset] == 'f') >+ ++offset; >+ return offset; >+} >+ >+std::optional<unsigned> Lexer::validIdentifier(unsigned offset) const >+{ >+ if (offset >= m_stringView.length() >+ || !((m_stringView[offset] >= 'a' && m_stringView[offset] <= 'z') >+ || (m_stringView[offset] >= 'A' && m_stringView[offset] <= 'Z') >+ || (m_stringView[offset] == '_'))) >+ return std::nullopt; >+ ++offset; >+ while (true) { >+ if (offset >= m_stringView.length() >+ || !((m_stringView[offset] >= 'a' && m_stringView[offset] <= 'z') >+ || (m_stringView[offset] >= 'A' && m_stringView[offset] <= 'Z') >+ || (m_stringView[offset] >= '0' && m_stringView[offset] <= '9') >+ || (m_stringView[offset] == '_'))) >+ return offset; >+ ++offset; >+ } >+} >+ >+std::optional<unsigned> Lexer::identifier(unsigned offset) const >+{ >+ return validIdentifier(offset); >+} >+ >+std::optional<unsigned> Lexer::operatorName(unsigned offset) const >+{ >+ if (auto result = string("operator&.", offset)) >+ return validIdentifier(*result); >+ if (auto result = string("operator.", offset)) { >+ if ((result = validIdentifier(*result))) { >+ if (auto result2 = character('=', *result)) >+ return result2; >+ return *result; >+ } >+ } >+ if (auto result = string("operator", offset)) { >+ // Sorted by length, so longer matches are preferable to shorter matches. >+ if (auto result2 = string("&[]", *result)) >+ return result2; >+ if (auto result2 = string("[]=", *result)) >+ return result2; >+ if (auto result2 = string(">>", *result)) >+ return result2; >+ if (auto result2 = string("<<", *result)) >+ return result2; >+ if (auto result2 = string("++", *result)) >+ return result2; >+ if (auto result2 = string("--", *result)) >+ return result2; >+ if (auto result2 = string("&&", *result)) >+ return result2; >+ if (auto result2 = string("||", *result)) >+ return result2; >+ if (auto result2 = string(">=", *result)) >+ return result2; >+ if (auto result2 = string("<=", *result)) >+ return result2; >+ if (auto result2 = string("==", *result)) >+ return result2; >+ if (auto result2 = string("[]", *result)) >+ return result2; >+ if (auto result2 = character('+', *result)) >+ return result2; >+ if (auto result2 = character('-', *result)) >+ return result2; >+ if (auto result2 = character('*', *result)) >+ return result2; >+ if (auto result2 = character('/', *result)) >+ return result2; >+ if (auto result2 = character('%', *result)) >+ return result2; >+ if (auto result2 = character('<', *result)) >+ return result2; >+ if (auto result2 = character('>', *result)) >+ return result2; >+ if (auto result2 = character('!', *result)) >+ return result2; >+ if (auto result2 = character('~', *result)) >+ return result2; >+ if (auto result2 = character('&', *result)) >+ return result2; >+ if (auto result2 = character('^', *result)) >+ return result2; >+ if (auto result2 = character('|', *result)) >+ return result2; >+ } >+ return std::nullopt; >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLLexer.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLLexer.h >new file mode 100644 >index 00000000000..f885c825c62 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLLexer.h >@@ -0,0 +1,283 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include <wtf/Optional.h> >+#include <wtf/Vector.h> >+#include <wtf/text/StringView.h> >+#include <wtf/text/WTFString.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+class Lexer { >+public: >+ Lexer() = default; >+ >+ Lexer(StringView stringView) >+ : m_stringView(stringView) >+ { >+ skipWhitespaceAndComments(); >+ } >+ >+ Lexer(const Lexer&) = delete; >+ Lexer(Lexer&&) = default; >+ >+ Lexer& operator=(const Lexer&) = delete; >+ Lexer& operator=(Lexer&&) = default; >+ >+ struct Token { >+ Token() = delete; >+ Token(const Token&) = default; >+ Token(Token&&) = default; >+ Token& operator=(const Token&) = default; >+ Token& operator=(Token&&) = default; >+ >+ StringView stringView; >+ unsigned lineNumber; >+ enum class Type { >+ IntLiteral, >+ UintLiteral, >+ FloatLiteral, >+ Struct, >+ Typedef, >+ Enum, >+ Operator, >+ If, >+ Else, >+ Continue, >+ Break, >+ Switch, >+ Case, >+ Default, >+ Fallthrough, >+ For, >+ While, >+ Do, >+ Return, >+ Trap, >+ Null, >+ True, >+ False, >+ Constant, >+ Device, >+ Threadgroup, >+ Thread, >+ Space, >+ Vertex, >+ Fragment, >+ Compute, >+ NumThreads, >+ SVInstanceID, >+ SVVertexID, >+ PSize, >+ SVPosition, >+ SVIsFrontFace, >+ SVSampleIndex, >+ SVInnerCoverage, >+ SVTarget, >+ SVDepth, >+ SVCoverage, >+ SVDispatchThreadID, >+ SVGroupID, >+ SVGroupIndex, >+ SVGroupThreadID, >+ Attribute, >+ Register, >+ Specialized, >+ Native, >+ Restricted, >+ Underscore, >+ Auto, >+ Protocol, >+ Const, >+ Static, >+ Qualifier, >+ Identifier, >+ OperatorName, >+ EqualsSign, >+ Semicolon, >+ LeftCurlyBracket, >+ RightCurlyBracket, >+ Colon, >+ Comma, >+ LeftParenthesis, >+ RightParenthesis, >+ SquareBracketPair, >+ LeftSquareBracket, >+ RightSquareBracket, >+ Star, >+ LessThanSign, >+ GreaterThanSign, >+ FullStop, >+ PlusEquals, >+ MinusEquals, >+ TimesEquals, >+ DivideEquals, >+ ModEquals, >+ XorEquals, >+ AndEquals, >+ OrEquals, >+ RightShiftEquals, >+ LeftShiftEquals, >+ PlusPlus, >+ MinusMinus, >+ Arrow, >+ QuestionMark, >+ OrOr, >+ AndAnd, >+ Or, >+ Xor, >+ And, >+ LessThanOrEqualTo, >+ GreaterThanOrEqualTo, >+ EqualComparison, >+ NotEqual, >+ RightShift, >+ LeftShift, >+ Plus, >+ Minus, >+ Divide, >+ Mod, >+ Tilde, >+ ExclamationPoint, >+ At, >+ } type; >+ >+ static const char* typeName(Type); >+ }; >+ >+ std::optional<Token> consumeToken() >+ { >+ if (!m_stack.isEmpty()) >+ return m_stack.takeLast(); >+ return consumeTokenFromStream(); >+ } >+ >+ void unconsumeToken(Token&& token) >+ { >+ m_stack.append(WTFMove(token)); >+ } >+ >+ struct State { >+ Vector<Token> stack; >+ unsigned offset; >+ unsigned lineNumber; >+ }; >+ >+ State state() const >+ { >+ return { m_stack, m_offset, m_lineNumber }; >+ } >+ >+ void setState(const State& state) >+ { >+ m_stack = state.stack; >+ m_offset = state.offset; >+ m_lineNumber = state.lineNumber; >+ } >+ >+ void setState(State&& state) >+ { >+ m_stack = WTFMove(state.stack); >+ m_offset = WTFMove(state.offset); >+ m_lineNumber = WTFMove(state.lineNumber); >+ } >+ >+ bool isFullyConsumed() const >+ { >+ return m_offset == m_stringView.length(); >+ } >+ >+ String errorString(const Token& token, const String& message) >+ { >+ return String::format("Parse error at line %u: %s", token.lineNumber, message.utf8().data()); >+ } >+ >+private: >+ std::optional<Token> consumeTokenFromStream(); >+ >+ void skipWhitespaceAndComments(); >+ void skipWhitespace(); >+ void skipLineComment(); >+ void skipLongComment(); >+ >+ std::optional<Token::Type> recognizeKeyword(unsigned end); >+ >+ std::optional<unsigned> coreDecimalIntLiteral(unsigned) const; >+ std::optional<unsigned> decimalIntLiteral(unsigned) const; >+ std::optional<unsigned> decimalUintLiteral(unsigned) const; >+ std::optional<unsigned> coreHexadecimalIntLiteral(unsigned) const; >+ std::optional<unsigned> hexadecimalIntLiteral(unsigned) const; >+ std::optional<unsigned> hexadecimalUintLiteral(unsigned) const; >+ std::optional<unsigned> intLiteral(unsigned) const; >+ std::optional<unsigned> uintLiteral(unsigned) const; >+ std::optional<unsigned> digit(unsigned) const; >+ unsigned digitStar(unsigned) const; >+ std::optional<unsigned> character(char, unsigned) const; >+ template<unsigned length> std::optional<unsigned> anyCharacter(const char (&string)[length], unsigned) const; >+ std::optional<unsigned> coreFloatLiteralType1(unsigned) const; >+ std::optional<unsigned> coreFloatLiteral(unsigned) const; >+ std::optional<unsigned> floatLiteral(unsigned) const; >+ template<unsigned length> std::optional<unsigned> string(const char (&string)[length], unsigned) const; >+ std::optional<unsigned> validIdentifier(unsigned) const; >+ std::optional<unsigned> identifier(unsigned) const; >+ std::optional<unsigned> operatorName(unsigned) const; >+ >+ StringView m_stringView; >+ Vector<Token> m_stack; >+ unsigned m_offset { 0 }; >+ unsigned m_lineNumber { 0 }; >+}; >+ >+template<unsigned length> std::optional<unsigned> Lexer::string(const char (&string)[length], unsigned offset) const >+{ >+ for (unsigned i = 0; i < length - 1; ++i) { >+ if (offset + i >= m_stringView.length() || m_stringView[offset + i] != string[i]) >+ return std::nullopt; >+ } >+ return offset + length - 1; >+} >+ >+template<unsigned length> std::optional<unsigned> Lexer::anyCharacter(const char (&string)[length], unsigned offset) const >+{ >+ if (offset >= m_stringView.length()) >+ return std::nullopt; >+ for (unsigned i = 0; i < length - 1; ++i) { >+ if (m_stringView[offset] == string[i]) >+ return offset + 1; >+ } >+ return std::nullopt; >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.cpp >new file mode 100644 >index 00000000000..b20f374a524 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.cpp >@@ -0,0 +1,2552 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "config.h" >+#include "WHLSLParser.h" >+ >+#include "WHLSLASTArrayReferenceType.h" >+#include "WHLSLASTArrayType.h" >+#include "WHLSLASTAssignmentExpression.h" >+#include "WHLSLASTBooleanLiteral.h" >+#include "WHLSLASTBreak.h" >+#include "WHLSLASTCallExpression.h" >+#include "WHLSLASTCommaExpression.h" >+#include "WHLSLASTContinue.h" >+#include "WHLSLASTDereferenceExpression.h" >+#include "WHLSLASTDotExpression.h" >+#include "WHLSLASTEffectfulExpressionStatement.h" >+#include "WHLSLASTFallthrough.h" >+#include "WHLSLASTFloatLiteral.h" >+#include "WHLSLASTIndexExpression.h" >+#include "WHLSLASTIntegerLiteral.h" >+#include "WHLSLASTLogicalExpression.h" >+#include "WHLSLASTLogicalNotExpression.h" >+#include "WHLSLASTMakeArrayReferenceExpression.h" >+#include "WHLSLASTMakePointerExpression.h" >+#include "WHLSLASTNullLiteral.h" >+#include "WHLSLASTPointerType.h" >+#include "WHLSLASTQualifier.h" >+#include "WHLSLASTReadModifyWriteExpression.h" >+#include "WHLSLASTReturn.h" >+#include "WHLSLASTTernaryExpression.h" >+#include "WHLSLASTTrap.h" >+#include "WHLSLASTTypeReference.h" >+#include "WHLSLASTUnsignedIntegerLiteral.h" >+#include "WHLSLASTVariableReference.h" >+#include <wtf/text/StringBuilder.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+Parser::Parser() >+{ >+} >+ >+auto Parser::parse(Program& result, StringView stringView, Mode mode) -> std::optional<Error> >+{ >+ m_lexer = Lexer(stringView); >+ m_mode = mode; >+ >+ while (!m_lexer.isFullyConsumed()) { >+ if (tryType(Lexer::Token::Type::Semicolon)) { >+ m_lexer.consumeToken(); >+ continue; >+ } >+ >+ { >+ auto typeDefinition = backtrackingScope<Expected<AST::TypeDefinition, Error>>([&]() { >+ return parseTypeDefinition(); >+ }); >+ if (typeDefinition) { >+ result.append(WTFMove(*typeDefinition)); >+ continue; >+ } >+ } >+ >+ { >+ auto structureDefinition = backtrackingScope<Expected<AST::StructureDefinition, Error>>([&]() { >+ return parseStructureDefinition(); >+ }); >+ if (structureDefinition) { >+ result.append(WTFMove(*structureDefinition)); >+ continue; >+ } >+ } >+ >+ { >+ auto enumerationDefinition = backtrackingScope<Expected<AST::EnumerationDefinition, Error>>([&]() { >+ return parseEnumerationDefinition(); >+ }); >+ if (enumerationDefinition) { >+ result.append(WTFMove(*enumerationDefinition)); >+ continue; >+ } >+ } >+ >+ std::optional<Error> error; >+ { >+ auto functionDefinition = backtrackingScope<Expected<AST::FunctionDefinition, Error>>([&]() { >+ return parseFunctionDefinition(); >+ }); >+ if (functionDefinition) { >+ result.append(WTFMove(*functionDefinition)); >+ continue; >+ } >+ error = functionDefinition.error(); >+ } >+ >+ if (m_mode == Mode::StandardLibrary) { >+ auto nativeFunctionDeclaration = backtrackingScope<Expected<AST::NativeFunctionDeclaration, Error>>([&]() { >+ return parseNativeFunctionDeclaration(); >+ }); >+ if (nativeFunctionDeclaration) { >+ result.append(WTFMove(*nativeFunctionDeclaration)); >+ continue; >+ } >+ } >+ >+ if (m_mode == Mode::StandardLibrary) { >+ auto nativeTypeDeclaration = backtrackingScope<Expected<AST::NativeTypeDeclaration, Error>>([&]() { >+ return parseNativeTypeDeclaration(); >+ }); >+ if (nativeTypeDeclaration) { >+ result.append(WTFMove(*nativeTypeDeclaration)); >+ continue; >+ } >+ } >+ >+ WTFLogAlways("%s", error->error.utf8().data()); >+ return WTFMove(*error); >+ } >+ return std::nullopt; >+} >+ >+auto Parser::fail(const String& message) -> Unexpected<Error> { >+ if (auto nextToken = peek()) >+ return Unexpected<Error>(Error(m_lexer.errorString(*nextToken, message))); >+ return Unexpected<Error>(Error(String::format("Cannot lex: %s", message.utf8().data()))); >+} >+ >+auto Parser::peek() -> Expected<Lexer::Token, Error> { >+ if (auto token = m_lexer.consumeToken()) { >+ m_lexer.unconsumeToken(Lexer::Token(*token)); >+ return *token; >+ } >+ return fail(String("Cannot consume token", String::ConstructFromLiteral)); >+} >+ >+std::optional<Lexer::Token> Parser::tryType(Lexer::Token::Type type) >+{ >+ if (auto token = m_lexer.consumeToken()) { >+ if (token->type == type) >+ return token; >+ m_lexer.unconsumeToken(Lexer::Token(*token)); >+ } >+ return std::nullopt; >+} >+ >+std::optional<Lexer::Token> Parser::tryTypes(Vector<Lexer::Token::Type> types) >+{ >+ if (auto token = m_lexer.consumeToken()) { >+ if (std::find(types.begin(), types.end(), token->type) != types.end()) >+ return token; >+ m_lexer.unconsumeToken(Lexer::Token(*token)); >+ } >+ return std::nullopt; >+} >+ >+auto Parser::consumeType(Lexer::Token::Type type) -> Expected<Lexer::Token, Error> { >+ if (auto token = m_lexer.consumeToken()) { >+ if (token->type == type) >+ return *token; >+ return fail(String::format("Unexpected token (expected %s got %s)", Lexer::Token::typeName(type), Lexer::Token::typeName(token->type))); >+ } >+ return fail(String::format("Cannot consume token (expected %s)", Lexer::Token::typeName(type))); >+} >+ >+auto Parser::consumeTypes(Vector<Lexer::Token::Type> types) -> Expected<Lexer::Token, Error> { >+ auto buildExpectedString = [&]() -> String { >+ StringBuilder builder; >+ builder.append("["); >+ for (unsigned i = 0; i < types.size(); ++i) { >+ if (i > 0) >+ builder.append(", "); >+ builder.append(Lexer::Token::typeName(types[i])); >+ } >+ builder.append("]"); >+ return builder.toString(); >+ }; >+ >+ if (auto token = m_lexer.consumeToken()) { >+ if (std::find(types.begin(), types.end(), token->type) != types.end()) >+ return *token; >+ return fail(String::format("Unexpected token (expected one of %s got %s)", buildExpectedString().utf8().data(), Lexer::Token::typeName(token->type))); >+ } >+ return fail(String::format("Cannot consume token (expected %s)", buildExpectedString().utf8().data())); >+} >+ >+static int digitValue(UChar character) >+{ >+ if (character >= '0' && character <= '9') >+ return character - '0'; >+ if (character >= 'a' && character <= 'f') >+ return character - 'a' + 10; >+ return character - 'A' + 10; >+} >+ >+static Expected<int, Parser::Error> intLiteralToInt(StringView text) >+{ >+ bool negate = false; >+ if (text.startsWith(String("-", String::ConstructFromLiteral))) { >+ negate = true; >+ text = text.substring(1); >+ } >+ int base = 10; >+ if (text.startsWith(String("0x", String::ConstructFromLiteral))) { >+ text = text.substring(2); >+ base = 16; >+ } >+ >+ int result = 0; >+ for (unsigned i = 0; i < text.length(); ++i) { >+ int digit = digitValue(text[i]); >+ auto previous = result; >+ result = result * base + digit; >+ if (result < previous) // FIXME: overflow on signed integers is undefined >+ return Unexpected<Parser::Error>(Parser::Error(String::format("int literal %s is out of bounds", text.utf8().data()))); >+ } >+ if (negate) >+ result *= -1; >+ // FIXME: This algorithm makes it impossible to represent 0x800000 (the most negative representable value) >+ return { result }; >+} >+ >+static Expected<unsigned, Parser::Error> uintLiteralToUint(StringView text) >+{ >+ unsigned base = 10; >+ if (text.startsWith(String("0x", String::ConstructFromLiteral))) { >+ text = text.substring(2); >+ base = 16; >+ } >+ ASSERT(text.substring(text.length() - 1) == "u"); >+ text = text.substring(0, text.length() - 1); >+ unsigned result = 0; >+ for (unsigned i = 0; i < text.length(); ++i) { >+ unsigned digit = digitValue(text[i]); >+ auto previous = result; >+ result = result * base + digit; >+ if (result < previous) >+ return Unexpected<Parser::Error>(Parser::Error(String::format("uint literal %s is out of bounds", text.utf8().data()))); >+ } >+ return { result }; >+} >+ >+static Expected<float, Parser::Error> floatLiteralToFloat(StringView text) >+{ >+ bool negate = false; >+ if (text.length() > 0 && text[0] == '-') { >+ negate = true; >+ text = text.substring(1); >+ } >+ if (text.length() > 0 && text[text.length() - 1] == 'f') >+ text = text.substring(0, text.length() - 1); >+ float result; >+ unsigned index = 0; >+ for (index = 0; index < text.length() && text[index] != '.'; ++index) { >+ ASSERT(text[index] >= '0' && text[index] <= '9'); >+ result = result * 10 + (text[index] - '0'); >+ } >+ ASSERT(index < text.length()); >+ ASSERT(text[index] == '.'); >+ float decimal = 1.0f / 10.0f; >+ for (++index; index < text.length(); ++index) { >+ ASSERT(text[index] >= '0' && text[index] <= '9'); >+ result += decimal * (text[index] - '0'); >+ decimal /= 10.0f; >+ } >+ if (negate) >+ result *= -1; >+ return result; >+} >+ >+auto Parser::consumeIntegralLiteral() -> Expected<Variant<int, unsigned>, Error> { >+ auto integralLiteralToken = consumeTypes({ Lexer::Token::Type::IntLiteral, Lexer::Token::Type::UintLiteral }); >+ if (!integralLiteralToken) >+ return Unexpected<Error>(integralLiteralToken.error()); >+ >+ switch (integralLiteralToken->type) { >+ case Lexer::Token::Type::IntLiteral: { >+ auto result = intLiteralToInt(integralLiteralToken->stringView); >+ if (result) >+ return {{ *result }}; >+ return Unexpected<Error>(result.error()); >+ } >+ case Lexer::Token::Type::UintLiteral: { >+ auto result = uintLiteralToUint(integralLiteralToken->stringView); >+ if (result) >+ return {{ *result }}; >+ return Unexpected<Error>(result.error()); >+ } >+ default: >+ ASSERT_NOT_REACHED(); >+ return Unexpected<Error>(Error(String("Something really bad happened", String::ConstructFromLiteral))); >+ } >+} >+ >+auto Parser::consumeNonNegativeIntegralLiteral() -> Expected<unsigned, Error> { >+ auto integralLiteral = consumeIntegralLiteral(); >+ if (!integralLiteral) >+ return Unexpected<Error>(integralLiteral.error()); >+ auto result = WTF::visit(WTF::makeVisitor([](int x) -> std::optional<unsigned> { >+ if (x < 0) >+ return std::nullopt; >+ return x; >+ }, [](unsigned x) -> std::optional<unsigned> { >+ return x; >+ }), *integralLiteral); >+ if (result) >+ return *result; >+ return fail(String("int literal is negative", String::ConstructFromLiteral)); >+} >+ >+static Expected<unsigned, Parser::Error> recognizeSimpleUnsignedInteger(StringView stringView) >+{ >+ unsigned result = 0; >+ if (stringView.length() < 1) >+ return Unexpected<Parser::Error>(Parser::Error(String::format("Simple unsigned literal %s is too short", stringView.utf8().data()))); >+ for (unsigned i = 0; i < stringView.length(); ++i) { >+ if (stringView[i] < '0' || stringView[i] > '9') >+ return Unexpected<Parser::Error>(Parser::Error(String::format("Simple unsigned literal %s isn't of the form [0-9]+", stringView.utf8().data()))); >+ auto previous = result; >+ result = result * 10 + (stringView[i] - '0'); >+ if (result < previous) >+ return Unexpected<Parser::Error>(Parser::Error(String::format("Simple unsigned literal %s is out of bounds", stringView.utf8().data()))); >+ } >+ return result; >+} >+ >+auto Parser::parseConstantExpression() -> Expected<AST::ConstantExpression, Error> { >+ auto type = consumeTypes({ >+ Lexer::Token::Type::IntLiteral, >+ Lexer::Token::Type::UintLiteral, >+ Lexer::Token::Type::FloatLiteral, >+ Lexer::Token::Type::Null, >+ Lexer::Token::Type::True, >+ Lexer::Token::Type::False, >+ Lexer::Token::Type::Identifier, >+ }); >+ if (!type) >+ return Unexpected<Error>(type.error()); >+ >+ switch (type->type) { >+ case Lexer::Token::Type::IntLiteral: { >+ auto value = intLiteralToInt(type->stringView); >+ if (!value) >+ return Unexpected<Error>(value.error()); >+ return {{ AST::IntegerLiteral(WTFMove(*type), *value) }}; >+ } >+ case Lexer::Token::Type::UintLiteral: { >+ auto value = uintLiteralToUint(type->stringView); >+ if (!value) >+ return Unexpected<Error>(value.error()); >+ return {{ AST::UnsignedIntegerLiteral(WTFMove(*type), *value) }}; >+ } >+ case Lexer::Token::Type::FloatLiteral: { >+ auto value = floatLiteralToFloat(type->stringView); >+ if (!value) >+ return Unexpected<Error>(value.error()); >+ return {{ AST::FloatLiteral(WTFMove(*type), *value) }}; >+ } >+ case Lexer::Token::Type::Null: >+ return { AST::NullLiteral(WTFMove(*type)) }; >+ case Lexer::Token::Type::True: >+ return { AST::BooleanLiteral(WTFMove(*type), true) }; >+ case Lexer::Token::Type::False: >+ return { AST::BooleanLiteral(WTFMove(*type), false) }; >+ case Lexer::Token::Type::Identifier: { >+ auto origin = consumeType(Lexer::Token::Type::FullStop); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ auto next = consumeType(Lexer::Token::Type::Identifier); >+ if (!next) >+ return Unexpected<Error>(next.error()); >+ return { AST::ConstantExpressionEnumerationMemberReference(WTFMove(*origin), type->stringView.toString(), next->stringView.toString()) }; >+ } >+ default: >+ ASSERT_NOT_REACHED(); >+ return Unexpected<Error>(Error(String("Something really bad happened", String::ConstructFromLiteral))); >+ } >+} >+ >+auto Parser::parseTypeArgument() -> Expected<AST::TypeArgument, Error> { >+ auto constantExpression = backtrackingScope<Expected<AST::ConstantExpression, Error>>([&]() { >+ return parseConstantExpression(); >+ }); >+ if (constantExpression) >+ return AST::TypeArgument(WTFMove(*constantExpression)); >+ auto result = consumeType(Lexer::Token::Type::Identifier); >+ if (!result) >+ return Unexpected<Error>(result.error()); >+ return { result->stringView.toString() }; >+} >+ >+auto Parser::parseTypeArguments() -> Expected<AST::TypeArguments, Error> { >+ auto typeArguments = backtrackingScope<std::optional<AST::TypeArguments>>([&]() -> std::optional<AST::TypeArguments> { >+ auto lessThanSign = consumeType(Lexer::Token::Type::LessThanSign); >+ if (!lessThanSign) >+ return std::nullopt; >+ AST::TypeArguments typeArguments; >+ auto typeArgument = parseTypeArgument(); >+ if (!typeArgument) >+ return std::nullopt; >+ typeArguments.append(WTFMove(*typeArgument)); >+ while (tryType(Lexer::Token::Type::Comma)) { >+ auto typeArgument = parseTypeArgument(); >+ if (!typeArgument) >+ return std::nullopt; >+ typeArguments.append(WTFMove(*typeArgument)); >+ } >+ auto greaterThanSign = consumeType(Lexer::Token::Type::GreaterThanSign); >+ if (!greaterThanSign) >+ return std::nullopt; >+ return typeArguments; >+ }); >+ if (typeArguments) >+ return WTFMove(*typeArguments); >+ >+ typeArguments = backtrackingScope<std::optional<AST::TypeArguments>>([&]() -> std::optional<AST::TypeArguments> { >+ auto lessThanSign = consumeType(Lexer::Token::Type::LessThanSign); >+ if (!lessThanSign) >+ return std::nullopt; >+ auto greaterThanSign = consumeType(Lexer::Token::Type::GreaterThanSign); >+ if (!greaterThanSign) >+ return std::nullopt; >+ return {{ }}; >+ }); >+ if (typeArguments) >+ return WTFMove(*typeArguments); >+ >+ return AST::TypeArguments(); >+} >+ >+auto Parser::parseTypeSuffixAbbreviated() -> Expected<TypeSuffixAbbreviated, Error> { >+ auto token = consumeTypes({ Lexer::Token::Type::Star, Lexer::Token::Type::SquareBracketPair, Lexer::Token::Type::LeftSquareBracket }); >+ if (!token) >+ return Unexpected<Error>(token.error()); >+ if (token->type == Lexer::Token::Type::LeftSquareBracket) { >+ auto numElements = consumeNonNegativeIntegralLiteral(); >+ if (!numElements) >+ return Unexpected<Error>(numElements.error()); >+ auto rightSquareBracket = consumeType(Lexer::Token::Type::RightSquareBracket); >+ if (!rightSquareBracket) >+ return Unexpected<Error>(rightSquareBracket.error()); >+ return {{ *token, *numElements }}; >+ } >+ return {{ *token, std::nullopt }}; >+} >+ >+auto Parser::parseTypeSuffixNonAbbreviated() -> Expected<TypeSuffixNonAbbreviated, Error> { >+ auto token = consumeTypes({ Lexer::Token::Type::Star, Lexer::Token::Type::SquareBracketPair, Lexer::Token::Type::LeftSquareBracket }); >+ if (!token) >+ return Unexpected<Error>(token.error()); >+ if (token->type == Lexer::Token::Type::LeftSquareBracket) { >+ auto numElements = consumeNonNegativeIntegralLiteral(); >+ if (!numElements) >+ return Unexpected<Error>(numElements.error()); >+ auto rightSquareBracket = consumeType(Lexer::Token::Type::RightSquareBracket); >+ if (!rightSquareBracket) >+ return Unexpected<Error>(rightSquareBracket.error()); >+ return {{ *token, std::nullopt, *numElements }}; >+ } >+ auto addressSpace = consumeTypes({ Lexer::Token::Type::Constant, Lexer::Token::Type::Device, Lexer::Token::Type::Threadgroup, Lexer::Token::Type::Thread}); >+ if (!addressSpace) >+ return Unexpected<Error>(addressSpace.error()); >+ return {{ *token, { *addressSpace }, std::nullopt }}; >+} >+ >+auto Parser::parseAddressSpaceType() -> Expected<std::unique_ptr<AST::Type>, Error> { >+ auto addressSpace = consumeTypes({ Lexer::Token::Type::Constant, Lexer::Token::Type::Device, Lexer::Token::Type::Threadgroup, Lexer::Token::Type::Thread}); >+ if (!addressSpace) >+ return Unexpected<Error>(addressSpace.error()); >+ auto name = consumeType(Lexer::Token::Type::Identifier); >+ if (!name) >+ return Unexpected<Error>(name.error()); >+ auto typeArguments = parseTypeArguments(); >+ if (!typeArguments) >+ return Unexpected<Error>(typeArguments.error()); >+ >+ auto constructTypeFromSuffixAbbreviated = [&](const TypeSuffixAbbreviated& typeSuffixAbbreviated, std::unique_ptr<AST::Type>&& previous) -> std::unique_ptr<AST::Type> { >+ switch (typeSuffixAbbreviated.token.type) { >+ case Lexer::Token::Type::Star: >+ return std::make_unique<AST::PointerType>(Lexer::Token(typeSuffixAbbreviated.token), addressSpace->stringView.toString(), WTFMove(previous)); >+ case Lexer::Token::Type::SquareBracketPair: >+ return std::make_unique<AST::ArrayReferenceType>(Lexer::Token(typeSuffixAbbreviated.token), addressSpace->stringView.toString(), WTFMove(previous)); >+ case Lexer::Token::Type::LeftSquareBracket: >+ return std::make_unique<AST::ArrayType>(Lexer::Token(typeSuffixAbbreviated.token), WTFMove(previous), *typeSuffixAbbreviated.numElements); >+ default: >+ ASSERT_NOT_REACHED(); >+ return nullptr; >+ } >+ }; >+ >+ auto firstTypeSuffixAbbreviated = parseTypeSuffixAbbreviated(); >+ if (!firstTypeSuffixAbbreviated) >+ return Unexpected<Error>(firstTypeSuffixAbbreviated.error()); >+ std::unique_ptr<AST::Type> result = std::make_unique<AST::TypeReference>(Lexer::Token(*addressSpace), name->stringView.toString(), WTFMove(*typeArguments)); >+ result = constructTypeFromSuffixAbbreviated(*firstTypeSuffixAbbreviated, WTFMove(result)); >+ while (true) { >+ auto typeSuffixAbbreviated = backtrackingScope<Expected<TypeSuffixAbbreviated, Error>>([&]() { >+ return parseTypeSuffixAbbreviated(); >+ }); >+ if (!typeSuffixAbbreviated) >+ break; >+ // FIXME: The nesting here might be in the wrong order. >+ result = constructTypeFromSuffixAbbreviated(*typeSuffixAbbreviated, WTFMove(result)); >+ } >+ >+ return result; >+} >+ >+auto Parser::parseNonAddressSpaceType() -> Expected<std::unique_ptr<AST::Type>, Error> { >+ auto origin = peek(); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ auto name = consumeType(Lexer::Token::Type::Identifier); >+ if (!name) >+ return Unexpected<Error>(name.error()); >+ auto typeArguments = parseTypeArguments(); >+ if (!typeArguments) >+ return Unexpected<Error>(typeArguments.error()); >+ >+ auto constructTypeFromSuffixNonAbbreviated = [&](const TypeSuffixNonAbbreviated& typeSuffixNonAbbreviated, std::unique_ptr<AST::Type>&& previous) -> std::unique_ptr<AST::Type> { >+ switch (typeSuffixNonAbbreviated.token.type) { >+ case Lexer::Token::Type::Star: >+ return std::make_unique<AST::PointerType>(Lexer::Token(typeSuffixNonAbbreviated.token), typeSuffixNonAbbreviated.addressSpace->stringView.toString(), WTFMove(previous)); >+ case Lexer::Token::Type::SquareBracketPair: >+ return std::make_unique<AST::ArrayReferenceType>(Lexer::Token(typeSuffixNonAbbreviated.token), typeSuffixNonAbbreviated.addressSpace->stringView.toString(), WTFMove(previous)); >+ case Lexer::Token::Type::LeftSquareBracket: >+ return std::make_unique<AST::ArrayType>(Lexer::Token(typeSuffixNonAbbreviated.token), WTFMove(previous), *typeSuffixNonAbbreviated.numElements); >+ default: >+ ASSERT_NOT_REACHED(); >+ return nullptr; >+ } >+ }; >+ >+ std::unique_ptr<AST::Type> result = std::make_unique<AST::TypeReference>(WTFMove(*origin), name->stringView.toString(), WTFMove(*typeArguments)); >+ while (true) { >+ auto typeSuffixNonAbbreviated = backtrackingScope<Expected<TypeSuffixNonAbbreviated, Error>>([&]() { >+ return parseTypeSuffixNonAbbreviated(); >+ }); >+ if (!typeSuffixNonAbbreviated) >+ break; >+ // FIXME: The nesting here might be in the wrong order. >+ result = constructTypeFromSuffixNonAbbreviated(*typeSuffixNonAbbreviated, WTFMove(result)); >+ } >+ >+ return result; >+} >+ >+auto Parser::parseType() -> Expected<std::unique_ptr<AST::Type>, Error> { >+ auto type = backtrackingScope<Expected<std::unique_ptr<AST::Type>, Error>>([&]() { >+ return parseAddressSpaceType(); >+ }); >+ if (type) >+ return type; >+ >+ type = backtrackingScope<Expected<std::unique_ptr<AST::Type>, Error>>([&]() { >+ return parseNonAddressSpaceType(); >+ }); >+ if (type) >+ return type; >+ >+ return Unexpected<Error>(type.error()); >+} >+ >+auto Parser::parseTypeDefinition() -> Expected<AST::TypeDefinition, Error> { >+ auto origin = consumeType(Lexer::Token::Type::Typedef); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ auto name = consumeType(Lexer::Token::Type::Identifier); >+ if (!name) >+ return Unexpected<Error>(name.error()); >+ auto equals = consumeType(Lexer::Token::Type::EqualsSign); >+ if (!equals) >+ return Unexpected<Error>(equals.error()); >+ auto type = parseType(); >+ if (!type) >+ return Unexpected<Error>(type.error()); >+ auto semicolon = consumeType(Lexer::Token::Type::Semicolon); >+ if (!semicolon) >+ return Unexpected<Error>(semicolon.error()); >+ return AST::TypeDefinition(WTFMove(*origin), name->stringView.toString(), WTFMove(*type)); >+} >+ >+auto Parser::parseBuiltInSemantic() -> Expected<AST::BuiltInSemantic, Error> { >+ auto origin = consumeTypes({ >+ Lexer::Token::Type::SVInstanceID, >+ Lexer::Token::Type::SVVertexID, >+ Lexer::Token::Type::PSize, >+ Lexer::Token::Type::SVPosition, >+ Lexer::Token::Type::SVIsFrontFace, >+ Lexer::Token::Type::SVSampleIndex, >+ Lexer::Token::Type::SVInnerCoverage, >+ Lexer::Token::Type::SVTarget, >+ Lexer::Token::Type::SVDepth, >+ Lexer::Token::Type::SVCoverage, >+ Lexer::Token::Type::SVDispatchThreadID, >+ Lexer::Token::Type::SVGroupID, >+ Lexer::Token::Type::SVGroupIndex, >+ Lexer::Token::Type::SVGroupThreadID}); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ switch (origin->type) { >+ case Lexer::Token::Type::SVInstanceID: >+ return AST::BuiltInSemantic(WTFMove(*origin), AST::BuiltInSemantic::Variable::SVInstanceID); >+ case Lexer::Token::Type::SVVertexID: >+ return AST::BuiltInSemantic(WTFMove(*origin), AST::BuiltInSemantic::Variable::SVVertexID); >+ case Lexer::Token::Type::PSize: >+ return AST::BuiltInSemantic(WTFMove(*origin), AST::BuiltInSemantic::Variable::PSize); >+ case Lexer::Token::Type::SVPosition: >+ return AST::BuiltInSemantic(WTFMove(*origin), AST::BuiltInSemantic::Variable::SVPosition); >+ case Lexer::Token::Type::SVIsFrontFace: >+ return AST::BuiltInSemantic(WTFMove(*origin), AST::BuiltInSemantic::Variable::SVIsFrontFace); >+ case Lexer::Token::Type::SVSampleIndex: >+ return AST::BuiltInSemantic(WTFMove(*origin), AST::BuiltInSemantic::Variable::SVSampleIndex); >+ case Lexer::Token::Type::SVInnerCoverage: >+ return AST::BuiltInSemantic(WTFMove(*origin), AST::BuiltInSemantic::Variable::SVInnerCoverage); >+ case Lexer::Token::Type::SVTarget: { >+ auto target = consumeNonNegativeIntegralLiteral(); >+ if (!target) >+ return Unexpected<Error>(target.error()); >+ return AST::BuiltInSemantic(WTFMove(*origin), AST::BuiltInSemantic::Variable::SVTarget, *target); >+ } >+ case Lexer::Token::Type::SVDepth: >+ return AST::BuiltInSemantic(WTFMove(*origin), AST::BuiltInSemantic::Variable::SVDepth); >+ case Lexer::Token::Type::SVCoverage: >+ return AST::BuiltInSemantic(WTFMove(*origin), AST::BuiltInSemantic::Variable::SVCoverage); >+ case Lexer::Token::Type::SVDispatchThreadID: >+ return AST::BuiltInSemantic(WTFMove(*origin), AST::BuiltInSemantic::Variable::SVDispatchThreadID); >+ case Lexer::Token::Type::SVGroupID: >+ return AST::BuiltInSemantic(WTFMove(*origin), AST::BuiltInSemantic::Variable::SVGroupID); >+ case Lexer::Token::Type::SVGroupIndex: >+ return AST::BuiltInSemantic(WTFMove(*origin), AST::BuiltInSemantic::Variable::SVGroupIndex); >+ case Lexer::Token::Type::SVGroupThreadID: >+ return AST::BuiltInSemantic(WTFMove(*origin), AST::BuiltInSemantic::Variable::SVGroupThreadID); >+ default: >+ ASSERT_NOT_REACHED(); >+ return Unexpected<Error>(Error(String("Something really bad happened", String::ConstructFromLiteral))); >+ } >+} >+ >+auto Parser::parseResourceSemantic() -> Expected<AST::ResourceSemantic, Error> { >+ auto origin = consumeType(Lexer::Token::Type::Register); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ auto leftParenthesis = consumeType(Lexer::Token::Type::LeftParenthesis); >+ if (!leftParenthesis) >+ return Unexpected<Error>(leftParenthesis.error()); >+ >+ auto info = consumeType(Lexer::Token::Type::Identifier); >+ if (!info) >+ return Unexpected<Error>(info.error()); >+ if (info->stringView.length() < 2 || (info->stringView[0] != 'u' >+ && info->stringView[0] != 't' >+ && info->stringView[0] != 'b' >+ && info->stringView[0] != 's')) >+ return Unexpected<Error>(Error(String::format("%c is not a known resource type ('u', 't', 'b', or 's')", info->stringView[0]))); >+ >+ AST::ResourceSemantic::Mode mode; >+ switch (info->stringView[0]) { >+ case 'u': >+ mode = AST::ResourceSemantic::Mode::UnorderedAccessView; >+ break; >+ case 't': >+ mode = AST::ResourceSemantic::Mode::Texture; >+ break; >+ case 'b': >+ mode = AST::ResourceSemantic::Mode::Buffer; >+ break; >+ case 's': >+ mode = AST::ResourceSemantic::Mode::Sampler; >+ break; >+ } >+ >+ auto index = recognizeSimpleUnsignedInteger(info->stringView.substring(1)); >+ if (!index) >+ return Unexpected<Error>(index.error()); >+ >+ unsigned space = 0; >+ if (tryType(Lexer::Token::Type::Comma)) { >+ auto spaceToken = consumeType(Lexer::Token::Type::Identifier); >+ if (!spaceToken) >+ return Unexpected<Error>(spaceToken.error()); >+ auto prefix = String("space", String::ConstructFromLiteral); >+ if (!spaceToken->stringView.startsWith(StringView(prefix))) >+ return Unexpected<Error>(Error(String::format("Second argument to resource semantic %s needs be of the form 'space0'", spaceToken->stringView.utf8().data()))); >+ if (spaceToken->stringView.length() <= prefix.length()) >+ return Unexpected<Error>(Error(String::format("Second argument to resource semantic %s needs be of the form 'space0'", spaceToken->stringView.utf8().data()))); >+ auto spaceValue = recognizeSimpleUnsignedInteger(spaceToken->stringView.substring(prefix.length())); >+ if (!spaceValue) >+ return Unexpected<Error>(spaceValue.error()); >+ space = *spaceValue; >+ } >+ >+ auto rightParenthesis = consumeType(Lexer::Token::Type::RightParenthesis); >+ if (!rightParenthesis) >+ return Unexpected<Error>(rightParenthesis.error()); >+ >+ return AST::ResourceSemantic(WTFMove(*origin), mode, *index, space); >+} >+ >+auto Parser::parseSpecializationConstantSemantic() -> Expected<AST::SpecializationConstantSemantic, Error> { >+ auto origin = consumeType(Lexer::Token::Type::Specialized); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ return AST::SpecializationConstantSemantic(WTFMove(*origin)); >+} >+ >+auto Parser::parseStageInOutSemantic() -> Expected<AST::StageInOutSemantic, Error> { >+ auto origin = consumeType(Lexer::Token::Type::Attribute); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ auto leftParenthesis = consumeType(Lexer::Token::Type::LeftParenthesis); >+ if (!leftParenthesis) >+ return Unexpected<Error>(leftParenthesis.error()); >+ >+ auto index = consumeNonNegativeIntegralLiteral(); >+ if (!index) >+ return Unexpected<Error>(index.error()); >+ >+ auto rightParenthesis = consumeType(Lexer::Token::Type::RightParenthesis); >+ if (!rightParenthesis) >+ return Unexpected<Error>(rightParenthesis.error()); >+ >+ return AST::StageInOutSemantic(WTFMove(*origin), *index); >+} >+ >+auto Parser::parseSemantic() -> Expected<AST::Semantic, Error> { >+ auto builtInSemantic = backtrackingScope<Expected<AST::BuiltInSemantic, Error>>([&]() { >+ return parseBuiltInSemantic(); >+ }); >+ if (builtInSemantic) >+ return AST::Semantic(WTFMove(*builtInSemantic)); >+ >+ auto resourceSemantic = backtrackingScope<Expected<AST::ResourceSemantic, Error>>([&]() { >+ return parseResourceSemantic(); >+ }); >+ if (resourceSemantic) >+ return AST::Semantic(WTFMove(*resourceSemantic)); >+ >+ auto specializationConstantSemantic = backtrackingScope<Expected<AST::SpecializationConstantSemantic, Error>>([&]() { >+ return parseSpecializationConstantSemantic(); >+ }); >+ if (specializationConstantSemantic) >+ return AST::Semantic(WTFMove(*specializationConstantSemantic)); >+ >+ auto stageInOutSemantic = backtrackingScope<Expected<AST::StageInOutSemantic, Error>>([&]() { >+ return parseStageInOutSemantic(); >+ }); >+ if (stageInOutSemantic) >+ return AST::Semantic(WTFMove(*stageInOutSemantic)); >+ >+ return Unexpected<Error>(stageInOutSemantic.error()); >+} >+ >+AST::Qualifiers Parser::parseQualifiers() >+{ >+ AST::Qualifiers qualifiers; >+ while (true) { >+ if (auto next = tryType(Lexer::Token::Type::Qualifier)) { >+ if ("nointerpolation" == next->stringView) >+ qualifiers.append(AST::Qualifier::Nointerpolation); >+ else if ("noperspective" == next->stringView) >+ qualifiers.append(AST::Qualifier::Noperspective); >+ else if ("uniform" == next->stringView) >+ qualifiers.append(AST::Qualifier::Uniform); >+ else if ("centroid" == next->stringView) >+ qualifiers.append(AST::Qualifier::Centroid); >+ else if ("sample" == next->stringView) >+ qualifiers.append(AST::Qualifier::Sample); >+ else >+ ASSERT_NOT_REACHED(); >+ } else >+ break; >+ } >+ return qualifiers; >+} >+ >+auto Parser::parseStructureElement() -> Expected<AST::StructureElement, Error> { >+ auto origin = peek(); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ AST::Qualifiers qualifiers = parseQualifiers(); >+ >+ auto type = parseType(); >+ if (!type) >+ return Unexpected<Error>(type.error()); >+ >+ auto name = consumeType(Lexer::Token::Type::Identifier); >+ if (!name) >+ return Unexpected<Error>(name.error()); >+ >+ if (tryType(Lexer::Token::Type::Colon)) { >+ auto semantic = parseSemantic(); >+ if (!semantic) >+ return Unexpected<Error>(semantic.error()); >+ >+ auto semicolon = consumeType(Lexer::Token::Type::Semicolon); >+ if (!semicolon) >+ return Unexpected<Error>(semicolon.error()); >+ >+ return AST::StructureElement(WTFMove(*origin), WTFMove(qualifiers), WTFMove(*type), name->stringView.toString(), WTFMove(*semantic)); >+ } >+ >+ auto semicolon = consumeType(Lexer::Token::Type::Semicolon); >+ if (!semicolon) >+ return Unexpected<Error>(semicolon.error()); >+ >+ return AST::StructureElement(WTFMove(*origin), WTFMove(qualifiers), WTFMove(*type), name->stringView.toString(), std::nullopt); >+} >+ >+auto Parser::parseStructureDefinition() -> Expected<AST::StructureDefinition, Error> { >+ auto origin = consumeType(Lexer::Token::Type::Struct); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ auto name = consumeType(Lexer::Token::Type::Identifier); >+ if (!name) >+ return Unexpected<Error>(name.error()); >+ >+ auto leftCurlyBracket = consumeType(Lexer::Token::Type::LeftCurlyBracket); >+ if (!leftCurlyBracket) >+ return Unexpected<Error>(leftCurlyBracket.error()); >+ >+ AST::StructureElements structureElements; >+ while (true) { >+ auto structureElement = backtrackingScope<Expected<AST::StructureElement, Error>>([&]() { >+ return parseStructureElement(); >+ }); >+ if (structureElement) >+ structureElements.append(WTFMove(*structureElement)); >+ else >+ break; >+ } >+ >+ auto rightCurlyBracket = consumeType(Lexer::Token::Type::RightCurlyBracket); >+ if (!rightCurlyBracket) >+ return Unexpected<Error>(rightCurlyBracket.error()); >+ >+ return AST::StructureDefinition(WTFMove(*origin), name->stringView.toString(), WTFMove(structureElements)); >+} >+ >+auto Parser::parseEnumerationDefinition() -> Expected<AST::EnumerationDefinition, Error> { >+ auto origin = consumeType(Lexer::Token::Type::Enum); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ auto name = consumeType(Lexer::Token::Type::Identifier); >+ if (!name) >+ return Unexpected<Error>(name.error()); >+ >+ std::unique_ptr<AST::Type> type; >+ if (tryType(Lexer::Token::Type::Colon)) { >+ auto parsedType = parseType(); >+ if (!parsedType) >+ return Unexpected<Error>(parsedType.error()); >+ type = WTFMove(*parsedType); >+ } >+ >+ auto leftCurlyBracket = consumeType(Lexer::Token::Type::LeftCurlyBracket); >+ if (!leftCurlyBracket) >+ return Unexpected<Error>(leftCurlyBracket.error()); >+ >+ auto firstEnumerationMember = parseEnumerationMember(); >+ if (!firstEnumerationMember) >+ return Unexpected<Error>(firstEnumerationMember.error()); >+ >+ Vector<AST::EnumerationMember> members; >+ members.append(WTFMove(*firstEnumerationMember)); >+ >+ while (tryType(Lexer::Token::Type::Comma)) { >+ auto member = parseEnumerationMember(); >+ if (!member) >+ return Unexpected<Error>(member.error()); >+ members.append(WTFMove(*member)); >+ } >+ >+ auto rightCurlyBracket = consumeType(Lexer::Token::Type::RightCurlyBracket); >+ if (!rightCurlyBracket) >+ return Unexpected<Error>(rightCurlyBracket.error()); >+ >+ return AST::EnumerationDefinition(WTFMove(*origin), name->stringView.toString(), WTFMove(type), WTFMove(members)); >+} >+ >+auto Parser::parseEnumerationMember() -> Expected<AST::EnumerationMember, Error> { >+ auto identifier = consumeType(Lexer::Token::Type::Identifier); >+ if (!identifier) >+ return Unexpected<Error>(identifier.error()); >+ auto name = identifier->stringView.toString(); >+ >+ if (tryType(Lexer::Token::Type::EqualsSign)) { >+ auto constantExpression = parseConstantExpression(); >+ if (!constantExpression) >+ return Unexpected<Error>(constantExpression.error()); >+ return AST::EnumerationMember(Lexer::Token(*identifier), WTFMove(name), WTFMove(*constantExpression)); >+ } >+ return AST::EnumerationMember(Lexer::Token(*identifier), WTFMove(name)); >+} >+ >+auto Parser::parseNativeTypeDeclaration() -> Expected<AST::NativeTypeDeclaration, Error> { >+ auto origin = consumeType(Lexer::Token::Type::Native); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ auto parsedTypedef = consumeType(Lexer::Token::Type::Typedef); >+ if (!parsedTypedef) >+ return Unexpected<Error>(parsedTypedef.error()); >+ >+ auto name = consumeType(Lexer::Token::Type::Identifier); >+ if (!name) >+ return Unexpected<Error>(name.error()); >+ >+ auto typeArguments = parseTypeArguments(); >+ if (!typeArguments) >+ return Unexpected<Error>(typeArguments.error()); >+ >+ auto semicolon = consumeType(Lexer::Token::Type::Semicolon); >+ if (!semicolon) >+ return Unexpected<Error>(semicolon.error()); >+ >+ return AST::NativeTypeDeclaration(WTFMove(*origin), name->stringView.toString(), WTFMove(*typeArguments)); >+} >+ >+auto Parser::parseNumThreadsFunctionAttribute() -> Expected<AST::NumThreadsFunctionAttribute, Error> { >+ auto origin = consumeType(Lexer::Token::Type::NumThreads); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ auto leftParenthesis = consumeType(Lexer::Token::Type::LeftParenthesis); >+ if (!leftParenthesis) >+ return Unexpected<Error>(leftParenthesis.error()); >+ >+ auto width = consumeNonNegativeIntegralLiteral(); >+ if (!width) >+ return Unexpected<Error>(width.error()); >+ >+ auto comma = consumeType(Lexer::Token::Type::Comma); >+ if (!comma) >+ return Unexpected<Error>(comma.error()); >+ >+ auto height = consumeNonNegativeIntegralLiteral(); >+ if (!height) >+ return Unexpected<Error>(height.error()); >+ >+ comma = consumeType(Lexer::Token::Type::Comma); >+ if (!comma) >+ return Unexpected<Error>(comma.error()); >+ >+ auto depth = consumeNonNegativeIntegralLiteral(); >+ if (!depth) >+ return Unexpected<Error>(depth.error()); >+ >+ auto rightParenthesis = consumeType(Lexer::Token::Type::RightParenthesis); >+ if (!rightParenthesis) >+ return Unexpected<Error>(rightParenthesis.error()); >+ >+ return AST::NumThreadsFunctionAttribute(WTFMove(*origin), *width, *height, *depth); >+} >+ >+auto Parser::parseAttributeBlock() -> Expected<AST::AttributeBlock, Error> { >+ auto leftSquareBracket = consumeType(Lexer::Token::Type::LeftSquareBracket); >+ if (!leftSquareBracket) >+ return Unexpected<Error>(leftSquareBracket.error()); >+ >+ AST::AttributeBlock result; >+ >+ while (true) { >+ auto numThreadsFunctionAttribute = backtrackingScope<Expected<AST::NumThreadsFunctionAttribute, Error>>([&]() { >+ return parseNumThreadsFunctionAttribute(); >+ }); >+ if (numThreadsFunctionAttribute) { >+ result.append(WTFMove(*numThreadsFunctionAttribute)); >+ continue; >+ } >+ >+ break; >+ } >+ >+ auto rightSquareBracket = consumeType(Lexer::Token::Type::RightSquareBracket); >+ if (!rightSquareBracket) >+ return Unexpected<Error>(rightSquareBracket.error()); >+ >+ return result; >+} >+ >+auto Parser::parseParameter() -> Expected<AST::Parameter, Error> { >+ auto origin = peek(); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ AST::Qualifiers qualifiers = parseQualifiers(); >+ >+ auto type = parseType(); >+ if (!type) >+ return Unexpected<Error>(type.error()); >+ >+ std::optional<String> name; >+ if (auto token = tryType(Lexer::Token::Type::Identifier)) >+ name = token->stringView.toString(); >+ >+ if (tryType(Lexer::Token::Type::Colon)) { >+ auto semantic = parseSemantic(); >+ if (!semantic) >+ return Unexpected<Error>(semantic.error()); >+ return AST::Parameter(WTFMove(*origin), WTFMove(qualifiers), WTFMove(*type), WTFMove(name), WTFMove(*semantic)); >+ } >+ >+ return AST::Parameter(WTFMove(*origin), WTFMove(qualifiers), WTFMove(*type), WTFMove(name), std::nullopt); >+} >+ >+auto Parser::parseParameters() -> Expected<AST::Parameters, Error> { >+ auto leftParenthesis = consumeType(Lexer::Token::Type::LeftParenthesis); >+ if (!leftParenthesis) >+ return Unexpected<Error>(leftParenthesis.error()); >+ >+ AST::Parameters parameters; >+ if (tryType(Lexer::Token::Type::RightParenthesis)) >+ return parameters; >+ >+ auto firstParameter = parseParameter(); >+ if (!firstParameter) >+ return Unexpected<Error>(firstParameter.error()); >+ parameters.append(WTFMove(*firstParameter)); >+ >+ while (tryType(Lexer::Token::Type::Comma)) { >+ auto parameter = parseParameter(); >+ if (!parameter) >+ return Unexpected<Error>(parameter.error()); >+ parameters.append(WTFMove(*parameter)); >+ } >+ >+ auto rightParenthesis = consumeType(Lexer::Token::Type::RightParenthesis); >+ if (!rightParenthesis) >+ return Unexpected<Error>(rightParenthesis.error()); >+ >+ return parameters; >+} >+ >+auto Parser::parseFunctionDefinition() -> Expected<AST::FunctionDefinition, Error> { >+ bool restricted = static_cast<bool>(tryType(Lexer::Token::Type::Restricted)); >+ >+ auto functionDeclaration = parseFunctionDeclaration(); >+ if (!functionDeclaration) >+ return Unexpected<Error>(functionDeclaration.error()); >+ >+ auto block = parseBlock(); >+ if (!block) >+ return Unexpected<Error>(block.error()); >+ >+ return AST::FunctionDefinition(WTFMove(*functionDeclaration), WTFMove(*block), restricted); >+} >+ >+auto Parser::parseEntryPointFunctionDeclaration() -> Expected<AST::FunctionDeclaration, Error> { >+ auto origin = peek(); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ AST::AttributeBlock attributeBlock; >+ AST::FunctionDeclaration::EntryPointType entryPointType; >+ >+ auto parsedAttributeBlock = backtrackingScope<Expected<AST::AttributeBlock, Error>>([&]() { >+ return parseAttributeBlock(); >+ }); >+ if (parsedAttributeBlock) { >+ auto compute = consumeType(Lexer::Token::Type::Compute); >+ if (!compute) >+ return Unexpected<Error>(compute.error()); >+ attributeBlock = WTFMove(*parsedAttributeBlock); >+ entryPointType = AST::FunctionDeclaration::EntryPointType::Compute; >+ } else { >+ auto type = consumeTypes({ Lexer::Token::Type::Vertex, Lexer::Token::Type::Fragment }); >+ if (!type) >+ return Unexpected<Error>(type.error()); >+ >+ switch (origin->type) { >+ case Lexer::Token::Type::Vertex: >+ entryPointType = AST::FunctionDeclaration::EntryPointType::Vertex; >+ break; >+ case Lexer::Token::Type::Fragment: >+ entryPointType = AST::FunctionDeclaration::EntryPointType::Fragment; >+ break; >+ default: >+ ASSERT_NOT_REACHED(); >+ entryPointType = AST::FunctionDeclaration::EntryPointType::Vertex; >+ } >+ } >+ >+ auto type = parseType(); >+ if (!type) >+ return Unexpected<Error>(type.error()); >+ >+ auto name = consumeType(Lexer::Token::Type::Identifier); >+ if (!name) >+ return Unexpected<Error>(name.error()); >+ >+ auto parameters = parseParameters(); >+ if (!parameters) >+ return Unexpected<Error>(parameters.error()); >+ >+ if (tryType(Lexer::Token::Type::Colon)) { >+ auto semantic = parseSemantic(); >+ if (!semantic) >+ return Unexpected<Error>(semantic.error()); >+ return AST::FunctionDeclaration(WTFMove(*origin), WTFMove(attributeBlock), entryPointType, WTFMove(*type), name->stringView.toString(), WTFMove(*parameters), WTFMove(*semantic)); >+ } >+ >+ return AST::FunctionDeclaration(WTFMove(*origin), WTFMove(attributeBlock), entryPointType, WTFMove(*type), name->stringView.toString(), WTFMove(*parameters), std::nullopt); >+} >+ >+auto Parser::parseRegularFunctionDeclaration() -> Expected<AST::FunctionDeclaration, Error> { >+ auto origin = peek(); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ auto type = parseType(); >+ if (!type) >+ return Unexpected<Error>(type.error()); >+ >+ auto name = consumeTypes({ Lexer::Token::Type::Identifier, Lexer::Token::Type::OperatorName }); >+ if (!name) >+ return Unexpected<Error>(name.error()); >+ >+ auto parameters = parseParameters(); >+ if (!parameters) >+ return Unexpected<Error>(parameters.error()); >+ >+ if (tryType(Lexer::Token::Type::Colon)) { >+ auto semantic = parseSemantic(); >+ if (!semantic) >+ return Unexpected<Error>(semantic.error()); >+ return AST::FunctionDeclaration(WTFMove(*origin), { }, std::nullopt, WTFMove(*type), name->stringView.toString(), WTFMove(*parameters), WTFMove(*semantic)); >+ } >+ >+ return AST::FunctionDeclaration(WTFMove(*origin), { }, std::nullopt, WTFMove(*type), name->stringView.toString(), WTFMove(*parameters), std::nullopt); >+} >+ >+auto Parser::parseOperatorFunctionDeclaration() -> Expected<AST::FunctionDeclaration, Error> { >+ auto origin = consumeType(Lexer::Token::Type::Operator); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ auto type = parseType(); >+ if (!type) >+ return Unexpected<Error>(type.error()); >+ >+ auto parameters = parseParameters(); >+ if (!parameters) >+ return Unexpected<Error>(parameters.error()); >+ >+ if (tryType(Lexer::Token::Type::Colon)) { >+ auto semantic = parseSemantic(); >+ if (!semantic) >+ return Unexpected<Error>(semantic.error()); >+ return AST::FunctionDeclaration(WTFMove(*origin), { }, std::nullopt, WTFMove(*type), String("Operator Cast", String::ConstructFromLiteral), WTFMove(*parameters), WTFMove(*semantic)); >+ } >+ >+ return AST::FunctionDeclaration(WTFMove(*origin), { }, std::nullopt, WTFMove(*type), String("Operator Cast", String::ConstructFromLiteral), WTFMove(*parameters), std::nullopt); >+} >+ >+auto Parser::parseFunctionDeclaration() -> Expected<AST::FunctionDeclaration, Error> { >+ auto entryPointFunctionDeclaration = backtrackingScope<Expected<AST::FunctionDeclaration, Error>>([&]() { >+ return parseEntryPointFunctionDeclaration(); >+ }); >+ if (entryPointFunctionDeclaration) >+ return WTFMove(*entryPointFunctionDeclaration); >+ >+ auto regularFunctionDeclaration = backtrackingScope<Expected<AST::FunctionDeclaration, Error>>([&]() { >+ return parseRegularFunctionDeclaration(); >+ }); >+ if (regularFunctionDeclaration) >+ return WTFMove(*regularFunctionDeclaration); >+ >+ auto operatorFunctionDeclaration = backtrackingScope<Expected<AST::FunctionDeclaration, Error>>([&]() { >+ return parseOperatorFunctionDeclaration(); >+ }); >+ if (operatorFunctionDeclaration) >+ return WTFMove(*operatorFunctionDeclaration); >+ >+ return Unexpected<Error>(operatorFunctionDeclaration.error()); >+} >+ >+auto Parser::parseNativeFunctionDeclaration() -> Expected<AST::NativeFunctionDeclaration, Error> { >+ std::optional<Lexer::Token> origin; >+ >+ bool restricted = false; >+ if (auto restrictedValue = tryType(Lexer::Token::Type::Restricted)) { >+ origin = *restrictedValue; >+ restricted = true; >+ } >+ >+ auto native = consumeType(Lexer::Token::Type::Native); >+ if (!native) >+ return Unexpected<Error>(native.error()); >+ if (!origin) >+ origin = *native; >+ >+ auto functionDeclaration = parseFunctionDeclaration(); >+ if (!functionDeclaration) >+ return Unexpected<Error>(functionDeclaration.error()); >+ >+ auto semicolon = consumeType(Lexer::Token::Type::Semicolon); >+ if (!semicolon) >+ return Unexpected<Error>(semicolon.error()); >+ >+ return AST::NativeFunctionDeclaration(functionDeclaration->takeOrigin(), functionDeclaration->takeAttributeBlock(), functionDeclaration->takeEntryPointType(), functionDeclaration->takeType(), functionDeclaration->takeName(), functionDeclaration->takeParameters(), functionDeclaration->takeSemantic(), restricted); >+} >+ >+auto Parser::parseBlock() -> Expected<AST::Block, Error> { >+ auto origin = consumeType(Lexer::Token::Type::LeftCurlyBracket); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ auto result = parseBlockBody(WTFMove(*origin)); >+ >+ auto rightCurlyBracket = consumeType(Lexer::Token::Type::RightCurlyBracket); >+ if (!rightCurlyBracket) >+ return Unexpected<Error>(rightCurlyBracket.error()); >+ >+ return result; >+} >+ >+AST::Block Parser::parseBlockBody(Lexer::Token&& origin) >+{ >+ Vector<std::unique_ptr<AST::Statement>> statements; >+ while (true) { >+ auto statement = backtrackingScope<Expected<std::unique_ptr<AST::Statement>, Error>>([&]() { >+ return parseStatement(); >+ }); >+ if (statement) >+ statements.append(WTFMove(*statement)); >+ else >+ break; >+ } >+ return AST::Block(WTFMove(origin), WTFMove(statements)); >+} >+ >+auto Parser::parseIfStatement() -> Expected<AST::IfStatement, Error> { >+ auto origin = consumeType(Lexer::Token::Type::If); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ auto leftParenthesis = consumeType(Lexer::Token::Type::LeftParenthesis); >+ if (!leftParenthesis) >+ return Unexpected<Error>(leftParenthesis.error()); >+ >+ auto conditional = parseExpression(); >+ if (!conditional) >+ return Unexpected<Error>(conditional.error()); >+ >+ auto rightParenthesis = consumeType(Lexer::Token::Type::RightParenthesis); >+ if (!rightParenthesis) >+ return Unexpected<Error>(rightParenthesis.error()); >+ >+ auto body = parseStatement(); >+ if (!body) >+ return Unexpected<Error>(body.error()); >+ >+ std::unique_ptr<AST::Statement> elseBody; >+ if (tryType(Lexer::Token::Type::Else)) { >+ auto parsedElseBody = parseStatement(); >+ if (!parsedElseBody) >+ return Unexpected<Error>(parsedElseBody.error()); >+ elseBody = WTFMove(*parsedElseBody); >+ } >+ >+ return AST::IfStatement(WTFMove(*origin), WTFMove(*conditional), WTFMove(*body), WTFMove(elseBody)); >+} >+ >+auto Parser::parseSwitchStatement() -> Expected<AST::SwitchStatement, Error> { >+ auto origin = consumeType(Lexer::Token::Type::Switch); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ auto leftParenthesis = consumeType(Lexer::Token::Type::LeftParenthesis); >+ if (!leftParenthesis) >+ return Unexpected<Error>(leftParenthesis.error()); >+ >+ auto value = parseExpression(); >+ if (!value) >+ return Unexpected<Error>(value.error()); >+ >+ auto rightParenthesis = consumeType(Lexer::Token::Type::RightParenthesis); >+ if (!rightParenthesis) >+ return Unexpected<Error>(rightParenthesis.error()); >+ >+ auto leftCurlyBracket = consumeType(Lexer::Token::Type::LeftCurlyBracket); >+ if (!leftCurlyBracket) >+ return Unexpected<Error>(leftCurlyBracket.error()); >+ >+ Vector<AST::SwitchCase> switchCases; >+ while (true) { >+ auto switchCase = backtrackingScope<Expected<AST::SwitchCase, Error>>([&]() { >+ return parseSwitchCase(); >+ }); >+ if (switchCase) >+ switchCases.append(WTFMove(*switchCase)); >+ else >+ break; >+ } >+ >+ auto rightCurlyBracket = consumeType(Lexer::Token::Type::RightCurlyBracket); >+ if (!rightCurlyBracket) >+ return Unexpected<Error>(rightCurlyBracket.error()); >+ >+ return AST::SwitchStatement(WTFMove(*origin), WTFMove(*value), WTFMove(switchCases)); >+} >+ >+auto Parser::parseSwitchCase() -> Expected<AST::SwitchCase, Error> { >+ auto origin = consumeTypes({ Lexer::Token::Type::Case, Lexer::Token::Type::Default }); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ switch (origin->type) { >+ case Lexer::Token::Type::Case: { >+ auto value = parseConstantExpression(); >+ if (!value) >+ return Unexpected<Error>(value.error()); >+ >+ auto origin = consumeType(Lexer::Token::Type::Colon); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ auto block = parseBlockBody(Lexer::Token(*origin)); >+ >+ return AST::SwitchCase(WTFMove(*origin), WTFMove(*value), WTFMove(block)); >+ } >+ case Lexer::Token::Type::Default: { >+ auto origin = consumeType(Lexer::Token::Type::Colon); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ auto block = parseBlockBody(Lexer::Token(*origin)); >+ >+ return AST::SwitchCase(WTFMove(*origin), std::nullopt, WTFMove(block)); >+ } >+ default: >+ ASSERT_NOT_REACHED(); >+ return Unexpected<Error>(Error(String("Something really bad happened", String::ConstructFromLiteral))); >+ } >+} >+ >+auto Parser::parseForLoop() -> Expected<AST::ForLoop, Error> { >+ auto origin = consumeType(Lexer::Token::Type::For); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ auto parseRemainder = [&](Variant<AST::VariableDeclarationsStatement, std::unique_ptr<AST::Expression>>&& initialization) -> Expected<AST::ForLoop, Error> { >+ auto semicolon = consumeType(Lexer::Token::Type::Semicolon); >+ if (!semicolon) >+ return Unexpected<Error>(semicolon.error()); >+ >+ auto condition = backtrackingScope<std::unique_ptr<AST::Expression>>([&]() -> std::unique_ptr<AST::Expression> { >+ if (auto expression = parseExpression()) >+ return WTFMove(*expression); >+ return nullptr; >+ }); >+ >+ semicolon = consumeType(Lexer::Token::Type::Semicolon); >+ if (!semicolon) >+ return Unexpected<Error>(semicolon.error()); >+ >+ auto increment = backtrackingScope<std::unique_ptr<AST::Expression>>([&]() -> std::unique_ptr<AST::Expression> { >+ if (auto expression = parseExpression()) >+ return WTFMove(*expression); >+ return nullptr; >+ }); >+ >+ auto rightParenthesis = consumeType(Lexer::Token::Type::RightParenthesis); >+ if (!rightParenthesis) >+ return Unexpected<Error>(rightParenthesis.error()); >+ >+ auto body = parseStatement(); >+ if (!body) >+ return Unexpected<Error>(body.error()); >+ >+ return AST::ForLoop(WTFMove(*origin), WTFMove(initialization), WTFMove(condition), WTFMove(increment), WTFMove(*body)); >+ }; >+ >+ auto leftParenthesis = consumeType(Lexer::Token::Type::LeftParenthesis); >+ if (!leftParenthesis) >+ return Unexpected<Error>(leftParenthesis.error()); >+ >+ auto variableDeclarations = backtrackingScope<Expected<AST::VariableDeclarationsStatement, Error>>([&]() { >+ return parseVariableDeclarations(); >+ }); >+ if (variableDeclarations) >+ return parseRemainder(WTFMove(*variableDeclarations)); >+ >+ auto effectfulExpression = parseEffectfulExpression(); >+ if (!effectfulExpression) >+ return Unexpected<Error>(effectfulExpression.error()); >+ >+ return parseRemainder(WTFMove(*effectfulExpression)); >+} >+ >+auto Parser::parseWhileLoop() -> Expected<AST::WhileLoop, Error> { >+ auto origin = consumeType(Lexer::Token::Type::While); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ auto leftParenthesis = consumeType(Lexer::Token::Type::LeftParenthesis); >+ if (!leftParenthesis) >+ return Unexpected<Error>(leftParenthesis.error()); >+ >+ auto conditional = parseExpression(); >+ if (!conditional) >+ return Unexpected<Error>(conditional.error()); >+ >+ auto rightParenthesis = consumeType(Lexer::Token::Type::RightParenthesis); >+ if (!rightParenthesis) >+ return Unexpected<Error>(rightParenthesis.error()); >+ >+ auto body = parseStatement(); >+ if (!body) >+ return Unexpected<Error>(body.error()); >+ >+ return AST::WhileLoop(WTFMove(*origin), WTFMove(*conditional), WTFMove(*body)); >+} >+ >+auto Parser::parseDoWhileLoop() -> Expected<AST::DoWhileLoop, Error> { >+ auto origin = consumeType(Lexer::Token::Type::Do); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ auto body = parseStatement(); >+ if (!body) >+ return Unexpected<Error>(body.error()); >+ >+ auto whileKeyword = consumeType(Lexer::Token::Type::While); >+ if (!whileKeyword) >+ return Unexpected<Error>(whileKeyword.error()); >+ >+ auto leftParenthesis = consumeType(Lexer::Token::Type::LeftParenthesis); >+ if (!leftParenthesis) >+ return Unexpected<Error>(leftParenthesis.error()); >+ >+ auto conditional = parseExpression(); >+ if (!conditional) >+ return Unexpected<Error>(conditional.error()); >+ >+ auto rightParenthesis = consumeType(Lexer::Token::Type::RightParenthesis); >+ if (!rightParenthesis) >+ return Unexpected<Error>(rightParenthesis.error()); >+ >+ return AST::DoWhileLoop(WTFMove(*origin), WTFMove(*body), WTFMove(*conditional)); >+} >+ >+auto Parser::parseVariableDeclaration(std::unique_ptr<AST::Type>&& type) -> Expected<AST::VariableDeclaration, Error> { >+ auto origin = peek(); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ auto qualifiers = parseQualifiers(); >+ >+ auto name = consumeType(Lexer::Token::Type::Identifier); >+ if (!name) >+ return Unexpected<Error>(name.error()); >+ >+ if (tryType(Lexer::Token::Type::Colon)) { >+ auto semantic = parseSemantic(); >+ if (!semantic) >+ return Unexpected<Error>(semantic.error()); >+ >+ if (tryType(Lexer::Token::Type::EqualsSign)) { >+ auto initializer = parseExpression(); >+ if (!initializer) >+ return Unexpected<Error>(initializer.error()); >+ return AST::VariableDeclaration(WTFMove(*origin), WTFMove(qualifiers), WTFMove(type), name->stringView.toString(), WTFMove(*semantic), WTFMove(*initializer)); >+ } >+ >+ return AST::VariableDeclaration(WTFMove(*origin), WTFMove(qualifiers), WTFMove(type), name->stringView.toString(), WTFMove(*semantic), nullptr); >+ } >+ >+ if (tryType(Lexer::Token::Type::EqualsSign)) { >+ auto initializer = parseExpression(); >+ if (!initializer) >+ return Unexpected<Error>(initializer.error()); >+ return AST::VariableDeclaration(WTFMove(*origin), WTFMove(qualifiers), WTFMove(type), name->stringView.toString(), std::nullopt, WTFMove(*initializer)); >+ } >+ >+ return AST::VariableDeclaration(WTFMove(*origin), WTFMove(qualifiers), WTFMove(type), name->stringView.toString(), std::nullopt, nullptr); >+} >+ >+auto Parser::parseVariableDeclarations() -> Expected<AST::VariableDeclarationsStatement, Error> { >+ auto origin = peek(); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ auto type = parseType(); >+ if (!type) >+ return Unexpected<Error>(type.error()); >+ >+ auto firstVariableDeclaration = parseVariableDeclaration(std::unique_ptr<AST::Type>((*type)->clone())); >+ if (!firstVariableDeclaration) >+ return Unexpected<Error>(firstVariableDeclaration.error()); >+ >+ Vector<AST::VariableDeclaration> result; >+ result.append(WTFMove(*firstVariableDeclaration)); >+ >+ while (tryType(Lexer::Token::Type::Comma)) { >+ auto variableDeclaration = parseVariableDeclaration(std::unique_ptr<AST::Type>((*type)->clone())); >+ if (!variableDeclaration) >+ return Unexpected<Error>(variableDeclaration.error()); >+ result.append(WTFMove(*variableDeclaration)); >+ } >+ >+ return AST::VariableDeclarationsStatement(WTFMove(*origin), WTFMove(result)); >+} >+ >+auto Parser::parseStatement() -> Expected<std::unique_ptr<AST::Statement>, Error> { >+ { >+ auto block = backtrackingScope<Expected<AST::Block, Error>>([&]() { >+ return parseBlock(); >+ }); >+ if (block) >+ return std::unique_ptr<AST::Statement>(std::make_unique<AST::Block>(WTFMove(*block))); >+ } >+ >+ { >+ auto ifStatement = backtrackingScope<Expected<AST::IfStatement, Error>>([&]() { >+ return parseIfStatement(); >+ }); >+ if (ifStatement) >+ return std::unique_ptr<AST::Statement>(std::make_unique<AST::IfStatement>(WTFMove(*ifStatement))); >+ } >+ >+ { >+ auto switchStatement = backtrackingScope<Expected<AST::SwitchStatement, Error>>([&]() { >+ return parseSwitchStatement(); >+ }); >+ if (switchStatement) >+ return std::unique_ptr<AST::Statement>(std::make_unique<AST::SwitchStatement>(WTFMove(*switchStatement))); >+ } >+ >+ { >+ auto forLoop = backtrackingScope<Expected<AST::ForLoop, Error>>([&]() { >+ return parseForLoop(); >+ }); >+ if (forLoop) >+ return std::unique_ptr<AST::Statement>(std::make_unique<AST::ForLoop>(WTFMove(*forLoop))); >+ } >+ >+ { >+ auto whileLoop = backtrackingScope<Expected<AST::WhileLoop, Error>>([&]() { >+ return parseWhileLoop(); >+ }); >+ if (whileLoop) >+ return std::unique_ptr<AST::Statement>(std::make_unique<AST::WhileLoop>(WTFMove(*whileLoop))); >+ } >+ >+ { >+ auto doWhileLoop = backtrackingScope<Expected<AST::DoWhileLoop, Error>>([&]() -> Expected<AST::DoWhileLoop, Error> { >+ auto result = parseDoWhileLoop(); >+ if (!result) >+ return Unexpected<Error>(result.error()); >+ >+ auto semicolon = consumeType(Lexer::Token::Type::Semicolon); >+ if (!semicolon) >+ return Unexpected<Error>(semicolon.error()); >+ >+ return result; >+ }); >+ if (doWhileLoop) >+ return std::unique_ptr<AST::Statement>(std::make_unique<AST::DoWhileLoop>(WTFMove(*doWhileLoop))); >+ } >+ >+ { >+ auto breakObject = backtrackingScope<Expected<AST::Break, Error>>([&]() -> Expected<AST::Break, Error> { >+ auto origin = consumeType(Lexer::Token::Type::Break); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ auto semicolon = consumeType(Lexer::Token::Type::Semicolon); >+ if (!semicolon) >+ return Unexpected<Error>(semicolon.error()); >+ >+ return AST::Break(WTFMove(*origin)); >+ }); >+ if (breakObject) >+ return std::unique_ptr<AST::Statement>(std::make_unique<AST::Break>(WTFMove(*breakObject))); >+ } >+ >+ { >+ auto continueObject = backtrackingScope<Expected<AST::Continue, Error>>([&]() -> Expected<AST::Continue, Error> { >+ auto origin = consumeType(Lexer::Token::Type::Continue); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ auto semicolon = consumeType(Lexer::Token::Type::Semicolon); >+ if (!semicolon) >+ return Unexpected<Error>(semicolon.error()); >+ >+ return AST::Continue(WTFMove(*origin)); >+ }); >+ if (continueObject) >+ return std::unique_ptr<AST::Statement>(std::make_unique<AST::Continue>(WTFMove(*continueObject))); >+ } >+ >+ { >+ auto fallthroughObject = backtrackingScope<Expected<AST::Fallthrough, Error>>([&]() -> Expected<AST::Fallthrough, Error> { >+ auto origin = consumeType(Lexer::Token::Type::Fallthrough); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ auto semicolon = consumeType(Lexer::Token::Type::Semicolon); >+ if (!semicolon) >+ return Unexpected<Error>(semicolon.error()); >+ >+ return AST::Fallthrough(WTFMove(*origin)); >+ }); >+ if (fallthroughObject) >+ return std::unique_ptr<AST::Statement>(std::make_unique<AST::Fallthrough>(WTFMove(*fallthroughObject))); >+ } >+ >+ { >+ auto trapObject = backtrackingScope<Expected<AST::Trap, Error>>([&]() -> Expected<AST::Trap, Error> { >+ auto origin = consumeType(Lexer::Token::Type::Trap); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ auto semicolon = consumeType(Lexer::Token::Type::Semicolon); >+ if (!semicolon) >+ return Unexpected<Error>(semicolon.error()); >+ >+ return AST::Trap(WTFMove(*origin)); >+ }); >+ if (trapObject) >+ return std::unique_ptr<AST::Statement>(std::make_unique<AST::Trap>(WTFMove(*trapObject))); >+ } >+ >+ { >+ auto returnObject = backtrackingScope<Expected<AST::Return, Error>>([&]() -> Expected<AST::Return, Error> { >+ auto origin = consumeType(Lexer::Token::Type::Return); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ if (auto semicolon = tryType(Lexer::Token::Type::Semicolon)) >+ return AST::Return(WTFMove(*origin), nullptr); >+ >+ auto expression = parseExpression(); >+ if (!expression) >+ return Unexpected<Error>(expression.error()); >+ >+ auto semicolon = consumeType(Lexer::Token::Type::Semicolon); >+ if (!semicolon) >+ return Unexpected<Error>(semicolon.error()); >+ >+ return AST::Return(WTFMove(*origin), WTFMove(*expression)); >+ }); >+ if (returnObject) >+ return std::unique_ptr<AST::Statement>(std::make_unique<AST::Return>(WTFMove(*returnObject))); >+ } >+ >+ { >+ auto variableDeclarations = backtrackingScope<Expected<AST::VariableDeclarationsStatement, Error>>([&]() -> Expected<AST::VariableDeclarationsStatement, Error> { >+ auto result = parseVariableDeclarations(); >+ if (!result) >+ return Unexpected<Error>(result.error()); >+ >+ auto semicolon = consumeType(Lexer::Token::Type::Semicolon); >+ if (!semicolon) >+ return Unexpected<Error>(semicolon.error()); >+ >+ return result; >+ }); >+ if (variableDeclarations) >+ return std::unique_ptr<AST::Statement>(std::make_unique<AST::VariableDeclarationsStatement>(WTFMove(*variableDeclarations))); >+ } >+ >+ auto effectfulExpression = backtrackingScope<Expected<std::unique_ptr<AST::Expression>, Error>>([&]() -> Expected<std::unique_ptr<AST::Expression>, Error> { >+ auto result = parseEffectfulExpression(); >+ if (!result) >+ return Unexpected<Error>(result.error()); >+ >+ auto semicolon = consumeType(Lexer::Token::Type::Semicolon); >+ if (!semicolon) >+ return Unexpected<Error>(semicolon.error()); >+ >+ return result; >+ }); >+ if (effectfulExpression) >+ return std::unique_ptr<AST::Statement>(std::make_unique<AST::EffectfulExpressionStatement>(WTFMove(*effectfulExpression))); >+ >+ return Unexpected<Error>(effectfulExpression.error()); >+} >+ >+auto Parser::parseEffectfulExpression() -> Expected<std::unique_ptr<AST::Expression>, Error> { >+ auto origin = peek(); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ Vector<std::unique_ptr<AST::Expression>> expressions; >+ >+ auto first = backtrackingScope<std::unique_ptr<AST::Expression>>([&]() -> std::unique_ptr<AST::Expression> { >+ auto effectfulExpression = parseEffectfulAssignment(); >+ if (!effectfulExpression) >+ return nullptr; >+ return WTFMove(*effectfulExpression); >+ }); >+ if (!first) >+ return std::unique_ptr<AST::Expression>(std::make_unique<AST::CommaExpression>(WTFMove(*origin), WTFMove(expressions))); >+ >+ expressions.append(WTFMove(first)); >+ >+ while (tryType(Lexer::Token::Type::Comma)) { >+ auto expression = parseEffectfulAssignment(); >+ if (!expression) >+ return Unexpected<Error>(expression.error()); >+ expressions.append(WTFMove(*expression)); >+ } >+ >+ if (expressions.size() == 1) >+ return WTFMove(expressions[0]); >+ return std::unique_ptr<AST::Expression>(std::make_unique<AST::CommaExpression>(WTFMove(*origin), WTFMove(expressions))); >+} >+ >+auto Parser::parseEffectfulAssignment() -> Expected<std::unique_ptr<AST::Expression>, Error> { >+ auto assignment = backtrackingScope<Expected<std::unique_ptr<AST::Expression>, Error>>([&]() { >+ return parseAssignment(); >+ }); >+ if (assignment) >+ return assignment; >+ >+ assignment = backtrackingScope<Expected<std::unique_ptr<AST::Expression>, Error>>([&]() { >+ return parseEffectfulPrefix(); >+ }); >+ if (assignment) >+ return assignment; >+ >+ assignment = backtrackingScope<Expected<std::unique_ptr<AST::Expression>, Error>>([&]() { >+ return parseCallExpression(); >+ }); >+ if (assignment) >+ return assignment; >+ >+ return Unexpected<Error>(assignment.error()); >+} >+ >+auto Parser::parseEffectfulPrefix() -> Expected<std::unique_ptr<AST::Expression>, Error> { >+ auto prefix = consumeTypes({ Lexer::Token::Type::PlusPlus, Lexer::Token::Type::MinusMinus }); >+ if (!prefix) >+ return Unexpected<Error>(prefix.error()); >+ >+ auto previous = parsePossiblePrefix(); >+ if (!previous) >+ return Unexpected<Error>(previous.error()); >+ >+ switch (prefix->type) { >+ case Lexer::Token::Type::PlusPlus: { >+ auto result = std::make_unique<AST::ReadModifyWriteExpression>(Lexer::Token(*prefix), WTFMove(*previous)); >+ Vector<std::unique_ptr<AST::Expression>> callArguments; >+ callArguments.append(result->oldVariableReference()); >+ result->setNewValueExpression(std::make_unique<AST::CallExpression>(WTFMove(*prefix), String("operator++", String::ConstructFromLiteral), WTFMove(callArguments))); >+ result->setResultExpression(result->newVariableReference()); >+ return std::unique_ptr<AST::Expression>(WTFMove(result)); >+ } >+ case Lexer::Token::Type::MinusMinus: { >+ auto result = std::make_unique<AST::ReadModifyWriteExpression>(Lexer::Token(*prefix), WTFMove(*previous)); >+ Vector<std::unique_ptr<AST::Expression>> callArguments; >+ callArguments.append(result->oldVariableReference()); >+ result->setNewValueExpression(std::make_unique<AST::CallExpression>(WTFMove(*prefix), String("operator--", String::ConstructFromLiteral), WTFMove(callArguments))); >+ result->setResultExpression(result->newVariableReference()); >+ return std::unique_ptr<AST::Expression>(WTFMove(result)); >+ } >+ default: >+ ASSERT_NOT_REACHED(); >+ return Unexpected<Error>(Error(String("Something really bad happened", String::ConstructFromLiteral))); >+ } >+} >+ >+auto Parser::parseEffectfulSuffix() -> Expected<std::unique_ptr<AST::Expression>, Error> { >+ auto effectfulSuffix = backtrackingScope<Expected<std::unique_ptr<AST::Expression>, Error>>([&]() -> Expected<std::unique_ptr<AST::Expression>, Error> { >+ auto previous = parsePossibleSuffix(); >+ if (!previous) >+ return Unexpected<Error>(previous.error()); >+ >+ auto suffix = consumeTypes({ Lexer::Token::Type::PlusPlus, Lexer::Token::Type::MinusMinus }); >+ if (!suffix) >+ return Unexpected<Error>(suffix.error()); >+ >+ switch (suffix->type) { >+ case Lexer::Token::Type::PlusPlus: { >+ auto result = std::make_unique<AST::ReadModifyWriteExpression>(Lexer::Token(*suffix), WTFMove(*previous)); >+ Vector<std::unique_ptr<AST::Expression>> callArguments; >+ callArguments.append(result->oldVariableReference()); >+ result->setNewValueExpression(std::make_unique<AST::CallExpression>(WTFMove(*suffix), String("operator++", String::ConstructFromLiteral), WTFMove(callArguments))); >+ result->setResultExpression(result->oldVariableReference()); >+ return std::unique_ptr<AST::Expression>(WTFMove(result)); >+ } >+ case Lexer::Token::Type::MinusMinus: { >+ auto result = std::make_unique<AST::ReadModifyWriteExpression>(Lexer::Token(*suffix), WTFMove(*previous)); >+ Vector<std::unique_ptr<AST::Expression>> callArguments; >+ callArguments.append(result->oldVariableReference()); >+ result->setNewValueExpression(std::make_unique<AST::CallExpression>(WTFMove(*suffix), String("operator--", String::ConstructFromLiteral), WTFMove(callArguments))); >+ result->setResultExpression(result->oldVariableReference()); >+ return std::unique_ptr<AST::Expression>(WTFMove(result)); >+ } >+ default: >+ ASSERT_NOT_REACHED(); >+ return Unexpected<Error>(Error(String("Something really bad happened", String::ConstructFromLiteral))); >+ } >+ }); >+ if (effectfulSuffix) >+ return effectfulSuffix; >+ >+ effectfulSuffix = backtrackingScope<Expected<std::unique_ptr<AST::Expression>, Error>>([&]() { >+ return parseCallExpression(); >+ }); >+ if (effectfulSuffix) >+ return effectfulSuffix; >+ >+ effectfulSuffix = backtrackingScope<Expected<std::unique_ptr<AST::Expression>, Error>>([&]() -> Expected<std::unique_ptr<AST::Expression>, Error> { >+ auto leftParenthesis = consumeType(Lexer::Token::Type::LeftParenthesis); >+ if (!leftParenthesis) >+ return Unexpected<Error>(leftParenthesis.error()); >+ >+ auto expression = parseExpression(); >+ if (!expression) >+ return Unexpected<Error>(expression.error()); >+ >+ auto rightParenthesis = consumeType(Lexer::Token::Type::RightParenthesis); >+ if (!rightParenthesis) >+ return Unexpected<Error>(rightParenthesis.error()); >+ >+ return std::unique_ptr<AST::Expression>(WTFMove(*expression)); >+ }); >+ if (effectfulSuffix) >+ return effectfulSuffix; >+ >+ return Unexpected<Error>(effectfulSuffix.error()); >+} >+ >+auto Parser::parseLimitedSuffixOperator(std::unique_ptr<AST::Expression>&& previous) -> SuffixExpression >+{ >+ auto type = consumeTypes({ Lexer::Token::Type::FullStop, Lexer::Token::Type::Arrow, Lexer::Token::Type::LeftSquareBracket }); >+ if (!type) >+ return SuffixExpression(WTFMove(previous), false); >+ >+ switch (type->type) { >+ case Lexer::Token::Type::FullStop: { >+ auto identifier = consumeType(Lexer::Token::Type::Identifier); >+ if (!identifier) >+ return SuffixExpression(WTFMove(previous), false); >+ return SuffixExpression(std::make_unique<AST::DotExpression>(WTFMove(*type), WTFMove(previous), identifier->stringView.toString()), true); >+ } >+ case Lexer::Token::Type::Arrow: { >+ auto identifier = consumeType(Lexer::Token::Type::Identifier); >+ if (!identifier) >+ return SuffixExpression(WTFMove(previous), false); >+ return SuffixExpression(std::make_unique<AST::DotExpression>(Lexer::Token(*type), std::make_unique<AST::DereferenceExpression>(WTFMove(*type), WTFMove(previous)), identifier->stringView.toString()), true); >+ } >+ case Lexer::Token::Type::LeftSquareBracket: { >+ auto expression = parseExpression(); >+ if (!expression) >+ return SuffixExpression(WTFMove(previous), false); >+ if (!consumeType(Lexer::Token::Type::RightSquareBracket)) >+ return SuffixExpression(WTFMove(previous), false); >+ return SuffixExpression(std::make_unique<AST::IndexExpression>(WTFMove(*type), WTFMove(previous), WTFMove(*expression)), true); >+ } >+ default: >+ ASSERT_NOT_REACHED(); >+ return SuffixExpression(WTFMove(previous), false); >+ } >+} >+ >+auto Parser::parseSuffixOperator(std::unique_ptr<AST::Expression>&& previous) -> SuffixExpression >+{ >+ auto suffix = consumeTypes({ Lexer::Token::Type::FullStop, Lexer::Token::Type::Arrow, Lexer::Token::Type::LeftSquareBracket, Lexer::Token::Type::PlusPlus, Lexer::Token::Type::MinusMinus }); >+ if (!suffix) >+ return SuffixExpression(WTFMove(previous), false); >+ >+ switch (suffix->type) { >+ case Lexer::Token::Type::FullStop: { >+ auto identifier = consumeType(Lexer::Token::Type::Identifier); >+ if (!identifier) >+ return SuffixExpression(WTFMove(previous), false); >+ return SuffixExpression(std::make_unique<AST::DotExpression>(WTFMove(*suffix), WTFMove(previous), identifier->stringView.toString()), true); >+ } >+ case Lexer::Token::Type::Arrow: { >+ auto identifier = consumeType(Lexer::Token::Type::Identifier); >+ if (!identifier) >+ return SuffixExpression(WTFMove(previous), false); >+ return SuffixExpression(std::make_unique<AST::DotExpression>(Lexer::Token(*suffix), std::make_unique<AST::DereferenceExpression>(WTFMove(*suffix), WTFMove(previous)), identifier->stringView.toString()), true); >+ } >+ case Lexer::Token::Type::LeftSquareBracket: { >+ auto expression = parseExpression(); >+ if (!expression) >+ return SuffixExpression(WTFMove(previous), false); >+ if (!consumeType(Lexer::Token::Type::RightSquareBracket)) >+ return SuffixExpression(WTFMove(previous), false); >+ return SuffixExpression(std::make_unique<AST::IndexExpression>(WTFMove(*suffix), WTFMove(previous), WTFMove(*expression)), true); >+ } >+ case Lexer::Token::Type::PlusPlus: { >+ auto result = std::make_unique<AST::ReadModifyWriteExpression>(Lexer::Token(*suffix), WTFMove(previous)); >+ Vector<std::unique_ptr<AST::Expression>> callArguments; >+ callArguments.append(result->oldVariableReference()); >+ result->setNewValueExpression(std::make_unique<AST::CallExpression>(WTFMove(*suffix), String("operator++", String::ConstructFromLiteral), WTFMove(callArguments))); >+ result->setResultExpression(result->oldVariableReference()); >+ return SuffixExpression(WTFMove(result), true); >+ } >+ case Lexer::Token::Type::MinusMinus: { >+ auto result = std::make_unique<AST::ReadModifyWriteExpression>(Lexer::Token(*suffix), WTFMove(previous)); >+ Vector<std::unique_ptr<AST::Expression>> callArguments; >+ callArguments.append(result->oldVariableReference()); >+ result->setNewValueExpression(std::make_unique<AST::CallExpression>(WTFMove(*suffix), String("operator--", String::ConstructFromLiteral), WTFMove(callArguments))); >+ result->setResultExpression(result->oldVariableReference()); >+ return SuffixExpression(WTFMove(result), true); >+ } >+ default: >+ ASSERT_NOT_REACHED(); >+ return SuffixExpression(WTFMove(previous), false); >+ } >+} >+ >+auto Parser::parseExpression() -> Expected<std::unique_ptr<AST::Expression>, Error> { >+ auto origin = peek(); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ auto first = parsePossibleTernaryConditional(); >+ if (!first) >+ return Unexpected<Error>(first.error()); >+ >+ Vector<std::unique_ptr<AST::Expression>> expressions; >+ expressions.append(WTFMove(*first)); >+ >+ while (tryType(Lexer::Token::Type::Comma)) { >+ auto expression = parsePossibleTernaryConditional(); >+ if (!expression) >+ return Unexpected<Error>(expression.error()); >+ expressions.append(WTFMove(*expression)); >+ } >+ >+ if (expressions.size() == 1) >+ return WTFMove(expressions[0]); >+ return std::unique_ptr<AST::Expression>(std::make_unique<AST::CommaExpression>(WTFMove(*origin), WTFMove(expressions))); >+} >+ >+auto Parser::parseTernaryConditional() -> Expected<std::unique_ptr<AST::Expression>, Error> { >+ auto origin = peek(); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ auto predicate = parsePossibleLogicalBinaryOperation(); >+ if (!predicate) >+ return Unexpected<Error>(predicate.error()); >+ >+ auto questionMark = consumeType(Lexer::Token::Type::QuestionMark); >+ if (!questionMark) >+ return Unexpected<Error>(questionMark.error()); >+ >+ auto bodyExpression = parseExpression(); >+ if (!bodyExpression) >+ return Unexpected<Error>(bodyExpression.error()); >+ >+ auto colon = consumeType(Lexer::Token::Type::Colon); >+ if (!colon) >+ return Unexpected<Error>(colon.error()); >+ >+ auto elseExpression = parsePossibleTernaryConditional(); >+ if (!elseExpression) >+ return Unexpected<Error>(elseExpression.error()); >+ >+ // FIXME: Cast the predicate to a bool. >+ return std::unique_ptr<AST::Expression>(std::make_unique<AST::TernaryExpression>(WTFMove(*origin), WTFMove(*predicate), WTFMove(*bodyExpression), WTFMove(*elseExpression))); >+} >+ >+auto Parser::parseAssignment() -> Expected<std::unique_ptr<AST::Expression>, Error> { >+ auto origin = peek(); >+ if (!origin) >+ return Unexpected<Error>(origin.error()); >+ >+ auto left = parsePossiblePrefix(); >+ if (!left) >+ return Unexpected<Error>(left.error()); >+ >+ auto assignmentOperator = consumeTypes({ >+ Lexer::Token::Type::EqualsSign, >+ Lexer::Token::Type::PlusEquals, >+ Lexer::Token::Type::MinusEquals, >+ Lexer::Token::Type::TimesEquals, >+ Lexer::Token::Type::DivideEquals, >+ Lexer::Token::Type::ModEquals, >+ Lexer::Token::Type::XorEquals, >+ Lexer::Token::Type::AndEquals, >+ Lexer::Token::Type::OrEquals, >+ Lexer::Token::Type::RightShiftEquals, >+ Lexer::Token::Type::LeftShiftEquals >+ }); >+ if (!assignmentOperator) >+ return Unexpected<Error>(assignmentOperator.error()); >+ >+ auto right = parsePossibleTernaryConditional(); >+ if (!right) >+ return Unexpected<Error>(right.error()); >+ >+ if (assignmentOperator->type == Lexer::Token::Type::EqualsSign) >+ return std::unique_ptr<AST::Expression>(std::make_unique<AST::AssignmentExpression>(WTFMove(*origin), WTFMove(*left), WTFMove(*right))); >+ >+ String name; >+ switch (assignmentOperator->type) { >+ case Lexer::Token::Type::PlusEquals: >+ name = String("operator+", String::ConstructFromLiteral); >+ break; >+ case Lexer::Token::Type::MinusEquals: >+ name = String("operator-", String::ConstructFromLiteral); >+ break; >+ case Lexer::Token::Type::TimesEquals: >+ name = String("operator*", String::ConstructFromLiteral); >+ break; >+ case Lexer::Token::Type::DivideEquals: >+ name = String("operator/", String::ConstructFromLiteral); >+ break; >+ case Lexer::Token::Type::ModEquals: >+ name = String("operator%", String::ConstructFromLiteral); >+ break; >+ case Lexer::Token::Type::XorEquals: >+ name = String("operator^", String::ConstructFromLiteral); >+ break; >+ case Lexer::Token::Type::AndEquals: >+ name = String("operator&", String::ConstructFromLiteral); >+ break; >+ case Lexer::Token::Type::OrEquals: >+ name = String("operator|", String::ConstructFromLiteral); >+ break; >+ case Lexer::Token::Type::RightShiftEquals: >+ name = String("operator>>", String::ConstructFromLiteral); >+ break; >+ case Lexer::Token::Type::LeftShiftEquals: >+ name = String("operator<<", String::ConstructFromLiteral); >+ break; >+ default: >+ ASSERT_NOT_REACHED(); >+ return Unexpected<Error>(Error(String("Something really bad happened", String::ConstructFromLiteral))); >+ } >+ >+ auto result = std::make_unique<AST::ReadModifyWriteExpression>(Lexer::Token(*origin), WTFMove(*left)); >+ Vector<std::unique_ptr<AST::Expression>> callArguments; >+ callArguments.append(result->oldVariableReference()); >+ callArguments.append(WTFMove(*right)); >+ result->setNewValueExpression(std::make_unique<AST::CallExpression>(WTFMove(*origin), WTFMove(name), WTFMove(callArguments))); >+ result->setResultExpression(result->newVariableReference()); >+ return std::unique_ptr<AST::Expression>(WTFMove(result)); >+} >+ >+auto Parser::parsePossibleTernaryConditional() -> Expected<std::unique_ptr<AST::Expression>, Error> { >+ auto ternaryExpression = backtrackingScope<Expected<std::unique_ptr<AST::Expression>, Error>>([&]() { >+ return parseTernaryConditional(); >+ }); >+ if (ternaryExpression) >+ return ternaryExpression; >+ >+ auto assignmentExpression = backtrackingScope<Expected<std::unique_ptr<AST::Expression>, Error>>([&]() { >+ return parseAssignment(); >+ }); >+ if (assignmentExpression) >+ return assignmentExpression; >+ >+ auto binaryOperation = backtrackingScope<Expected<std::unique_ptr<AST::Expression>, Error>>([&]() { >+ return parsePossibleLogicalBinaryOperation(); >+ }); >+ if (binaryOperation) >+ return binaryOperation; >+ >+ return Unexpected<Error>(binaryOperation.error()); >+} >+ >+auto Parser::parsePossibleLogicalBinaryOperation() -> Expected<std::unique_ptr<AST::Expression>, Error> { >+ std::unique_ptr<AST::Expression> previous; >+ auto parsedPrevious = parsePossibleRelationalBinaryOperation(); >+ if (!parsedPrevious) >+ return Unexpected<Error>(parsedPrevious.error()); >+ previous = WTFMove(*parsedPrevious); >+ >+ while (auto logicalBinaryOperation = tryTypes({ >+ Lexer::Token::Type::OrOr, >+ Lexer::Token::Type::AndAnd, >+ Lexer::Token::Type::Or, >+ Lexer::Token::Type::Xor, >+ Lexer::Token::Type::And >+ })) { >+ auto next = parsePossibleRelationalBinaryOperation(); >+ if (!next) >+ return Unexpected<Error>(next.error()); >+ >+ switch (logicalBinaryOperation->type) { >+ case Lexer::Token::Type::OrOr: >+ previous = std::make_unique<AST::LogicalExpression>(WTFMove(*logicalBinaryOperation), AST::LogicalExpression::Type::Or, WTFMove(previous), WTFMove(*next)); >+ break; >+ case Lexer::Token::Type::AndAnd: >+ previous = std::make_unique<AST::LogicalExpression>(WTFMove(*logicalBinaryOperation), AST::LogicalExpression::Type::And, WTFMove(previous), WTFMove(*next)); >+ break; >+ case Lexer::Token::Type::Or: { >+ Vector<std::unique_ptr<AST::Expression>> callArguments; >+ callArguments.append(WTFMove(previous)); >+ callArguments.append(WTFMove(*next)); >+ previous = std::make_unique<AST::CallExpression>(WTFMove(*logicalBinaryOperation), String("operator|", String::ConstructFromLiteral), WTFMove(callArguments)); >+ break; >+ } >+ case Lexer::Token::Type::Xor: { >+ Vector<std::unique_ptr<AST::Expression>> callArguments; >+ callArguments.append(WTFMove(previous)); >+ callArguments.append(WTFMove(*next)); >+ previous = std::make_unique<AST::CallExpression>(WTFMove(*logicalBinaryOperation), String("operator^", String::ConstructFromLiteral), WTFMove(callArguments)); >+ break; >+ } >+ case Lexer::Token::Type::And: { >+ Vector<std::unique_ptr<AST::Expression>> callArguments; >+ callArguments.append(WTFMove(previous)); >+ callArguments.append(WTFMove(*next)); >+ previous = std::make_unique<AST::CallExpression>(WTFMove(*logicalBinaryOperation), String("operator&", String::ConstructFromLiteral), WTFMove(callArguments)); >+ break; >+ } >+ default: >+ ASSERT_NOT_REACHED(); >+ return Unexpected<Error>(Error(String("Something really bad happened", String::ConstructFromLiteral))); >+ } >+ } >+ >+ return previous; >+} >+ >+auto Parser::parsePossibleRelationalBinaryOperation() -> Expected<std::unique_ptr<AST::Expression>, Error> { >+ std::unique_ptr<AST::Expression> previous; >+ auto parsedPrevious = parsePossibleShift(); >+ if (!parsedPrevious) >+ return Unexpected<Error>(parsedPrevious.error()); >+ previous = WTFMove(*parsedPrevious); >+ >+ while (auto relationalBinaryOperation = tryTypes({ >+ Lexer::Token::Type::LessThanSign, >+ Lexer::Token::Type::GreaterThanSign, >+ Lexer::Token::Type::LessThanOrEqualTo, >+ Lexer::Token::Type::GreaterThanOrEqualTo, >+ Lexer::Token::Type::EqualComparison, >+ Lexer::Token::Type::NotEqual >+ })) { >+ auto next = parsePossibleShift(); >+ if (!next) >+ return Unexpected<Error>(next.error()); >+ >+ switch (relationalBinaryOperation->type) { >+ case Lexer::Token::Type::LessThanSign: { >+ Vector<std::unique_ptr<AST::Expression>> callArguments; >+ callArguments.append(WTFMove(previous)); >+ callArguments.append(WTFMove(*next)); >+ previous = std::make_unique<AST::CallExpression>(WTFMove(*relationalBinaryOperation), String("operator<", String::ConstructFromLiteral), WTFMove(callArguments)); >+ break; >+ } >+ case Lexer::Token::Type::GreaterThanSign: { >+ Vector<std::unique_ptr<AST::Expression>> callArguments; >+ callArguments.append(WTFMove(previous)); >+ callArguments.append(WTFMove(*next)); >+ previous = std::make_unique<AST::CallExpression>(WTFMove(*relationalBinaryOperation), String("operator>", String::ConstructFromLiteral), WTFMove(callArguments)); >+ break; >+ } >+ case Lexer::Token::Type::LessThanOrEqualTo: { >+ Vector<std::unique_ptr<AST::Expression>> callArguments; >+ callArguments.append(WTFMove(previous)); >+ callArguments.append(WTFMove(*next)); >+ previous = std::make_unique<AST::CallExpression>(WTFMove(*relationalBinaryOperation), String("operator<=", String::ConstructFromLiteral), WTFMove(callArguments)); >+ break; >+ } >+ case Lexer::Token::Type::GreaterThanOrEqualTo: { >+ Vector<std::unique_ptr<AST::Expression>> callArguments; >+ callArguments.append(WTFMove(previous)); >+ callArguments.append(WTFMove(*next)); >+ previous = std::make_unique<AST::CallExpression>(WTFMove(*relationalBinaryOperation), String("operator>=", String::ConstructFromLiteral), WTFMove(callArguments)); >+ break; >+ } >+ case Lexer::Token::Type::EqualComparison: { >+ Vector<std::unique_ptr<AST::Expression>> callArguments; >+ callArguments.append(WTFMove(previous)); >+ callArguments.append(WTFMove(*next)); >+ previous = std::make_unique<AST::CallExpression>(WTFMove(*relationalBinaryOperation), String("operator==", String::ConstructFromLiteral), WTFMove(callArguments)); >+ break; >+ } >+ case Lexer::Token::Type::NotEqual: { >+ Vector<std::unique_ptr<AST::Expression>> callArguments; >+ callArguments.append(WTFMove(previous)); >+ callArguments.append(WTFMove(*next)); >+ previous = std::make_unique<AST::CallExpression>(Lexer::Token(*relationalBinaryOperation), String("operator==", String::ConstructFromLiteral), WTFMove(callArguments)); >+ // FIXME: Cast the argument to a bool >+ previous = std::make_unique<AST::LogicalNotExpression>(WTFMove(*relationalBinaryOperation), WTFMove(previous)); >+ break; >+ } >+ default: >+ ASSERT_NOT_REACHED(); >+ return Unexpected<Error>(Error(String("Something really bad happened", String::ConstructFromLiteral))); >+ } >+ } >+ >+ return previous; >+} >+ >+auto Parser::parsePossibleShift() -> Expected<std::unique_ptr<AST::Expression>, Error> { >+ std::unique_ptr<AST::Expression> previous; >+ auto parsedPrevious = parsePossibleAdd(); >+ if (!parsedPrevious) >+ return Unexpected<Error>(parsedPrevious.error()); >+ previous = WTFMove(*parsedPrevious); >+ >+ while (auto shift = tryTypes({ >+ Lexer::Token::Type::LeftShift, >+ Lexer::Token::Type::RightShift >+ })) { >+ auto next = parsePossibleAdd(); >+ if (!next) >+ return Unexpected<Error>(next.error()); >+ >+ switch (shift->type) { >+ case Lexer::Token::Type::LeftShift: { >+ Vector<std::unique_ptr<AST::Expression>> callArguments; >+ callArguments.append(WTFMove(previous)); >+ callArguments.append(WTFMove(*next)); >+ previous = std::make_unique<AST::CallExpression>(WTFMove(*shift), String("operator<<", String::ConstructFromLiteral), WTFMove(callArguments)); >+ break; >+ } >+ case Lexer::Token::Type::RightShift: { >+ Vector<std::unique_ptr<AST::Expression>> callArguments; >+ callArguments.append(WTFMove(previous)); >+ callArguments.append(WTFMove(*next)); >+ previous = std::make_unique<AST::CallExpression>(WTFMove(*shift), String("operator>>", String::ConstructFromLiteral), WTFMove(callArguments)); >+ break; >+ } >+ default: >+ ASSERT_NOT_REACHED(); >+ return Unexpected<Error>(Error(String("Something really bad happened", String::ConstructFromLiteral))); >+ } >+ } >+ >+ return previous; >+} >+ >+auto Parser::parsePossibleAdd() -> Expected<std::unique_ptr<AST::Expression>, Error> { >+ std::unique_ptr<AST::Expression> previous; >+ auto parsedPrevious = parsePossibleMultiply(); >+ if (!parsedPrevious) >+ return Unexpected<Error>(parsedPrevious.error()); >+ previous = WTFMove(*parsedPrevious); >+ >+ while (auto add = tryTypes({ >+ Lexer::Token::Type::Plus, >+ Lexer::Token::Type::Minus >+ })) { >+ auto next = parsePossibleMultiply(); >+ if (!next) >+ return Unexpected<Error>(next.error()); >+ >+ switch (add->type) { >+ case Lexer::Token::Type::Plus: { >+ Vector<std::unique_ptr<AST::Expression>> callArguments; >+ callArguments.append(WTFMove(previous)); >+ callArguments.append(WTFMove(*next)); >+ previous = std::make_unique<AST::CallExpression>(WTFMove(*add), String("operator+", String::ConstructFromLiteral), WTFMove(callArguments)); >+ break; >+ } >+ case Lexer::Token::Type::Minus: { >+ Vector<std::unique_ptr<AST::Expression>> callArguments; >+ callArguments.append(WTFMove(previous)); >+ callArguments.append(WTFMove(*next)); >+ previous = std::make_unique<AST::CallExpression>(WTFMove(*add), String("operator-", String::ConstructFromLiteral), WTFMove(callArguments)); >+ break; >+ } >+ default: >+ ASSERT_NOT_REACHED(); >+ return Unexpected<Error>(Error(String("Something really bad happened", String::ConstructFromLiteral))); >+ } >+ } >+ >+ return previous; >+} >+ >+auto Parser::parsePossibleMultiply() -> Expected<std::unique_ptr<AST::Expression>, Error> { >+ std::unique_ptr<AST::Expression> previous; >+ auto parsedPrevious = parsePossiblePrefix(); >+ if (!parsedPrevious) >+ return Unexpected<Error>(parsedPrevious.error()); >+ previous = WTFMove(*parsedPrevious); >+ >+ while (auto multiply = tryTypes({ >+ Lexer::Token::Type::Star, >+ Lexer::Token::Type::Divide, >+ Lexer::Token::Type::Mod >+ })) { >+ auto next = parsePossiblePrefix(); >+ if (!next) >+ return Unexpected<Error>(next.error()); >+ >+ switch (multiply->type) { >+ case Lexer::Token::Type::Star: { >+ Vector<std::unique_ptr<AST::Expression>> callArguments; >+ callArguments.append(WTFMove(previous)); >+ callArguments.append(WTFMove(*next)); >+ previous = std::make_unique<AST::CallExpression>(WTFMove(*multiply), String("operator*", String::ConstructFromLiteral), WTFMove(callArguments)); >+ break; >+ } >+ case Lexer::Token::Type::Divide: { >+ Vector<std::unique_ptr<AST::Expression>> callArguments; >+ callArguments.append(WTFMove(previous)); >+ callArguments.append(WTFMove(*next)); >+ previous = std::make_unique<AST::CallExpression>(WTFMove(*multiply), String("operator/", String::ConstructFromLiteral), WTFMove(callArguments)); >+ break; >+ } >+ case Lexer::Token::Type::Mod: { >+ Vector<std::unique_ptr<AST::Expression>> callArguments; >+ callArguments.append(WTFMove(previous)); >+ callArguments.append(WTFMove(*next)); >+ previous = std::make_unique<AST::CallExpression>(WTFMove(*multiply), String("operator%", String::ConstructFromLiteral), WTFMove(callArguments)); >+ break; >+ } >+ default: >+ ASSERT_NOT_REACHED(); >+ return Unexpected<Error>(Error(String("Something really bad happened", String::ConstructFromLiteral))); >+ } >+ } >+ >+ return previous; >+} >+ >+auto Parser::parsePossiblePrefix() -> Expected<std::unique_ptr<AST::Expression>, Error> { >+ if (auto prefix = tryTypes({ >+ Lexer::Token::Type::PlusPlus, >+ Lexer::Token::Type::MinusMinus, >+ Lexer::Token::Type::Plus, >+ Lexer::Token::Type::Minus, >+ Lexer::Token::Type::Tilde, >+ Lexer::Token::Type::ExclamationPoint, >+ Lexer::Token::Type::And, >+ Lexer::Token::Type::At, >+ Lexer::Token::Type::Star >+ })) { >+ auto next = parsePossiblePrefix(); >+ if (!next) >+ return Unexpected<Error>(next.error()); >+ >+ switch (prefix->type) { >+ case Lexer::Token::Type::PlusPlus: { >+ auto result = std::make_unique<AST::ReadModifyWriteExpression>(Lexer::Token(*prefix), WTFMove(*next)); >+ Vector<std::unique_ptr<AST::Expression>> callArguments; >+ callArguments.append(result->oldVariableReference()); >+ result->setNewValueExpression(std::make_unique<AST::CallExpression>(Lexer::Token(*prefix), String("operator++", String::ConstructFromLiteral), WTFMove(callArguments))); >+ result->setResultExpression(result->newVariableReference()); >+ return std::unique_ptr<AST::Expression>(WTFMove(result)); >+ } >+ case Lexer::Token::Type::MinusMinus: { >+ auto result = std::make_unique<AST::ReadModifyWriteExpression>(Lexer::Token(*prefix), WTFMove(*next)); >+ Vector<std::unique_ptr<AST::Expression>> callArguments; >+ callArguments.append(result->oldVariableReference()); >+ result->setNewValueExpression(std::make_unique<AST::CallExpression>(Lexer::Token(*prefix), String("operator--", String::ConstructFromLiteral), WTFMove(callArguments))); >+ result->setResultExpression(result->newVariableReference()); >+ return std::unique_ptr<AST::Expression>(WTFMove(result)); >+ } >+ case Lexer::Token::Type::Plus: { >+ Vector<std::unique_ptr<AST::Expression>> callArguments; >+ callArguments.append(WTFMove(*next)); >+ return std::unique_ptr<AST::Expression>(std::make_unique<AST::CallExpression>(Lexer::Token(*prefix), String("operator+", String::ConstructFromLiteral), WTFMove(callArguments))); >+ } >+ case Lexer::Token::Type::Minus: { >+ Vector<std::unique_ptr<AST::Expression>> callArguments; >+ callArguments.append(WTFMove(*next)); >+ return std::unique_ptr<AST::Expression>(std::make_unique<AST::CallExpression>(Lexer::Token(*prefix), String("operator-", String::ConstructFromLiteral), WTFMove(callArguments))); >+ } >+ case Lexer::Token::Type::Tilde: { >+ Vector<std::unique_ptr<AST::Expression>> callArguments; >+ callArguments.append(WTFMove(*next)); >+ return std::unique_ptr<AST::Expression>(std::make_unique<AST::CallExpression>(Lexer::Token(*prefix), String("operator~", String::ConstructFromLiteral), WTFMove(callArguments))); >+ } >+ case Lexer::Token::Type::ExclamationPoint: >+ return std::unique_ptr<AST::Expression>(std::make_unique<AST::LogicalNotExpression>(Lexer::Token(*prefix), WTFMove(*next))); >+ case Lexer::Token::Type::And: >+ return std::unique_ptr<AST::Expression>(std::make_unique<AST::MakePointerExpression>(Lexer::Token(*prefix), WTFMove(*next))); >+ case Lexer::Token::Type::At: >+ return std::unique_ptr<AST::Expression>(std::make_unique<AST::MakeArrayReferenceExpression>(Lexer::Token(*prefix), WTFMove(*next))); >+ case Lexer::Token::Type::Star: >+ return std::unique_ptr<AST::Expression>(std::make_unique<AST::DereferenceExpression>(Lexer::Token(*prefix), WTFMove(*next))); >+ default: >+ ASSERT_NOT_REACHED(); >+ return Unexpected<Error>(Error(String("Something really bad happened", String::ConstructFromLiteral))); >+ } >+ } >+ >+ return parsePossibleSuffix(); >+} >+ >+auto Parser::parsePossibleSuffix() -> Expected<std::unique_ptr<AST::Expression>, Error> { >+ auto suffix = backtrackingScope<Expected<std::unique_ptr<AST::Expression>, Error>>([&]() -> Expected<std::unique_ptr<AST::Expression>, Error> { >+ auto expression = parseCallExpression(); >+ if (!expression) >+ return Unexpected<Error>(expression.error()); >+ >+ while (true) { >+ auto result = backtrackingScope<SuffixExpression>([&]() -> SuffixExpression { >+ return parseLimitedSuffixOperator(WTFMove(*expression)); >+ }); >+ expression = WTFMove(result.result); >+ if (!result) >+ break; >+ } >+ return expression; >+ }); >+ if (suffix) >+ return suffix; >+ >+ suffix = backtrackingScope<Expected<std::unique_ptr<AST::Expression>, Error>>([&]() -> Expected<std::unique_ptr<AST::Expression>, Error> { >+ auto expression = parseTerm(); >+ if (!expression) >+ return Unexpected<Error>(expression.error()); >+ >+ while (true) { >+ auto result = backtrackingScope<SuffixExpression>([&]() -> SuffixExpression { >+ return parseSuffixOperator(WTFMove(*expression)); >+ }); >+ expression = WTFMove(result.result); >+ if (!result) >+ break; >+ } >+ return expression; >+ }); >+ if (suffix) >+ return suffix; >+ >+ return Unexpected<Error>(suffix.error()); >+} >+ >+auto Parser::parseCallExpression() -> Expected<std::unique_ptr<AST::Expression>, Error> { >+ auto name = consumeType(Lexer::Token::Type::Identifier); >+ if (!name) >+ return Unexpected<Error>(name.error()); >+ auto callName = name->stringView.toString(); >+ >+ auto leftParenthesis = consumeType(Lexer::Token::Type::LeftParenthesis); >+ if (!leftParenthesis) >+ return Unexpected<Error>(leftParenthesis.error()); >+ >+ Vector<std::unique_ptr<AST::Expression>> arguments; >+ if (tryType(Lexer::Token::Type::RightParenthesis)) >+ return std::unique_ptr<AST::Expression>(std::make_unique<AST::CallExpression>(WTFMove(*name), WTFMove(callName), WTFMove(arguments))); >+ >+ auto firstArgument = parsePossibleTernaryConditional(); >+ if (!firstArgument) >+ return Unexpected<Error>(firstArgument.error()); >+ arguments.append(WTFMove(*firstArgument)); >+ while (tryType(Lexer::Token::Type::Comma)) { >+ auto argument = parsePossibleTernaryConditional(); >+ if (!argument) >+ return Unexpected<Error>(argument.error()); >+ arguments.append(WTFMove(*argument)); >+ } >+ >+ auto rightParenthesis = consumeType(Lexer::Token::Type::RightParenthesis); >+ if (!rightParenthesis) >+ return Unexpected<Error>(rightParenthesis.error()); >+ >+ return std::unique_ptr<AST::Expression>(std::make_unique<AST::CallExpression>(WTFMove(*name), WTFMove(callName), WTFMove(arguments))); >+} >+ >+auto Parser::parseTerm() -> Expected<std::unique_ptr<AST::Expression>, Error> { >+ auto type = consumeTypes({ >+ Lexer::Token::Type::IntLiteral, >+ Lexer::Token::Type::UintLiteral, >+ Lexer::Token::Type::FloatLiteral, >+ Lexer::Token::Type::Null, >+ Lexer::Token::Type::True, >+ Lexer::Token::Type::False, >+ Lexer::Token::Type::Identifier, >+ Lexer::Token::Type::LeftParenthesis >+ }); >+ if (!type) >+ return Unexpected<Error>(type.error()); >+ >+ switch (type->type) { >+ case Lexer::Token::Type::IntLiteral: { >+ auto value = intLiteralToInt(type->stringView); >+ if (!value) >+ return Unexpected<Error>(value.error()); >+ return std::unique_ptr<AST::Expression>(std::make_unique<AST::IntegerLiteral>(WTFMove(*type), *value)); >+ } >+ case Lexer::Token::Type::UintLiteral: { >+ auto value = uintLiteralToUint(type->stringView); >+ if (!value) >+ return Unexpected<Error>(value.error()); >+ return std::unique_ptr<AST::Expression>(std::make_unique<AST::UnsignedIntegerLiteral>(WTFMove(*type), *value)); >+ } >+ case Lexer::Token::Type::FloatLiteral: { >+ auto value = floatLiteralToFloat(type->stringView); >+ if (!value) >+ return Unexpected<Error>(value.error()); >+ return std::unique_ptr<AST::Expression>(std::make_unique<AST::FloatLiteral>(WTFMove(*type), *value)); >+ } >+ case Lexer::Token::Type::Null: >+ return std::unique_ptr<AST::Expression>(std::make_unique<AST::NullLiteral>(WTFMove(*type))); >+ case Lexer::Token::Type::True: >+ return std::unique_ptr<AST::Expression>(std::make_unique<AST::BooleanLiteral>(WTFMove(*type), true)); >+ case Lexer::Token::Type::False: >+ return std::unique_ptr<AST::Expression>(std::make_unique<AST::BooleanLiteral>(WTFMove(*type), false)); >+ case Lexer::Token::Type::Identifier: { >+ auto name = type->stringView.toString(); >+ return std::unique_ptr<AST::Expression>(std::make_unique<AST::VariableReference>(WTFMove(*type), WTFMove(name))); >+ } >+ case Lexer::Token::Type::LeftParenthesis: { >+ auto expression = parseExpression(); >+ if (!expression) >+ return Unexpected<Error>(expression.error()); >+ >+ auto rightParenthesis = consumeType(Lexer::Token::Type::RightParenthesis); >+ if (!rightParenthesis) >+ return Unexpected<Error>(rightParenthesis.error()); >+ >+ return std::unique_ptr<AST::Expression>(WTFMove(*expression)); >+ } >+ default: >+ ASSERT_NOT_REACHED(); >+ return Unexpected<Error>(Error(String("Something really bad happened", String::ConstructFromLiteral))); >+ } >+} >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.h >new file mode 100644 >index 00000000000..0513ea4ac03 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.h >@@ -0,0 +1,194 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTBlock.h" >+#include "WHLSLASTCommaExpression.h" >+#include "WHLSLASTConstantExpression.h" >+#include "WHLSLASTDoWhileLoop.h" >+#include "WHLSLASTExpression.h" >+#include "WHLSLASTForLoop.h" >+#include "WHLSLASTFunctionAttribute.h" >+#include "WHLSLASTFunctionDeclaration.h" >+#include "WHLSLASTFunctionDefinition.h" >+#include "WHLSLASTIfStatement.h" >+#include "WHLSLASTNativeTypeDeclaration.h" >+#include "WHLSLASTParameter.h" >+#include "WHLSLASTSemantic.h" >+#include "WHLSLASTStatement.h" >+#include "WHLSLASTStructureDefinition.h" >+#include "WHLSLASTStructureElement.h" >+#include "WHLSLASTSwitchCase.h" >+#include "WHLSLASTSwitchStatement.h" >+#include "WHLSLASTTypeArgument.h" >+#include "WHLSLASTTypeDefinition.h" >+#include "WHLSLASTVariableDeclaration.h" >+#include "WHLSLASTVariableDeclarationsStatement.h" >+#include "WHLSLASTWhileLoop.h" >+#include "WHLSLLexer.h" >+#include "WHLSLProgram.h" >+#include <wtf/Expected.h> >+#include <wtf/Optional.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+class Parser { >+public: >+ enum class Mode { >+ StandardLibrary, >+ User >+ }; >+ >+ struct Error { >+ Error(String&& error) >+ : error(WTFMove(error)) >+ { >+ } >+ >+ String error; >+ }; >+ >+ Parser(); >+ >+ std::optional<Error> parse(Program&, StringView, Mode); >+ >+private: >+ template<typename T> T backtrackingScope(std::function<T()> callback) >+ { >+ auto state = m_lexer.state(); >+ auto result = callback(); >+ if (result) >+ return result; >+ m_lexer.setState(WTFMove(state)); >+ return result; >+ } >+ >+ Unexpected<Error> fail(const String& message); >+ Expected<Lexer::Token, Error> peek(); >+ std::optional<Lexer::Token> tryType(Lexer::Token::Type); >+ std::optional<Lexer::Token> tryTypes(Vector<Lexer::Token::Type>); >+ Expected<Lexer::Token, Error> consumeType(Lexer::Token::Type); >+ Expected<Lexer::Token, Error> consumeTypes(Vector<Lexer::Token::Type>); >+ >+ Expected<Variant<int, unsigned>, Error> consumeIntegralLiteral(); >+ Expected<unsigned, Error> consumeNonNegativeIntegralLiteral(); >+ Expected<AST::ConstantExpression, Error> parseConstantExpression(); >+ Expected<AST::TypeArgument, Error> parseTypeArgument(); >+ Expected<AST::TypeArguments, Error> parseTypeArguments(); >+ struct TypeSuffixAbbreviated { >+ Lexer::Token token; >+ std::optional<unsigned> numElements; >+ }; >+ Expected<TypeSuffixAbbreviated, Error> parseTypeSuffixAbbreviated(); >+ struct TypeSuffixNonAbbreviated { >+ Lexer::Token token; >+ std::optional<Lexer::Token> addressSpace; >+ std::optional<unsigned> numElements; >+ }; >+ Expected<TypeSuffixNonAbbreviated, Error> parseTypeSuffixNonAbbreviated(); >+ Expected<std::unique_ptr<AST::Type>, Error> parseAddressSpaceType(); >+ Expected<std::unique_ptr<AST::Type>, Error> parseNonAddressSpaceType(); >+ Expected<std::unique_ptr<AST::Type>, Error> parseType(); >+ Expected<AST::TypeDefinition, Error> parseTypeDefinition(); >+ Expected<AST::BuiltInSemantic, Error> parseBuiltInSemantic(); >+ Expected<AST::ResourceSemantic, Error> parseResourceSemantic(); >+ Expected<AST::SpecializationConstantSemantic, Error> parseSpecializationConstantSemantic(); >+ Expected<AST::StageInOutSemantic, Error> parseStageInOutSemantic(); >+ Expected<AST::Semantic, Error> parseSemantic(); >+ AST::Qualifiers parseQualifiers(); >+ Expected<AST::StructureElement, Error> parseStructureElement(); >+ Expected<AST::StructureDefinition, Error> parseStructureDefinition(); >+ Expected<AST::EnumerationDefinition, Error> parseEnumerationDefinition(); >+ Expected<AST::EnumerationMember, Error> parseEnumerationMember(); >+ Expected<AST::NativeTypeDeclaration, Error> parseNativeTypeDeclaration(); >+ Expected<AST::NumThreadsFunctionAttribute, Error> parseNumThreadsFunctionAttribute(); >+ Expected<AST::AttributeBlock, Error> parseAttributeBlock(); >+ Expected<AST::Parameter, Error> parseParameter(); >+ Expected<AST::Parameters, Error> parseParameters(); >+ Expected<AST::FunctionDeclaration, Error> parseEntryPointFunctionDeclaration(); >+ Expected<AST::FunctionDeclaration, Error> parseRegularFunctionDeclaration(); >+ Expected<AST::FunctionDeclaration, Error> parseOperatorFunctionDeclaration(); >+ Expected<AST::FunctionDeclaration, Error> parseFunctionDeclaration(); >+ Expected<AST::FunctionDefinition, Error> parseFunctionDefinition(); >+ Expected<AST::NativeFunctionDeclaration, Error> parseNativeFunctionDeclaration(); >+ >+ Expected<AST::Block, Error> parseBlock(); >+ AST::Block parseBlockBody(Lexer::Token&& origin); >+ Expected<AST::IfStatement, Error> parseIfStatement(); >+ Expected<AST::SwitchStatement, Error> parseSwitchStatement(); >+ Expected<AST::SwitchCase, Error> parseSwitchCase(); >+ Expected<AST::ForLoop, Error> parseForLoop(); >+ Expected<AST::WhileLoop, Error> parseWhileLoop(); >+ Expected<AST::DoWhileLoop, Error> parseDoWhileLoop(); >+ Expected<AST::VariableDeclaration, Error> parseVariableDeclaration(std::unique_ptr<AST::Type>&&); >+ Expected<AST::VariableDeclarationsStatement, Error> parseVariableDeclarations(); >+ Expected<std::unique_ptr<AST::Statement>, Error> parseStatement(); >+ >+ Expected<std::unique_ptr<AST::Expression>, Error> parseEffectfulExpression(); >+ Expected<std::unique_ptr<AST::Expression>, Error> parseEffectfulAssignment(); >+ Expected<std::unique_ptr<AST::Expression>, Error> parseEffectfulPrefix(); >+ Expected<std::unique_ptr<AST::Expression>, Error> parseEffectfulSuffix(); >+ struct SuffixExpression { >+ SuffixExpression(std::unique_ptr<AST::Expression>&& result, bool success) >+ : result(WTFMove(result)) >+ , success(success) >+ { >+ } >+ >+ std::unique_ptr<AST::Expression> result; >+ bool success; >+ operator bool() const { return success; } >+ }; >+ SuffixExpression parseLimitedSuffixOperator(std::unique_ptr<AST::Expression>&&); >+ SuffixExpression parseSuffixOperator(std::unique_ptr<AST::Expression>&&); >+ >+ Expected<std::unique_ptr<AST::Expression>, Error> parseExpression(); >+ Expected<std::unique_ptr<AST::Expression>, Error> parseTernaryConditional(); >+ Expected<std::unique_ptr<AST::Expression>, Error> parseAssignment(); >+ Expected<std::unique_ptr<AST::Expression>, Error> parsePossibleTernaryConditional(); >+ Expected<std::unique_ptr<AST::Expression>, Error> parsePossibleLogicalBinaryOperation(); >+ Expected<std::unique_ptr<AST::Expression>, Error> parsePossibleRelationalBinaryOperation(); >+ Expected<std::unique_ptr<AST::Expression>, Error> parsePossibleShift(); >+ Expected<std::unique_ptr<AST::Expression>, Error> parsePossibleAdd(); >+ Expected<std::unique_ptr<AST::Expression>, Error> parsePossibleMultiply(); >+ Expected<std::unique_ptr<AST::Expression>, Error> parsePossiblePrefix(); >+ Expected<std::unique_ptr<AST::Expression>, Error> parsePossibleSuffix(); >+ Expected<std::unique_ptr<AST::Expression>, Error> parseCallExpression(); >+ Expected<std::unique_ptr<AST::Expression>, Error> parseTerm(); >+ >+ Lexer m_lexer; >+ Mode m_mode; >+}; >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLProgram.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLProgram.h >new file mode 100644 >index 00000000000..65e613a9fb3 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLProgram.h >@@ -0,0 +1,85 @@ >+/* >+ * Copyright (C) 2018 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBGPU) >+ >+#include "WHLSLASTEnumerationDefinition.h" >+#include "WHLSLASTFunctionDefinition.h" >+#include "WHLSLASTNativeFunctionDeclaration.h" >+#include "WHLSLASTNativeTypeDeclaration.h" >+#include "WHLSLASTStructureDefinition.h" >+#include "WHLSLASTTypeDefinition.h" >+#include <wtf/Vector.h> >+ >+namespace WebCore { >+ >+namespace WHLSL { >+ >+class Program { >+public: >+ Program() = default; >+ Program(Program&&) = default; >+ >+ void append(AST::TypeDefinition&& typeDefinition) >+ { >+ m_typeDefinitions.append(WTFMove(typeDefinition)); >+ } >+ void append(AST::StructureDefinition&& structureDefinition) >+ { >+ m_structureDefinitions.append(WTFMove(structureDefinition)); >+ } >+ void append(AST::EnumerationDefinition&& enumerationDefinition) >+ { >+ m_enumerationDefinitions.append(WTFMove(enumerationDefinition)); >+ } >+ void append(AST::FunctionDefinition&& functionDefinition) >+ { >+ m_functionDefinitions.append(WTFMove(functionDefinition)); >+ } >+ void append(AST::NativeFunctionDeclaration&& nativeFunctionDeclaration) >+ { >+ m_nativeFunctionDeclarations.append(WTFMove(nativeFunctionDeclaration)); >+ } >+ void append(AST::NativeTypeDeclaration&& nativeTypeDeclaration) >+ { >+ m_nativeTypeDeclarations.append(WTFMove(nativeTypeDeclaration)); >+ } >+ >+private: >+ Vector<AST::TypeDefinition> m_typeDefinitions; >+ Vector<AST::StructureDefinition> m_structureDefinitions; >+ Vector<AST::EnumerationDefinition> m_enumerationDefinitions; >+ Vector<AST::FunctionDefinition> m_functionDefinitions; >+ Vector<AST::NativeFunctionDeclaration> m_nativeFunctionDeclarations; >+ Vector<AST::NativeTypeDeclaration> m_nativeTypeDeclarations; >+}; >+ >+} >+ >+} >+ >+#endif >diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLStandardLibrary.txt b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLStandardLibrary.txt >new file mode 100644 >index 00000000000..823502910e9 >--- /dev/null >+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLStandardLibrary.txt >@@ -0,0 +1,91991 @@ >+// https://github.com/gpuweb/WHLSL/blob/9528f19aaa71fd5c3c706d2873f4b8c8cce857b5/Spec/source/Generate_Standard_Library.js >+// This was autogenerated from Generate_Standard_Library.js! Do not edit!! >+ >+native typedef void; >+native typedef bool; >+native typedef uchar; >+native typedef ushort; >+native typedef uint; >+native typedef char; >+native typedef short; >+native typedef int; >+native typedef half; >+native typedef float; >+native typedef atomic_int; >+native typedef atomic_uint; >+native typedef vector<bool, 2>; >+typedef bool2 = vector<bool, 2>; >+native typedef vector<bool, 3>; >+typedef bool3 = vector<bool, 3>; >+native typedef vector<bool, 4>; >+typedef bool4 = vector<bool, 4>; >+native typedef vector<uchar, 2>; >+typedef uchar2 = vector<uchar, 2>; >+native typedef vector<uchar, 3>; >+typedef uchar3 = vector<uchar, 3>; >+native typedef vector<uchar, 4>; >+typedef uchar4 = vector<uchar, 4>; >+native typedef vector<ushort, 2>; >+typedef ushort2 = vector<ushort, 2>; >+native typedef vector<ushort, 3>; >+typedef ushort3 = vector<ushort, 3>; >+native typedef vector<ushort, 4>; >+typedef ushort4 = vector<ushort, 4>; >+native typedef vector<uint, 2>; >+typedef uint2 = vector<uint, 2>; >+native typedef vector<uint, 3>; >+typedef uint3 = vector<uint, 3>; >+native typedef vector<uint, 4>; >+typedef uint4 = vector<uint, 4>; >+native typedef vector<char, 2>; >+typedef char2 = vector<char, 2>; >+native typedef vector<char, 3>; >+typedef char3 = vector<char, 3>; >+native typedef vector<char, 4>; >+typedef char4 = vector<char, 4>; >+native typedef vector<short, 2>; >+typedef short2 = vector<short, 2>; >+native typedef vector<short, 3>; >+typedef short3 = vector<short, 3>; >+native typedef vector<short, 4>; >+typedef short4 = vector<short, 4>; >+native typedef vector<int, 2>; >+typedef int2 = vector<int, 2>; >+native typedef vector<int, 3>; >+typedef int3 = vector<int, 3>; >+native typedef vector<int, 4>; >+typedef int4 = vector<int, 4>; >+native typedef vector<half, 2>; >+typedef half2 = vector<half, 2>; >+native typedef vector<half, 3>; >+typedef half3 = vector<half, 3>; >+native typedef vector<half, 4>; >+typedef half4 = vector<half, 4>; >+native typedef vector<float, 2>; >+typedef float2 = vector<float, 2>; >+native typedef vector<float, 3>; >+typedef float3 = vector<float, 3>; >+native typedef vector<float, 4>; >+typedef float4 = vector<float, 4>; >+ >+native typedef matrix<half, 2, 2>; >+typedef half2x2 = matrix<half, 2, 2>; >+native typedef matrix<half, 2, 3>; >+typedef half2x3 = matrix<half, 2, 3>; >+native typedef matrix<half, 2, 4>; >+typedef half2x4 = matrix<half, 2, 4>; >+native typedef matrix<half, 3, 2>; >+typedef half3x2 = matrix<half, 3, 2>; >+native typedef matrix<half, 3, 3>; >+typedef half3x3 = matrix<half, 3, 3>; >+native typedef matrix<half, 3, 4>; >+typedef half3x4 = matrix<half, 3, 4>; >+native typedef matrix<half, 4, 2>; >+typedef half4x2 = matrix<half, 4, 2>; >+native typedef matrix<half, 4, 3>; >+typedef half4x3 = matrix<half, 4, 3>; >+native typedef matrix<half, 4, 4>; >+typedef half4x4 = matrix<half, 4, 4>; >+native typedef matrix<float, 2, 2>; >+typedef float2x2 = matrix<float, 2, 2>; >+native typedef matrix<float, 2, 3>; >+typedef float2x3 = matrix<float, 2, 3>; >+native typedef matrix<float, 2, 4>; >+typedef float2x4 = matrix<float, 2, 4>; >+native typedef matrix<float, 3, 2>; >+typedef float3x2 = matrix<float, 3, 2>; >+native typedef matrix<float, 3, 3>; >+typedef float3x3 = matrix<float, 3, 3>; >+native typedef matrix<float, 3, 4>; >+typedef float3x4 = matrix<float, 3, 4>; >+native typedef matrix<float, 4, 2>; >+typedef float4x2 = matrix<float, 4, 2>; >+native typedef matrix<float, 4, 3>; >+typedef float4x3 = matrix<float, 4, 3>; >+native typedef matrix<float, 4, 4>; >+typedef float4x4 = matrix<float, 4, 4>; >+native typedef sampler; >+native typedef Texture1D<uchar>; >+native typedef Texture1D<uchar2>; >+native typedef Texture1D<uchar3>; >+native typedef Texture1D<uchar4>; >+native typedef Texture1D<ushort>; >+native typedef Texture1D<ushort2>; >+native typedef Texture1D<ushort3>; >+native typedef Texture1D<ushort4>; >+native typedef Texture1D<uint>; >+native typedef Texture1D<uint2>; >+native typedef Texture1D<uint3>; >+native typedef Texture1D<uint4>; >+native typedef Texture1D<char>; >+native typedef Texture1D<char2>; >+native typedef Texture1D<char3>; >+native typedef Texture1D<char4>; >+native typedef Texture1D<short>; >+native typedef Texture1D<short2>; >+native typedef Texture1D<short3>; >+native typedef Texture1D<short4>; >+native typedef Texture1D<int>; >+native typedef Texture1D<int2>; >+native typedef Texture1D<int3>; >+native typedef Texture1D<int4>; >+native typedef Texture1D<half>; >+native typedef Texture1D<half2>; >+native typedef Texture1D<half3>; >+native typedef Texture1D<half4>; >+native typedef Texture1D<float>; >+native typedef Texture1D<float2>; >+native typedef Texture1D<float3>; >+native typedef Texture1D<float4>; >+native typedef RWTexture1D<uchar>; >+native typedef RWTexture1D<uchar2>; >+native typedef RWTexture1D<uchar3>; >+native typedef RWTexture1D<uchar4>; >+native typedef RWTexture1D<ushort>; >+native typedef RWTexture1D<ushort2>; >+native typedef RWTexture1D<ushort3>; >+native typedef RWTexture1D<ushort4>; >+native typedef RWTexture1D<uint>; >+native typedef RWTexture1D<uint2>; >+native typedef RWTexture1D<uint3>; >+native typedef RWTexture1D<uint4>; >+native typedef RWTexture1D<char>; >+native typedef RWTexture1D<char2>; >+native typedef RWTexture1D<char3>; >+native typedef RWTexture1D<char4>; >+native typedef RWTexture1D<short>; >+native typedef RWTexture1D<short2>; >+native typedef RWTexture1D<short3>; >+native typedef RWTexture1D<short4>; >+native typedef RWTexture1D<int>; >+native typedef RWTexture1D<int2>; >+native typedef RWTexture1D<int3>; >+native typedef RWTexture1D<int4>; >+native typedef RWTexture1D<half>; >+native typedef RWTexture1D<half2>; >+native typedef RWTexture1D<half3>; >+native typedef RWTexture1D<half4>; >+native typedef RWTexture1D<float>; >+native typedef RWTexture1D<float2>; >+native typedef RWTexture1D<float3>; >+native typedef RWTexture1D<float4>; >+native typedef Texture1DArray<uchar>; >+native typedef Texture1DArray<uchar2>; >+native typedef Texture1DArray<uchar3>; >+native typedef Texture1DArray<uchar4>; >+native typedef Texture1DArray<ushort>; >+native typedef Texture1DArray<ushort2>; >+native typedef Texture1DArray<ushort3>; >+native typedef Texture1DArray<ushort4>; >+native typedef Texture1DArray<uint>; >+native typedef Texture1DArray<uint2>; >+native typedef Texture1DArray<uint3>; >+native typedef Texture1DArray<uint4>; >+native typedef Texture1DArray<char>; >+native typedef Texture1DArray<char2>; >+native typedef Texture1DArray<char3>; >+native typedef Texture1DArray<char4>; >+native typedef Texture1DArray<short>; >+native typedef Texture1DArray<short2>; >+native typedef Texture1DArray<short3>; >+native typedef Texture1DArray<short4>; >+native typedef Texture1DArray<int>; >+native typedef Texture1DArray<int2>; >+native typedef Texture1DArray<int3>; >+native typedef Texture1DArray<int4>; >+native typedef Texture1DArray<half>; >+native typedef Texture1DArray<half2>; >+native typedef Texture1DArray<half3>; >+native typedef Texture1DArray<half4>; >+native typedef Texture1DArray<float>; >+native typedef Texture1DArray<float2>; >+native typedef Texture1DArray<float3>; >+native typedef Texture1DArray<float4>; >+native typedef RWTexture1DArray<uchar>; >+native typedef RWTexture1DArray<uchar2>; >+native typedef RWTexture1DArray<uchar3>; >+native typedef RWTexture1DArray<uchar4>; >+native typedef RWTexture1DArray<ushort>; >+native typedef RWTexture1DArray<ushort2>; >+native typedef RWTexture1DArray<ushort3>; >+native typedef RWTexture1DArray<ushort4>; >+native typedef RWTexture1DArray<uint>; >+native typedef RWTexture1DArray<uint2>; >+native typedef RWTexture1DArray<uint3>; >+native typedef RWTexture1DArray<uint4>; >+native typedef RWTexture1DArray<char>; >+native typedef RWTexture1DArray<char2>; >+native typedef RWTexture1DArray<char3>; >+native typedef RWTexture1DArray<char4>; >+native typedef RWTexture1DArray<short>; >+native typedef RWTexture1DArray<short2>; >+native typedef RWTexture1DArray<short3>; >+native typedef RWTexture1DArray<short4>; >+native typedef RWTexture1DArray<int>; >+native typedef RWTexture1DArray<int2>; >+native typedef RWTexture1DArray<int3>; >+native typedef RWTexture1DArray<int4>; >+native typedef RWTexture1DArray<half>; >+native typedef RWTexture1DArray<half2>; >+native typedef RWTexture1DArray<half3>; >+native typedef RWTexture1DArray<half4>; >+native typedef RWTexture1DArray<float>; >+native typedef RWTexture1DArray<float2>; >+native typedef RWTexture1DArray<float3>; >+native typedef RWTexture1DArray<float4>; >+native typedef Texture2D<uchar>; >+native typedef Texture2D<uchar2>; >+native typedef Texture2D<uchar3>; >+native typedef Texture2D<uchar4>; >+native typedef Texture2D<ushort>; >+native typedef Texture2D<ushort2>; >+native typedef Texture2D<ushort3>; >+native typedef Texture2D<ushort4>; >+native typedef Texture2D<uint>; >+native typedef Texture2D<uint2>; >+native typedef Texture2D<uint3>; >+native typedef Texture2D<uint4>; >+native typedef Texture2D<char>; >+native typedef Texture2D<char2>; >+native typedef Texture2D<char3>; >+native typedef Texture2D<char4>; >+native typedef Texture2D<short>; >+native typedef Texture2D<short2>; >+native typedef Texture2D<short3>; >+native typedef Texture2D<short4>; >+native typedef Texture2D<int>; >+native typedef Texture2D<int2>; >+native typedef Texture2D<int3>; >+native typedef Texture2D<int4>; >+native typedef Texture2D<half>; >+native typedef Texture2D<half2>; >+native typedef Texture2D<half3>; >+native typedef Texture2D<half4>; >+native typedef Texture2D<float>; >+native typedef Texture2D<float2>; >+native typedef Texture2D<float3>; >+native typedef Texture2D<float4>; >+native typedef RWTexture2D<uchar>; >+native typedef RWTexture2D<uchar2>; >+native typedef RWTexture2D<uchar3>; >+native typedef RWTexture2D<uchar4>; >+native typedef RWTexture2D<ushort>; >+native typedef RWTexture2D<ushort2>; >+native typedef RWTexture2D<ushort3>; >+native typedef RWTexture2D<ushort4>; >+native typedef RWTexture2D<uint>; >+native typedef RWTexture2D<uint2>; >+native typedef RWTexture2D<uint3>; >+native typedef RWTexture2D<uint4>; >+native typedef RWTexture2D<char>; >+native typedef RWTexture2D<char2>; >+native typedef RWTexture2D<char3>; >+native typedef RWTexture2D<char4>; >+native typedef RWTexture2D<short>; >+native typedef RWTexture2D<short2>; >+native typedef RWTexture2D<short3>; >+native typedef RWTexture2D<short4>; >+native typedef RWTexture2D<int>; >+native typedef RWTexture2D<int2>; >+native typedef RWTexture2D<int3>; >+native typedef RWTexture2D<int4>; >+native typedef RWTexture2D<half>; >+native typedef RWTexture2D<half2>; >+native typedef RWTexture2D<half3>; >+native typedef RWTexture2D<half4>; >+native typedef RWTexture2D<float>; >+native typedef RWTexture2D<float2>; >+native typedef RWTexture2D<float3>; >+native typedef RWTexture2D<float4>; >+native typedef Texture2DArray<uchar>; >+native typedef Texture2DArray<uchar2>; >+native typedef Texture2DArray<uchar3>; >+native typedef Texture2DArray<uchar4>; >+native typedef Texture2DArray<ushort>; >+native typedef Texture2DArray<ushort2>; >+native typedef Texture2DArray<ushort3>; >+native typedef Texture2DArray<ushort4>; >+native typedef Texture2DArray<uint>; >+native typedef Texture2DArray<uint2>; >+native typedef Texture2DArray<uint3>; >+native typedef Texture2DArray<uint4>; >+native typedef Texture2DArray<char>; >+native typedef Texture2DArray<char2>; >+native typedef Texture2DArray<char3>; >+native typedef Texture2DArray<char4>; >+native typedef Texture2DArray<short>; >+native typedef Texture2DArray<short2>; >+native typedef Texture2DArray<short3>; >+native typedef Texture2DArray<short4>; >+native typedef Texture2DArray<int>; >+native typedef Texture2DArray<int2>; >+native typedef Texture2DArray<int3>; >+native typedef Texture2DArray<int4>; >+native typedef Texture2DArray<half>; >+native typedef Texture2DArray<half2>; >+native typedef Texture2DArray<half3>; >+native typedef Texture2DArray<half4>; >+native typedef Texture2DArray<float>; >+native typedef Texture2DArray<float2>; >+native typedef Texture2DArray<float3>; >+native typedef Texture2DArray<float4>; >+native typedef RWTexture2DArray<uchar>; >+native typedef RWTexture2DArray<uchar2>; >+native typedef RWTexture2DArray<uchar3>; >+native typedef RWTexture2DArray<uchar4>; >+native typedef RWTexture2DArray<ushort>; >+native typedef RWTexture2DArray<ushort2>; >+native typedef RWTexture2DArray<ushort3>; >+native typedef RWTexture2DArray<ushort4>; >+native typedef RWTexture2DArray<uint>; >+native typedef RWTexture2DArray<uint2>; >+native typedef RWTexture2DArray<uint3>; >+native typedef RWTexture2DArray<uint4>; >+native typedef RWTexture2DArray<char>; >+native typedef RWTexture2DArray<char2>; >+native typedef RWTexture2DArray<char3>; >+native typedef RWTexture2DArray<char4>; >+native typedef RWTexture2DArray<short>; >+native typedef RWTexture2DArray<short2>; >+native typedef RWTexture2DArray<short3>; >+native typedef RWTexture2DArray<short4>; >+native typedef RWTexture2DArray<int>; >+native typedef RWTexture2DArray<int2>; >+native typedef RWTexture2DArray<int3>; >+native typedef RWTexture2DArray<int4>; >+native typedef RWTexture2DArray<half>; >+native typedef RWTexture2DArray<half2>; >+native typedef RWTexture2DArray<half3>; >+native typedef RWTexture2DArray<half4>; >+native typedef RWTexture2DArray<float>; >+native typedef RWTexture2DArray<float2>; >+native typedef RWTexture2DArray<float3>; >+native typedef RWTexture2DArray<float4>; >+native typedef Texture3D<uchar>; >+native typedef Texture3D<uchar2>; >+native typedef Texture3D<uchar3>; >+native typedef Texture3D<uchar4>; >+native typedef Texture3D<ushort>; >+native typedef Texture3D<ushort2>; >+native typedef Texture3D<ushort3>; >+native typedef Texture3D<ushort4>; >+native typedef Texture3D<uint>; >+native typedef Texture3D<uint2>; >+native typedef Texture3D<uint3>; >+native typedef Texture3D<uint4>; >+native typedef Texture3D<char>; >+native typedef Texture3D<char2>; >+native typedef Texture3D<char3>; >+native typedef Texture3D<char4>; >+native typedef Texture3D<short>; >+native typedef Texture3D<short2>; >+native typedef Texture3D<short3>; >+native typedef Texture3D<short4>; >+native typedef Texture3D<int>; >+native typedef Texture3D<int2>; >+native typedef Texture3D<int3>; >+native typedef Texture3D<int4>; >+native typedef Texture3D<half>; >+native typedef Texture3D<half2>; >+native typedef Texture3D<half3>; >+native typedef Texture3D<half4>; >+native typedef Texture3D<float>; >+native typedef Texture3D<float2>; >+native typedef Texture3D<float3>; >+native typedef Texture3D<float4>; >+native typedef RWTexture3D<uchar>; >+native typedef RWTexture3D<uchar2>; >+native typedef RWTexture3D<uchar3>; >+native typedef RWTexture3D<uchar4>; >+native typedef RWTexture3D<ushort>; >+native typedef RWTexture3D<ushort2>; >+native typedef RWTexture3D<ushort3>; >+native typedef RWTexture3D<ushort4>; >+native typedef RWTexture3D<uint>; >+native typedef RWTexture3D<uint2>; >+native typedef RWTexture3D<uint3>; >+native typedef RWTexture3D<uint4>; >+native typedef RWTexture3D<char>; >+native typedef RWTexture3D<char2>; >+native typedef RWTexture3D<char3>; >+native typedef RWTexture3D<char4>; >+native typedef RWTexture3D<short>; >+native typedef RWTexture3D<short2>; >+native typedef RWTexture3D<short3>; >+native typedef RWTexture3D<short4>; >+native typedef RWTexture3D<int>; >+native typedef RWTexture3D<int2>; >+native typedef RWTexture3D<int3>; >+native typedef RWTexture3D<int4>; >+native typedef RWTexture3D<half>; >+native typedef RWTexture3D<half2>; >+native typedef RWTexture3D<half3>; >+native typedef RWTexture3D<half4>; >+native typedef RWTexture3D<float>; >+native typedef RWTexture3D<float2>; >+native typedef RWTexture3D<float3>; >+native typedef RWTexture3D<float4>; >+native typedef TextureCube<uchar>; >+native typedef TextureCube<uchar2>; >+native typedef TextureCube<uchar3>; >+native typedef TextureCube<uchar4>; >+native typedef TextureCube<ushort>; >+native typedef TextureCube<ushort2>; >+native typedef TextureCube<ushort3>; >+native typedef TextureCube<ushort4>; >+native typedef TextureCube<uint>; >+native typedef TextureCube<uint2>; >+native typedef TextureCube<uint3>; >+native typedef TextureCube<uint4>; >+native typedef TextureCube<char>; >+native typedef TextureCube<char2>; >+native typedef TextureCube<char3>; >+native typedef TextureCube<char4>; >+native typedef TextureCube<short>; >+native typedef TextureCube<short2>; >+native typedef TextureCube<short3>; >+native typedef TextureCube<short4>; >+native typedef TextureCube<int>; >+native typedef TextureCube<int2>; >+native typedef TextureCube<int3>; >+native typedef TextureCube<int4>; >+native typedef TextureCube<half>; >+native typedef TextureCube<half2>; >+native typedef TextureCube<half3>; >+native typedef TextureCube<half4>; >+native typedef TextureCube<float>; >+native typedef TextureCube<float2>; >+native typedef TextureCube<float3>; >+native typedef TextureCube<float4>; >+native typedef TextureDepth2D<float>; >+native typedef TextureDepth2D<half>; >+native typedef RWTextureDepth2D<float>; >+native typedef RWTextureDepth2D<half>; >+native typedef TextureDepth2DArray<float>; >+native typedef TextureDepth2DArray<half>; >+native typedef RWTextureDepth2DArray<float>; >+native typedef RWTextureDepth2DArray<half>; >+native typedef TextureDepthCube<float>; >+native typedef TextureDepthCube<half>; >+ >+native operator uchar(ushort); >+native operator uchar(uint); >+native operator uchar(char); >+native operator uchar(short); >+native operator uchar(int); >+native operator uchar(half); >+native operator uchar(float); >+native operator ushort(uchar); >+native operator ushort(uint); >+native operator ushort(char); >+native operator ushort(short); >+native operator ushort(int); >+native operator ushort(half); >+native operator ushort(float); >+native operator uint(uchar); >+native operator uint(ushort); >+native operator uint(char); >+native operator uint(short); >+native operator uint(int); >+native operator uint(half); >+native operator uint(float); >+native operator char(uchar); >+native operator char(ushort); >+native operator char(uint); >+native operator char(short); >+native operator char(int); >+native operator char(half); >+native operator char(float); >+native operator short(uchar); >+native operator short(ushort); >+native operator short(uint); >+native operator short(char); >+native operator short(int); >+native operator short(half); >+native operator short(float); >+native operator int(uchar); >+native operator int(ushort); >+native operator int(uint); >+native operator int(char); >+native operator int(short); >+native operator int(half); >+native operator int(float); >+native operator half(uchar); >+native operator half(ushort); >+native operator half(uint); >+native operator half(char); >+native operator half(short); >+native operator half(int); >+native operator half(float); >+native operator float(uchar); >+native operator float(ushort); >+native operator float(uint); >+native operator float(char); >+native operator float(short); >+native operator float(int); >+native operator float(half); >+ >+operator bool(uchar x) { >+ return x != 0; >+} >+operator bool(ushort x) { >+ return x != 0; >+} >+operator bool(uint x) { >+ return x != 0; >+} >+operator bool(char x) { >+ return x != 0; >+} >+operator bool(short x) { >+ return x != 0; >+} >+operator bool(int x) { >+ return x != 0; >+} >+operator bool(half x) { >+ return x != 0; >+} >+operator bool(float x) { >+ return x != 0; >+} >+ >+native operator int(atomic_int); >+native operator uint(atomic_uint); >+ >+native bool operator==(bool, bool); >+bool operator&(bool a, bool b) { >+ return a && b; >+} >+bool operator|(bool a, bool b) { >+ return a || b; >+} >+bool operator^(bool a, bool b) { >+ if (a) >+ return !b; >+ return b; >+} >+bool operator~(bool value) { >+ return !value; >+} >+native int operator+(int, int); >+native int operator-(int, int); >+native int operator*(int, int); >+native int operator/(int, int); >+native bool operator==(int, int); >+native bool operator<(int, int); >+native bool operator<=(int, int); >+native bool operator>(int, int); >+native bool operator>=(int, int); >+native uint operator+(uint, uint); >+native uint operator-(uint, uint); >+native uint operator*(uint, uint); >+native uint operator/(uint, uint); >+native bool operator==(uint, uint); >+native bool operator<(uint, uint); >+native bool operator<=(uint, uint); >+native bool operator>(uint, uint); >+native bool operator>=(uint, uint); >+native float operator+(float, float); >+native float operator-(float, float); >+native float operator*(float, float); >+native float operator/(float, float); >+native bool operator==(float, float); >+native bool operator<(float, float); >+native bool operator<=(float, float); >+native bool operator>(float, float); >+native bool operator>=(float, float); >+native int operator&(int, int); >+native int operator|(int, int); >+native int operator^(int, int); >+native int operator~(int); >+native int operator<<(int, uint); >+native int operator>>(int, uint); >+native uint operator&(uint, uint); >+native uint operator|(uint, uint); >+native uint operator^(uint, uint); >+native uint operator~(uint); >+native uint operator<<(uint, uint); >+native uint operator>>(uint, uint); >+uchar operator+(uchar a, uchar b) { >+ return uchar(uint(a) + uint(b)); >+} >+uchar operator-(uchar a, uchar b) { >+ return uchar(uint(a) - uint(b)); >+} >+uchar operator*(uchar a, uchar b) { >+ return uchar(uint(a) * uint(b)); >+} >+uchar operator/(uchar a, uchar b) { >+ return uchar(uint(a) / uint(b)); >+} >+uchar operator&(uchar a, uchar b) { >+ return uchar(uint(a) & uint(b)); >+} >+uchar operator|(uchar a, uchar b) { >+ return uchar(uint(a) | uint(b)); >+} >+uchar operator^(uchar a, uchar b) { >+ return uchar(uint(a) ^ uint(b)); >+} >+uchar operator~(uchar a) { >+ return uint(a); >+} >+bool operator==(uchar a, uchar b) { >+ return uint(a) == uint(b); >+} >+bool operator<(uchar a, uchar b) { >+ return uint(a) < uint(b); >+} >+bool operator<=(uchar a, uchar b) { >+ return uint(a) <= uint(b); >+} >+bool operator>(uchar a, uchar b) { >+ return uint(a) > uint(b); >+} >+bool operator>=(uchar a, uchar b) { >+ return uint(a) >= uint(b); >+} >+ushort operator+(ushort a, ushort b) { >+ return ushort(uint(a) + uint(b)); >+} >+ushort operator-(ushort a, ushort b) { >+ return ushort(uint(a) - uint(b)); >+} >+ushort operator*(ushort a, ushort b) { >+ return ushort(uint(a) * uint(b)); >+} >+ushort operator/(ushort a, ushort b) { >+ return ushort(uint(a) / uint(b)); >+} >+ushort operator&(ushort a, ushort b) { >+ return ushort(uint(a) & uint(b)); >+} >+ushort operator|(ushort a, ushort b) { >+ return ushort(uint(a) | uint(b)); >+} >+ushort operator^(ushort a, ushort b) { >+ return ushort(uint(a) ^ uint(b)); >+} >+ushort operator~(ushort a) { >+ return ushort(~uint(a)); >+} >+bool operator==(ushort a, ushort b) { >+ return uint(a) == uint(b); >+} >+bool operator<(ushort a, ushort b) { >+ return uint(a) < uint(b); >+} >+bool operator<=(ushort a, ushort b) { >+ return uint(a) <= uint(b); >+} >+bool operator>(ushort a, ushort b) { >+ return uint(a) > uint(b); >+} >+bool operator>=(ushort a, ushort b) { >+ return uint(a) >= uint(b); >+} >+uchar operator<<(uchar a, uint b) { >+ return uchar(uint(a) << (b & 255)); >+} >+ushort operator<<(ushort a, uint b) { >+ return ushort(uint(a) << (b & 65535)); >+} >+uchar operator>>(uchar a, uint b) { >+ return uchar(uint(a) >> (b & 255)); >+} >+ushort operator>>(ushort a, uint b) { >+ return ushort(uint(a) >> (b & 65535)); >+} >+char operator+(char a, char b) { >+ return char(int(a) + int(b)); >+} >+char operator-(char a, char b) { >+ return char(int(a) - int(b)); >+} >+char operator*(char a, char b) { >+ return char(int(a) * int(b)); >+} >+char operator/(char a, char b) { >+ return char(int(a) / int(b)); >+} >+char operator&(char a, char b) { >+ return char(int(a) & int(b)); >+} >+char operator|(char a, char b) { >+ return char(int(a) | int(b)); >+} >+char operator^(char a, char b) { >+ return char(int(a) ^ int(b)); >+} >+char operator~(char a) { >+ return char(~int(a)); >+} >+bool operator==(char a, char b) { >+ return int(a) == int(b); >+} >+bool operator>(char a, char b) { >+ return int(a) > int(b); >+} >+bool operator>=(char a, char b) { >+ return int(a) >= int(b); >+} >+bool operator<(char a, char b) { >+ return int(a) < int(b); >+} >+bool operator<=(char a, char b) { >+ return int(a) <= int(b); >+} >+short operator+(short a, short b) { >+ return short(int(a) + int(b)); >+} >+short operator-(short a, short b) { >+ return short(int(a) - int(b)); >+} >+short operator*(short a, short b) { >+ return short(int(a) * int(b)); >+} >+short operator/(short a, short b) { >+ return short(int(a) / int(b)); >+} >+short operator&(short a, short b) { >+ return short(int(a) & int(b)); >+} >+short operator|(short a, short b) { >+ return short(int(a) | int(b)); >+} >+short operator^(short a, short b) { >+ return short(int(a) ^ int(b)); >+} >+short operator~(short a) { >+ return short(~int(a)); >+} >+bool operator==(short a, short b) { >+ return int(a) == int(b); >+} >+bool operator>(short a, short b) { >+ return int(a) > int(b); >+} >+bool operator>=(short a, short b) { >+ return int(a) >= int(b); >+} >+bool operator<(short a, short b) { >+ return int(a) < int(b); >+} >+bool operator<=(short a, short b) { >+ return int(a) <= int(b); >+} >+char operator<<(char a, uint b) { >+ return char(int(a) << (b & 255)); >+} >+short operator<<(short a, uint b) { >+ return short(int(a) << (b & 65535)); >+} >+char operator>>(char a, uint b) { >+ return char(int(a) >> (b & 255)); >+} >+short operator>>(short a, uint b) { >+ return short(int(a) >> (b & 65535)); >+} >+uchar operator++(uchar value) { >+ return value + 1; >+} >+uchar operator--(uchar value) { >+ return value - 1; >+} >+ushort operator++(ushort value) { >+ return value + 1; >+} >+ushort operator--(ushort value) { >+ return value - 1; >+} >+uint operator++(uint value) { >+ return value + 1; >+} >+uint operator--(uint value) { >+ return value - 1; >+} >+char operator++(char value) { >+ return value + 1; >+} >+char operator--(char value) { >+ return value - 1; >+} >+short operator++(short value) { >+ return value + 1; >+} >+short operator--(short value) { >+ return value - 1; >+} >+int operator++(int value) { >+ return value + 1; >+} >+int operator--(int value) { >+ return value - 1; >+} >+half operator++(half value) { >+ return value + 1; >+} >+half operator--(half value) { >+ return value - 1; >+} >+float operator++(float value) { >+ return value + 1; >+} >+float operator--(float value) { >+ return value - 1; >+} >+half operator+(half a, half b) { >+ return half(float(a) + float(b)); >+} >+half operator-(half a, half b) { >+ return half(float(a) - float(b)); >+} >+half operator*(half a, half b) { >+ return half(float(a) * float(b)); >+} >+half operator/(half a, half b) { >+ return half(float(a) / float(b)); >+} >+bool operator==(half a, half b) { >+ return float(a) == float(b); >+} >+bool operator<(half a, half b) { >+ return float(a) < float(b); >+} >+bool operator<=(half a, half b) { >+ return float(a) <= float(b); >+} >+bool operator>(half a, half b) { >+ return float(a) < float(b); >+} >+bool operator>=(half a, half b) { >+ return float(a) <= float(b); >+} >+char operator-(char x) { >+ return char(-int(x)); >+} >+short operator-(short x) { >+ return short(-int(x)); >+} >+half operator-(half x) { >+ return half(-float(x)); >+} >+native int operator-(int); >+native float operator-(float); >+ >+uchar2 operator+(uchar2 a, uchar2 b) { >+ uchar2 result; >+ result[0] = a[0] + b[0]; >+ result[1] = a[1] + b[1]; >+ return result; >+} >+uchar2 operator-(uchar2 a, uchar2 b) { >+ uchar2 result; >+ result[0] = a[0] - b[0]; >+ result[1] = a[1] - b[1]; >+ return result; >+} >+uchar2 operator*(uchar2 a, uchar2 b) { >+ uchar2 result; >+ result[0] = a[0] * b[0]; >+ result[1] = a[1] * b[1]; >+ return result; >+} >+uchar2 operator*(uchar2 a, uchar b) { >+ uchar2 result; >+ result[0] = a[0] * b; >+ result[1] = a[1] * b; >+ return result; >+} >+uchar2 operator*(uchar a, uchar2 b) { >+ uchar2 result; >+ result[0] = a * b[0]; >+ result[1] = a * b[1]; >+ return result; >+} >+uchar2 operator/(uchar2 a, uchar2 b) { >+ uchar2 result; >+ result[0] = a[0] / b[0]; >+ result[1] = a[1] / b[1]; >+ return result; >+} >+uchar2 operator/(uchar2 a, uchar b) { >+ uchar2 result; >+ result[0] = a[0] / b; >+ result[1] = a[1] / b; >+ return result; >+} >+uchar2 operator/(uchar a, uchar2 b) { >+ uchar2 result; >+ result[0] = a / b[0]; >+ result[1] = a / b[1]; >+ return result; >+} >+uchar3 operator+(uchar3 a, uchar3 b) { >+ uchar3 result; >+ result[0] = a[0] + b[0]; >+ result[1] = a[1] + b[1]; >+ result[2] = a[2] + b[2]; >+ return result; >+} >+uchar3 operator-(uchar3 a, uchar3 b) { >+ uchar3 result; >+ result[0] = a[0] - b[0]; >+ result[1] = a[1] - b[1]; >+ result[2] = a[2] - b[2]; >+ return result; >+} >+uchar3 operator*(uchar3 a, uchar3 b) { >+ uchar3 result; >+ result[0] = a[0] * b[0]; >+ result[1] = a[1] * b[1]; >+ result[2] = a[2] * b[2]; >+ return result; >+} >+uchar3 operator*(uchar3 a, uchar b) { >+ uchar3 result; >+ result[0] = a[0] * b; >+ result[1] = a[1] * b; >+ result[2] = a[2] * b; >+ return result; >+} >+uchar3 operator*(uchar a, uchar3 b) { >+ uchar3 result; >+ result[0] = a * b[0]; >+ result[1] = a * b[1]; >+ result[2] = a * b[2]; >+ return result; >+} >+uchar3 operator/(uchar3 a, uchar3 b) { >+ uchar3 result; >+ result[0] = a[0] / b[0]; >+ result[1] = a[1] / b[1]; >+ result[2] = a[2] / b[2]; >+ return result; >+} >+uchar3 operator/(uchar3 a, uchar b) { >+ uchar3 result; >+ result[0] = a[0] / b; >+ result[1] = a[1] / b; >+ result[2] = a[2] / b; >+ return result; >+} >+uchar3 operator/(uchar a, uchar3 b) { >+ uchar3 result; >+ result[0] = a / b[0]; >+ result[1] = a / b[1]; >+ result[2] = a / b[2]; >+ return result; >+} >+uchar4 operator+(uchar4 a, uchar4 b) { >+ uchar4 result; >+ result[0] = a[0] + b[0]; >+ result[1] = a[1] + b[1]; >+ result[2] = a[2] + b[2]; >+ result[3] = a[3] + b[3]; >+ return result; >+} >+uchar4 operator-(uchar4 a, uchar4 b) { >+ uchar4 result; >+ result[0] = a[0] - b[0]; >+ result[1] = a[1] - b[1]; >+ result[2] = a[2] - b[2]; >+ result[3] = a[3] - b[3]; >+ return result; >+} >+uchar4 operator*(uchar4 a, uchar4 b) { >+ uchar4 result; >+ result[0] = a[0] * b[0]; >+ result[1] = a[1] * b[1]; >+ result[2] = a[2] * b[2]; >+ result[3] = a[3] * b[3]; >+ return result; >+} >+uchar4 operator*(uchar4 a, uchar b) { >+ uchar4 result; >+ result[0] = a[0] * b; >+ result[1] = a[1] * b; >+ result[2] = a[2] * b; >+ result[3] = a[3] * b; >+ return result; >+} >+uchar4 operator*(uchar a, uchar4 b) { >+ uchar4 result; >+ result[0] = a * b[0]; >+ result[1] = a * b[1]; >+ result[2] = a * b[2]; >+ result[3] = a * b[3]; >+ return result; >+} >+uchar4 operator/(uchar4 a, uchar4 b) { >+ uchar4 result; >+ result[0] = a[0] / b[0]; >+ result[1] = a[1] / b[1]; >+ result[2] = a[2] / b[2]; >+ result[3] = a[3] / b[3]; >+ return result; >+} >+uchar4 operator/(uchar4 a, uchar b) { >+ uchar4 result; >+ result[0] = a[0] / b; >+ result[1] = a[1] / b; >+ result[2] = a[2] / b; >+ result[3] = a[3] / b; >+ return result; >+} >+uchar4 operator/(uchar a, uchar4 b) { >+ uchar4 result; >+ result[0] = a / b[0]; >+ result[1] = a / b[1]; >+ result[2] = a / b[2]; >+ result[3] = a / b[3]; >+ return result; >+} >+ushort2 operator+(ushort2 a, ushort2 b) { >+ ushort2 result; >+ result[0] = a[0] + b[0]; >+ result[1] = a[1] + b[1]; >+ return result; >+} >+ushort2 operator-(ushort2 a, ushort2 b) { >+ ushort2 result; >+ result[0] = a[0] - b[0]; >+ result[1] = a[1] - b[1]; >+ return result; >+} >+ushort2 operator*(ushort2 a, ushort2 b) { >+ ushort2 result; >+ result[0] = a[0] * b[0]; >+ result[1] = a[1] * b[1]; >+ return result; >+} >+ushort2 operator*(ushort2 a, ushort b) { >+ ushort2 result; >+ result[0] = a[0] * b; >+ result[1] = a[1] * b; >+ return result; >+} >+ushort2 operator*(ushort a, ushort2 b) { >+ ushort2 result; >+ result[0] = a * b[0]; >+ result[1] = a * b[1]; >+ return result; >+} >+ushort2 operator/(ushort2 a, ushort2 b) { >+ ushort2 result; >+ result[0] = a[0] / b[0]; >+ result[1] = a[1] / b[1]; >+ return result; >+} >+ushort2 operator/(ushort2 a, ushort b) { >+ ushort2 result; >+ result[0] = a[0] / b; >+ result[1] = a[1] / b; >+ return result; >+} >+ushort2 operator/(ushort a, ushort2 b) { >+ ushort2 result; >+ result[0] = a / b[0]; >+ result[1] = a / b[1]; >+ return result; >+} >+ushort3 operator+(ushort3 a, ushort3 b) { >+ ushort3 result; >+ result[0] = a[0] + b[0]; >+ result[1] = a[1] + b[1]; >+ result[2] = a[2] + b[2]; >+ return result; >+} >+ushort3 operator-(ushort3 a, ushort3 b) { >+ ushort3 result; >+ result[0] = a[0] - b[0]; >+ result[1] = a[1] - b[1]; >+ result[2] = a[2] - b[2]; >+ return result; >+} >+ushort3 operator*(ushort3 a, ushort3 b) { >+ ushort3 result; >+ result[0] = a[0] * b[0]; >+ result[1] = a[1] * b[1]; >+ result[2] = a[2] * b[2]; >+ return result; >+} >+ushort3 operator*(ushort3 a, ushort b) { >+ ushort3 result; >+ result[0] = a[0] * b; >+ result[1] = a[1] * b; >+ result[2] = a[2] * b; >+ return result; >+} >+ushort3 operator*(ushort a, ushort3 b) { >+ ushort3 result; >+ result[0] = a * b[0]; >+ result[1] = a * b[1]; >+ result[2] = a * b[2]; >+ return result; >+} >+ushort3 operator/(ushort3 a, ushort3 b) { >+ ushort3 result; >+ result[0] = a[0] / b[0]; >+ result[1] = a[1] / b[1]; >+ result[2] = a[2] / b[2]; >+ return result; >+} >+ushort3 operator/(ushort3 a, ushort b) { >+ ushort3 result; >+ result[0] = a[0] / b; >+ result[1] = a[1] / b; >+ result[2] = a[2] / b; >+ return result; >+} >+ushort3 operator/(ushort a, ushort3 b) { >+ ushort3 result; >+ result[0] = a / b[0]; >+ result[1] = a / b[1]; >+ result[2] = a / b[2]; >+ return result; >+} >+ushort4 operator+(ushort4 a, ushort4 b) { >+ ushort4 result; >+ result[0] = a[0] + b[0]; >+ result[1] = a[1] + b[1]; >+ result[2] = a[2] + b[2]; >+ result[3] = a[3] + b[3]; >+ return result; >+} >+ushort4 operator-(ushort4 a, ushort4 b) { >+ ushort4 result; >+ result[0] = a[0] - b[0]; >+ result[1] = a[1] - b[1]; >+ result[2] = a[2] - b[2]; >+ result[3] = a[3] - b[3]; >+ return result; >+} >+ushort4 operator*(ushort4 a, ushort4 b) { >+ ushort4 result; >+ result[0] = a[0] * b[0]; >+ result[1] = a[1] * b[1]; >+ result[2] = a[2] * b[2]; >+ result[3] = a[3] * b[3]; >+ return result; >+} >+ushort4 operator*(ushort4 a, ushort b) { >+ ushort4 result; >+ result[0] = a[0] * b; >+ result[1] = a[1] * b; >+ result[2] = a[2] * b; >+ result[3] = a[3] * b; >+ return result; >+} >+ushort4 operator*(ushort a, ushort4 b) { >+ ushort4 result; >+ result[0] = a * b[0]; >+ result[1] = a * b[1]; >+ result[2] = a * b[2]; >+ result[3] = a * b[3]; >+ return result; >+} >+ushort4 operator/(ushort4 a, ushort4 b) { >+ ushort4 result; >+ result[0] = a[0] / b[0]; >+ result[1] = a[1] / b[1]; >+ result[2] = a[2] / b[2]; >+ result[3] = a[3] / b[3]; >+ return result; >+} >+ushort4 operator/(ushort4 a, ushort b) { >+ ushort4 result; >+ result[0] = a[0] / b; >+ result[1] = a[1] / b; >+ result[2] = a[2] / b; >+ result[3] = a[3] / b; >+ return result; >+} >+ushort4 operator/(ushort a, ushort4 b) { >+ ushort4 result; >+ result[0] = a / b[0]; >+ result[1] = a / b[1]; >+ result[2] = a / b[2]; >+ result[3] = a / b[3]; >+ return result; >+} >+uint2 operator+(uint2 a, uint2 b) { >+ uint2 result; >+ result[0] = a[0] + b[0]; >+ result[1] = a[1] + b[1]; >+ return result; >+} >+uint2 operator-(uint2 a, uint2 b) { >+ uint2 result; >+ result[0] = a[0] - b[0]; >+ result[1] = a[1] - b[1]; >+ return result; >+} >+uint2 operator*(uint2 a, uint2 b) { >+ uint2 result; >+ result[0] = a[0] * b[0]; >+ result[1] = a[1] * b[1]; >+ return result; >+} >+uint2 operator*(uint2 a, uint b) { >+ uint2 result; >+ result[0] = a[0] * b; >+ result[1] = a[1] * b; >+ return result; >+} >+uint2 operator*(uint a, uint2 b) { >+ uint2 result; >+ result[0] = a * b[0]; >+ result[1] = a * b[1]; >+ return result; >+} >+uint2 operator/(uint2 a, uint2 b) { >+ uint2 result; >+ result[0] = a[0] / b[0]; >+ result[1] = a[1] / b[1]; >+ return result; >+} >+uint2 operator/(uint2 a, uint b) { >+ uint2 result; >+ result[0] = a[0] / b; >+ result[1] = a[1] / b; >+ return result; >+} >+uint2 operator/(uint a, uint2 b) { >+ uint2 result; >+ result[0] = a / b[0]; >+ result[1] = a / b[1]; >+ return result; >+} >+uint3 operator+(uint3 a, uint3 b) { >+ uint3 result; >+ result[0] = a[0] + b[0]; >+ result[1] = a[1] + b[1]; >+ result[2] = a[2] + b[2]; >+ return result; >+} >+uint3 operator-(uint3 a, uint3 b) { >+ uint3 result; >+ result[0] = a[0] - b[0]; >+ result[1] = a[1] - b[1]; >+ result[2] = a[2] - b[2]; >+ return result; >+} >+uint3 operator*(uint3 a, uint3 b) { >+ uint3 result; >+ result[0] = a[0] * b[0]; >+ result[1] = a[1] * b[1]; >+ result[2] = a[2] * b[2]; >+ return result; >+} >+uint3 operator*(uint3 a, uint b) { >+ uint3 result; >+ result[0] = a[0] * b; >+ result[1] = a[1] * b; >+ result[2] = a[2] * b; >+ return result; >+} >+uint3 operator*(uint a, uint3 b) { >+ uint3 result; >+ result[0] = a * b[0]; >+ result[1] = a * b[1]; >+ result[2] = a * b[2]; >+ return result; >+} >+uint3 operator/(uint3 a, uint3 b) { >+ uint3 result; >+ result[0] = a[0] / b[0]; >+ result[1] = a[1] / b[1]; >+ result[2] = a[2] / b[2]; >+ return result; >+} >+uint3 operator/(uint3 a, uint b) { >+ uint3 result; >+ result[0] = a[0] / b; >+ result[1] = a[1] / b; >+ result[2] = a[2] / b; >+ return result; >+} >+uint3 operator/(uint a, uint3 b) { >+ uint3 result; >+ result[0] = a / b[0]; >+ result[1] = a / b[1]; >+ result[2] = a / b[2]; >+ return result; >+} >+uint4 operator+(uint4 a, uint4 b) { >+ uint4 result; >+ result[0] = a[0] + b[0]; >+ result[1] = a[1] + b[1]; >+ result[2] = a[2] + b[2]; >+ result[3] = a[3] + b[3]; >+ return result; >+} >+uint4 operator-(uint4 a, uint4 b) { >+ uint4 result; >+ result[0] = a[0] - b[0]; >+ result[1] = a[1] - b[1]; >+ result[2] = a[2] - b[2]; >+ result[3] = a[3] - b[3]; >+ return result; >+} >+uint4 operator*(uint4 a, uint4 b) { >+ uint4 result; >+ result[0] = a[0] * b[0]; >+ result[1] = a[1] * b[1]; >+ result[2] = a[2] * b[2]; >+ result[3] = a[3] * b[3]; >+ return result; >+} >+uint4 operator*(uint4 a, uint b) { >+ uint4 result; >+ result[0] = a[0] * b; >+ result[1] = a[1] * b; >+ result[2] = a[2] * b; >+ result[3] = a[3] * b; >+ return result; >+} >+uint4 operator*(uint a, uint4 b) { >+ uint4 result; >+ result[0] = a * b[0]; >+ result[1] = a * b[1]; >+ result[2] = a * b[2]; >+ result[3] = a * b[3]; >+ return result; >+} >+uint4 operator/(uint4 a, uint4 b) { >+ uint4 result; >+ result[0] = a[0] / b[0]; >+ result[1] = a[1] / b[1]; >+ result[2] = a[2] / b[2]; >+ result[3] = a[3] / b[3]; >+ return result; >+} >+uint4 operator/(uint4 a, uint b) { >+ uint4 result; >+ result[0] = a[0] / b; >+ result[1] = a[1] / b; >+ result[2] = a[2] / b; >+ result[3] = a[3] / b; >+ return result; >+} >+uint4 operator/(uint a, uint4 b) { >+ uint4 result; >+ result[0] = a / b[0]; >+ result[1] = a / b[1]; >+ result[2] = a / b[2]; >+ result[3] = a / b[3]; >+ return result; >+} >+char2 operator+(char2 a, char2 b) { >+ char2 result; >+ result[0] = a[0] + b[0]; >+ result[1] = a[1] + b[1]; >+ return result; >+} >+char2 operator-(char2 a, char2 b) { >+ char2 result; >+ result[0] = a[0] - b[0]; >+ result[1] = a[1] - b[1]; >+ return result; >+} >+char2 operator*(char2 a, char2 b) { >+ char2 result; >+ result[0] = a[0] * b[0]; >+ result[1] = a[1] * b[1]; >+ return result; >+} >+char2 operator*(char2 a, char b) { >+ char2 result; >+ result[0] = a[0] * b; >+ result[1] = a[1] * b; >+ return result; >+} >+char2 operator*(char a, char2 b) { >+ char2 result; >+ result[0] = a * b[0]; >+ result[1] = a * b[1]; >+ return result; >+} >+char2 operator/(char2 a, char2 b) { >+ char2 result; >+ result[0] = a[0] / b[0]; >+ result[1] = a[1] / b[1]; >+ return result; >+} >+char2 operator/(char2 a, char b) { >+ char2 result; >+ result[0] = a[0] / b; >+ result[1] = a[1] / b; >+ return result; >+} >+char2 operator/(char a, char2 b) { >+ char2 result; >+ result[0] = a / b[0]; >+ result[1] = a / b[1]; >+ return result; >+} >+char3 operator+(char3 a, char3 b) { >+ char3 result; >+ result[0] = a[0] + b[0]; >+ result[1] = a[1] + b[1]; >+ result[2] = a[2] + b[2]; >+ return result; >+} >+char3 operator-(char3 a, char3 b) { >+ char3 result; >+ result[0] = a[0] - b[0]; >+ result[1] = a[1] - b[1]; >+ result[2] = a[2] - b[2]; >+ return result; >+} >+char3 operator*(char3 a, char3 b) { >+ char3 result; >+ result[0] = a[0] * b[0]; >+ result[1] = a[1] * b[1]; >+ result[2] = a[2] * b[2]; >+ return result; >+} >+char3 operator*(char3 a, char b) { >+ char3 result; >+ result[0] = a[0] * b; >+ result[1] = a[1] * b; >+ result[2] = a[2] * b; >+ return result; >+} >+char3 operator*(char a, char3 b) { >+ char3 result; >+ result[0] = a * b[0]; >+ result[1] = a * b[1]; >+ result[2] = a * b[2]; >+ return result; >+} >+char3 operator/(char3 a, char3 b) { >+ char3 result; >+ result[0] = a[0] / b[0]; >+ result[1] = a[1] / b[1]; >+ result[2] = a[2] / b[2]; >+ return result; >+} >+char3 operator/(char3 a, char b) { >+ char3 result; >+ result[0] = a[0] / b; >+ result[1] = a[1] / b; >+ result[2] = a[2] / b; >+ return result; >+} >+char3 operator/(char a, char3 b) { >+ char3 result; >+ result[0] = a / b[0]; >+ result[1] = a / b[1]; >+ result[2] = a / b[2]; >+ return result; >+} >+char4 operator+(char4 a, char4 b) { >+ char4 result; >+ result[0] = a[0] + b[0]; >+ result[1] = a[1] + b[1]; >+ result[2] = a[2] + b[2]; >+ result[3] = a[3] + b[3]; >+ return result; >+} >+char4 operator-(char4 a, char4 b) { >+ char4 result; >+ result[0] = a[0] - b[0]; >+ result[1] = a[1] - b[1]; >+ result[2] = a[2] - b[2]; >+ result[3] = a[3] - b[3]; >+ return result; >+} >+char4 operator*(char4 a, char4 b) { >+ char4 result; >+ result[0] = a[0] * b[0]; >+ result[1] = a[1] * b[1]; >+ result[2] = a[2] * b[2]; >+ result[3] = a[3] * b[3]; >+ return result; >+} >+char4 operator*(char4 a, char b) { >+ char4 result; >+ result[0] = a[0] * b; >+ result[1] = a[1] * b; >+ result[2] = a[2] * b; >+ result[3] = a[3] * b; >+ return result; >+} >+char4 operator*(char a, char4 b) { >+ char4 result; >+ result[0] = a * b[0]; >+ result[1] = a * b[1]; >+ result[2] = a * b[2]; >+ result[3] = a * b[3]; >+ return result; >+} >+char4 operator/(char4 a, char4 b) { >+ char4 result; >+ result[0] = a[0] / b[0]; >+ result[1] = a[1] / b[1]; >+ result[2] = a[2] / b[2]; >+ result[3] = a[3] / b[3]; >+ return result; >+} >+char4 operator/(char4 a, char b) { >+ char4 result; >+ result[0] = a[0] / b; >+ result[1] = a[1] / b; >+ result[2] = a[2] / b; >+ result[3] = a[3] / b; >+ return result; >+} >+char4 operator/(char a, char4 b) { >+ char4 result; >+ result[0] = a / b[0]; >+ result[1] = a / b[1]; >+ result[2] = a / b[2]; >+ result[3] = a / b[3]; >+ return result; >+} >+short2 operator+(short2 a, short2 b) { >+ short2 result; >+ result[0] = a[0] + b[0]; >+ result[1] = a[1] + b[1]; >+ return result; >+} >+short2 operator-(short2 a, short2 b) { >+ short2 result; >+ result[0] = a[0] - b[0]; >+ result[1] = a[1] - b[1]; >+ return result; >+} >+short2 operator*(short2 a, short2 b) { >+ short2 result; >+ result[0] = a[0] * b[0]; >+ result[1] = a[1] * b[1]; >+ return result; >+} >+short2 operator*(short2 a, short b) { >+ short2 result; >+ result[0] = a[0] * b; >+ result[1] = a[1] * b; >+ return result; >+} >+short2 operator*(short a, short2 b) { >+ short2 result; >+ result[0] = a * b[0]; >+ result[1] = a * b[1]; >+ return result; >+} >+short2 operator/(short2 a, short2 b) { >+ short2 result; >+ result[0] = a[0] / b[0]; >+ result[1] = a[1] / b[1]; >+ return result; >+} >+short2 operator/(short2 a, short b) { >+ short2 result; >+ result[0] = a[0] / b; >+ result[1] = a[1] / b; >+ return result; >+} >+short2 operator/(short a, short2 b) { >+ short2 result; >+ result[0] = a / b[0]; >+ result[1] = a / b[1]; >+ return result; >+} >+short3 operator+(short3 a, short3 b) { >+ short3 result; >+ result[0] = a[0] + b[0]; >+ result[1] = a[1] + b[1]; >+ result[2] = a[2] + b[2]; >+ return result; >+} >+short3 operator-(short3 a, short3 b) { >+ short3 result; >+ result[0] = a[0] - b[0]; >+ result[1] = a[1] - b[1]; >+ result[2] = a[2] - b[2]; >+ return result; >+} >+short3 operator*(short3 a, short3 b) { >+ short3 result; >+ result[0] = a[0] * b[0]; >+ result[1] = a[1] * b[1]; >+ result[2] = a[2] * b[2]; >+ return result; >+} >+short3 operator*(short3 a, short b) { >+ short3 result; >+ result[0] = a[0] * b; >+ result[1] = a[1] * b; >+ result[2] = a[2] * b; >+ return result; >+} >+short3 operator*(short a, short3 b) { >+ short3 result; >+ result[0] = a * b[0]; >+ result[1] = a * b[1]; >+ result[2] = a * b[2]; >+ return result; >+} >+short3 operator/(short3 a, short3 b) { >+ short3 result; >+ result[0] = a[0] / b[0]; >+ result[1] = a[1] / b[1]; >+ result[2] = a[2] / b[2]; >+ return result; >+} >+short3 operator/(short3 a, short b) { >+ short3 result; >+ result[0] = a[0] / b; >+ result[1] = a[1] / b; >+ result[2] = a[2] / b; >+ return result; >+} >+short3 operator/(short a, short3 b) { >+ short3 result; >+ result[0] = a / b[0]; >+ result[1] = a / b[1]; >+ result[2] = a / b[2]; >+ return result; >+} >+short4 operator+(short4 a, short4 b) { >+ short4 result; >+ result[0] = a[0] + b[0]; >+ result[1] = a[1] + b[1]; >+ result[2] = a[2] + b[2]; >+ result[3] = a[3] + b[3]; >+ return result; >+} >+short4 operator-(short4 a, short4 b) { >+ short4 result; >+ result[0] = a[0] - b[0]; >+ result[1] = a[1] - b[1]; >+ result[2] = a[2] - b[2]; >+ result[3] = a[3] - b[3]; >+ return result; >+} >+short4 operator*(short4 a, short4 b) { >+ short4 result; >+ result[0] = a[0] * b[0]; >+ result[1] = a[1] * b[1]; >+ result[2] = a[2] * b[2]; >+ result[3] = a[3] * b[3]; >+ return result; >+} >+short4 operator*(short4 a, short b) { >+ short4 result; >+ result[0] = a[0] * b; >+ result[1] = a[1] * b; >+ result[2] = a[2] * b; >+ result[3] = a[3] * b; >+ return result; >+} >+short4 operator*(short a, short4 b) { >+ short4 result; >+ result[0] = a * b[0]; >+ result[1] = a * b[1]; >+ result[2] = a * b[2]; >+ result[3] = a * b[3]; >+ return result; >+} >+short4 operator/(short4 a, short4 b) { >+ short4 result; >+ result[0] = a[0] / b[0]; >+ result[1] = a[1] / b[1]; >+ result[2] = a[2] / b[2]; >+ result[3] = a[3] / b[3]; >+ return result; >+} >+short4 operator/(short4 a, short b) { >+ short4 result; >+ result[0] = a[0] / b; >+ result[1] = a[1] / b; >+ result[2] = a[2] / b; >+ result[3] = a[3] / b; >+ return result; >+} >+short4 operator/(short a, short4 b) { >+ short4 result; >+ result[0] = a / b[0]; >+ result[1] = a / b[1]; >+ result[2] = a / b[2]; >+ result[3] = a / b[3]; >+ return result; >+} >+int2 operator+(int2 a, int2 b) { >+ int2 result; >+ result[0] = a[0] + b[0]; >+ result[1] = a[1] + b[1]; >+ return result; >+} >+int2 operator-(int2 a, int2 b) { >+ int2 result; >+ result[0] = a[0] - b[0]; >+ result[1] = a[1] - b[1]; >+ return result; >+} >+int2 operator*(int2 a, int2 b) { >+ int2 result; >+ result[0] = a[0] * b[0]; >+ result[1] = a[1] * b[1]; >+ return result; >+} >+int2 operator*(int2 a, int b) { >+ int2 result; >+ result[0] = a[0] * b; >+ result[1] = a[1] * b; >+ return result; >+} >+int2 operator*(int a, int2 b) { >+ int2 result; >+ result[0] = a * b[0]; >+ result[1] = a * b[1]; >+ return result; >+} >+int2 operator/(int2 a, int2 b) { >+ int2 result; >+ result[0] = a[0] / b[0]; >+ result[1] = a[1] / b[1]; >+ return result; >+} >+int2 operator/(int2 a, int b) { >+ int2 result; >+ result[0] = a[0] / b; >+ result[1] = a[1] / b; >+ return result; >+} >+int2 operator/(int a, int2 b) { >+ int2 result; >+ result[0] = a / b[0]; >+ result[1] = a / b[1]; >+ return result; >+} >+int3 operator+(int3 a, int3 b) { >+ int3 result; >+ result[0] = a[0] + b[0]; >+ result[1] = a[1] + b[1]; >+ result[2] = a[2] + b[2]; >+ return result; >+} >+int3 operator-(int3 a, int3 b) { >+ int3 result; >+ result[0] = a[0] - b[0]; >+ result[1] = a[1] - b[1]; >+ result[2] = a[2] - b[2]; >+ return result; >+} >+int3 operator*(int3 a, int3 b) { >+ int3 result; >+ result[0] = a[0] * b[0]; >+ result[1] = a[1] * b[1]; >+ result[2] = a[2] * b[2]; >+ return result; >+} >+int3 operator*(int3 a, int b) { >+ int3 result; >+ result[0] = a[0] * b; >+ result[1] = a[1] * b; >+ result[2] = a[2] * b; >+ return result; >+} >+int3 operator*(int a, int3 b) { >+ int3 result; >+ result[0] = a * b[0]; >+ result[1] = a * b[1]; >+ result[2] = a * b[2]; >+ return result; >+} >+int3 operator/(int3 a, int3 b) { >+ int3 result; >+ result[0] = a[0] / b[0]; >+ result[1] = a[1] / b[1]; >+ result[2] = a[2] / b[2]; >+ return result; >+} >+int3 operator/(int3 a, int b) { >+ int3 result; >+ result[0] = a[0] / b; >+ result[1] = a[1] / b; >+ result[2] = a[2] / b; >+ return result; >+} >+int3 operator/(int a, int3 b) { >+ int3 result; >+ result[0] = a / b[0]; >+ result[1] = a / b[1]; >+ result[2] = a / b[2]; >+ return result; >+} >+int4 operator+(int4 a, int4 b) { >+ int4 result; >+ result[0] = a[0] + b[0]; >+ result[1] = a[1] + b[1]; >+ result[2] = a[2] + b[2]; >+ result[3] = a[3] + b[3]; >+ return result; >+} >+int4 operator-(int4 a, int4 b) { >+ int4 result; >+ result[0] = a[0] - b[0]; >+ result[1] = a[1] - b[1]; >+ result[2] = a[2] - b[2]; >+ result[3] = a[3] - b[3]; >+ return result; >+} >+int4 operator*(int4 a, int4 b) { >+ int4 result; >+ result[0] = a[0] * b[0]; >+ result[1] = a[1] * b[1]; >+ result[2] = a[2] * b[2]; >+ result[3] = a[3] * b[3]; >+ return result; >+} >+int4 operator*(int4 a, int b) { >+ int4 result; >+ result[0] = a[0] * b; >+ result[1] = a[1] * b; >+ result[2] = a[2] * b; >+ result[3] = a[3] * b; >+ return result; >+} >+int4 operator*(int a, int4 b) { >+ int4 result; >+ result[0] = a * b[0]; >+ result[1] = a * b[1]; >+ result[2] = a * b[2]; >+ result[3] = a * b[3]; >+ return result; >+} >+int4 operator/(int4 a, int4 b) { >+ int4 result; >+ result[0] = a[0] / b[0]; >+ result[1] = a[1] / b[1]; >+ result[2] = a[2] / b[2]; >+ result[3] = a[3] / b[3]; >+ return result; >+} >+int4 operator/(int4 a, int b) { >+ int4 result; >+ result[0] = a[0] / b; >+ result[1] = a[1] / b; >+ result[2] = a[2] / b; >+ result[3] = a[3] / b; >+ return result; >+} >+int4 operator/(int a, int4 b) { >+ int4 result; >+ result[0] = a / b[0]; >+ result[1] = a / b[1]; >+ result[2] = a / b[2]; >+ result[3] = a / b[3]; >+ return result; >+} >+half2 operator+(half2 a, half2 b) { >+ half2 result; >+ result[0] = a[0] + b[0]; >+ result[1] = a[1] + b[1]; >+ return result; >+} >+half2 operator-(half2 a, half2 b) { >+ half2 result; >+ result[0] = a[0] - b[0]; >+ result[1] = a[1] - b[1]; >+ return result; >+} >+half2 operator*(half2 a, half2 b) { >+ half2 result; >+ result[0] = a[0] * b[0]; >+ result[1] = a[1] * b[1]; >+ return result; >+} >+half2 operator*(half2 a, half b) { >+ half2 result; >+ result[0] = a[0] * b; >+ result[1] = a[1] * b; >+ return result; >+} >+half2 operator*(half a, half2 b) { >+ half2 result; >+ result[0] = a * b[0]; >+ result[1] = a * b[1]; >+ return result; >+} >+half2 operator/(half2 a, half2 b) { >+ half2 result; >+ result[0] = a[0] / b[0]; >+ result[1] = a[1] / b[1]; >+ return result; >+} >+half2 operator/(half2 a, half b) { >+ half2 result; >+ result[0] = a[0] / b; >+ result[1] = a[1] / b; >+ return result; >+} >+half2 operator/(half a, half2 b) { >+ half2 result; >+ result[0] = a / b[0]; >+ result[1] = a / b[1]; >+ return result; >+} >+half3 operator+(half3 a, half3 b) { >+ half3 result; >+ result[0] = a[0] + b[0]; >+ result[1] = a[1] + b[1]; >+ result[2] = a[2] + b[2]; >+ return result; >+} >+half3 operator-(half3 a, half3 b) { >+ half3 result; >+ result[0] = a[0] - b[0]; >+ result[1] = a[1] - b[1]; >+ result[2] = a[2] - b[2]; >+ return result; >+} >+half3 operator*(half3 a, half3 b) { >+ half3 result; >+ result[0] = a[0] * b[0]; >+ result[1] = a[1] * b[1]; >+ result[2] = a[2] * b[2]; >+ return result; >+} >+half3 operator*(half3 a, half b) { >+ half3 result; >+ result[0] = a[0] * b; >+ result[1] = a[1] * b; >+ result[2] = a[2] * b; >+ return result; >+} >+half3 operator*(half a, half3 b) { >+ half3 result; >+ result[0] = a * b[0]; >+ result[1] = a * b[1]; >+ result[2] = a * b[2]; >+ return result; >+} >+half3 operator/(half3 a, half3 b) { >+ half3 result; >+ result[0] = a[0] / b[0]; >+ result[1] = a[1] / b[1]; >+ result[2] = a[2] / b[2]; >+ return result; >+} >+half3 operator/(half3 a, half b) { >+ half3 result; >+ result[0] = a[0] / b; >+ result[1] = a[1] / b; >+ result[2] = a[2] / b; >+ return result; >+} >+half3 operator/(half a, half3 b) { >+ half3 result; >+ result[0] = a / b[0]; >+ result[1] = a / b[1]; >+ result[2] = a / b[2]; >+ return result; >+} >+half4 operator+(half4 a, half4 b) { >+ half4 result; >+ result[0] = a[0] + b[0]; >+ result[1] = a[1] + b[1]; >+ result[2] = a[2] + b[2]; >+ result[3] = a[3] + b[3]; >+ return result; >+} >+half4 operator-(half4 a, half4 b) { >+ half4 result; >+ result[0] = a[0] - b[0]; >+ result[1] = a[1] - b[1]; >+ result[2] = a[2] - b[2]; >+ result[3] = a[3] - b[3]; >+ return result; >+} >+half4 operator*(half4 a, half4 b) { >+ half4 result; >+ result[0] = a[0] * b[0]; >+ result[1] = a[1] * b[1]; >+ result[2] = a[2] * b[2]; >+ result[3] = a[3] * b[3]; >+ return result; >+} >+half4 operator*(half4 a, half b) { >+ half4 result; >+ result[0] = a[0] * b; >+ result[1] = a[1] * b; >+ result[2] = a[2] * b; >+ result[3] = a[3] * b; >+ return result; >+} >+half4 operator*(half a, half4 b) { >+ half4 result; >+ result[0] = a * b[0]; >+ result[1] = a * b[1]; >+ result[2] = a * b[2]; >+ result[3] = a * b[3]; >+ return result; >+} >+half4 operator/(half4 a, half4 b) { >+ half4 result; >+ result[0] = a[0] / b[0]; >+ result[1] = a[1] / b[1]; >+ result[2] = a[2] / b[2]; >+ result[3] = a[3] / b[3]; >+ return result; >+} >+half4 operator/(half4 a, half b) { >+ half4 result; >+ result[0] = a[0] / b; >+ result[1] = a[1] / b; >+ result[2] = a[2] / b; >+ result[3] = a[3] / b; >+ return result; >+} >+half4 operator/(half a, half4 b) { >+ half4 result; >+ result[0] = a / b[0]; >+ result[1] = a / b[1]; >+ result[2] = a / b[2]; >+ result[3] = a / b[3]; >+ return result; >+} >+float2 operator+(float2 a, float2 b) { >+ float2 result; >+ result[0] = a[0] + b[0]; >+ result[1] = a[1] + b[1]; >+ return result; >+} >+float2 operator-(float2 a, float2 b) { >+ float2 result; >+ result[0] = a[0] - b[0]; >+ result[1] = a[1] - b[1]; >+ return result; >+} >+float2 operator*(float2 a, float2 b) { >+ float2 result; >+ result[0] = a[0] * b[0]; >+ result[1] = a[1] * b[1]; >+ return result; >+} >+float2 operator*(float2 a, float b) { >+ float2 result; >+ result[0] = a[0] * b; >+ result[1] = a[1] * b; >+ return result; >+} >+float2 operator*(float a, float2 b) { >+ float2 result; >+ result[0] = a * b[0]; >+ result[1] = a * b[1]; >+ return result; >+} >+float2 operator/(float2 a, float2 b) { >+ float2 result; >+ result[0] = a[0] / b[0]; >+ result[1] = a[1] / b[1]; >+ return result; >+} >+float2 operator/(float2 a, float b) { >+ float2 result; >+ result[0] = a[0] / b; >+ result[1] = a[1] / b; >+ return result; >+} >+float2 operator/(float a, float2 b) { >+ float2 result; >+ result[0] = a / b[0]; >+ result[1] = a / b[1]; >+ return result; >+} >+float3 operator+(float3 a, float3 b) { >+ float3 result; >+ result[0] = a[0] + b[0]; >+ result[1] = a[1] + b[1]; >+ result[2] = a[2] + b[2]; >+ return result; >+} >+float3 operator-(float3 a, float3 b) { >+ float3 result; >+ result[0] = a[0] - b[0]; >+ result[1] = a[1] - b[1]; >+ result[2] = a[2] - b[2]; >+ return result; >+} >+float3 operator*(float3 a, float3 b) { >+ float3 result; >+ result[0] = a[0] * b[0]; >+ result[1] = a[1] * b[1]; >+ result[2] = a[2] * b[2]; >+ return result; >+} >+float3 operator*(float3 a, float b) { >+ float3 result; >+ result[0] = a[0] * b; >+ result[1] = a[1] * b; >+ result[2] = a[2] * b; >+ return result; >+} >+float3 operator*(float a, float3 b) { >+ float3 result; >+ result[0] = a * b[0]; >+ result[1] = a * b[1]; >+ result[2] = a * b[2]; >+ return result; >+} >+float3 operator/(float3 a, float3 b) { >+ float3 result; >+ result[0] = a[0] / b[0]; >+ result[1] = a[1] / b[1]; >+ result[2] = a[2] / b[2]; >+ return result; >+} >+float3 operator/(float3 a, float b) { >+ float3 result; >+ result[0] = a[0] / b; >+ result[1] = a[1] / b; >+ result[2] = a[2] / b; >+ return result; >+} >+float3 operator/(float a, float3 b) { >+ float3 result; >+ result[0] = a / b[0]; >+ result[1] = a / b[1]; >+ result[2] = a / b[2]; >+ return result; >+} >+float4 operator+(float4 a, float4 b) { >+ float4 result; >+ result[0] = a[0] + b[0]; >+ result[1] = a[1] + b[1]; >+ result[2] = a[2] + b[2]; >+ result[3] = a[3] + b[3]; >+ return result; >+} >+float4 operator-(float4 a, float4 b) { >+ float4 result; >+ result[0] = a[0] - b[0]; >+ result[1] = a[1] - b[1]; >+ result[2] = a[2] - b[2]; >+ result[3] = a[3] - b[3]; >+ return result; >+} >+float4 operator*(float4 a, float4 b) { >+ float4 result; >+ result[0] = a[0] * b[0]; >+ result[1] = a[1] * b[1]; >+ result[2] = a[2] * b[2]; >+ result[3] = a[3] * b[3]; >+ return result; >+} >+float4 operator*(float4 a, float b) { >+ float4 result; >+ result[0] = a[0] * b; >+ result[1] = a[1] * b; >+ result[2] = a[2] * b; >+ result[3] = a[3] * b; >+ return result; >+} >+float4 operator*(float a, float4 b) { >+ float4 result; >+ result[0] = a * b[0]; >+ result[1] = a * b[1]; >+ result[2] = a * b[2]; >+ result[3] = a * b[3]; >+ return result; >+} >+float4 operator/(float4 a, float4 b) { >+ float4 result; >+ result[0] = a[0] / b[0]; >+ result[1] = a[1] / b[1]; >+ result[2] = a[2] / b[2]; >+ result[3] = a[3] / b[3]; >+ return result; >+} >+float4 operator/(float4 a, float b) { >+ float4 result; >+ result[0] = a[0] / b; >+ result[1] = a[1] / b; >+ result[2] = a[2] / b; >+ result[3] = a[3] / b; >+ return result; >+} >+float4 operator/(float a, float4 b) { >+ float4 result; >+ result[0] = a / b[0]; >+ result[1] = a / b[1]; >+ result[2] = a / b[2]; >+ result[3] = a / b[3]; >+ return result; >+} >+char2 operator-(char2 a) { >+ char2 result; >+ result[0] = -a[0]; >+ result[1] = -a[1]; >+ return result; >+} >+char3 operator-(char3 a) { >+ char3 result; >+ result[0] = -a[0]; >+ result[1] = -a[1]; >+ result[2] = -a[2]; >+ return result; >+} >+char4 operator-(char4 a) { >+ char4 result; >+ result[0] = -a[0]; >+ result[1] = -a[1]; >+ result[2] = -a[2]; >+ result[3] = -a[3]; >+ return result; >+} >+short2 operator-(short2 a) { >+ short2 result; >+ result[0] = -a[0]; >+ result[1] = -a[1]; >+ return result; >+} >+short3 operator-(short3 a) { >+ short3 result; >+ result[0] = -a[0]; >+ result[1] = -a[1]; >+ result[2] = -a[2]; >+ return result; >+} >+short4 operator-(short4 a) { >+ short4 result; >+ result[0] = -a[0]; >+ result[1] = -a[1]; >+ result[2] = -a[2]; >+ result[3] = -a[3]; >+ return result; >+} >+int2 operator-(int2 a) { >+ int2 result; >+ result[0] = -a[0]; >+ result[1] = -a[1]; >+ return result; >+} >+int3 operator-(int3 a) { >+ int3 result; >+ result[0] = -a[0]; >+ result[1] = -a[1]; >+ result[2] = -a[2]; >+ return result; >+} >+int4 operator-(int4 a) { >+ int4 result; >+ result[0] = -a[0]; >+ result[1] = -a[1]; >+ result[2] = -a[2]; >+ result[3] = -a[3]; >+ return result; >+} >+half2 operator-(half2 a) { >+ half2 result; >+ result[0] = -a[0]; >+ result[1] = -a[1]; >+ return result; >+} >+half3 operator-(half3 a) { >+ half3 result; >+ result[0] = -a[0]; >+ result[1] = -a[1]; >+ result[2] = -a[2]; >+ return result; >+} >+half4 operator-(half4 a) { >+ half4 result; >+ result[0] = -a[0]; >+ result[1] = -a[1]; >+ result[2] = -a[2]; >+ result[3] = -a[3]; >+ return result; >+} >+float2 operator-(float2 a) { >+ float2 result; >+ result[0] = -a[0]; >+ result[1] = -a[1]; >+ return result; >+} >+float3 operator-(float3 a) { >+ float3 result; >+ result[0] = -a[0]; >+ result[1] = -a[1]; >+ result[2] = -a[2]; >+ return result; >+} >+float4 operator-(float4 a) { >+ float4 result; >+ result[0] = -a[0]; >+ result[1] = -a[1]; >+ result[2] = -a[2]; >+ result[3] = -a[3]; >+ return result; >+} >+half2x2 operator+(half2x2 a, half2x2 b) { >+ half2x2 result; >+ result[0][0] = a[0][0] + b[0][0]; >+ result[0][1] = a[0][1] + b[0][1]; >+ result[1][0] = a[1][0] + b[1][0]; >+ result[1][1] = a[1][1] + b[1][1]; >+ return result; >+} >+half2x2 operator-(half2x2 a, half2x2 b) { >+ half2x2 result; >+ result[0][0] = a[0][0] - b[0][0]; >+ result[0][1] = a[0][1] - b[0][1]; >+ result[1][0] = a[1][0] - b[1][0]; >+ result[1][1] = a[1][1] - b[1][1]; >+ return result; >+} >+half2x2 operator-(half2x2 a) { >+ half2x2 result; >+ result[0][0] = -a[0][0]; >+ result[0][1] = -a[0][1]; >+ result[1][0] = -a[1][0]; >+ result[1][1] = -a[1][1]; >+ return result; >+} >+half2x2 operator*(half2x2 a, half2x2 b) { >+ half2x2 result; >+ result[0][0] = a[0][0] * b[0][0]; >+ result[0][1] = a[0][1] * b[0][1]; >+ result[1][0] = a[1][0] * b[1][0]; >+ result[1][1] = a[1][1] * b[1][1]; >+ return result; >+} >+half2x2 operator*(half2x2 a, half b) { >+ half2x2 result; >+ result[0][0] = a[0][0] * b; >+ result[0][1] = a[0][1] * b; >+ result[1][0] = a[1][0] * b; >+ result[1][1] = a[1][1] * b; >+ return result; >+} >+half2x2 operator*(half a, half2x2 b) { >+ half2x2 result; >+ result[0][0] = a * b[0][0]; >+ result[0][1] = a * b[0][1]; >+ result[1][0] = a * b[1][0]; >+ result[1][1] = a * b[1][1]; >+ return result; >+} >+half2x2 operator/(half2x2 a, half2x2 b) { >+ half2x2 result; >+ result[0][0] = a[0][0] / b[0][0]; >+ result[0][1] = a[0][1] / b[0][1]; >+ result[1][0] = a[1][0] / b[1][0]; >+ result[1][1] = a[1][1] / b[1][1]; >+ return result; >+} >+half2x2 operator/(half2x2 a, half b) { >+ half2x2 result; >+ result[0][0] = a[0][0] / b; >+ result[0][1] = a[0][1] / b; >+ result[1][0] = a[1][0] / b; >+ result[1][1] = a[1][1] / b; >+ return result; >+} >+half2x2 operator/(half a, half2x2 b) { >+ half2x2 result; >+ result[0][0] = a / b[0][0]; >+ result[0][1] = a / b[0][1]; >+ result[1][0] = a / b[1][0]; >+ result[1][1] = a / b[1][1]; >+ return result; >+} >+half2x3 operator+(half2x3 a, half2x3 b) { >+ half2x3 result; >+ result[0][0] = a[0][0] + b[0][0]; >+ result[0][1] = a[0][1] + b[0][1]; >+ result[0][2] = a[0][2] + b[0][2]; >+ result[1][0] = a[1][0] + b[1][0]; >+ result[1][1] = a[1][1] + b[1][1]; >+ result[1][2] = a[1][2] + b[1][2]; >+ return result; >+} >+half2x3 operator-(half2x3 a, half2x3 b) { >+ half2x3 result; >+ result[0][0] = a[0][0] - b[0][0]; >+ result[0][1] = a[0][1] - b[0][1]; >+ result[0][2] = a[0][2] - b[0][2]; >+ result[1][0] = a[1][0] - b[1][0]; >+ result[1][1] = a[1][1] - b[1][1]; >+ result[1][2] = a[1][2] - b[1][2]; >+ return result; >+} >+half2x3 operator-(half2x3 a) { >+ half2x3 result; >+ result[0][0] = -a[0][0]; >+ result[0][1] = -a[0][1]; >+ result[0][2] = -a[0][2]; >+ result[1][0] = -a[1][0]; >+ result[1][1] = -a[1][1]; >+ result[1][2] = -a[1][2]; >+ return result; >+} >+half2x3 operator*(half2x3 a, half2x3 b) { >+ half2x3 result; >+ result[0][0] = a[0][0] * b[0][0]; >+ result[0][1] = a[0][1] * b[0][1]; >+ result[0][2] = a[0][2] * b[0][2]; >+ result[1][0] = a[1][0] * b[1][0]; >+ result[1][1] = a[1][1] * b[1][1]; >+ result[1][2] = a[1][2] * b[1][2]; >+ return result; >+} >+half2x3 operator*(half2x3 a, half b) { >+ half2x3 result; >+ result[0][0] = a[0][0] * b; >+ result[0][1] = a[0][1] * b; >+ result[0][2] = a[0][2] * b; >+ result[1][0] = a[1][0] * b; >+ result[1][1] = a[1][1] * b; >+ result[1][2] = a[1][2] * b; >+ return result; >+} >+half2x3 operator*(half a, half2x3 b) { >+ half2x3 result; >+ result[0][0] = a * b[0][0]; >+ result[0][1] = a * b[0][1]; >+ result[0][2] = a * b[0][2]; >+ result[1][0] = a * b[1][0]; >+ result[1][1] = a * b[1][1]; >+ result[1][2] = a * b[1][2]; >+ return result; >+} >+half2x3 operator/(half2x3 a, half2x3 b) { >+ half2x3 result; >+ result[0][0] = a[0][0] / b[0][0]; >+ result[0][1] = a[0][1] / b[0][1]; >+ result[0][2] = a[0][2] / b[0][2]; >+ result[1][0] = a[1][0] / b[1][0]; >+ result[1][1] = a[1][1] / b[1][1]; >+ result[1][2] = a[1][2] / b[1][2]; >+ return result; >+} >+half2x3 operator/(half2x3 a, half b) { >+ half2x3 result; >+ result[0][0] = a[0][0] / b; >+ result[0][1] = a[0][1] / b; >+ result[0][2] = a[0][2] / b; >+ result[1][0] = a[1][0] / b; >+ result[1][1] = a[1][1] / b; >+ result[1][2] = a[1][2] / b; >+ return result; >+} >+half2x3 operator/(half a, half2x3 b) { >+ half2x3 result; >+ result[0][0] = a / b[0][0]; >+ result[0][1] = a / b[0][1]; >+ result[0][2] = a / b[0][2]; >+ result[1][0] = a / b[1][0]; >+ result[1][1] = a / b[1][1]; >+ result[1][2] = a / b[1][2]; >+ return result; >+} >+half2x4 operator+(half2x4 a, half2x4 b) { >+ half2x4 result; >+ result[0][0] = a[0][0] + b[0][0]; >+ result[0][1] = a[0][1] + b[0][1]; >+ result[0][2] = a[0][2] + b[0][2]; >+ result[0][3] = a[0][3] + b[0][3]; >+ result[1][0] = a[1][0] + b[1][0]; >+ result[1][1] = a[1][1] + b[1][1]; >+ result[1][2] = a[1][2] + b[1][2]; >+ result[1][3] = a[1][3] + b[1][3]; >+ return result; >+} >+half2x4 operator-(half2x4 a, half2x4 b) { >+ half2x4 result; >+ result[0][0] = a[0][0] - b[0][0]; >+ result[0][1] = a[0][1] - b[0][1]; >+ result[0][2] = a[0][2] - b[0][2]; >+ result[0][3] = a[0][3] - b[0][3]; >+ result[1][0] = a[1][0] - b[1][0]; >+ result[1][1] = a[1][1] - b[1][1]; >+ result[1][2] = a[1][2] - b[1][2]; >+ result[1][3] = a[1][3] - b[1][3]; >+ return result; >+} >+half2x4 operator-(half2x4 a) { >+ half2x4 result; >+ result[0][0] = -a[0][0]; >+ result[0][1] = -a[0][1]; >+ result[0][2] = -a[0][2]; >+ result[0][3] = -a[0][3]; >+ result[1][0] = -a[1][0]; >+ result[1][1] = -a[1][1]; >+ result[1][2] = -a[1][2]; >+ result[1][3] = -a[1][3]; >+ return result; >+} >+half2x4 operator*(half2x4 a, half2x4 b) { >+ half2x4 result; >+ result[0][0] = a[0][0] * b[0][0]; >+ result[0][1] = a[0][1] * b[0][1]; >+ result[0][2] = a[0][2] * b[0][2]; >+ result[0][3] = a[0][3] * b[0][3]; >+ result[1][0] = a[1][0] * b[1][0]; >+ result[1][1] = a[1][1] * b[1][1]; >+ result[1][2] = a[1][2] * b[1][2]; >+ result[1][3] = a[1][3] * b[1][3]; >+ return result; >+} >+half2x4 operator*(half2x4 a, half b) { >+ half2x4 result; >+ result[0][0] = a[0][0] * b; >+ result[0][1] = a[0][1] * b; >+ result[0][2] = a[0][2] * b; >+ result[0][3] = a[0][3] * b; >+ result[1][0] = a[1][0] * b; >+ result[1][1] = a[1][1] * b; >+ result[1][2] = a[1][2] * b; >+ result[1][3] = a[1][3] * b; >+ return result; >+} >+half2x4 operator*(half a, half2x4 b) { >+ half2x4 result; >+ result[0][0] = a * b[0][0]; >+ result[0][1] = a * b[0][1]; >+ result[0][2] = a * b[0][2]; >+ result[0][3] = a * b[0][3]; >+ result[1][0] = a * b[1][0]; >+ result[1][1] = a * b[1][1]; >+ result[1][2] = a * b[1][2]; >+ result[1][3] = a * b[1][3]; >+ return result; >+} >+half2x4 operator/(half2x4 a, half2x4 b) { >+ half2x4 result; >+ result[0][0] = a[0][0] / b[0][0]; >+ result[0][1] = a[0][1] / b[0][1]; >+ result[0][2] = a[0][2] / b[0][2]; >+ result[0][3] = a[0][3] / b[0][3]; >+ result[1][0] = a[1][0] / b[1][0]; >+ result[1][1] = a[1][1] / b[1][1]; >+ result[1][2] = a[1][2] / b[1][2]; >+ result[1][3] = a[1][3] / b[1][3]; >+ return result; >+} >+half2x4 operator/(half2x4 a, half b) { >+ half2x4 result; >+ result[0][0] = a[0][0] / b; >+ result[0][1] = a[0][1] / b; >+ result[0][2] = a[0][2] / b; >+ result[0][3] = a[0][3] / b; >+ result[1][0] = a[1][0] / b; >+ result[1][1] = a[1][1] / b; >+ result[1][2] = a[1][2] / b; >+ result[1][3] = a[1][3] / b; >+ return result; >+} >+half2x4 operator/(half a, half2x4 b) { >+ half2x4 result; >+ result[0][0] = a / b[0][0]; >+ result[0][1] = a / b[0][1]; >+ result[0][2] = a / b[0][2]; >+ result[0][3] = a / b[0][3]; >+ result[1][0] = a / b[1][0]; >+ result[1][1] = a / b[1][1]; >+ result[1][2] = a / b[1][2]; >+ result[1][3] = a / b[1][3]; >+ return result; >+} >+half3x2 operator+(half3x2 a, half3x2 b) { >+ half3x2 result; >+ result[0][0] = a[0][0] + b[0][0]; >+ result[0][1] = a[0][1] + b[0][1]; >+ result[1][0] = a[1][0] + b[1][0]; >+ result[1][1] = a[1][1] + b[1][1]; >+ result[2][0] = a[2][0] + b[2][0]; >+ result[2][1] = a[2][1] + b[2][1]; >+ return result; >+} >+half3x2 operator-(half3x2 a, half3x2 b) { >+ half3x2 result; >+ result[0][0] = a[0][0] - b[0][0]; >+ result[0][1] = a[0][1] - b[0][1]; >+ result[1][0] = a[1][0] - b[1][0]; >+ result[1][1] = a[1][1] - b[1][1]; >+ result[2][0] = a[2][0] - b[2][0]; >+ result[2][1] = a[2][1] - b[2][1]; >+ return result; >+} >+half3x2 operator-(half3x2 a) { >+ half3x2 result; >+ result[0][0] = -a[0][0]; >+ result[0][1] = -a[0][1]; >+ result[1][0] = -a[1][0]; >+ result[1][1] = -a[1][1]; >+ result[2][0] = -a[2][0]; >+ result[2][1] = -a[2][1]; >+ return result; >+} >+half3x2 operator*(half3x2 a, half3x2 b) { >+ half3x2 result; >+ result[0][0] = a[0][0] * b[0][0]; >+ result[0][1] = a[0][1] * b[0][1]; >+ result[1][0] = a[1][0] * b[1][0]; >+ result[1][1] = a[1][1] * b[1][1]; >+ result[2][0] = a[2][0] * b[2][0]; >+ result[2][1] = a[2][1] * b[2][1]; >+ return result; >+} >+half3x2 operator*(half3x2 a, half b) { >+ half3x2 result; >+ result[0][0] = a[0][0] * b; >+ result[0][1] = a[0][1] * b; >+ result[1][0] = a[1][0] * b; >+ result[1][1] = a[1][1] * b; >+ result[2][0] = a[2][0] * b; >+ result[2][1] = a[2][1] * b; >+ return result; >+} >+half3x2 operator*(half a, half3x2 b) { >+ half3x2 result; >+ result[0][0] = a * b[0][0]; >+ result[0][1] = a * b[0][1]; >+ result[1][0] = a * b[1][0]; >+ result[1][1] = a * b[1][1]; >+ result[2][0] = a * b[2][0]; >+ result[2][1] = a * b[2][1]; >+ return result; >+} >+half3x2 operator/(half3x2 a, half3x2 b) { >+ half3x2 result; >+ result[0][0] = a[0][0] / b[0][0]; >+ result[0][1] = a[0][1] / b[0][1]; >+ result[1][0] = a[1][0] / b[1][0]; >+ result[1][1] = a[1][1] / b[1][1]; >+ result[2][0] = a[2][0] / b[2][0]; >+ result[2][1] = a[2][1] / b[2][1]; >+ return result; >+} >+half3x2 operator/(half3x2 a, half b) { >+ half3x2 result; >+ result[0][0] = a[0][0] / b; >+ result[0][1] = a[0][1] / b; >+ result[1][0] = a[1][0] / b; >+ result[1][1] = a[1][1] / b; >+ result[2][0] = a[2][0] / b; >+ result[2][1] = a[2][1] / b; >+ return result; >+} >+half3x2 operator/(half a, half3x2 b) { >+ half3x2 result; >+ result[0][0] = a / b[0][0]; >+ result[0][1] = a / b[0][1]; >+ result[1][0] = a / b[1][0]; >+ result[1][1] = a / b[1][1]; >+ result[2][0] = a / b[2][0]; >+ result[2][1] = a / b[2][1]; >+ return result; >+} >+half3x3 operator+(half3x3 a, half3x3 b) { >+ half3x3 result; >+ result[0][0] = a[0][0] + b[0][0]; >+ result[0][1] = a[0][1] + b[0][1]; >+ result[0][2] = a[0][2] + b[0][2]; >+ result[1][0] = a[1][0] + b[1][0]; >+ result[1][1] = a[1][1] + b[1][1]; >+ result[1][2] = a[1][2] + b[1][2]; >+ result[2][0] = a[2][0] + b[2][0]; >+ result[2][1] = a[2][1] + b[2][1]; >+ result[2][2] = a[2][2] + b[2][2]; >+ return result; >+} >+half3x3 operator-(half3x3 a, half3x3 b) { >+ half3x3 result; >+ result[0][0] = a[0][0] - b[0][0]; >+ result[0][1] = a[0][1] - b[0][1]; >+ result[0][2] = a[0][2] - b[0][2]; >+ result[1][0] = a[1][0] - b[1][0]; >+ result[1][1] = a[1][1] - b[1][1]; >+ result[1][2] = a[1][2] - b[1][2]; >+ result[2][0] = a[2][0] - b[2][0]; >+ result[2][1] = a[2][1] - b[2][1]; >+ result[2][2] = a[2][2] - b[2][2]; >+ return result; >+} >+half3x3 operator-(half3x3 a) { >+ half3x3 result; >+ result[0][0] = -a[0][0]; >+ result[0][1] = -a[0][1]; >+ result[0][2] = -a[0][2]; >+ result[1][0] = -a[1][0]; >+ result[1][1] = -a[1][1]; >+ result[1][2] = -a[1][2]; >+ result[2][0] = -a[2][0]; >+ result[2][1] = -a[2][1]; >+ result[2][2] = -a[2][2]; >+ return result; >+} >+half3x3 operator*(half3x3 a, half3x3 b) { >+ half3x3 result; >+ result[0][0] = a[0][0] * b[0][0]; >+ result[0][1] = a[0][1] * b[0][1]; >+ result[0][2] = a[0][2] * b[0][2]; >+ result[1][0] = a[1][0] * b[1][0]; >+ result[1][1] = a[1][1] * b[1][1]; >+ result[1][2] = a[1][2] * b[1][2]; >+ result[2][0] = a[2][0] * b[2][0]; >+ result[2][1] = a[2][1] * b[2][1]; >+ result[2][2] = a[2][2] * b[2][2]; >+ return result; >+} >+half3x3 operator*(half3x3 a, half b) { >+ half3x3 result; >+ result[0][0] = a[0][0] * b; >+ result[0][1] = a[0][1] * b; >+ result[0][2] = a[0][2] * b; >+ result[1][0] = a[1][0] * b; >+ result[1][1] = a[1][1] * b; >+ result[1][2] = a[1][2] * b; >+ result[2][0] = a[2][0] * b; >+ result[2][1] = a[2][1] * b; >+ result[2][2] = a[2][2] * b; >+ return result; >+} >+half3x3 operator*(half a, half3x3 b) { >+ half3x3 result; >+ result[0][0] = a * b[0][0]; >+ result[0][1] = a * b[0][1]; >+ result[0][2] = a * b[0][2]; >+ result[1][0] = a * b[1][0]; >+ result[1][1] = a * b[1][1]; >+ result[1][2] = a * b[1][2]; >+ result[2][0] = a * b[2][0]; >+ result[2][1] = a * b[2][1]; >+ result[2][2] = a * b[2][2]; >+ return result; >+} >+half3x3 operator/(half3x3 a, half3x3 b) { >+ half3x3 result; >+ result[0][0] = a[0][0] / b[0][0]; >+ result[0][1] = a[0][1] / b[0][1]; >+ result[0][2] = a[0][2] / b[0][2]; >+ result[1][0] = a[1][0] / b[1][0]; >+ result[1][1] = a[1][1] / b[1][1]; >+ result[1][2] = a[1][2] / b[1][2]; >+ result[2][0] = a[2][0] / b[2][0]; >+ result[2][1] = a[2][1] / b[2][1]; >+ result[2][2] = a[2][2] / b[2][2]; >+ return result; >+} >+half3x3 operator/(half3x3 a, half b) { >+ half3x3 result; >+ result[0][0] = a[0][0] / b; >+ result[0][1] = a[0][1] / b; >+ result[0][2] = a[0][2] / b; >+ result[1][0] = a[1][0] / b; >+ result[1][1] = a[1][1] / b; >+ result[1][2] = a[1][2] / b; >+ result[2][0] = a[2][0] / b; >+ result[2][1] = a[2][1] / b; >+ result[2][2] = a[2][2] / b; >+ return result; >+} >+half3x3 operator/(half a, half3x3 b) { >+ half3x3 result; >+ result[0][0] = a / b[0][0]; >+ result[0][1] = a / b[0][1]; >+ result[0][2] = a / b[0][2]; >+ result[1][0] = a / b[1][0]; >+ result[1][1] = a / b[1][1]; >+ result[1][2] = a / b[1][2]; >+ result[2][0] = a / b[2][0]; >+ result[2][1] = a / b[2][1]; >+ result[2][2] = a / b[2][2]; >+ return result; >+} >+half3x4 operator+(half3x4 a, half3x4 b) { >+ half3x4 result; >+ result[0][0] = a[0][0] + b[0][0]; >+ result[0][1] = a[0][1] + b[0][1]; >+ result[0][2] = a[0][2] + b[0][2]; >+ result[0][3] = a[0][3] + b[0][3]; >+ result[1][0] = a[1][0] + b[1][0]; >+ result[1][1] = a[1][1] + b[1][1]; >+ result[1][2] = a[1][2] + b[1][2]; >+ result[1][3] = a[1][3] + b[1][3]; >+ result[2][0] = a[2][0] + b[2][0]; >+ result[2][1] = a[2][1] + b[2][1]; >+ result[2][2] = a[2][2] + b[2][2]; >+ result[2][3] = a[2][3] + b[2][3]; >+ return result; >+} >+half3x4 operator-(half3x4 a, half3x4 b) { >+ half3x4 result; >+ result[0][0] = a[0][0] - b[0][0]; >+ result[0][1] = a[0][1] - b[0][1]; >+ result[0][2] = a[0][2] - b[0][2]; >+ result[0][3] = a[0][3] - b[0][3]; >+ result[1][0] = a[1][0] - b[1][0]; >+ result[1][1] = a[1][1] - b[1][1]; >+ result[1][2] = a[1][2] - b[1][2]; >+ result[1][3] = a[1][3] - b[1][3]; >+ result[2][0] = a[2][0] - b[2][0]; >+ result[2][1] = a[2][1] - b[2][1]; >+ result[2][2] = a[2][2] - b[2][2]; >+ result[2][3] = a[2][3] - b[2][3]; >+ return result; >+} >+half3x4 operator-(half3x4 a) { >+ half3x4 result; >+ result[0][0] = -a[0][0]; >+ result[0][1] = -a[0][1]; >+ result[0][2] = -a[0][2]; >+ result[0][3] = -a[0][3]; >+ result[1][0] = -a[1][0]; >+ result[1][1] = -a[1][1]; >+ result[1][2] = -a[1][2]; >+ result[1][3] = -a[1][3]; >+ result[2][0] = -a[2][0]; >+ result[2][1] = -a[2][1]; >+ result[2][2] = -a[2][2]; >+ result[2][3] = -a[2][3]; >+ return result; >+} >+half3x4 operator*(half3x4 a, half3x4 b) { >+ half3x4 result; >+ result[0][0] = a[0][0] * b[0][0]; >+ result[0][1] = a[0][1] * b[0][1]; >+ result[0][2] = a[0][2] * b[0][2]; >+ result[0][3] = a[0][3] * b[0][3]; >+ result[1][0] = a[1][0] * b[1][0]; >+ result[1][1] = a[1][1] * b[1][1]; >+ result[1][2] = a[1][2] * b[1][2]; >+ result[1][3] = a[1][3] * b[1][3]; >+ result[2][0] = a[2][0] * b[2][0]; >+ result[2][1] = a[2][1] * b[2][1]; >+ result[2][2] = a[2][2] * b[2][2]; >+ result[2][3] = a[2][3] * b[2][3]; >+ return result; >+} >+half3x4 operator*(half3x4 a, half b) { >+ half3x4 result; >+ result[0][0] = a[0][0] * b; >+ result[0][1] = a[0][1] * b; >+ result[0][2] = a[0][2] * b; >+ result[0][3] = a[0][3] * b; >+ result[1][0] = a[1][0] * b; >+ result[1][1] = a[1][1] * b; >+ result[1][2] = a[1][2] * b; >+ result[1][3] = a[1][3] * b; >+ result[2][0] = a[2][0] * b; >+ result[2][1] = a[2][1] * b; >+ result[2][2] = a[2][2] * b; >+ result[2][3] = a[2][3] * b; >+ return result; >+} >+half3x4 operator*(half a, half3x4 b) { >+ half3x4 result; >+ result[0][0] = a * b[0][0]; >+ result[0][1] = a * b[0][1]; >+ result[0][2] = a * b[0][2]; >+ result[0][3] = a * b[0][3]; >+ result[1][0] = a * b[1][0]; >+ result[1][1] = a * b[1][1]; >+ result[1][2] = a * b[1][2]; >+ result[1][3] = a * b[1][3]; >+ result[2][0] = a * b[2][0]; >+ result[2][1] = a * b[2][1]; >+ result[2][2] = a * b[2][2]; >+ result[2][3] = a * b[2][3]; >+ return result; >+} >+half3x4 operator/(half3x4 a, half3x4 b) { >+ half3x4 result; >+ result[0][0] = a[0][0] / b[0][0]; >+ result[0][1] = a[0][1] / b[0][1]; >+ result[0][2] = a[0][2] / b[0][2]; >+ result[0][3] = a[0][3] / b[0][3]; >+ result[1][0] = a[1][0] / b[1][0]; >+ result[1][1] = a[1][1] / b[1][1]; >+ result[1][2] = a[1][2] / b[1][2]; >+ result[1][3] = a[1][3] / b[1][3]; >+ result[2][0] = a[2][0] / b[2][0]; >+ result[2][1] = a[2][1] / b[2][1]; >+ result[2][2] = a[2][2] / b[2][2]; >+ result[2][3] = a[2][3] / b[2][3]; >+ return result; >+} >+half3x4 operator/(half3x4 a, half b) { >+ half3x4 result; >+ result[0][0] = a[0][0] / b; >+ result[0][1] = a[0][1] / b; >+ result[0][2] = a[0][2] / b; >+ result[0][3] = a[0][3] / b; >+ result[1][0] = a[1][0] / b; >+ result[1][1] = a[1][1] / b; >+ result[1][2] = a[1][2] / b; >+ result[1][3] = a[1][3] / b; >+ result[2][0] = a[2][0] / b; >+ result[2][1] = a[2][1] / b; >+ result[2][2] = a[2][2] / b; >+ result[2][3] = a[2][3] / b; >+ return result; >+} >+half3x4 operator/(half a, half3x4 b) { >+ half3x4 result; >+ result[0][0] = a / b[0][0]; >+ result[0][1] = a / b[0][1]; >+ result[0][2] = a / b[0][2]; >+ result[0][3] = a / b[0][3]; >+ result[1][0] = a / b[1][0]; >+ result[1][1] = a / b[1][1]; >+ result[1][2] = a / b[1][2]; >+ result[1][3] = a / b[1][3]; >+ result[2][0] = a / b[2][0]; >+ result[2][1] = a / b[2][1]; >+ result[2][2] = a / b[2][2]; >+ result[2][3] = a / b[2][3]; >+ return result; >+} >+half4x2 operator+(half4x2 a, half4x2 b) { >+ half4x2 result; >+ result[0][0] = a[0][0] + b[0][0]; >+ result[0][1] = a[0][1] + b[0][1]; >+ result[1][0] = a[1][0] + b[1][0]; >+ result[1][1] = a[1][1] + b[1][1]; >+ result[2][0] = a[2][0] + b[2][0]; >+ result[2][1] = a[2][1] + b[2][1]; >+ result[3][0] = a[3][0] + b[3][0]; >+ result[3][1] = a[3][1] + b[3][1]; >+ return result; >+} >+half4x2 operator-(half4x2 a, half4x2 b) { >+ half4x2 result; >+ result[0][0] = a[0][0] - b[0][0]; >+ result[0][1] = a[0][1] - b[0][1]; >+ result[1][0] = a[1][0] - b[1][0]; >+ result[1][1] = a[1][1] - b[1][1]; >+ result[2][0] = a[2][0] - b[2][0]; >+ result[2][1] = a[2][1] - b[2][1]; >+ result[3][0] = a[3][0] - b[3][0]; >+ result[3][1] = a[3][1] - b[3][1]; >+ return result; >+} >+half4x2 operator-(half4x2 a) { >+ half4x2 result; >+ result[0][0] = -a[0][0]; >+ result[0][1] = -a[0][1]; >+ result[1][0] = -a[1][0]; >+ result[1][1] = -a[1][1]; >+ result[2][0] = -a[2][0]; >+ result[2][1] = -a[2][1]; >+ result[3][0] = -a[3][0]; >+ result[3][1] = -a[3][1]; >+ return result; >+} >+half4x2 operator*(half4x2 a, half4x2 b) { >+ half4x2 result; >+ result[0][0] = a[0][0] * b[0][0]; >+ result[0][1] = a[0][1] * b[0][1]; >+ result[1][0] = a[1][0] * b[1][0]; >+ result[1][1] = a[1][1] * b[1][1]; >+ result[2][0] = a[2][0] * b[2][0]; >+ result[2][1] = a[2][1] * b[2][1]; >+ result[3][0] = a[3][0] * b[3][0]; >+ result[3][1] = a[3][1] * b[3][1]; >+ return result; >+} >+half4x2 operator*(half4x2 a, half b) { >+ half4x2 result; >+ result[0][0] = a[0][0] * b; >+ result[0][1] = a[0][1] * b; >+ result[1][0] = a[1][0] * b; >+ result[1][1] = a[1][1] * b; >+ result[2][0] = a[2][0] * b; >+ result[2][1] = a[2][1] * b; >+ result[3][0] = a[3][0] * b; >+ result[3][1] = a[3][1] * b; >+ return result; >+} >+half4x2 operator*(half a, half4x2 b) { >+ half4x2 result; >+ result[0][0] = a * b[0][0]; >+ result[0][1] = a * b[0][1]; >+ result[1][0] = a * b[1][0]; >+ result[1][1] = a * b[1][1]; >+ result[2][0] = a * b[2][0]; >+ result[2][1] = a * b[2][1]; >+ result[3][0] = a * b[3][0]; >+ result[3][1] = a * b[3][1]; >+ return result; >+} >+half4x2 operator/(half4x2 a, half4x2 b) { >+ half4x2 result; >+ result[0][0] = a[0][0] / b[0][0]; >+ result[0][1] = a[0][1] / b[0][1]; >+ result[1][0] = a[1][0] / b[1][0]; >+ result[1][1] = a[1][1] / b[1][1]; >+ result[2][0] = a[2][0] / b[2][0]; >+ result[2][1] = a[2][1] / b[2][1]; >+ result[3][0] = a[3][0] / b[3][0]; >+ result[3][1] = a[3][1] / b[3][1]; >+ return result; >+} >+half4x2 operator/(half4x2 a, half b) { >+ half4x2 result; >+ result[0][0] = a[0][0] / b; >+ result[0][1] = a[0][1] / b; >+ result[1][0] = a[1][0] / b; >+ result[1][1] = a[1][1] / b; >+ result[2][0] = a[2][0] / b; >+ result[2][1] = a[2][1] / b; >+ result[3][0] = a[3][0] / b; >+ result[3][1] = a[3][1] / b; >+ return result; >+} >+half4x2 operator/(half a, half4x2 b) { >+ half4x2 result; >+ result[0][0] = a / b[0][0]; >+ result[0][1] = a / b[0][1]; >+ result[1][0] = a / b[1][0]; >+ result[1][1] = a / b[1][1]; >+ result[2][0] = a / b[2][0]; >+ result[2][1] = a / b[2][1]; >+ result[3][0] = a / b[3][0]; >+ result[3][1] = a / b[3][1]; >+ return result; >+} >+half4x3 operator+(half4x3 a, half4x3 b) { >+ half4x3 result; >+ result[0][0] = a[0][0] + b[0][0]; >+ result[0][1] = a[0][1] + b[0][1]; >+ result[0][2] = a[0][2] + b[0][2]; >+ result[1][0] = a[1][0] + b[1][0]; >+ result[1][1] = a[1][1] + b[1][1]; >+ result[1][2] = a[1][2] + b[1][2]; >+ result[2][0] = a[2][0] + b[2][0]; >+ result[2][1] = a[2][1] + b[2][1]; >+ result[2][2] = a[2][2] + b[2][2]; >+ result[3][0] = a[3][0] + b[3][0]; >+ result[3][1] = a[3][1] + b[3][1]; >+ result[3][2] = a[3][2] + b[3][2]; >+ return result; >+} >+half4x3 operator-(half4x3 a, half4x3 b) { >+ half4x3 result; >+ result[0][0] = a[0][0] - b[0][0]; >+ result[0][1] = a[0][1] - b[0][1]; >+ result[0][2] = a[0][2] - b[0][2]; >+ result[1][0] = a[1][0] - b[1][0]; >+ result[1][1] = a[1][1] - b[1][1]; >+ result[1][2] = a[1][2] - b[1][2]; >+ result[2][0] = a[2][0] - b[2][0]; >+ result[2][1] = a[2][1] - b[2][1]; >+ result[2][2] = a[2][2] - b[2][2]; >+ result[3][0] = a[3][0] - b[3][0]; >+ result[3][1] = a[3][1] - b[3][1]; >+ result[3][2] = a[3][2] - b[3][2]; >+ return result; >+} >+half4x3 operator-(half4x3 a) { >+ half4x3 result; >+ result[0][0] = -a[0][0]; >+ result[0][1] = -a[0][1]; >+ result[0][2] = -a[0][2]; >+ result[1][0] = -a[1][0]; >+ result[1][1] = -a[1][1]; >+ result[1][2] = -a[1][2]; >+ result[2][0] = -a[2][0]; >+ result[2][1] = -a[2][1]; >+ result[2][2] = -a[2][2]; >+ result[3][0] = -a[3][0]; >+ result[3][1] = -a[3][1]; >+ result[3][2] = -a[3][2]; >+ return result; >+} >+half4x3 operator*(half4x3 a, half4x3 b) { >+ half4x3 result; >+ result[0][0] = a[0][0] * b[0][0]; >+ result[0][1] = a[0][1] * b[0][1]; >+ result[0][2] = a[0][2] * b[0][2]; >+ result[1][0] = a[1][0] * b[1][0]; >+ result[1][1] = a[1][1] * b[1][1]; >+ result[1][2] = a[1][2] * b[1][2]; >+ result[2][0] = a[2][0] * b[2][0]; >+ result[2][1] = a[2][1] * b[2][1]; >+ result[2][2] = a[2][2] * b[2][2]; >+ result[3][0] = a[3][0] * b[3][0]; >+ result[3][1] = a[3][1] * b[3][1]; >+ result[3][2] = a[3][2] * b[3][2]; >+ return result; >+} >+half4x3 operator*(half4x3 a, half b) { >+ half4x3 result; >+ result[0][0] = a[0][0] * b; >+ result[0][1] = a[0][1] * b; >+ result[0][2] = a[0][2] * b; >+ result[1][0] = a[1][0] * b; >+ result[1][1] = a[1][1] * b; >+ result[1][2] = a[1][2] * b; >+ result[2][0] = a[2][0] * b; >+ result[2][1] = a[2][1] * b; >+ result[2][2] = a[2][2] * b; >+ result[3][0] = a[3][0] * b; >+ result[3][1] = a[3][1] * b; >+ result[3][2] = a[3][2] * b; >+ return result; >+} >+half4x3 operator*(half a, half4x3 b) { >+ half4x3 result; >+ result[0][0] = a * b[0][0]; >+ result[0][1] = a * b[0][1]; >+ result[0][2] = a * b[0][2]; >+ result[1][0] = a * b[1][0]; >+ result[1][1] = a * b[1][1]; >+ result[1][2] = a * b[1][2]; >+ result[2][0] = a * b[2][0]; >+ result[2][1] = a * b[2][1]; >+ result[2][2] = a * b[2][2]; >+ result[3][0] = a * b[3][0]; >+ result[3][1] = a * b[3][1]; >+ result[3][2] = a * b[3][2]; >+ return result; >+} >+half4x3 operator/(half4x3 a, half4x3 b) { >+ half4x3 result; >+ result[0][0] = a[0][0] / b[0][0]; >+ result[0][1] = a[0][1] / b[0][1]; >+ result[0][2] = a[0][2] / b[0][2]; >+ result[1][0] = a[1][0] / b[1][0]; >+ result[1][1] = a[1][1] / b[1][1]; >+ result[1][2] = a[1][2] / b[1][2]; >+ result[2][0] = a[2][0] / b[2][0]; >+ result[2][1] = a[2][1] / b[2][1]; >+ result[2][2] = a[2][2] / b[2][2]; >+ result[3][0] = a[3][0] / b[3][0]; >+ result[3][1] = a[3][1] / b[3][1]; >+ result[3][2] = a[3][2] / b[3][2]; >+ return result; >+} >+half4x3 operator/(half4x3 a, half b) { >+ half4x3 result; >+ result[0][0] = a[0][0] / b; >+ result[0][1] = a[0][1] / b; >+ result[0][2] = a[0][2] / b; >+ result[1][0] = a[1][0] / b; >+ result[1][1] = a[1][1] / b; >+ result[1][2] = a[1][2] / b; >+ result[2][0] = a[2][0] / b; >+ result[2][1] = a[2][1] / b; >+ result[2][2] = a[2][2] / b; >+ result[3][0] = a[3][0] / b; >+ result[3][1] = a[3][1] / b; >+ result[3][2] = a[3][2] / b; >+ return result; >+} >+half4x3 operator/(half a, half4x3 b) { >+ half4x3 result; >+ result[0][0] = a / b[0][0]; >+ result[0][1] = a / b[0][1]; >+ result[0][2] = a / b[0][2]; >+ result[1][0] = a / b[1][0]; >+ result[1][1] = a / b[1][1]; >+ result[1][2] = a / b[1][2]; >+ result[2][0] = a / b[2][0]; >+ result[2][1] = a / b[2][1]; >+ result[2][2] = a / b[2][2]; >+ result[3][0] = a / b[3][0]; >+ result[3][1] = a / b[3][1]; >+ result[3][2] = a / b[3][2]; >+ return result; >+} >+half4x4 operator+(half4x4 a, half4x4 b) { >+ half4x4 result; >+ result[0][0] = a[0][0] + b[0][0]; >+ result[0][1] = a[0][1] + b[0][1]; >+ result[0][2] = a[0][2] + b[0][2]; >+ result[0][3] = a[0][3] + b[0][3]; >+ result[1][0] = a[1][0] + b[1][0]; >+ result[1][1] = a[1][1] + b[1][1]; >+ result[1][2] = a[1][2] + b[1][2]; >+ result[1][3] = a[1][3] + b[1][3]; >+ result[2][0] = a[2][0] + b[2][0]; >+ result[2][1] = a[2][1] + b[2][1]; >+ result[2][2] = a[2][2] + b[2][2]; >+ result[2][3] = a[2][3] + b[2][3]; >+ result[3][0] = a[3][0] + b[3][0]; >+ result[3][1] = a[3][1] + b[3][1]; >+ result[3][2] = a[3][2] + b[3][2]; >+ result[3][3] = a[3][3] + b[3][3]; >+ return result; >+} >+half4x4 operator-(half4x4 a, half4x4 b) { >+ half4x4 result; >+ result[0][0] = a[0][0] - b[0][0]; >+ result[0][1] = a[0][1] - b[0][1]; >+ result[0][2] = a[0][2] - b[0][2]; >+ result[0][3] = a[0][3] - b[0][3]; >+ result[1][0] = a[1][0] - b[1][0]; >+ result[1][1] = a[1][1] - b[1][1]; >+ result[1][2] = a[1][2] - b[1][2]; >+ result[1][3] = a[1][3] - b[1][3]; >+ result[2][0] = a[2][0] - b[2][0]; >+ result[2][1] = a[2][1] - b[2][1]; >+ result[2][2] = a[2][2] - b[2][2]; >+ result[2][3] = a[2][3] - b[2][3]; >+ result[3][0] = a[3][0] - b[3][0]; >+ result[3][1] = a[3][1] - b[3][1]; >+ result[3][2] = a[3][2] - b[3][2]; >+ result[3][3] = a[3][3] - b[3][3]; >+ return result; >+} >+half4x4 operator-(half4x4 a) { >+ half4x4 result; >+ result[0][0] = -a[0][0]; >+ result[0][1] = -a[0][1]; >+ result[0][2] = -a[0][2]; >+ result[0][3] = -a[0][3]; >+ result[1][0] = -a[1][0]; >+ result[1][1] = -a[1][1]; >+ result[1][2] = -a[1][2]; >+ result[1][3] = -a[1][3]; >+ result[2][0] = -a[2][0]; >+ result[2][1] = -a[2][1]; >+ result[2][2] = -a[2][2]; >+ result[2][3] = -a[2][3]; >+ result[3][0] = -a[3][0]; >+ result[3][1] = -a[3][1]; >+ result[3][2] = -a[3][2]; >+ result[3][3] = -a[3][3]; >+ return result; >+} >+half4x4 operator*(half4x4 a, half4x4 b) { >+ half4x4 result; >+ result[0][0] = a[0][0] * b[0][0]; >+ result[0][1] = a[0][1] * b[0][1]; >+ result[0][2] = a[0][2] * b[0][2]; >+ result[0][3] = a[0][3] * b[0][3]; >+ result[1][0] = a[1][0] * b[1][0]; >+ result[1][1] = a[1][1] * b[1][1]; >+ result[1][2] = a[1][2] * b[1][2]; >+ result[1][3] = a[1][3] * b[1][3]; >+ result[2][0] = a[2][0] * b[2][0]; >+ result[2][1] = a[2][1] * b[2][1]; >+ result[2][2] = a[2][2] * b[2][2]; >+ result[2][3] = a[2][3] * b[2][3]; >+ result[3][0] = a[3][0] * b[3][0]; >+ result[3][1] = a[3][1] * b[3][1]; >+ result[3][2] = a[3][2] * b[3][2]; >+ result[3][3] = a[3][3] * b[3][3]; >+ return result; >+} >+half4x4 operator*(half4x4 a, half b) { >+ half4x4 result; >+ result[0][0] = a[0][0] * b; >+ result[0][1] = a[0][1] * b; >+ result[0][2] = a[0][2] * b; >+ result[0][3] = a[0][3] * b; >+ result[1][0] = a[1][0] * b; >+ result[1][1] = a[1][1] * b; >+ result[1][2] = a[1][2] * b; >+ result[1][3] = a[1][3] * b; >+ result[2][0] = a[2][0] * b; >+ result[2][1] = a[2][1] * b; >+ result[2][2] = a[2][2] * b; >+ result[2][3] = a[2][3] * b; >+ result[3][0] = a[3][0] * b; >+ result[3][1] = a[3][1] * b; >+ result[3][2] = a[3][2] * b; >+ result[3][3] = a[3][3] * b; >+ return result; >+} >+half4x4 operator*(half a, half4x4 b) { >+ half4x4 result; >+ result[0][0] = a * b[0][0]; >+ result[0][1] = a * b[0][1]; >+ result[0][2] = a * b[0][2]; >+ result[0][3] = a * b[0][3]; >+ result[1][0] = a * b[1][0]; >+ result[1][1] = a * b[1][1]; >+ result[1][2] = a * b[1][2]; >+ result[1][3] = a * b[1][3]; >+ result[2][0] = a * b[2][0]; >+ result[2][1] = a * b[2][1]; >+ result[2][2] = a * b[2][2]; >+ result[2][3] = a * b[2][3]; >+ result[3][0] = a * b[3][0]; >+ result[3][1] = a * b[3][1]; >+ result[3][2] = a * b[3][2]; >+ result[3][3] = a * b[3][3]; >+ return result; >+} >+half4x4 operator/(half4x4 a, half4x4 b) { >+ half4x4 result; >+ result[0][0] = a[0][0] / b[0][0]; >+ result[0][1] = a[0][1] / b[0][1]; >+ result[0][2] = a[0][2] / b[0][2]; >+ result[0][3] = a[0][3] / b[0][3]; >+ result[1][0] = a[1][0] / b[1][0]; >+ result[1][1] = a[1][1] / b[1][1]; >+ result[1][2] = a[1][2] / b[1][2]; >+ result[1][3] = a[1][3] / b[1][3]; >+ result[2][0] = a[2][0] / b[2][0]; >+ result[2][1] = a[2][1] / b[2][1]; >+ result[2][2] = a[2][2] / b[2][2]; >+ result[2][3] = a[2][3] / b[2][3]; >+ result[3][0] = a[3][0] / b[3][0]; >+ result[3][1] = a[3][1] / b[3][1]; >+ result[3][2] = a[3][2] / b[3][2]; >+ result[3][3] = a[3][3] / b[3][3]; >+ return result; >+} >+half4x4 operator/(half4x4 a, half b) { >+ half4x4 result; >+ result[0][0] = a[0][0] / b; >+ result[0][1] = a[0][1] / b; >+ result[0][2] = a[0][2] / b; >+ result[0][3] = a[0][3] / b; >+ result[1][0] = a[1][0] / b; >+ result[1][1] = a[1][1] / b; >+ result[1][2] = a[1][2] / b; >+ result[1][3] = a[1][3] / b; >+ result[2][0] = a[2][0] / b; >+ result[2][1] = a[2][1] / b; >+ result[2][2] = a[2][2] / b; >+ result[2][3] = a[2][3] / b; >+ result[3][0] = a[3][0] / b; >+ result[3][1] = a[3][1] / b; >+ result[3][2] = a[3][2] / b; >+ result[3][3] = a[3][3] / b; >+ return result; >+} >+half4x4 operator/(half a, half4x4 b) { >+ half4x4 result; >+ result[0][0] = a / b[0][0]; >+ result[0][1] = a / b[0][1]; >+ result[0][2] = a / b[0][2]; >+ result[0][3] = a / b[0][3]; >+ result[1][0] = a / b[1][0]; >+ result[1][1] = a / b[1][1]; >+ result[1][2] = a / b[1][2]; >+ result[1][3] = a / b[1][3]; >+ result[2][0] = a / b[2][0]; >+ result[2][1] = a / b[2][1]; >+ result[2][2] = a / b[2][2]; >+ result[2][3] = a / b[2][3]; >+ result[3][0] = a / b[3][0]; >+ result[3][1] = a / b[3][1]; >+ result[3][2] = a / b[3][2]; >+ result[3][3] = a / b[3][3]; >+ return result; >+} >+float2x2 operator+(float2x2 a, float2x2 b) { >+ float2x2 result; >+ result[0][0] = a[0][0] + b[0][0]; >+ result[0][1] = a[0][1] + b[0][1]; >+ result[1][0] = a[1][0] + b[1][0]; >+ result[1][1] = a[1][1] + b[1][1]; >+ return result; >+} >+float2x2 operator-(float2x2 a, float2x2 b) { >+ float2x2 result; >+ result[0][0] = a[0][0] - b[0][0]; >+ result[0][1] = a[0][1] - b[0][1]; >+ result[1][0] = a[1][0] - b[1][0]; >+ result[1][1] = a[1][1] - b[1][1]; >+ return result; >+} >+float2x2 operator-(float2x2 a) { >+ float2x2 result; >+ result[0][0] = -a[0][0]; >+ result[0][1] = -a[0][1]; >+ result[1][0] = -a[1][0]; >+ result[1][1] = -a[1][1]; >+ return result; >+} >+float2x2 operator*(float2x2 a, float2x2 b) { >+ float2x2 result; >+ result[0][0] = a[0][0] * b[0][0]; >+ result[0][1] = a[0][1] * b[0][1]; >+ result[1][0] = a[1][0] * b[1][0]; >+ result[1][1] = a[1][1] * b[1][1]; >+ return result; >+} >+float2x2 operator*(float2x2 a, float b) { >+ float2x2 result; >+ result[0][0] = a[0][0] * b; >+ result[0][1] = a[0][1] * b; >+ result[1][0] = a[1][0] * b; >+ result[1][1] = a[1][1] * b; >+ return result; >+} >+float2x2 operator*(float a, float2x2 b) { >+ float2x2 result; >+ result[0][0] = a * b[0][0]; >+ result[0][1] = a * b[0][1]; >+ result[1][0] = a * b[1][0]; >+ result[1][1] = a * b[1][1]; >+ return result; >+} >+float2x2 operator/(float2x2 a, float2x2 b) { >+ float2x2 result; >+ result[0][0] = a[0][0] / b[0][0]; >+ result[0][1] = a[0][1] / b[0][1]; >+ result[1][0] = a[1][0] / b[1][0]; >+ result[1][1] = a[1][1] / b[1][1]; >+ return result; >+} >+float2x2 operator/(float2x2 a, float b) { >+ float2x2 result; >+ result[0][0] = a[0][0] / b; >+ result[0][1] = a[0][1] / b; >+ result[1][0] = a[1][0] / b; >+ result[1][1] = a[1][1] / b; >+ return result; >+} >+float2x2 operator/(float a, float2x2 b) { >+ float2x2 result; >+ result[0][0] = a / b[0][0]; >+ result[0][1] = a / b[0][1]; >+ result[1][0] = a / b[1][0]; >+ result[1][1] = a / b[1][1]; >+ return result; >+} >+float2x3 operator+(float2x3 a, float2x3 b) { >+ float2x3 result; >+ result[0][0] = a[0][0] + b[0][0]; >+ result[0][1] = a[0][1] + b[0][1]; >+ result[0][2] = a[0][2] + b[0][2]; >+ result[1][0] = a[1][0] + b[1][0]; >+ result[1][1] = a[1][1] + b[1][1]; >+ result[1][2] = a[1][2] + b[1][2]; >+ return result; >+} >+float2x3 operator-(float2x3 a, float2x3 b) { >+ float2x3 result; >+ result[0][0] = a[0][0] - b[0][0]; >+ result[0][1] = a[0][1] - b[0][1]; >+ result[0][2] = a[0][2] - b[0][2]; >+ result[1][0] = a[1][0] - b[1][0]; >+ result[1][1] = a[1][1] - b[1][1]; >+ result[1][2] = a[1][2] - b[1][2]; >+ return result; >+} >+float2x3 operator-(float2x3 a) { >+ float2x3 result; >+ result[0][0] = -a[0][0]; >+ result[0][1] = -a[0][1]; >+ result[0][2] = -a[0][2]; >+ result[1][0] = -a[1][0]; >+ result[1][1] = -a[1][1]; >+ result[1][2] = -a[1][2]; >+ return result; >+} >+float2x3 operator*(float2x3 a, float2x3 b) { >+ float2x3 result; >+ result[0][0] = a[0][0] * b[0][0]; >+ result[0][1] = a[0][1] * b[0][1]; >+ result[0][2] = a[0][2] * b[0][2]; >+ result[1][0] = a[1][0] * b[1][0]; >+ result[1][1] = a[1][1] * b[1][1]; >+ result[1][2] = a[1][2] * b[1][2]; >+ return result; >+} >+float2x3 operator*(float2x3 a, float b) { >+ float2x3 result; >+ result[0][0] = a[0][0] * b; >+ result[0][1] = a[0][1] * b; >+ result[0][2] = a[0][2] * b; >+ result[1][0] = a[1][0] * b; >+ result[1][1] = a[1][1] * b; >+ result[1][2] = a[1][2] * b; >+ return result; >+} >+float2x3 operator*(float a, float2x3 b) { >+ float2x3 result; >+ result[0][0] = a * b[0][0]; >+ result[0][1] = a * b[0][1]; >+ result[0][2] = a * b[0][2]; >+ result[1][0] = a * b[1][0]; >+ result[1][1] = a * b[1][1]; >+ result[1][2] = a * b[1][2]; >+ return result; >+} >+float2x3 operator/(float2x3 a, float2x3 b) { >+ float2x3 result; >+ result[0][0] = a[0][0] / b[0][0]; >+ result[0][1] = a[0][1] / b[0][1]; >+ result[0][2] = a[0][2] / b[0][2]; >+ result[1][0] = a[1][0] / b[1][0]; >+ result[1][1] = a[1][1] / b[1][1]; >+ result[1][2] = a[1][2] / b[1][2]; >+ return result; >+} >+float2x3 operator/(float2x3 a, float b) { >+ float2x3 result; >+ result[0][0] = a[0][0] / b; >+ result[0][1] = a[0][1] / b; >+ result[0][2] = a[0][2] / b; >+ result[1][0] = a[1][0] / b; >+ result[1][1] = a[1][1] / b; >+ result[1][2] = a[1][2] / b; >+ return result; >+} >+float2x3 operator/(float a, float2x3 b) { >+ float2x3 result; >+ result[0][0] = a / b[0][0]; >+ result[0][1] = a / b[0][1]; >+ result[0][2] = a / b[0][2]; >+ result[1][0] = a / b[1][0]; >+ result[1][1] = a / b[1][1]; >+ result[1][2] = a / b[1][2]; >+ return result; >+} >+float2x4 operator+(float2x4 a, float2x4 b) { >+ float2x4 result; >+ result[0][0] = a[0][0] + b[0][0]; >+ result[0][1] = a[0][1] + b[0][1]; >+ result[0][2] = a[0][2] + b[0][2]; >+ result[0][3] = a[0][3] + b[0][3]; >+ result[1][0] = a[1][0] + b[1][0]; >+ result[1][1] = a[1][1] + b[1][1]; >+ result[1][2] = a[1][2] + b[1][2]; >+ result[1][3] = a[1][3] + b[1][3]; >+ return result; >+} >+float2x4 operator-(float2x4 a, float2x4 b) { >+ float2x4 result; >+ result[0][0] = a[0][0] - b[0][0]; >+ result[0][1] = a[0][1] - b[0][1]; >+ result[0][2] = a[0][2] - b[0][2]; >+ result[0][3] = a[0][3] - b[0][3]; >+ result[1][0] = a[1][0] - b[1][0]; >+ result[1][1] = a[1][1] - b[1][1]; >+ result[1][2] = a[1][2] - b[1][2]; >+ result[1][3] = a[1][3] - b[1][3]; >+ return result; >+} >+float2x4 operator-(float2x4 a) { >+ float2x4 result; >+ result[0][0] = -a[0][0]; >+ result[0][1] = -a[0][1]; >+ result[0][2] = -a[0][2]; >+ result[0][3] = -a[0][3]; >+ result[1][0] = -a[1][0]; >+ result[1][1] = -a[1][1]; >+ result[1][2] = -a[1][2]; >+ result[1][3] = -a[1][3]; >+ return result; >+} >+float2x4 operator*(float2x4 a, float2x4 b) { >+ float2x4 result; >+ result[0][0] = a[0][0] * b[0][0]; >+ result[0][1] = a[0][1] * b[0][1]; >+ result[0][2] = a[0][2] * b[0][2]; >+ result[0][3] = a[0][3] * b[0][3]; >+ result[1][0] = a[1][0] * b[1][0]; >+ result[1][1] = a[1][1] * b[1][1]; >+ result[1][2] = a[1][2] * b[1][2]; >+ result[1][3] = a[1][3] * b[1][3]; >+ return result; >+} >+float2x4 operator*(float2x4 a, float b) { >+ float2x4 result; >+ result[0][0] = a[0][0] * b; >+ result[0][1] = a[0][1] * b; >+ result[0][2] = a[0][2] * b; >+ result[0][3] = a[0][3] * b; >+ result[1][0] = a[1][0] * b; >+ result[1][1] = a[1][1] * b; >+ result[1][2] = a[1][2] * b; >+ result[1][3] = a[1][3] * b; >+ return result; >+} >+float2x4 operator*(float a, float2x4 b) { >+ float2x4 result; >+ result[0][0] = a * b[0][0]; >+ result[0][1] = a * b[0][1]; >+ result[0][2] = a * b[0][2]; >+ result[0][3] = a * b[0][3]; >+ result[1][0] = a * b[1][0]; >+ result[1][1] = a * b[1][1]; >+ result[1][2] = a * b[1][2]; >+ result[1][3] = a * b[1][3]; >+ return result; >+} >+float2x4 operator/(float2x4 a, float2x4 b) { >+ float2x4 result; >+ result[0][0] = a[0][0] / b[0][0]; >+ result[0][1] = a[0][1] / b[0][1]; >+ result[0][2] = a[0][2] / b[0][2]; >+ result[0][3] = a[0][3] / b[0][3]; >+ result[1][0] = a[1][0] / b[1][0]; >+ result[1][1] = a[1][1] / b[1][1]; >+ result[1][2] = a[1][2] / b[1][2]; >+ result[1][3] = a[1][3] / b[1][3]; >+ return result; >+} >+float2x4 operator/(float2x4 a, float b) { >+ float2x4 result; >+ result[0][0] = a[0][0] / b; >+ result[0][1] = a[0][1] / b; >+ result[0][2] = a[0][2] / b; >+ result[0][3] = a[0][3] / b; >+ result[1][0] = a[1][0] / b; >+ result[1][1] = a[1][1] / b; >+ result[1][2] = a[1][2] / b; >+ result[1][3] = a[1][3] / b; >+ return result; >+} >+float2x4 operator/(float a, float2x4 b) { >+ float2x4 result; >+ result[0][0] = a / b[0][0]; >+ result[0][1] = a / b[0][1]; >+ result[0][2] = a / b[0][2]; >+ result[0][3] = a / b[0][3]; >+ result[1][0] = a / b[1][0]; >+ result[1][1] = a / b[1][1]; >+ result[1][2] = a / b[1][2]; >+ result[1][3] = a / b[1][3]; >+ return result; >+} >+float3x2 operator+(float3x2 a, float3x2 b) { >+ float3x2 result; >+ result[0][0] = a[0][0] + b[0][0]; >+ result[0][1] = a[0][1] + b[0][1]; >+ result[1][0] = a[1][0] + b[1][0]; >+ result[1][1] = a[1][1] + b[1][1]; >+ result[2][0] = a[2][0] + b[2][0]; >+ result[2][1] = a[2][1] + b[2][1]; >+ return result; >+} >+float3x2 operator-(float3x2 a, float3x2 b) { >+ float3x2 result; >+ result[0][0] = a[0][0] - b[0][0]; >+ result[0][1] = a[0][1] - b[0][1]; >+ result[1][0] = a[1][0] - b[1][0]; >+ result[1][1] = a[1][1] - b[1][1]; >+ result[2][0] = a[2][0] - b[2][0]; >+ result[2][1] = a[2][1] - b[2][1]; >+ return result; >+} >+float3x2 operator-(float3x2 a) { >+ float3x2 result; >+ result[0][0] = -a[0][0]; >+ result[0][1] = -a[0][1]; >+ result[1][0] = -a[1][0]; >+ result[1][1] = -a[1][1]; >+ result[2][0] = -a[2][0]; >+ result[2][1] = -a[2][1]; >+ return result; >+} >+float3x2 operator*(float3x2 a, float3x2 b) { >+ float3x2 result; >+ result[0][0] = a[0][0] * b[0][0]; >+ result[0][1] = a[0][1] * b[0][1]; >+ result[1][0] = a[1][0] * b[1][0]; >+ result[1][1] = a[1][1] * b[1][1]; >+ result[2][0] = a[2][0] * b[2][0]; >+ result[2][1] = a[2][1] * b[2][1]; >+ return result; >+} >+float3x2 operator*(float3x2 a, float b) { >+ float3x2 result; >+ result[0][0] = a[0][0] * b; >+ result[0][1] = a[0][1] * b; >+ result[1][0] = a[1][0] * b; >+ result[1][1] = a[1][1] * b; >+ result[2][0] = a[2][0] * b; >+ result[2][1] = a[2][1] * b; >+ return result; >+} >+float3x2 operator*(float a, float3x2 b) { >+ float3x2 result; >+ result[0][0] = a * b[0][0]; >+ result[0][1] = a * b[0][1]; >+ result[1][0] = a * b[1][0]; >+ result[1][1] = a * b[1][1]; >+ result[2][0] = a * b[2][0]; >+ result[2][1] = a * b[2][1]; >+ return result; >+} >+float3x2 operator/(float3x2 a, float3x2 b) { >+ float3x2 result; >+ result[0][0] = a[0][0] / b[0][0]; >+ result[0][1] = a[0][1] / b[0][1]; >+ result[1][0] = a[1][0] / b[1][0]; >+ result[1][1] = a[1][1] / b[1][1]; >+ result[2][0] = a[2][0] / b[2][0]; >+ result[2][1] = a[2][1] / b[2][1]; >+ return result; >+} >+float3x2 operator/(float3x2 a, float b) { >+ float3x2 result; >+ result[0][0] = a[0][0] / b; >+ result[0][1] = a[0][1] / b; >+ result[1][0] = a[1][0] / b; >+ result[1][1] = a[1][1] / b; >+ result[2][0] = a[2][0] / b; >+ result[2][1] = a[2][1] / b; >+ return result; >+} >+float3x2 operator/(float a, float3x2 b) { >+ float3x2 result; >+ result[0][0] = a / b[0][0]; >+ result[0][1] = a / b[0][1]; >+ result[1][0] = a / b[1][0]; >+ result[1][1] = a / b[1][1]; >+ result[2][0] = a / b[2][0]; >+ result[2][1] = a / b[2][1]; >+ return result; >+} >+float3x3 operator+(float3x3 a, float3x3 b) { >+ float3x3 result; >+ result[0][0] = a[0][0] + b[0][0]; >+ result[0][1] = a[0][1] + b[0][1]; >+ result[0][2] = a[0][2] + b[0][2]; >+ result[1][0] = a[1][0] + b[1][0]; >+ result[1][1] = a[1][1] + b[1][1]; >+ result[1][2] = a[1][2] + b[1][2]; >+ result[2][0] = a[2][0] + b[2][0]; >+ result[2][1] = a[2][1] + b[2][1]; >+ result[2][2] = a[2][2] + b[2][2]; >+ return result; >+} >+float3x3 operator-(float3x3 a, float3x3 b) { >+ float3x3 result; >+ result[0][0] = a[0][0] - b[0][0]; >+ result[0][1] = a[0][1] - b[0][1]; >+ result[0][2] = a[0][2] - b[0][2]; >+ result[1][0] = a[1][0] - b[1][0]; >+ result[1][1] = a[1][1] - b[1][1]; >+ result[1][2] = a[1][2] - b[1][2]; >+ result[2][0] = a[2][0] - b[2][0]; >+ result[2][1] = a[2][1] - b[2][1]; >+ result[2][2] = a[2][2] - b[2][2]; >+ return result; >+} >+float3x3 operator-(float3x3 a) { >+ float3x3 result; >+ result[0][0] = -a[0][0]; >+ result[0][1] = -a[0][1]; >+ result[0][2] = -a[0][2]; >+ result[1][0] = -a[1][0]; >+ result[1][1] = -a[1][1]; >+ result[1][2] = -a[1][2]; >+ result[2][0] = -a[2][0]; >+ result[2][1] = -a[2][1]; >+ result[2][2] = -a[2][2]; >+ return result; >+} >+float3x3 operator*(float3x3 a, float3x3 b) { >+ float3x3 result; >+ result[0][0] = a[0][0] * b[0][0]; >+ result[0][1] = a[0][1] * b[0][1]; >+ result[0][2] = a[0][2] * b[0][2]; >+ result[1][0] = a[1][0] * b[1][0]; >+ result[1][1] = a[1][1] * b[1][1]; >+ result[1][2] = a[1][2] * b[1][2]; >+ result[2][0] = a[2][0] * b[2][0]; >+ result[2][1] = a[2][1] * b[2][1]; >+ result[2][2] = a[2][2] * b[2][2]; >+ return result; >+} >+float3x3 operator*(float3x3 a, float b) { >+ float3x3 result; >+ result[0][0] = a[0][0] * b; >+ result[0][1] = a[0][1] * b; >+ result[0][2] = a[0][2] * b; >+ result[1][0] = a[1][0] * b; >+ result[1][1] = a[1][1] * b; >+ result[1][2] = a[1][2] * b; >+ result[2][0] = a[2][0] * b; >+ result[2][1] = a[2][1] * b; >+ result[2][2] = a[2][2] * b; >+ return result; >+} >+float3x3 operator*(float a, float3x3 b) { >+ float3x3 result; >+ result[0][0] = a * b[0][0]; >+ result[0][1] = a * b[0][1]; >+ result[0][2] = a * b[0][2]; >+ result[1][0] = a * b[1][0]; >+ result[1][1] = a * b[1][1]; >+ result[1][2] = a * b[1][2]; >+ result[2][0] = a * b[2][0]; >+ result[2][1] = a * b[2][1]; >+ result[2][2] = a * b[2][2]; >+ return result; >+} >+float3x3 operator/(float3x3 a, float3x3 b) { >+ float3x3 result; >+ result[0][0] = a[0][0] / b[0][0]; >+ result[0][1] = a[0][1] / b[0][1]; >+ result[0][2] = a[0][2] / b[0][2]; >+ result[1][0] = a[1][0] / b[1][0]; >+ result[1][1] = a[1][1] / b[1][1]; >+ result[1][2] = a[1][2] / b[1][2]; >+ result[2][0] = a[2][0] / b[2][0]; >+ result[2][1] = a[2][1] / b[2][1]; >+ result[2][2] = a[2][2] / b[2][2]; >+ return result; >+} >+float3x3 operator/(float3x3 a, float b) { >+ float3x3 result; >+ result[0][0] = a[0][0] / b; >+ result[0][1] = a[0][1] / b; >+ result[0][2] = a[0][2] / b; >+ result[1][0] = a[1][0] / b; >+ result[1][1] = a[1][1] / b; >+ result[1][2] = a[1][2] / b; >+ result[2][0] = a[2][0] / b; >+ result[2][1] = a[2][1] / b; >+ result[2][2] = a[2][2] / b; >+ return result; >+} >+float3x3 operator/(float a, float3x3 b) { >+ float3x3 result; >+ result[0][0] = a / b[0][0]; >+ result[0][1] = a / b[0][1]; >+ result[0][2] = a / b[0][2]; >+ result[1][0] = a / b[1][0]; >+ result[1][1] = a / b[1][1]; >+ result[1][2] = a / b[1][2]; >+ result[2][0] = a / b[2][0]; >+ result[2][1] = a / b[2][1]; >+ result[2][2] = a / b[2][2]; >+ return result; >+} >+float3x4 operator+(float3x4 a, float3x4 b) { >+ float3x4 result; >+ result[0][0] = a[0][0] + b[0][0]; >+ result[0][1] = a[0][1] + b[0][1]; >+ result[0][2] = a[0][2] + b[0][2]; >+ result[0][3] = a[0][3] + b[0][3]; >+ result[1][0] = a[1][0] + b[1][0]; >+ result[1][1] = a[1][1] + b[1][1]; >+ result[1][2] = a[1][2] + b[1][2]; >+ result[1][3] = a[1][3] + b[1][3]; >+ result[2][0] = a[2][0] + b[2][0]; >+ result[2][1] = a[2][1] + b[2][1]; >+ result[2][2] = a[2][2] + b[2][2]; >+ result[2][3] = a[2][3] + b[2][3]; >+ return result; >+} >+float3x4 operator-(float3x4 a, float3x4 b) { >+ float3x4 result; >+ result[0][0] = a[0][0] - b[0][0]; >+ result[0][1] = a[0][1] - b[0][1]; >+ result[0][2] = a[0][2] - b[0][2]; >+ result[0][3] = a[0][3] - b[0][3]; >+ result[1][0] = a[1][0] - b[1][0]; >+ result[1][1] = a[1][1] - b[1][1]; >+ result[1][2] = a[1][2] - b[1][2]; >+ result[1][3] = a[1][3] - b[1][3]; >+ result[2][0] = a[2][0] - b[2][0]; >+ result[2][1] = a[2][1] - b[2][1]; >+ result[2][2] = a[2][2] - b[2][2]; >+ result[2][3] = a[2][3] - b[2][3]; >+ return result; >+} >+float3x4 operator-(float3x4 a) { >+ float3x4 result; >+ result[0][0] = -a[0][0]; >+ result[0][1] = -a[0][1]; >+ result[0][2] = -a[0][2]; >+ result[0][3] = -a[0][3]; >+ result[1][0] = -a[1][0]; >+ result[1][1] = -a[1][1]; >+ result[1][2] = -a[1][2]; >+ result[1][3] = -a[1][3]; >+ result[2][0] = -a[2][0]; >+ result[2][1] = -a[2][1]; >+ result[2][2] = -a[2][2]; >+ result[2][3] = -a[2][3]; >+ return result; >+} >+float3x4 operator*(float3x4 a, float3x4 b) { >+ float3x4 result; >+ result[0][0] = a[0][0] * b[0][0]; >+ result[0][1] = a[0][1] * b[0][1]; >+ result[0][2] = a[0][2] * b[0][2]; >+ result[0][3] = a[0][3] * b[0][3]; >+ result[1][0] = a[1][0] * b[1][0]; >+ result[1][1] = a[1][1] * b[1][1]; >+ result[1][2] = a[1][2] * b[1][2]; >+ result[1][3] = a[1][3] * b[1][3]; >+ result[2][0] = a[2][0] * b[2][0]; >+ result[2][1] = a[2][1] * b[2][1]; >+ result[2][2] = a[2][2] * b[2][2]; >+ result[2][3] = a[2][3] * b[2][3]; >+ return result; >+} >+float3x4 operator*(float3x4 a, float b) { >+ float3x4 result; >+ result[0][0] = a[0][0] * b; >+ result[0][1] = a[0][1] * b; >+ result[0][2] = a[0][2] * b; >+ result[0][3] = a[0][3] * b; >+ result[1][0] = a[1][0] * b; >+ result[1][1] = a[1][1] * b; >+ result[1][2] = a[1][2] * b; >+ result[1][3] = a[1][3] * b; >+ result[2][0] = a[2][0] * b; >+ result[2][1] = a[2][1] * b; >+ result[2][2] = a[2][2] * b; >+ result[2][3] = a[2][3] * b; >+ return result; >+} >+float3x4 operator*(float a, float3x4 b) { >+ float3x4 result; >+ result[0][0] = a * b[0][0]; >+ result[0][1] = a * b[0][1]; >+ result[0][2] = a * b[0][2]; >+ result[0][3] = a * b[0][3]; >+ result[1][0] = a * b[1][0]; >+ result[1][1] = a * b[1][1]; >+ result[1][2] = a * b[1][2]; >+ result[1][3] = a * b[1][3]; >+ result[2][0] = a * b[2][0]; >+ result[2][1] = a * b[2][1]; >+ result[2][2] = a * b[2][2]; >+ result[2][3] = a * b[2][3]; >+ return result; >+} >+float3x4 operator/(float3x4 a, float3x4 b) { >+ float3x4 result; >+ result[0][0] = a[0][0] / b[0][0]; >+ result[0][1] = a[0][1] / b[0][1]; >+ result[0][2] = a[0][2] / b[0][2]; >+ result[0][3] = a[0][3] / b[0][3]; >+ result[1][0] = a[1][0] / b[1][0]; >+ result[1][1] = a[1][1] / b[1][1]; >+ result[1][2] = a[1][2] / b[1][2]; >+ result[1][3] = a[1][3] / b[1][3]; >+ result[2][0] = a[2][0] / b[2][0]; >+ result[2][1] = a[2][1] / b[2][1]; >+ result[2][2] = a[2][2] / b[2][2]; >+ result[2][3] = a[2][3] / b[2][3]; >+ return result; >+} >+float3x4 operator/(float3x4 a, float b) { >+ float3x4 result; >+ result[0][0] = a[0][0] / b; >+ result[0][1] = a[0][1] / b; >+ result[0][2] = a[0][2] / b; >+ result[0][3] = a[0][3] / b; >+ result[1][0] = a[1][0] / b; >+ result[1][1] = a[1][1] / b; >+ result[1][2] = a[1][2] / b; >+ result[1][3] = a[1][3] / b; >+ result[2][0] = a[2][0] / b; >+ result[2][1] = a[2][1] / b; >+ result[2][2] = a[2][2] / b; >+ result[2][3] = a[2][3] / b; >+ return result; >+} >+float3x4 operator/(float a, float3x4 b) { >+ float3x4 result; >+ result[0][0] = a / b[0][0]; >+ result[0][1] = a / b[0][1]; >+ result[0][2] = a / b[0][2]; >+ result[0][3] = a / b[0][3]; >+ result[1][0] = a / b[1][0]; >+ result[1][1] = a / b[1][1]; >+ result[1][2] = a / b[1][2]; >+ result[1][3] = a / b[1][3]; >+ result[2][0] = a / b[2][0]; >+ result[2][1] = a / b[2][1]; >+ result[2][2] = a / b[2][2]; >+ result[2][3] = a / b[2][3]; >+ return result; >+} >+float4x2 operator+(float4x2 a, float4x2 b) { >+ float4x2 result; >+ result[0][0] = a[0][0] + b[0][0]; >+ result[0][1] = a[0][1] + b[0][1]; >+ result[1][0] = a[1][0] + b[1][0]; >+ result[1][1] = a[1][1] + b[1][1]; >+ result[2][0] = a[2][0] + b[2][0]; >+ result[2][1] = a[2][1] + b[2][1]; >+ result[3][0] = a[3][0] + b[3][0]; >+ result[3][1] = a[3][1] + b[3][1]; >+ return result; >+} >+float4x2 operator-(float4x2 a, float4x2 b) { >+ float4x2 result; >+ result[0][0] = a[0][0] - b[0][0]; >+ result[0][1] = a[0][1] - b[0][1]; >+ result[1][0] = a[1][0] - b[1][0]; >+ result[1][1] = a[1][1] - b[1][1]; >+ result[2][0] = a[2][0] - b[2][0]; >+ result[2][1] = a[2][1] - b[2][1]; >+ result[3][0] = a[3][0] - b[3][0]; >+ result[3][1] = a[3][1] - b[3][1]; >+ return result; >+} >+float4x2 operator-(float4x2 a) { >+ float4x2 result; >+ result[0][0] = -a[0][0]; >+ result[0][1] = -a[0][1]; >+ result[1][0] = -a[1][0]; >+ result[1][1] = -a[1][1]; >+ result[2][0] = -a[2][0]; >+ result[2][1] = -a[2][1]; >+ result[3][0] = -a[3][0]; >+ result[3][1] = -a[3][1]; >+ return result; >+} >+float4x2 operator*(float4x2 a, float4x2 b) { >+ float4x2 result; >+ result[0][0] = a[0][0] * b[0][0]; >+ result[0][1] = a[0][1] * b[0][1]; >+ result[1][0] = a[1][0] * b[1][0]; >+ result[1][1] = a[1][1] * b[1][1]; >+ result[2][0] = a[2][0] * b[2][0]; >+ result[2][1] = a[2][1] * b[2][1]; >+ result[3][0] = a[3][0] * b[3][0]; >+ result[3][1] = a[3][1] * b[3][1]; >+ return result; >+} >+float4x2 operator*(float4x2 a, float b) { >+ float4x2 result; >+ result[0][0] = a[0][0] * b; >+ result[0][1] = a[0][1] * b; >+ result[1][0] = a[1][0] * b; >+ result[1][1] = a[1][1] * b; >+ result[2][0] = a[2][0] * b; >+ result[2][1] = a[2][1] * b; >+ result[3][0] = a[3][0] * b; >+ result[3][1] = a[3][1] * b; >+ return result; >+} >+float4x2 operator*(float a, float4x2 b) { >+ float4x2 result; >+ result[0][0] = a * b[0][0]; >+ result[0][1] = a * b[0][1]; >+ result[1][0] = a * b[1][0]; >+ result[1][1] = a * b[1][1]; >+ result[2][0] = a * b[2][0]; >+ result[2][1] = a * b[2][1]; >+ result[3][0] = a * b[3][0]; >+ result[3][1] = a * b[3][1]; >+ return result; >+} >+float4x2 operator/(float4x2 a, float4x2 b) { >+ float4x2 result; >+ result[0][0] = a[0][0] / b[0][0]; >+ result[0][1] = a[0][1] / b[0][1]; >+ result[1][0] = a[1][0] / b[1][0]; >+ result[1][1] = a[1][1] / b[1][1]; >+ result[2][0] = a[2][0] / b[2][0]; >+ result[2][1] = a[2][1] / b[2][1]; >+ result[3][0] = a[3][0] / b[3][0]; >+ result[3][1] = a[3][1] / b[3][1]; >+ return result; >+} >+float4x2 operator/(float4x2 a, float b) { >+ float4x2 result; >+ result[0][0] = a[0][0] / b; >+ result[0][1] = a[0][1] / b; >+ result[1][0] = a[1][0] / b; >+ result[1][1] = a[1][1] / b; >+ result[2][0] = a[2][0] / b; >+ result[2][1] = a[2][1] / b; >+ result[3][0] = a[3][0] / b; >+ result[3][1] = a[3][1] / b; >+ return result; >+} >+float4x2 operator/(float a, float4x2 b) { >+ float4x2 result; >+ result[0][0] = a / b[0][0]; >+ result[0][1] = a / b[0][1]; >+ result[1][0] = a / b[1][0]; >+ result[1][1] = a / b[1][1]; >+ result[2][0] = a / b[2][0]; >+ result[2][1] = a / b[2][1]; >+ result[3][0] = a / b[3][0]; >+ result[3][1] = a / b[3][1]; >+ return result; >+} >+float4x3 operator+(float4x3 a, float4x3 b) { >+ float4x3 result; >+ result[0][0] = a[0][0] + b[0][0]; >+ result[0][1] = a[0][1] + b[0][1]; >+ result[0][2] = a[0][2] + b[0][2]; >+ result[1][0] = a[1][0] + b[1][0]; >+ result[1][1] = a[1][1] + b[1][1]; >+ result[1][2] = a[1][2] + b[1][2]; >+ result[2][0] = a[2][0] + b[2][0]; >+ result[2][1] = a[2][1] + b[2][1]; >+ result[2][2] = a[2][2] + b[2][2]; >+ result[3][0] = a[3][0] + b[3][0]; >+ result[3][1] = a[3][1] + b[3][1]; >+ result[3][2] = a[3][2] + b[3][2]; >+ return result; >+} >+float4x3 operator-(float4x3 a, float4x3 b) { >+ float4x3 result; >+ result[0][0] = a[0][0] - b[0][0]; >+ result[0][1] = a[0][1] - b[0][1]; >+ result[0][2] = a[0][2] - b[0][2]; >+ result[1][0] = a[1][0] - b[1][0]; >+ result[1][1] = a[1][1] - b[1][1]; >+ result[1][2] = a[1][2] - b[1][2]; >+ result[2][0] = a[2][0] - b[2][0]; >+ result[2][1] = a[2][1] - b[2][1]; >+ result[2][2] = a[2][2] - b[2][2]; >+ result[3][0] = a[3][0] - b[3][0]; >+ result[3][1] = a[3][1] - b[3][1]; >+ result[3][2] = a[3][2] - b[3][2]; >+ return result; >+} >+float4x3 operator-(float4x3 a) { >+ float4x3 result; >+ result[0][0] = -a[0][0]; >+ result[0][1] = -a[0][1]; >+ result[0][2] = -a[0][2]; >+ result[1][0] = -a[1][0]; >+ result[1][1] = -a[1][1]; >+ result[1][2] = -a[1][2]; >+ result[2][0] = -a[2][0]; >+ result[2][1] = -a[2][1]; >+ result[2][2] = -a[2][2]; >+ result[3][0] = -a[3][0]; >+ result[3][1] = -a[3][1]; >+ result[3][2] = -a[3][2]; >+ return result; >+} >+float4x3 operator*(float4x3 a, float4x3 b) { >+ float4x3 result; >+ result[0][0] = a[0][0] * b[0][0]; >+ result[0][1] = a[0][1] * b[0][1]; >+ result[0][2] = a[0][2] * b[0][2]; >+ result[1][0] = a[1][0] * b[1][0]; >+ result[1][1] = a[1][1] * b[1][1]; >+ result[1][2] = a[1][2] * b[1][2]; >+ result[2][0] = a[2][0] * b[2][0]; >+ result[2][1] = a[2][1] * b[2][1]; >+ result[2][2] = a[2][2] * b[2][2]; >+ result[3][0] = a[3][0] * b[3][0]; >+ result[3][1] = a[3][1] * b[3][1]; >+ result[3][2] = a[3][2] * b[3][2]; >+ return result; >+} >+float4x3 operator*(float4x3 a, float b) { >+ float4x3 result; >+ result[0][0] = a[0][0] * b; >+ result[0][1] = a[0][1] * b; >+ result[0][2] = a[0][2] * b; >+ result[1][0] = a[1][0] * b; >+ result[1][1] = a[1][1] * b; >+ result[1][2] = a[1][2] * b; >+ result[2][0] = a[2][0] * b; >+ result[2][1] = a[2][1] * b; >+ result[2][2] = a[2][2] * b; >+ result[3][0] = a[3][0] * b; >+ result[3][1] = a[3][1] * b; >+ result[3][2] = a[3][2] * b; >+ return result; >+} >+float4x3 operator*(float a, float4x3 b) { >+ float4x3 result; >+ result[0][0] = a * b[0][0]; >+ result[0][1] = a * b[0][1]; >+ result[0][2] = a * b[0][2]; >+ result[1][0] = a * b[1][0]; >+ result[1][1] = a * b[1][1]; >+ result[1][2] = a * b[1][2]; >+ result[2][0] = a * b[2][0]; >+ result[2][1] = a * b[2][1]; >+ result[2][2] = a * b[2][2]; >+ result[3][0] = a * b[3][0]; >+ result[3][1] = a * b[3][1]; >+ result[3][2] = a * b[3][2]; >+ return result; >+} >+float4x3 operator/(float4x3 a, float4x3 b) { >+ float4x3 result; >+ result[0][0] = a[0][0] / b[0][0]; >+ result[0][1] = a[0][1] / b[0][1]; >+ result[0][2] = a[0][2] / b[0][2]; >+ result[1][0] = a[1][0] / b[1][0]; >+ result[1][1] = a[1][1] / b[1][1]; >+ result[1][2] = a[1][2] / b[1][2]; >+ result[2][0] = a[2][0] / b[2][0]; >+ result[2][1] = a[2][1] / b[2][1]; >+ result[2][2] = a[2][2] / b[2][2]; >+ result[3][0] = a[3][0] / b[3][0]; >+ result[3][1] = a[3][1] / b[3][1]; >+ result[3][2] = a[3][2] / b[3][2]; >+ return result; >+} >+float4x3 operator/(float4x3 a, float b) { >+ float4x3 result; >+ result[0][0] = a[0][0] / b; >+ result[0][1] = a[0][1] / b; >+ result[0][2] = a[0][2] / b; >+ result[1][0] = a[1][0] / b; >+ result[1][1] = a[1][1] / b; >+ result[1][2] = a[1][2] / b; >+ result[2][0] = a[2][0] / b; >+ result[2][1] = a[2][1] / b; >+ result[2][2] = a[2][2] / b; >+ result[3][0] = a[3][0] / b; >+ result[3][1] = a[3][1] / b; >+ result[3][2] = a[3][2] / b; >+ return result; >+} >+float4x3 operator/(float a, float4x3 b) { >+ float4x3 result; >+ result[0][0] = a / b[0][0]; >+ result[0][1] = a / b[0][1]; >+ result[0][2] = a / b[0][2]; >+ result[1][0] = a / b[1][0]; >+ result[1][1] = a / b[1][1]; >+ result[1][2] = a / b[1][2]; >+ result[2][0] = a / b[2][0]; >+ result[2][1] = a / b[2][1]; >+ result[2][2] = a / b[2][2]; >+ result[3][0] = a / b[3][0]; >+ result[3][1] = a / b[3][1]; >+ result[3][2] = a / b[3][2]; >+ return result; >+} >+float4x4 operator+(float4x4 a, float4x4 b) { >+ float4x4 result; >+ result[0][0] = a[0][0] + b[0][0]; >+ result[0][1] = a[0][1] + b[0][1]; >+ result[0][2] = a[0][2] + b[0][2]; >+ result[0][3] = a[0][3] + b[0][3]; >+ result[1][0] = a[1][0] + b[1][0]; >+ result[1][1] = a[1][1] + b[1][1]; >+ result[1][2] = a[1][2] + b[1][2]; >+ result[1][3] = a[1][3] + b[1][3]; >+ result[2][0] = a[2][0] + b[2][0]; >+ result[2][1] = a[2][1] + b[2][1]; >+ result[2][2] = a[2][2] + b[2][2]; >+ result[2][3] = a[2][3] + b[2][3]; >+ result[3][0] = a[3][0] + b[3][0]; >+ result[3][1] = a[3][1] + b[3][1]; >+ result[3][2] = a[3][2] + b[3][2]; >+ result[3][3] = a[3][3] + b[3][3]; >+ return result; >+} >+float4x4 operator-(float4x4 a, float4x4 b) { >+ float4x4 result; >+ result[0][0] = a[0][0] - b[0][0]; >+ result[0][1] = a[0][1] - b[0][1]; >+ result[0][2] = a[0][2] - b[0][2]; >+ result[0][3] = a[0][3] - b[0][3]; >+ result[1][0] = a[1][0] - b[1][0]; >+ result[1][1] = a[1][1] - b[1][1]; >+ result[1][2] = a[1][2] - b[1][2]; >+ result[1][3] = a[1][3] - b[1][3]; >+ result[2][0] = a[2][0] - b[2][0]; >+ result[2][1] = a[2][1] - b[2][1]; >+ result[2][2] = a[2][2] - b[2][2]; >+ result[2][3] = a[2][3] - b[2][3]; >+ result[3][0] = a[3][0] - b[3][0]; >+ result[3][1] = a[3][1] - b[3][1]; >+ result[3][2] = a[3][2] - b[3][2]; >+ result[3][3] = a[3][3] - b[3][3]; >+ return result; >+} >+float4x4 operator-(float4x4 a) { >+ float4x4 result; >+ result[0][0] = -a[0][0]; >+ result[0][1] = -a[0][1]; >+ result[0][2] = -a[0][2]; >+ result[0][3] = -a[0][3]; >+ result[1][0] = -a[1][0]; >+ result[1][1] = -a[1][1]; >+ result[1][2] = -a[1][2]; >+ result[1][3] = -a[1][3]; >+ result[2][0] = -a[2][0]; >+ result[2][1] = -a[2][1]; >+ result[2][2] = -a[2][2]; >+ result[2][3] = -a[2][3]; >+ result[3][0] = -a[3][0]; >+ result[3][1] = -a[3][1]; >+ result[3][2] = -a[3][2]; >+ result[3][3] = -a[3][3]; >+ return result; >+} >+float4x4 operator*(float4x4 a, float4x4 b) { >+ float4x4 result; >+ result[0][0] = a[0][0] * b[0][0]; >+ result[0][1] = a[0][1] * b[0][1]; >+ result[0][2] = a[0][2] * b[0][2]; >+ result[0][3] = a[0][3] * b[0][3]; >+ result[1][0] = a[1][0] * b[1][0]; >+ result[1][1] = a[1][1] * b[1][1]; >+ result[1][2] = a[1][2] * b[1][2]; >+ result[1][3] = a[1][3] * b[1][3]; >+ result[2][0] = a[2][0] * b[2][0]; >+ result[2][1] = a[2][1] * b[2][1]; >+ result[2][2] = a[2][2] * b[2][2]; >+ result[2][3] = a[2][3] * b[2][3]; >+ result[3][0] = a[3][0] * b[3][0]; >+ result[3][1] = a[3][1] * b[3][1]; >+ result[3][2] = a[3][2] * b[3][2]; >+ result[3][3] = a[3][3] * b[3][3]; >+ return result; >+} >+float4x4 operator*(float4x4 a, float b) { >+ float4x4 result; >+ result[0][0] = a[0][0] * b; >+ result[0][1] = a[0][1] * b; >+ result[0][2] = a[0][2] * b; >+ result[0][3] = a[0][3] * b; >+ result[1][0] = a[1][0] * b; >+ result[1][1] = a[1][1] * b; >+ result[1][2] = a[1][2] * b; >+ result[1][3] = a[1][3] * b; >+ result[2][0] = a[2][0] * b; >+ result[2][1] = a[2][1] * b; >+ result[2][2] = a[2][2] * b; >+ result[2][3] = a[2][3] * b; >+ result[3][0] = a[3][0] * b; >+ result[3][1] = a[3][1] * b; >+ result[3][2] = a[3][2] * b; >+ result[3][3] = a[3][3] * b; >+ return result; >+} >+float4x4 operator*(float a, float4x4 b) { >+ float4x4 result; >+ result[0][0] = a * b[0][0]; >+ result[0][1] = a * b[0][1]; >+ result[0][2] = a * b[0][2]; >+ result[0][3] = a * b[0][3]; >+ result[1][0] = a * b[1][0]; >+ result[1][1] = a * b[1][1]; >+ result[1][2] = a * b[1][2]; >+ result[1][3] = a * b[1][3]; >+ result[2][0] = a * b[2][0]; >+ result[2][1] = a * b[2][1]; >+ result[2][2] = a * b[2][2]; >+ result[2][3] = a * b[2][3]; >+ result[3][0] = a * b[3][0]; >+ result[3][1] = a * b[3][1]; >+ result[3][2] = a * b[3][2]; >+ result[3][3] = a * b[3][3]; >+ return result; >+} >+float4x4 operator/(float4x4 a, float4x4 b) { >+ float4x4 result; >+ result[0][0] = a[0][0] / b[0][0]; >+ result[0][1] = a[0][1] / b[0][1]; >+ result[0][2] = a[0][2] / b[0][2]; >+ result[0][3] = a[0][3] / b[0][3]; >+ result[1][0] = a[1][0] / b[1][0]; >+ result[1][1] = a[1][1] / b[1][1]; >+ result[1][2] = a[1][2] / b[1][2]; >+ result[1][3] = a[1][3] / b[1][3]; >+ result[2][0] = a[2][0] / b[2][0]; >+ result[2][1] = a[2][1] / b[2][1]; >+ result[2][2] = a[2][2] / b[2][2]; >+ result[2][3] = a[2][3] / b[2][3]; >+ result[3][0] = a[3][0] / b[3][0]; >+ result[3][1] = a[3][1] / b[3][1]; >+ result[3][2] = a[3][2] / b[3][2]; >+ result[3][3] = a[3][3] / b[3][3]; >+ return result; >+} >+float4x4 operator/(float4x4 a, float b) { >+ float4x4 result; >+ result[0][0] = a[0][0] / b; >+ result[0][1] = a[0][1] / b; >+ result[0][2] = a[0][2] / b; >+ result[0][3] = a[0][3] / b; >+ result[1][0] = a[1][0] / b; >+ result[1][1] = a[1][1] / b; >+ result[1][2] = a[1][2] / b; >+ result[1][3] = a[1][3] / b; >+ result[2][0] = a[2][0] / b; >+ result[2][1] = a[2][1] / b; >+ result[2][2] = a[2][2] / b; >+ result[2][3] = a[2][3] / b; >+ result[3][0] = a[3][0] / b; >+ result[3][1] = a[3][1] / b; >+ result[3][2] = a[3][2] / b; >+ result[3][3] = a[3][3] / b; >+ return result; >+} >+float4x4 operator/(float a, float4x4 b) { >+ float4x4 result; >+ result[0][0] = a / b[0][0]; >+ result[0][1] = a / b[0][1]; >+ result[0][2] = a / b[0][2]; >+ result[0][3] = a / b[0][3]; >+ result[1][0] = a / b[1][0]; >+ result[1][1] = a / b[1][1]; >+ result[1][2] = a / b[1][2]; >+ result[1][3] = a / b[1][3]; >+ result[2][0] = a / b[2][0]; >+ result[2][1] = a / b[2][1]; >+ result[2][2] = a / b[2][2]; >+ result[2][3] = a / b[2][3]; >+ result[3][0] = a / b[3][0]; >+ result[3][1] = a / b[3][1]; >+ result[3][2] = a / b[3][2]; >+ result[3][3] = a / b[3][3]; >+ return result; >+} >+operator bool2(bool x, bool y) { >+ bool2 result; >+ result.x = x; >+ result.y = y; >+ return result; >+} >+operator bool3(bool x, bool y, bool z) { >+ bool3 result; >+ result.x = x; >+ result.y = y; >+ result.z = z; >+ return result; >+} >+operator bool3(bool2 x, bool y) { >+ bool3 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = y; >+ return result; >+} >+operator bool3(bool x, bool2 y) { >+ bool3 result; >+ result.x = x; >+ result.y = y.x; >+ result.z = y.y; >+ return result; >+} >+operator bool4(bool x, bool y, bool z, bool w) { >+ bool4 result; >+ result.x = x; >+ result.y = y; >+ result.z = z; >+ result.w = w; >+ return result; >+} >+operator bool4(bool2 x, bool y, bool z) { >+ bool4 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = y; >+ result.w = z; >+ return result; >+} >+operator bool4(bool x, bool2 y, bool z) { >+ bool4 result; >+ result.x = x; >+ result.y = y.x; >+ result.z = y.y; >+ result.w = z; >+ return result; >+} >+operator bool4(bool x, bool y, bool2 z) { >+ bool4 result; >+ result.x = x; >+ result.y = y; >+ result.z = z.x; >+ result.w = z.y; >+ return result; >+} >+operator bool4(bool2 x, bool2 y) { >+ bool4 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = y.x; >+ result.w = y.y; >+ return result; >+} >+operator bool4(bool3 x, bool y) { >+ bool4 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = x.z; >+ result.w = y; >+ return result; >+} >+operator bool4(bool x, bool3 y) { >+ bool4 result; >+ result.x = x; >+ result.y = y.x; >+ result.z = y.y; >+ result.w = y.z; >+ return result; >+} >+uint operator.length(bool2) { >+ return 2; >+} >+uint operator.length(bool3) { >+ return 3; >+} >+uint operator.length(bool4) { >+ return 4; >+} >+operator uchar2(uchar x, uchar y) { >+ uchar2 result; >+ result.x = x; >+ result.y = y; >+ return result; >+} >+operator uchar3(uchar x, uchar y, uchar z) { >+ uchar3 result; >+ result.x = x; >+ result.y = y; >+ result.z = z; >+ return result; >+} >+operator uchar3(uchar2 x, uchar y) { >+ uchar3 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = y; >+ return result; >+} >+operator uchar3(uchar x, uchar2 y) { >+ uchar3 result; >+ result.x = x; >+ result.y = y.x; >+ result.z = y.y; >+ return result; >+} >+operator uchar4(uchar x, uchar y, uchar z, uchar w) { >+ uchar4 result; >+ result.x = x; >+ result.y = y; >+ result.z = z; >+ result.w = w; >+ return result; >+} >+operator uchar4(uchar2 x, uchar y, uchar z) { >+ uchar4 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = y; >+ result.w = z; >+ return result; >+} >+operator uchar4(uchar x, uchar2 y, uchar z) { >+ uchar4 result; >+ result.x = x; >+ result.y = y.x; >+ result.z = y.y; >+ result.w = z; >+ return result; >+} >+operator uchar4(uchar x, uchar y, uchar2 z) { >+ uchar4 result; >+ result.x = x; >+ result.y = y; >+ result.z = z.x; >+ result.w = z.y; >+ return result; >+} >+operator uchar4(uchar2 x, uchar2 y) { >+ uchar4 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = y.x; >+ result.w = y.y; >+ return result; >+} >+operator uchar4(uchar3 x, uchar y) { >+ uchar4 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = x.z; >+ result.w = y; >+ return result; >+} >+operator uchar4(uchar x, uchar3 y) { >+ uchar4 result; >+ result.x = x; >+ result.y = y.x; >+ result.z = y.y; >+ result.w = y.z; >+ return result; >+} >+uint operator.length(uchar2) { >+ return 2; >+} >+uint operator.length(uchar3) { >+ return 3; >+} >+uint operator.length(uchar4) { >+ return 4; >+} >+operator ushort2(ushort x, ushort y) { >+ ushort2 result; >+ result.x = x; >+ result.y = y; >+ return result; >+} >+operator ushort3(ushort x, ushort y, ushort z) { >+ ushort3 result; >+ result.x = x; >+ result.y = y; >+ result.z = z; >+ return result; >+} >+operator ushort3(ushort2 x, ushort y) { >+ ushort3 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = y; >+ return result; >+} >+operator ushort3(ushort x, ushort2 y) { >+ ushort3 result; >+ result.x = x; >+ result.y = y.x; >+ result.z = y.y; >+ return result; >+} >+operator ushort4(ushort x, ushort y, ushort z, ushort w) { >+ ushort4 result; >+ result.x = x; >+ result.y = y; >+ result.z = z; >+ result.w = w; >+ return result; >+} >+operator ushort4(ushort2 x, ushort y, ushort z) { >+ ushort4 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = y; >+ result.w = z; >+ return result; >+} >+operator ushort4(ushort x, ushort2 y, ushort z) { >+ ushort4 result; >+ result.x = x; >+ result.y = y.x; >+ result.z = y.y; >+ result.w = z; >+ return result; >+} >+operator ushort4(ushort x, ushort y, ushort2 z) { >+ ushort4 result; >+ result.x = x; >+ result.y = y; >+ result.z = z.x; >+ result.w = z.y; >+ return result; >+} >+operator ushort4(ushort2 x, ushort2 y) { >+ ushort4 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = y.x; >+ result.w = y.y; >+ return result; >+} >+operator ushort4(ushort3 x, ushort y) { >+ ushort4 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = x.z; >+ result.w = y; >+ return result; >+} >+operator ushort4(ushort x, ushort3 y) { >+ ushort4 result; >+ result.x = x; >+ result.y = y.x; >+ result.z = y.y; >+ result.w = y.z; >+ return result; >+} >+uint operator.length(ushort2) { >+ return 2; >+} >+uint operator.length(ushort3) { >+ return 3; >+} >+uint operator.length(ushort4) { >+ return 4; >+} >+operator uint2(uint x, uint y) { >+ uint2 result; >+ result.x = x; >+ result.y = y; >+ return result; >+} >+operator uint3(uint x, uint y, uint z) { >+ uint3 result; >+ result.x = x; >+ result.y = y; >+ result.z = z; >+ return result; >+} >+operator uint3(uint2 x, uint y) { >+ uint3 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = y; >+ return result; >+} >+operator uint3(uint x, uint2 y) { >+ uint3 result; >+ result.x = x; >+ result.y = y.x; >+ result.z = y.y; >+ return result; >+} >+operator uint4(uint x, uint y, uint z, uint w) { >+ uint4 result; >+ result.x = x; >+ result.y = y; >+ result.z = z; >+ result.w = w; >+ return result; >+} >+operator uint4(uint2 x, uint y, uint z) { >+ uint4 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = y; >+ result.w = z; >+ return result; >+} >+operator uint4(uint x, uint2 y, uint z) { >+ uint4 result; >+ result.x = x; >+ result.y = y.x; >+ result.z = y.y; >+ result.w = z; >+ return result; >+} >+operator uint4(uint x, uint y, uint2 z) { >+ uint4 result; >+ result.x = x; >+ result.y = y; >+ result.z = z.x; >+ result.w = z.y; >+ return result; >+} >+operator uint4(uint2 x, uint2 y) { >+ uint4 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = y.x; >+ result.w = y.y; >+ return result; >+} >+operator uint4(uint3 x, uint y) { >+ uint4 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = x.z; >+ result.w = y; >+ return result; >+} >+operator uint4(uint x, uint3 y) { >+ uint4 result; >+ result.x = x; >+ result.y = y.x; >+ result.z = y.y; >+ result.w = y.z; >+ return result; >+} >+uint operator.length(uint2) { >+ return 2; >+} >+uint operator.length(uint3) { >+ return 3; >+} >+uint operator.length(uint4) { >+ return 4; >+} >+operator char2(char x, char y) { >+ char2 result; >+ result.x = x; >+ result.y = y; >+ return result; >+} >+operator char3(char x, char y, char z) { >+ char3 result; >+ result.x = x; >+ result.y = y; >+ result.z = z; >+ return result; >+} >+operator char3(char2 x, char y) { >+ char3 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = y; >+ return result; >+} >+operator char3(char x, char2 y) { >+ char3 result; >+ result.x = x; >+ result.y = y.x; >+ result.z = y.y; >+ return result; >+} >+operator char4(char x, char y, char z, char w) { >+ char4 result; >+ result.x = x; >+ result.y = y; >+ result.z = z; >+ result.w = w; >+ return result; >+} >+operator char4(char2 x, char y, char z) { >+ char4 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = y; >+ result.w = z; >+ return result; >+} >+operator char4(char x, char2 y, char z) { >+ char4 result; >+ result.x = x; >+ result.y = y.x; >+ result.z = y.y; >+ result.w = z; >+ return result; >+} >+operator char4(char x, char y, char2 z) { >+ char4 result; >+ result.x = x; >+ result.y = y; >+ result.z = z.x; >+ result.w = z.y; >+ return result; >+} >+operator char4(char2 x, char2 y) { >+ char4 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = y.x; >+ result.w = y.y; >+ return result; >+} >+operator char4(char3 x, char y) { >+ char4 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = x.z; >+ result.w = y; >+ return result; >+} >+operator char4(char x, char3 y) { >+ char4 result; >+ result.x = x; >+ result.y = y.x; >+ result.z = y.y; >+ result.w = y.z; >+ return result; >+} >+uint operator.length(char2) { >+ return 2; >+} >+uint operator.length(char3) { >+ return 3; >+} >+uint operator.length(char4) { >+ return 4; >+} >+operator short2(short x, short y) { >+ short2 result; >+ result.x = x; >+ result.y = y; >+ return result; >+} >+operator short3(short x, short y, short z) { >+ short3 result; >+ result.x = x; >+ result.y = y; >+ result.z = z; >+ return result; >+} >+operator short3(short2 x, short y) { >+ short3 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = y; >+ return result; >+} >+operator short3(short x, short2 y) { >+ short3 result; >+ result.x = x; >+ result.y = y.x; >+ result.z = y.y; >+ return result; >+} >+operator short4(short x, short y, short z, short w) { >+ short4 result; >+ result.x = x; >+ result.y = y; >+ result.z = z; >+ result.w = w; >+ return result; >+} >+operator short4(short2 x, short y, short z) { >+ short4 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = y; >+ result.w = z; >+ return result; >+} >+operator short4(short x, short2 y, short z) { >+ short4 result; >+ result.x = x; >+ result.y = y.x; >+ result.z = y.y; >+ result.w = z; >+ return result; >+} >+operator short4(short x, short y, short2 z) { >+ short4 result; >+ result.x = x; >+ result.y = y; >+ result.z = z.x; >+ result.w = z.y; >+ return result; >+} >+operator short4(short2 x, short2 y) { >+ short4 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = y.x; >+ result.w = y.y; >+ return result; >+} >+operator short4(short3 x, short y) { >+ short4 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = x.z; >+ result.w = y; >+ return result; >+} >+operator short4(short x, short3 y) { >+ short4 result; >+ result.x = x; >+ result.y = y.x; >+ result.z = y.y; >+ result.w = y.z; >+ return result; >+} >+uint operator.length(short2) { >+ return 2; >+} >+uint operator.length(short3) { >+ return 3; >+} >+uint operator.length(short4) { >+ return 4; >+} >+operator int2(int x, int y) { >+ int2 result; >+ result.x = x; >+ result.y = y; >+ return result; >+} >+operator int3(int x, int y, int z) { >+ int3 result; >+ result.x = x; >+ result.y = y; >+ result.z = z; >+ return result; >+} >+operator int3(int2 x, int y) { >+ int3 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = y; >+ return result; >+} >+operator int3(int x, int2 y) { >+ int3 result; >+ result.x = x; >+ result.y = y.x; >+ result.z = y.y; >+ return result; >+} >+operator int4(int x, int y, int z, int w) { >+ int4 result; >+ result.x = x; >+ result.y = y; >+ result.z = z; >+ result.w = w; >+ return result; >+} >+operator int4(int2 x, int y, int z) { >+ int4 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = y; >+ result.w = z; >+ return result; >+} >+operator int4(int x, int2 y, int z) { >+ int4 result; >+ result.x = x; >+ result.y = y.x; >+ result.z = y.y; >+ result.w = z; >+ return result; >+} >+operator int4(int x, int y, int2 z) { >+ int4 result; >+ result.x = x; >+ result.y = y; >+ result.z = z.x; >+ result.w = z.y; >+ return result; >+} >+operator int4(int2 x, int2 y) { >+ int4 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = y.x; >+ result.w = y.y; >+ return result; >+} >+operator int4(int3 x, int y) { >+ int4 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = x.z; >+ result.w = y; >+ return result; >+} >+operator int4(int x, int3 y) { >+ int4 result; >+ result.x = x; >+ result.y = y.x; >+ result.z = y.y; >+ result.w = y.z; >+ return result; >+} >+uint operator.length(int2) { >+ return 2; >+} >+uint operator.length(int3) { >+ return 3; >+} >+uint operator.length(int4) { >+ return 4; >+} >+operator half2(half x, half y) { >+ half2 result; >+ result.x = x; >+ result.y = y; >+ return result; >+} >+operator half3(half x, half y, half z) { >+ half3 result; >+ result.x = x; >+ result.y = y; >+ result.z = z; >+ return result; >+} >+operator half3(half2 x, half y) { >+ half3 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = y; >+ return result; >+} >+operator half3(half x, half2 y) { >+ half3 result; >+ result.x = x; >+ result.y = y.x; >+ result.z = y.y; >+ return result; >+} >+operator half4(half x, half y, half z, half w) { >+ half4 result; >+ result.x = x; >+ result.y = y; >+ result.z = z; >+ result.w = w; >+ return result; >+} >+operator half4(half2 x, half y, half z) { >+ half4 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = y; >+ result.w = z; >+ return result; >+} >+operator half4(half x, half2 y, half z) { >+ half4 result; >+ result.x = x; >+ result.y = y.x; >+ result.z = y.y; >+ result.w = z; >+ return result; >+} >+operator half4(half x, half y, half2 z) { >+ half4 result; >+ result.x = x; >+ result.y = y; >+ result.z = z.x; >+ result.w = z.y; >+ return result; >+} >+operator half4(half2 x, half2 y) { >+ half4 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = y.x; >+ result.w = y.y; >+ return result; >+} >+operator half4(half3 x, half y) { >+ half4 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = x.z; >+ result.w = y; >+ return result; >+} >+operator half4(half x, half3 y) { >+ half4 result; >+ result.x = x; >+ result.y = y.x; >+ result.z = y.y; >+ result.w = y.z; >+ return result; >+} >+uint operator.length(half2) { >+ return 2; >+} >+uint operator.length(half3) { >+ return 3; >+} >+uint operator.length(half4) { >+ return 4; >+} >+operator float2(float x, float y) { >+ float2 result; >+ result.x = x; >+ result.y = y; >+ return result; >+} >+operator float3(float x, float y, float z) { >+ float3 result; >+ result.x = x; >+ result.y = y; >+ result.z = z; >+ return result; >+} >+operator float3(float2 x, float y) { >+ float3 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = y; >+ return result; >+} >+operator float3(float x, float2 y) { >+ float3 result; >+ result.x = x; >+ result.y = y.x; >+ result.z = y.y; >+ return result; >+} >+operator float4(float x, float y, float z, float w) { >+ float4 result; >+ result.x = x; >+ result.y = y; >+ result.z = z; >+ result.w = w; >+ return result; >+} >+operator float4(float2 x, float y, float z) { >+ float4 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = y; >+ result.w = z; >+ return result; >+} >+operator float4(float x, float2 y, float z) { >+ float4 result; >+ result.x = x; >+ result.y = y.x; >+ result.z = y.y; >+ result.w = z; >+ return result; >+} >+operator float4(float x, float y, float2 z) { >+ float4 result; >+ result.x = x; >+ result.y = y; >+ result.z = z.x; >+ result.w = z.y; >+ return result; >+} >+operator float4(float2 x, float2 y) { >+ float4 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = y.x; >+ result.w = y.y; >+ return result; >+} >+operator float4(float3 x, float y) { >+ float4 result; >+ result.x = x.x; >+ result.y = x.y; >+ result.z = x.z; >+ result.w = y; >+ return result; >+} >+operator float4(float x, float3 y) { >+ float4 result; >+ result.x = x; >+ result.y = y.x; >+ result.z = y.y; >+ result.w = y.z; >+ return result; >+} >+uint operator.length(float2) { >+ return 2; >+} >+uint operator.length(float3) { >+ return 3; >+} >+uint operator.length(float4) { >+ return 4; >+} >+ >+operator half2x2(half2 a, half2 b) { >+ half2x2 result; >+ result[0] = a; >+ result[1] = b; >+ return result; >+} >+operator half2x3(half3 a, half3 b) { >+ half2x3 result; >+ result[0] = a; >+ result[1] = b; >+ return result; >+} >+operator half2x4(half4 a, half4 b) { >+ half2x4 result; >+ result[0] = a; >+ result[1] = b; >+ return result; >+} >+operator half3x2(half2 a, half2 b, half2 c) { >+ half3x2 result; >+ result[0] = a; >+ result[1] = b; >+ result[2] = c; >+ return result; >+} >+operator half3x3(half3 a, half3 b, half3 c) { >+ half3x3 result; >+ result[0] = a; >+ result[1] = b; >+ result[2] = c; >+ return result; >+} >+operator half3x4(half4 a, half4 b, half4 c) { >+ half3x4 result; >+ result[0] = a; >+ result[1] = b; >+ result[2] = c; >+ return result; >+} >+operator half4x2(half2 a, half2 b, half2 c, half2 d) { >+ half4x2 result; >+ result[0] = a; >+ result[1] = b; >+ result[2] = c; >+ result[3] = d; >+ return result; >+} >+operator half4x3(half3 a, half3 b, half3 c, half3 d) { >+ half4x3 result; >+ result[0] = a; >+ result[1] = b; >+ result[2] = c; >+ result[3] = d; >+ return result; >+} >+operator half4x4(half4 a, half4 b, half4 c, half4 d) { >+ half4x4 result; >+ result[0] = a; >+ result[1] = b; >+ result[2] = c; >+ result[3] = d; >+ return result; >+} >+operator float2x2(float2 a, float2 b) { >+ float2x2 result; >+ result[0] = a; >+ result[1] = b; >+ return result; >+} >+operator float2x3(float3 a, float3 b) { >+ float2x3 result; >+ result[0] = a; >+ result[1] = b; >+ return result; >+} >+operator float2x4(float4 a, float4 b) { >+ float2x4 result; >+ result[0] = a; >+ result[1] = b; >+ return result; >+} >+operator float3x2(float2 a, float2 b, float2 c) { >+ float3x2 result; >+ result[0] = a; >+ result[1] = b; >+ result[2] = c; >+ return result; >+} >+operator float3x3(float3 a, float3 b, float3 c) { >+ float3x3 result; >+ result[0] = a; >+ result[1] = b; >+ result[2] = c; >+ return result; >+} >+operator float3x4(float4 a, float4 b, float4 c) { >+ float3x4 result; >+ result[0] = a; >+ result[1] = b; >+ result[2] = c; >+ return result; >+} >+operator float4x2(float2 a, float2 b, float2 c, float2 d) { >+ float4x2 result; >+ result[0] = a; >+ result[1] = b; >+ result[2] = c; >+ result[3] = d; >+ return result; >+} >+operator float4x3(float3 a, float3 b, float3 c, float3 d) { >+ float4x3 result; >+ result[0] = a; >+ result[1] = b; >+ result[2] = c; >+ result[3] = d; >+ return result; >+} >+operator float4x4(float4 a, float4 b, float4 c, float4 d) { >+ float4x4 result; >+ result[0] = a; >+ result[1] = b; >+ result[2] = c; >+ result[3] = d; >+ return result; >+} >+ >+bool operator==(bool2 a, bool2 b) { >+ return a.x == b.x && a.y == b.y; >+} >+bool operator==(bool3 a, bool3 b) { >+ return a.x == b.x && a.y == b.y && a.z == b.z; >+} >+bool operator==(bool4 a, bool4 b) { >+ return a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w; >+} >+native bool operator.x(bool2); >+native bool operator.y(bool2); >+native bool operator.x(bool3); >+native bool operator.y(bool3); >+native bool operator.z(bool3); >+native bool operator.x(bool4); >+native bool operator.y(bool4); >+native bool operator.z(bool4); >+native bool operator.w(bool4); >+native bool2 operator.x=(bool2, bool); >+native bool2 operator.y=(bool2, bool); >+native bool3 operator.x=(bool3, bool); >+native bool3 operator.y=(bool3, bool); >+native bool3 operator.z=(bool3, bool); >+native bool4 operator.x=(bool4, bool); >+native bool4 operator.y=(bool4, bool); >+native bool4 operator.z=(bool4, bool); >+native bool4 operator.w=(bool4, bool); >+bool operator[](bool2 v, uint index) { >+ switch (index) { >+ case 0: >+ return v.x; >+ case 1: >+ return v.y; >+ default: >+ trap; >+ } >+} >+bool operator[](bool3 v, uint index) { >+ switch (index) { >+ case 0: >+ return v.x; >+ case 1: >+ return v.y; >+ case 2: >+ return v.z; >+ default: >+ trap; >+ } >+} >+bool operator[](bool4 v, uint index) { >+ switch (index) { >+ case 0: >+ return v.x; >+ case 1: >+ return v.y; >+ case 2: >+ return v.z; >+ case 3: >+ return v.w; >+ default: >+ trap; >+ } >+} >+bool2 operator[]=(bool2 v, uint index, bool a) { >+ switch (index) { >+ case 0: >+ v.x = a; >+ break; >+ case 1: >+ v.y = a; >+ break; >+ default: >+ trap; >+ } >+ return v; >+} >+bool3 operator[]=(bool3 v, uint index, bool a) { >+ switch (index) { >+ case 0: >+ v.x = a; >+ break; >+ case 1: >+ v.y = a; >+ break; >+ case 2: >+ v.z = a; >+ break; >+ default: >+ trap; >+ } >+ return v; >+} >+bool4 operator[]=(bool4 v, uint index, bool a) { >+ switch (index) { >+ case 0: >+ v.x = a; >+ break; >+ case 1: >+ v.y = a; >+ break; >+ case 2: >+ v.z = a; >+ break; >+ case 3: >+ v.w = a; >+ break; >+ default: >+ trap; >+ } >+ return v; >+} >+bool operator==(uchar2 a, uchar2 b) { >+ return a.x == b.x && a.y == b.y; >+} >+bool operator==(uchar3 a, uchar3 b) { >+ return a.x == b.x && a.y == b.y && a.z == b.z; >+} >+bool operator==(uchar4 a, uchar4 b) { >+ return a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w; >+} >+native uchar operator.x(uchar2); >+native uchar operator.y(uchar2); >+native uchar operator.x(uchar3); >+native uchar operator.y(uchar3); >+native uchar operator.z(uchar3); >+native uchar operator.x(uchar4); >+native uchar operator.y(uchar4); >+native uchar operator.z(uchar4); >+native uchar operator.w(uchar4); >+native uchar2 operator.x=(uchar2, uchar); >+native uchar2 operator.y=(uchar2, uchar); >+native uchar3 operator.x=(uchar3, uchar); >+native uchar3 operator.y=(uchar3, uchar); >+native uchar3 operator.z=(uchar3, uchar); >+native uchar4 operator.x=(uchar4, uchar); >+native uchar4 operator.y=(uchar4, uchar); >+native uchar4 operator.z=(uchar4, uchar); >+native uchar4 operator.w=(uchar4, uchar); >+uchar operator[](uchar2 v, uint index) { >+ switch (index) { >+ case 0: >+ return v.x; >+ case 1: >+ return v.y; >+ default: >+ trap; >+ } >+} >+uchar operator[](uchar3 v, uint index) { >+ switch (index) { >+ case 0: >+ return v.x; >+ case 1: >+ return v.y; >+ case 2: >+ return v.z; >+ default: >+ trap; >+ } >+} >+uchar operator[](uchar4 v, uint index) { >+ switch (index) { >+ case 0: >+ return v.x; >+ case 1: >+ return v.y; >+ case 2: >+ return v.z; >+ case 3: >+ return v.w; >+ default: >+ trap; >+ } >+} >+uchar2 operator[]=(uchar2 v, uint index, uchar a) { >+ switch (index) { >+ case 0: >+ v.x = a; >+ break; >+ case 1: >+ v.y = a; >+ break; >+ default: >+ trap; >+ } >+ return v; >+} >+uchar3 operator[]=(uchar3 v, uint index, uchar a) { >+ switch (index) { >+ case 0: >+ v.x = a; >+ break; >+ case 1: >+ v.y = a; >+ break; >+ case 2: >+ v.z = a; >+ break; >+ default: >+ trap; >+ } >+ return v; >+} >+uchar4 operator[]=(uchar4 v, uint index, uchar a) { >+ switch (index) { >+ case 0: >+ v.x = a; >+ break; >+ case 1: >+ v.y = a; >+ break; >+ case 2: >+ v.z = a; >+ break; >+ case 3: >+ v.w = a; >+ break; >+ default: >+ trap; >+ } >+ return v; >+} >+bool operator==(ushort2 a, ushort2 b) { >+ return a.x == b.x && a.y == b.y; >+} >+bool operator==(ushort3 a, ushort3 b) { >+ return a.x == b.x && a.y == b.y && a.z == b.z; >+} >+bool operator==(ushort4 a, ushort4 b) { >+ return a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w; >+} >+native ushort operator.x(ushort2); >+native ushort operator.y(ushort2); >+native ushort operator.x(ushort3); >+native ushort operator.y(ushort3); >+native ushort operator.z(ushort3); >+native ushort operator.x(ushort4); >+native ushort operator.y(ushort4); >+native ushort operator.z(ushort4); >+native ushort operator.w(ushort4); >+native ushort2 operator.x=(ushort2, ushort); >+native ushort2 operator.y=(ushort2, ushort); >+native ushort3 operator.x=(ushort3, ushort); >+native ushort3 operator.y=(ushort3, ushort); >+native ushort3 operator.z=(ushort3, ushort); >+native ushort4 operator.x=(ushort4, ushort); >+native ushort4 operator.y=(ushort4, ushort); >+native ushort4 operator.z=(ushort4, ushort); >+native ushort4 operator.w=(ushort4, ushort); >+ushort operator[](ushort2 v, uint index) { >+ switch (index) { >+ case 0: >+ return v.x; >+ case 1: >+ return v.y; >+ default: >+ trap; >+ } >+} >+ushort operator[](ushort3 v, uint index) { >+ switch (index) { >+ case 0: >+ return v.x; >+ case 1: >+ return v.y; >+ case 2: >+ return v.z; >+ default: >+ trap; >+ } >+} >+ushort operator[](ushort4 v, uint index) { >+ switch (index) { >+ case 0: >+ return v.x; >+ case 1: >+ return v.y; >+ case 2: >+ return v.z; >+ case 3: >+ return v.w; >+ default: >+ trap; >+ } >+} >+ushort2 operator[]=(ushort2 v, uint index, ushort a) { >+ switch (index) { >+ case 0: >+ v.x = a; >+ break; >+ case 1: >+ v.y = a; >+ break; >+ default: >+ trap; >+ } >+ return v; >+} >+ushort3 operator[]=(ushort3 v, uint index, ushort a) { >+ switch (index) { >+ case 0: >+ v.x = a; >+ break; >+ case 1: >+ v.y = a; >+ break; >+ case 2: >+ v.z = a; >+ break; >+ default: >+ trap; >+ } >+ return v; >+} >+ushort4 operator[]=(ushort4 v, uint index, ushort a) { >+ switch (index) { >+ case 0: >+ v.x = a; >+ break; >+ case 1: >+ v.y = a; >+ break; >+ case 2: >+ v.z = a; >+ break; >+ case 3: >+ v.w = a; >+ break; >+ default: >+ trap; >+ } >+ return v; >+} >+bool operator==(uint2 a, uint2 b) { >+ return a.x == b.x && a.y == b.y; >+} >+bool operator==(uint3 a, uint3 b) { >+ return a.x == b.x && a.y == b.y && a.z == b.z; >+} >+bool operator==(uint4 a, uint4 b) { >+ return a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w; >+} >+native uint operator.x(uint2); >+native uint operator.y(uint2); >+native uint operator.x(uint3); >+native uint operator.y(uint3); >+native uint operator.z(uint3); >+native uint operator.x(uint4); >+native uint operator.y(uint4); >+native uint operator.z(uint4); >+native uint operator.w(uint4); >+native uint2 operator.x=(uint2, uint); >+native uint2 operator.y=(uint2, uint); >+native uint3 operator.x=(uint3, uint); >+native uint3 operator.y=(uint3, uint); >+native uint3 operator.z=(uint3, uint); >+native uint4 operator.x=(uint4, uint); >+native uint4 operator.y=(uint4, uint); >+native uint4 operator.z=(uint4, uint); >+native uint4 operator.w=(uint4, uint); >+uint operator[](uint2 v, uint index) { >+ switch (index) { >+ case 0: >+ return v.x; >+ case 1: >+ return v.y; >+ default: >+ trap; >+ } >+} >+uint operator[](uint3 v, uint index) { >+ switch (index) { >+ case 0: >+ return v.x; >+ case 1: >+ return v.y; >+ case 2: >+ return v.z; >+ default: >+ trap; >+ } >+} >+uint operator[](uint4 v, uint index) { >+ switch (index) { >+ case 0: >+ return v.x; >+ case 1: >+ return v.y; >+ case 2: >+ return v.z; >+ case 3: >+ return v.w; >+ default: >+ trap; >+ } >+} >+uint2 operator[]=(uint2 v, uint index, uint a) { >+ switch (index) { >+ case 0: >+ v.x = a; >+ break; >+ case 1: >+ v.y = a; >+ break; >+ default: >+ trap; >+ } >+ return v; >+} >+uint3 operator[]=(uint3 v, uint index, uint a) { >+ switch (index) { >+ case 0: >+ v.x = a; >+ break; >+ case 1: >+ v.y = a; >+ break; >+ case 2: >+ v.z = a; >+ break; >+ default: >+ trap; >+ } >+ return v; >+} >+uint4 operator[]=(uint4 v, uint index, uint a) { >+ switch (index) { >+ case 0: >+ v.x = a; >+ break; >+ case 1: >+ v.y = a; >+ break; >+ case 2: >+ v.z = a; >+ break; >+ case 3: >+ v.w = a; >+ break; >+ default: >+ trap; >+ } >+ return v; >+} >+bool operator==(char2 a, char2 b) { >+ return a.x == b.x && a.y == b.y; >+} >+bool operator==(char3 a, char3 b) { >+ return a.x == b.x && a.y == b.y && a.z == b.z; >+} >+bool operator==(char4 a, char4 b) { >+ return a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w; >+} >+native char operator.x(char2); >+native char operator.y(char2); >+native char operator.x(char3); >+native char operator.y(char3); >+native char operator.z(char3); >+native char operator.x(char4); >+native char operator.y(char4); >+native char operator.z(char4); >+native char operator.w(char4); >+native char2 operator.x=(char2, char); >+native char2 operator.y=(char2, char); >+native char3 operator.x=(char3, char); >+native char3 operator.y=(char3, char); >+native char3 operator.z=(char3, char); >+native char4 operator.x=(char4, char); >+native char4 operator.y=(char4, char); >+native char4 operator.z=(char4, char); >+native char4 operator.w=(char4, char); >+char operator[](char2 v, uint index) { >+ switch (index) { >+ case 0: >+ return v.x; >+ case 1: >+ return v.y; >+ default: >+ trap; >+ } >+} >+char operator[](char3 v, uint index) { >+ switch (index) { >+ case 0: >+ return v.x; >+ case 1: >+ return v.y; >+ case 2: >+ return v.z; >+ default: >+ trap; >+ } >+} >+char operator[](char4 v, uint index) { >+ switch (index) { >+ case 0: >+ return v.x; >+ case 1: >+ return v.y; >+ case 2: >+ return v.z; >+ case 3: >+ return v.w; >+ default: >+ trap; >+ } >+} >+char2 operator[]=(char2 v, uint index, char a) { >+ switch (index) { >+ case 0: >+ v.x = a; >+ break; >+ case 1: >+ v.y = a; >+ break; >+ default: >+ trap; >+ } >+ return v; >+} >+char3 operator[]=(char3 v, uint index, char a) { >+ switch (index) { >+ case 0: >+ v.x = a; >+ break; >+ case 1: >+ v.y = a; >+ break; >+ case 2: >+ v.z = a; >+ break; >+ default: >+ trap; >+ } >+ return v; >+} >+char4 operator[]=(char4 v, uint index, char a) { >+ switch (index) { >+ case 0: >+ v.x = a; >+ break; >+ case 1: >+ v.y = a; >+ break; >+ case 2: >+ v.z = a; >+ break; >+ case 3: >+ v.w = a; >+ break; >+ default: >+ trap; >+ } >+ return v; >+} >+bool operator==(short2 a, short2 b) { >+ return a.x == b.x && a.y == b.y; >+} >+bool operator==(short3 a, short3 b) { >+ return a.x == b.x && a.y == b.y && a.z == b.z; >+} >+bool operator==(short4 a, short4 b) { >+ return a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w; >+} >+native short operator.x(short2); >+native short operator.y(short2); >+native short operator.x(short3); >+native short operator.y(short3); >+native short operator.z(short3); >+native short operator.x(short4); >+native short operator.y(short4); >+native short operator.z(short4); >+native short operator.w(short4); >+native short2 operator.x=(short2, short); >+native short2 operator.y=(short2, short); >+native short3 operator.x=(short3, short); >+native short3 operator.y=(short3, short); >+native short3 operator.z=(short3, short); >+native short4 operator.x=(short4, short); >+native short4 operator.y=(short4, short); >+native short4 operator.z=(short4, short); >+native short4 operator.w=(short4, short); >+short operator[](short2 v, uint index) { >+ switch (index) { >+ case 0: >+ return v.x; >+ case 1: >+ return v.y; >+ default: >+ trap; >+ } >+} >+short operator[](short3 v, uint index) { >+ switch (index) { >+ case 0: >+ return v.x; >+ case 1: >+ return v.y; >+ case 2: >+ return v.z; >+ default: >+ trap; >+ } >+} >+short operator[](short4 v, uint index) { >+ switch (index) { >+ case 0: >+ return v.x; >+ case 1: >+ return v.y; >+ case 2: >+ return v.z; >+ case 3: >+ return v.w; >+ default: >+ trap; >+ } >+} >+short2 operator[]=(short2 v, uint index, short a) { >+ switch (index) { >+ case 0: >+ v.x = a; >+ break; >+ case 1: >+ v.y = a; >+ break; >+ default: >+ trap; >+ } >+ return v; >+} >+short3 operator[]=(short3 v, uint index, short a) { >+ switch (index) { >+ case 0: >+ v.x = a; >+ break; >+ case 1: >+ v.y = a; >+ break; >+ case 2: >+ v.z = a; >+ break; >+ default: >+ trap; >+ } >+ return v; >+} >+short4 operator[]=(short4 v, uint index, short a) { >+ switch (index) { >+ case 0: >+ v.x = a; >+ break; >+ case 1: >+ v.y = a; >+ break; >+ case 2: >+ v.z = a; >+ break; >+ case 3: >+ v.w = a; >+ break; >+ default: >+ trap; >+ } >+ return v; >+} >+bool operator==(int2 a, int2 b) { >+ return a.x == b.x && a.y == b.y; >+} >+bool operator==(int3 a, int3 b) { >+ return a.x == b.x && a.y == b.y && a.z == b.z; >+} >+bool operator==(int4 a, int4 b) { >+ return a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w; >+} >+native int operator.x(int2); >+native int operator.y(int2); >+native int operator.x(int3); >+native int operator.y(int3); >+native int operator.z(int3); >+native int operator.x(int4); >+native int operator.y(int4); >+native int operator.z(int4); >+native int operator.w(int4); >+native int2 operator.x=(int2, int); >+native int2 operator.y=(int2, int); >+native int3 operator.x=(int3, int); >+native int3 operator.y=(int3, int); >+native int3 operator.z=(int3, int); >+native int4 operator.x=(int4, int); >+native int4 operator.y=(int4, int); >+native int4 operator.z=(int4, int); >+native int4 operator.w=(int4, int); >+int operator[](int2 v, uint index) { >+ switch (index) { >+ case 0: >+ return v.x; >+ case 1: >+ return v.y; >+ default: >+ trap; >+ } >+} >+int operator[](int3 v, uint index) { >+ switch (index) { >+ case 0: >+ return v.x; >+ case 1: >+ return v.y; >+ case 2: >+ return v.z; >+ default: >+ trap; >+ } >+} >+int operator[](int4 v, uint index) { >+ switch (index) { >+ case 0: >+ return v.x; >+ case 1: >+ return v.y; >+ case 2: >+ return v.z; >+ case 3: >+ return v.w; >+ default: >+ trap; >+ } >+} >+int2 operator[]=(int2 v, uint index, int a) { >+ switch (index) { >+ case 0: >+ v.x = a; >+ break; >+ case 1: >+ v.y = a; >+ break; >+ default: >+ trap; >+ } >+ return v; >+} >+int3 operator[]=(int3 v, uint index, int a) { >+ switch (index) { >+ case 0: >+ v.x = a; >+ break; >+ case 1: >+ v.y = a; >+ break; >+ case 2: >+ v.z = a; >+ break; >+ default: >+ trap; >+ } >+ return v; >+} >+int4 operator[]=(int4 v, uint index, int a) { >+ switch (index) { >+ case 0: >+ v.x = a; >+ break; >+ case 1: >+ v.y = a; >+ break; >+ case 2: >+ v.z = a; >+ break; >+ case 3: >+ v.w = a; >+ break; >+ default: >+ trap; >+ } >+ return v; >+} >+bool operator==(half2 a, half2 b) { >+ return a.x == b.x && a.y == b.y; >+} >+bool operator==(half3 a, half3 b) { >+ return a.x == b.x && a.y == b.y && a.z == b.z; >+} >+bool operator==(half4 a, half4 b) { >+ return a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w; >+} >+native half operator.x(half2); >+native half operator.y(half2); >+native half operator.x(half3); >+native half operator.y(half3); >+native half operator.z(half3); >+native half operator.x(half4); >+native half operator.y(half4); >+native half operator.z(half4); >+native half operator.w(half4); >+native half2 operator.x=(half2, half); >+native half2 operator.y=(half2, half); >+native half3 operator.x=(half3, half); >+native half3 operator.y=(half3, half); >+native half3 operator.z=(half3, half); >+native half4 operator.x=(half4, half); >+native half4 operator.y=(half4, half); >+native half4 operator.z=(half4, half); >+native half4 operator.w=(half4, half); >+half operator[](half2 v, uint index) { >+ switch (index) { >+ case 0: >+ return v.x; >+ case 1: >+ return v.y; >+ default: >+ trap; >+ } >+} >+half operator[](half3 v, uint index) { >+ switch (index) { >+ case 0: >+ return v.x; >+ case 1: >+ return v.y; >+ case 2: >+ return v.z; >+ default: >+ trap; >+ } >+} >+half operator[](half4 v, uint index) { >+ switch (index) { >+ case 0: >+ return v.x; >+ case 1: >+ return v.y; >+ case 2: >+ return v.z; >+ case 3: >+ return v.w; >+ default: >+ trap; >+ } >+} >+half2 operator[]=(half2 v, uint index, half a) { >+ switch (index) { >+ case 0: >+ v.x = a; >+ break; >+ case 1: >+ v.y = a; >+ break; >+ default: >+ trap; >+ } >+ return v; >+} >+half3 operator[]=(half3 v, uint index, half a) { >+ switch (index) { >+ case 0: >+ v.x = a; >+ break; >+ case 1: >+ v.y = a; >+ break; >+ case 2: >+ v.z = a; >+ break; >+ default: >+ trap; >+ } >+ return v; >+} >+half4 operator[]=(half4 v, uint index, half a) { >+ switch (index) { >+ case 0: >+ v.x = a; >+ break; >+ case 1: >+ v.y = a; >+ break; >+ case 2: >+ v.z = a; >+ break; >+ case 3: >+ v.w = a; >+ break; >+ default: >+ trap; >+ } >+ return v; >+} >+bool operator==(float2 a, float2 b) { >+ return a.x == b.x && a.y == b.y; >+} >+bool operator==(float3 a, float3 b) { >+ return a.x == b.x && a.y == b.y && a.z == b.z; >+} >+bool operator==(float4 a, float4 b) { >+ return a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w; >+} >+native float operator.x(float2); >+native float operator.y(float2); >+native float operator.x(float3); >+native float operator.y(float3); >+native float operator.z(float3); >+native float operator.x(float4); >+native float operator.y(float4); >+native float operator.z(float4); >+native float operator.w(float4); >+native float2 operator.x=(float2, float); >+native float2 operator.y=(float2, float); >+native float3 operator.x=(float3, float); >+native float3 operator.y=(float3, float); >+native float3 operator.z=(float3, float); >+native float4 operator.x=(float4, float); >+native float4 operator.y=(float4, float); >+native float4 operator.z=(float4, float); >+native float4 operator.w=(float4, float); >+float operator[](float2 v, uint index) { >+ switch (index) { >+ case 0: >+ return v.x; >+ case 1: >+ return v.y; >+ default: >+ trap; >+ } >+} >+float operator[](float3 v, uint index) { >+ switch (index) { >+ case 0: >+ return v.x; >+ case 1: >+ return v.y; >+ case 2: >+ return v.z; >+ default: >+ trap; >+ } >+} >+float operator[](float4 v, uint index) { >+ switch (index) { >+ case 0: >+ return v.x; >+ case 1: >+ return v.y; >+ case 2: >+ return v.z; >+ case 3: >+ return v.w; >+ default: >+ trap; >+ } >+} >+float2 operator[]=(float2 v, uint index, float a) { >+ switch (index) { >+ case 0: >+ v.x = a; >+ break; >+ case 1: >+ v.y = a; >+ break; >+ default: >+ trap; >+ } >+ return v; >+} >+float3 operator[]=(float3 v, uint index, float a) { >+ switch (index) { >+ case 0: >+ v.x = a; >+ break; >+ case 1: >+ v.y = a; >+ break; >+ case 2: >+ v.z = a; >+ break; >+ default: >+ trap; >+ } >+ return v; >+} >+float4 operator[]=(float4 v, uint index, float a) { >+ switch (index) { >+ case 0: >+ v.x = a; >+ break; >+ case 1: >+ v.y = a; >+ break; >+ case 2: >+ v.z = a; >+ break; >+ case 3: >+ v.w = a; >+ break; >+ default: >+ trap; >+ } >+ return v; >+} >+ >+native half2 operator[](half2x2, uint); >+native half2x2 operator[]=(half2x2, uint, half2); >+native half3 operator[](half2x3, uint); >+native half2x3 operator[]=(half2x3, uint, half3); >+native half4 operator[](half2x4, uint); >+native half2x4 operator[]=(half2x4, uint, half4); >+native half2 operator[](half3x2, uint); >+native half3x2 operator[]=(half3x2, uint, half2); >+native half3 operator[](half3x3, uint); >+native half3x3 operator[]=(half3x3, uint, half3); >+native half4 operator[](half3x4, uint); >+native half3x4 operator[]=(half3x4, uint, half4); >+native half2 operator[](half4x2, uint); >+native half4x2 operator[]=(half4x2, uint, half2); >+native half3 operator[](half4x3, uint); >+native half4x3 operator[]=(half4x3, uint, half3); >+native half4 operator[](half4x4, uint); >+native half4x4 operator[]=(half4x4, uint, half4); >+native float2 operator[](float2x2, uint); >+native float2x2 operator[]=(float2x2, uint, float2); >+native float3 operator[](float2x3, uint); >+native float2x3 operator[]=(float2x3, uint, float3); >+native float4 operator[](float2x4, uint); >+native float2x4 operator[]=(float2x4, uint, float4); >+native float2 operator[](float3x2, uint); >+native float3x2 operator[]=(float3x2, uint, float2); >+native float3 operator[](float3x3, uint); >+native float3x3 operator[]=(float3x3, uint, float3); >+native float4 operator[](float3x4, uint); >+native float3x4 operator[]=(float3x4, uint, float4); >+native float2 operator[](float4x2, uint); >+native float4x2 operator[]=(float4x2, uint, float2); >+native float3 operator[](float4x3, uint); >+native float4x3 operator[]=(float4x3, uint, float3); >+native float4 operator[](float4x4, uint); >+native float4x4 operator[]=(float4x4, uint, float4); >+ >+bool operator==(half2x2 a, half2x2 b) { >+ return >+ a[0][0] == b[0][0] && >+ a[0][1] == b[0][1] && >+ a[1][0] == b[1][0] && >+ a[1][1] == b[1][1] && >+ true; >+} >+bool operator==(half2x3 a, half2x3 b) { >+ return >+ a[0][0] == b[0][0] && >+ a[0][1] == b[0][1] && >+ a[0][2] == b[0][2] && >+ a[1][0] == b[1][0] && >+ a[1][1] == b[1][1] && >+ a[1][2] == b[1][2] && >+ true; >+} >+bool operator==(half2x4 a, half2x4 b) { >+ return >+ a[0][0] == b[0][0] && >+ a[0][1] == b[0][1] && >+ a[0][2] == b[0][2] && >+ a[0][3] == b[0][3] && >+ a[1][0] == b[1][0] && >+ a[1][1] == b[1][1] && >+ a[1][2] == b[1][2] && >+ a[1][3] == b[1][3] && >+ true; >+} >+bool operator==(half3x2 a, half3x2 b) { >+ return >+ a[0][0] == b[0][0] && >+ a[0][1] == b[0][1] && >+ a[1][0] == b[1][0] && >+ a[1][1] == b[1][1] && >+ a[2][0] == b[2][0] && >+ a[2][1] == b[2][1] && >+ true; >+} >+bool operator==(half3x3 a, half3x3 b) { >+ return >+ a[0][0] == b[0][0] && >+ a[0][1] == b[0][1] && >+ a[0][2] == b[0][2] && >+ a[1][0] == b[1][0] && >+ a[1][1] == b[1][1] && >+ a[1][2] == b[1][2] && >+ a[2][0] == b[2][0] && >+ a[2][1] == b[2][1] && >+ a[2][2] == b[2][2] && >+ true; >+} >+bool operator==(half3x4 a, half3x4 b) { >+ return >+ a[0][0] == b[0][0] && >+ a[0][1] == b[0][1] && >+ a[0][2] == b[0][2] && >+ a[0][3] == b[0][3] && >+ a[1][0] == b[1][0] && >+ a[1][1] == b[1][1] && >+ a[1][2] == b[1][2] && >+ a[1][3] == b[1][3] && >+ a[2][0] == b[2][0] && >+ a[2][1] == b[2][1] && >+ a[2][2] == b[2][2] && >+ a[2][3] == b[2][3] && >+ true; >+} >+bool operator==(half4x2 a, half4x2 b) { >+ return >+ a[0][0] == b[0][0] && >+ a[0][1] == b[0][1] && >+ a[1][0] == b[1][0] && >+ a[1][1] == b[1][1] && >+ a[2][0] == b[2][0] && >+ a[2][1] == b[2][1] && >+ a[3][0] == b[3][0] && >+ a[3][1] == b[3][1] && >+ true; >+} >+bool operator==(half4x3 a, half4x3 b) { >+ return >+ a[0][0] == b[0][0] && >+ a[0][1] == b[0][1] && >+ a[0][2] == b[0][2] && >+ a[1][0] == b[1][0] && >+ a[1][1] == b[1][1] && >+ a[1][2] == b[1][2] && >+ a[2][0] == b[2][0] && >+ a[2][1] == b[2][1] && >+ a[2][2] == b[2][2] && >+ a[3][0] == b[3][0] && >+ a[3][1] == b[3][1] && >+ a[3][2] == b[3][2] && >+ true; >+} >+bool operator==(half4x4 a, half4x4 b) { >+ return >+ a[0][0] == b[0][0] && >+ a[0][1] == b[0][1] && >+ a[0][2] == b[0][2] && >+ a[0][3] == b[0][3] && >+ a[1][0] == b[1][0] && >+ a[1][1] == b[1][1] && >+ a[1][2] == b[1][2] && >+ a[1][3] == b[1][3] && >+ a[2][0] == b[2][0] && >+ a[2][1] == b[2][1] && >+ a[2][2] == b[2][2] && >+ a[2][3] == b[2][3] && >+ a[3][0] == b[3][0] && >+ a[3][1] == b[3][1] && >+ a[3][2] == b[3][2] && >+ a[3][3] == b[3][3] && >+ true; >+} >+bool operator==(float2x2 a, float2x2 b) { >+ return >+ a[0][0] == b[0][0] && >+ a[0][1] == b[0][1] && >+ a[1][0] == b[1][0] && >+ a[1][1] == b[1][1] && >+ true; >+} >+bool operator==(float2x3 a, float2x3 b) { >+ return >+ a[0][0] == b[0][0] && >+ a[0][1] == b[0][1] && >+ a[0][2] == b[0][2] && >+ a[1][0] == b[1][0] && >+ a[1][1] == b[1][1] && >+ a[1][2] == b[1][2] && >+ true; >+} >+bool operator==(float2x4 a, float2x4 b) { >+ return >+ a[0][0] == b[0][0] && >+ a[0][1] == b[0][1] && >+ a[0][2] == b[0][2] && >+ a[0][3] == b[0][3] && >+ a[1][0] == b[1][0] && >+ a[1][1] == b[1][1] && >+ a[1][2] == b[1][2] && >+ a[1][3] == b[1][3] && >+ true; >+} >+bool operator==(float3x2 a, float3x2 b) { >+ return >+ a[0][0] == b[0][0] && >+ a[0][1] == b[0][1] && >+ a[1][0] == b[1][0] && >+ a[1][1] == b[1][1] && >+ a[2][0] == b[2][0] && >+ a[2][1] == b[2][1] && >+ true; >+} >+bool operator==(float3x3 a, float3x3 b) { >+ return >+ a[0][0] == b[0][0] && >+ a[0][1] == b[0][1] && >+ a[0][2] == b[0][2] && >+ a[1][0] == b[1][0] && >+ a[1][1] == b[1][1] && >+ a[1][2] == b[1][2] && >+ a[2][0] == b[2][0] && >+ a[2][1] == b[2][1] && >+ a[2][2] == b[2][2] && >+ true; >+} >+bool operator==(float3x4 a, float3x4 b) { >+ return >+ a[0][0] == b[0][0] && >+ a[0][1] == b[0][1] && >+ a[0][2] == b[0][2] && >+ a[0][3] == b[0][3] && >+ a[1][0] == b[1][0] && >+ a[1][1] == b[1][1] && >+ a[1][2] == b[1][2] && >+ a[1][3] == b[1][3] && >+ a[2][0] == b[2][0] && >+ a[2][1] == b[2][1] && >+ a[2][2] == b[2][2] && >+ a[2][3] == b[2][3] && >+ true; >+} >+bool operator==(float4x2 a, float4x2 b) { >+ return >+ a[0][0] == b[0][0] && >+ a[0][1] == b[0][1] && >+ a[1][0] == b[1][0] && >+ a[1][1] == b[1][1] && >+ a[2][0] == b[2][0] && >+ a[2][1] == b[2][1] && >+ a[3][0] == b[3][0] && >+ a[3][1] == b[3][1] && >+ true; >+} >+bool operator==(float4x3 a, float4x3 b) { >+ return >+ a[0][0] == b[0][0] && >+ a[0][1] == b[0][1] && >+ a[0][2] == b[0][2] && >+ a[1][0] == b[1][0] && >+ a[1][1] == b[1][1] && >+ a[1][2] == b[1][2] && >+ a[2][0] == b[2][0] && >+ a[2][1] == b[2][1] && >+ a[2][2] == b[2][2] && >+ a[3][0] == b[3][0] && >+ a[3][1] == b[3][1] && >+ a[3][2] == b[3][2] && >+ true; >+} >+bool operator==(float4x4 a, float4x4 b) { >+ return >+ a[0][0] == b[0][0] && >+ a[0][1] == b[0][1] && >+ a[0][2] == b[0][2] && >+ a[0][3] == b[0][3] && >+ a[1][0] == b[1][0] && >+ a[1][1] == b[1][1] && >+ a[1][2] == b[1][2] && >+ a[1][3] == b[1][3] && >+ a[2][0] == b[2][0] && >+ a[2][1] == b[2][1] && >+ a[2][2] == b[2][2] && >+ a[2][3] == b[2][3] && >+ a[3][0] == b[3][0] && >+ a[3][1] == b[3][1] && >+ a[3][2] == b[3][2] && >+ a[3][3] == b[3][3] && >+ true; >+} >+bool2 operator.xx(bool2 v) { >+ bool2 result; >+ result.x = v.x; >+ result.y = v.x; >+ return result; >+} >+bool2 operator.xy(bool2 v) { >+ bool2 result; >+ result.x = v.x; >+ result.y = v.y; >+ return result; >+} >+bool2 operator.xy=(bool2 v, bool2 c) { >+ bool2 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ return result; >+} >+bool2 operator.yx(bool2 v) { >+ bool2 result; >+ result.x = v.y; >+ result.y = v.x; >+ return result; >+} >+bool2 operator.yx=(bool2 v, bool2 c) { >+ bool2 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ return result; >+} >+bool2 operator.yy(bool2 v) { >+ bool2 result; >+ result.x = v.y; >+ result.y = v.y; >+ return result; >+} >+bool2 operator.xx(bool3 v) { >+ bool2 result; >+ result.x = v.x; >+ result.y = v.x; >+ return result; >+} >+bool2 operator.xy(bool3 v) { >+ bool2 result; >+ result.x = v.x; >+ result.y = v.y; >+ return result; >+} >+bool3 operator.xy=(bool3 v, bool2 c) { >+ bool3 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ return result; >+} >+bool2 operator.xz(bool3 v) { >+ bool2 result; >+ result.x = v.x; >+ result.y = v.z; >+ return result; >+} >+bool3 operator.xz=(bool3 v, bool2 c) { >+ bool3 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ return result; >+} >+bool2 operator.yx(bool3 v) { >+ bool2 result; >+ result.x = v.y; >+ result.y = v.x; >+ return result; >+} >+bool3 operator.yx=(bool3 v, bool2 c) { >+ bool3 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ return result; >+} >+bool2 operator.yy(bool3 v) { >+ bool2 result; >+ result.x = v.y; >+ result.y = v.y; >+ return result; >+} >+bool2 operator.yz(bool3 v) { >+ bool2 result; >+ result.x = v.y; >+ result.y = v.z; >+ return result; >+} >+bool3 operator.yz=(bool3 v, bool2 c) { >+ bool3 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ return result; >+} >+bool2 operator.zx(bool3 v) { >+ bool2 result; >+ result.x = v.z; >+ result.y = v.x; >+ return result; >+} >+bool3 operator.zx=(bool3 v, bool2 c) { >+ bool3 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ return result; >+} >+bool2 operator.zy(bool3 v) { >+ bool2 result; >+ result.x = v.z; >+ result.y = v.y; >+ return result; >+} >+bool3 operator.zy=(bool3 v, bool2 c) { >+ bool3 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ return result; >+} >+bool2 operator.zz(bool3 v) { >+ bool2 result; >+ result.x = v.z; >+ result.y = v.z; >+ return result; >+} >+bool2 operator.xx(bool4 v) { >+ bool2 result; >+ result.x = v.x; >+ result.y = v.x; >+ return result; >+} >+bool2 operator.xy(bool4 v) { >+ bool2 result; >+ result.x = v.x; >+ result.y = v.y; >+ return result; >+} >+bool4 operator.xy=(bool4 v, bool2 c) { >+ bool4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ return result; >+} >+bool2 operator.xz(bool4 v) { >+ bool2 result; >+ result.x = v.x; >+ result.y = v.z; >+ return result; >+} >+bool4 operator.xz=(bool4 v, bool2 c) { >+ bool4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ return result; >+} >+bool2 operator.xw(bool4 v) { >+ bool2 result; >+ result.x = v.x; >+ result.y = v.w; >+ return result; >+} >+bool4 operator.xw=(bool4 v, bool2 c) { >+ bool4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ return result; >+} >+bool2 operator.yx(bool4 v) { >+ bool2 result; >+ result.x = v.y; >+ result.y = v.x; >+ return result; >+} >+bool4 operator.yx=(bool4 v, bool2 c) { >+ bool4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ return result; >+} >+bool2 operator.yy(bool4 v) { >+ bool2 result; >+ result.x = v.y; >+ result.y = v.y; >+ return result; >+} >+bool2 operator.yz(bool4 v) { >+ bool2 result; >+ result.x = v.y; >+ result.y = v.z; >+ return result; >+} >+bool4 operator.yz=(bool4 v, bool2 c) { >+ bool4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ return result; >+} >+bool2 operator.yw(bool4 v) { >+ bool2 result; >+ result.x = v.y; >+ result.y = v.w; >+ return result; >+} >+bool4 operator.yw=(bool4 v, bool2 c) { >+ bool4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ return result; >+} >+bool2 operator.zx(bool4 v) { >+ bool2 result; >+ result.x = v.z; >+ result.y = v.x; >+ return result; >+} >+bool4 operator.zx=(bool4 v, bool2 c) { >+ bool4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ return result; >+} >+bool2 operator.zy(bool4 v) { >+ bool2 result; >+ result.x = v.z; >+ result.y = v.y; >+ return result; >+} >+bool4 operator.zy=(bool4 v, bool2 c) { >+ bool4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ return result; >+} >+bool2 operator.zz(bool4 v) { >+ bool2 result; >+ result.x = v.z; >+ result.y = v.z; >+ return result; >+} >+bool2 operator.zw(bool4 v) { >+ bool2 result; >+ result.x = v.z; >+ result.y = v.w; >+ return result; >+} >+bool4 operator.zw=(bool4 v, bool2 c) { >+ bool4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ return result; >+} >+bool2 operator.wx(bool4 v) { >+ bool2 result; >+ result.x = v.w; >+ result.y = v.x; >+ return result; >+} >+bool4 operator.wx=(bool4 v, bool2 c) { >+ bool4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ return result; >+} >+bool2 operator.wy(bool4 v) { >+ bool2 result; >+ result.x = v.w; >+ result.y = v.y; >+ return result; >+} >+bool4 operator.wy=(bool4 v, bool2 c) { >+ bool4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ return result; >+} >+bool2 operator.wz(bool4 v) { >+ bool2 result; >+ result.x = v.w; >+ result.y = v.z; >+ return result; >+} >+bool4 operator.wz=(bool4 v, bool2 c) { >+ bool4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ return result; >+} >+bool2 operator.ww(bool4 v) { >+ bool2 result; >+ result.x = v.w; >+ result.y = v.w; >+ return result; >+} >+bool3 operator.xxx(bool2 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+bool3 operator.xxy(bool2 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+bool3 operator.xyx(bool2 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+bool3 operator.xyy(bool2 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+bool3 operator.yxx(bool2 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+bool3 operator.yxy(bool2 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+bool3 operator.yyx(bool2 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+bool3 operator.yyy(bool2 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+bool3 operator.xxx(bool3 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+bool3 operator.xxy(bool3 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+bool3 operator.xxz(bool3 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+bool3 operator.xyx(bool3 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+bool3 operator.xyy(bool3 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+bool3 operator.xyz(bool3 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+bool3 operator.xyz=(bool3 v, bool3 c) { >+ bool3 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ return result; >+} >+bool3 operator.xzx(bool3 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+bool3 operator.xzy(bool3 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+bool3 operator.xzy=(bool3 v, bool3 c) { >+ bool3 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ return result; >+} >+bool3 operator.xzz(bool3 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+bool3 operator.yxx(bool3 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+bool3 operator.yxy(bool3 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+bool3 operator.yxz(bool3 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+bool3 operator.yxz=(bool3 v, bool3 c) { >+ bool3 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ return result; >+} >+bool3 operator.yyx(bool3 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+bool3 operator.yyy(bool3 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+bool3 operator.yyz(bool3 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+bool3 operator.yzx(bool3 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+bool3 operator.yzx=(bool3 v, bool3 c) { >+ bool3 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ return result; >+} >+bool3 operator.yzy(bool3 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+bool3 operator.yzz(bool3 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+bool3 operator.zxx(bool3 v) { >+ bool3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+bool3 operator.zxy(bool3 v) { >+ bool3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+bool3 operator.zxy=(bool3 v, bool3 c) { >+ bool3 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ return result; >+} >+bool3 operator.zxz(bool3 v) { >+ bool3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+bool3 operator.zyx(bool3 v) { >+ bool3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+bool3 operator.zyx=(bool3 v, bool3 c) { >+ bool3 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ return result; >+} >+bool3 operator.zyy(bool3 v) { >+ bool3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+bool3 operator.zyz(bool3 v) { >+ bool3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+bool3 operator.zzx(bool3 v) { >+ bool3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+bool3 operator.zzy(bool3 v) { >+ bool3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+bool3 operator.zzz(bool3 v) { >+ bool3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+bool3 operator.xxx(bool4 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+bool3 operator.xxy(bool4 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+bool3 operator.xxz(bool4 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+bool3 operator.xxw(bool4 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+bool3 operator.xyx(bool4 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+bool3 operator.xyy(bool4 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+bool3 operator.xyz(bool4 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+bool4 operator.xyz=(bool4 v, bool3 c) { >+ bool4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ return result; >+} >+bool3 operator.xyw(bool4 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+bool4 operator.xyw=(bool4 v, bool3 c) { >+ bool4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ return result; >+} >+bool3 operator.xzx(bool4 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+bool3 operator.xzy(bool4 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+bool4 operator.xzy=(bool4 v, bool3 c) { >+ bool4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ return result; >+} >+bool3 operator.xzz(bool4 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+bool3 operator.xzw(bool4 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+bool4 operator.xzw=(bool4 v, bool3 c) { >+ bool4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ return result; >+} >+bool3 operator.xwx(bool4 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+bool3 operator.xwy(bool4 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+bool4 operator.xwy=(bool4 v, bool3 c) { >+ bool4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ return result; >+} >+bool3 operator.xwz(bool4 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+bool4 operator.xwz=(bool4 v, bool3 c) { >+ bool4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ return result; >+} >+bool3 operator.xww(bool4 v) { >+ bool3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+bool3 operator.yxx(bool4 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+bool3 operator.yxy(bool4 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+bool3 operator.yxz(bool4 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+bool4 operator.yxz=(bool4 v, bool3 c) { >+ bool4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ return result; >+} >+bool3 operator.yxw(bool4 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+bool4 operator.yxw=(bool4 v, bool3 c) { >+ bool4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ return result; >+} >+bool3 operator.yyx(bool4 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+bool3 operator.yyy(bool4 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+bool3 operator.yyz(bool4 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+bool3 operator.yyw(bool4 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+bool3 operator.yzx(bool4 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+bool4 operator.yzx=(bool4 v, bool3 c) { >+ bool4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ return result; >+} >+bool3 operator.yzy(bool4 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+bool3 operator.yzz(bool4 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+bool3 operator.yzw(bool4 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+bool4 operator.yzw=(bool4 v, bool3 c) { >+ bool4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ return result; >+} >+bool3 operator.ywx(bool4 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+bool4 operator.ywx=(bool4 v, bool3 c) { >+ bool4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ return result; >+} >+bool3 operator.ywy(bool4 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+bool3 operator.ywz(bool4 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+bool4 operator.ywz=(bool4 v, bool3 c) { >+ bool4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ return result; >+} >+bool3 operator.yww(bool4 v) { >+ bool3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+bool3 operator.zxx(bool4 v) { >+ bool3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+bool3 operator.zxy(bool4 v) { >+ bool3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+bool4 operator.zxy=(bool4 v, bool3 c) { >+ bool4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ return result; >+} >+bool3 operator.zxz(bool4 v) { >+ bool3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+bool3 operator.zxw(bool4 v) { >+ bool3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+bool4 operator.zxw=(bool4 v, bool3 c) { >+ bool4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ return result; >+} >+bool3 operator.zyx(bool4 v) { >+ bool3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+bool4 operator.zyx=(bool4 v, bool3 c) { >+ bool4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ return result; >+} >+bool3 operator.zyy(bool4 v) { >+ bool3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+bool3 operator.zyz(bool4 v) { >+ bool3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+bool3 operator.zyw(bool4 v) { >+ bool3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+bool4 operator.zyw=(bool4 v, bool3 c) { >+ bool4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ return result; >+} >+bool3 operator.zzx(bool4 v) { >+ bool3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+bool3 operator.zzy(bool4 v) { >+ bool3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+bool3 operator.zzz(bool4 v) { >+ bool3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+bool3 operator.zzw(bool4 v) { >+ bool3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+bool3 operator.zwx(bool4 v) { >+ bool3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+bool4 operator.zwx=(bool4 v, bool3 c) { >+ bool4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ return result; >+} >+bool3 operator.zwy(bool4 v) { >+ bool3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+bool4 operator.zwy=(bool4 v, bool3 c) { >+ bool4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ return result; >+} >+bool3 operator.zwz(bool4 v) { >+ bool3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+bool3 operator.zww(bool4 v) { >+ bool3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+bool3 operator.wxx(bool4 v) { >+ bool3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+bool3 operator.wxy(bool4 v) { >+ bool3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+bool4 operator.wxy=(bool4 v, bool3 c) { >+ bool4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ return result; >+} >+bool3 operator.wxz(bool4 v) { >+ bool3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+bool4 operator.wxz=(bool4 v, bool3 c) { >+ bool4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ return result; >+} >+bool3 operator.wxw(bool4 v) { >+ bool3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+bool3 operator.wyx(bool4 v) { >+ bool3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+bool4 operator.wyx=(bool4 v, bool3 c) { >+ bool4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ return result; >+} >+bool3 operator.wyy(bool4 v) { >+ bool3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+bool3 operator.wyz(bool4 v) { >+ bool3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+bool4 operator.wyz=(bool4 v, bool3 c) { >+ bool4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ return result; >+} >+bool3 operator.wyw(bool4 v) { >+ bool3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+bool3 operator.wzx(bool4 v) { >+ bool3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+bool4 operator.wzx=(bool4 v, bool3 c) { >+ bool4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ return result; >+} >+bool3 operator.wzy(bool4 v) { >+ bool3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+bool4 operator.wzy=(bool4 v, bool3 c) { >+ bool4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ return result; >+} >+bool3 operator.wzz(bool4 v) { >+ bool3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+bool3 operator.wzw(bool4 v) { >+ bool3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+bool3 operator.wwx(bool4 v) { >+ bool3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+bool3 operator.wwy(bool4 v) { >+ bool3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+bool3 operator.wwz(bool4 v) { >+ bool3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+bool3 operator.www(bool4 v) { >+ bool3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+bool4 operator.xxxx(bool2 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xxxy(bool2 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xxyx(bool2 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xxyy(bool2 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xyxx(bool2 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xyxy(bool2 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xyyx(bool2 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xyyy(bool2 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.yxxx(bool2 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.yxxy(bool2 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.yxyx(bool2 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.yxyy(bool2 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.yyxx(bool2 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.yyxy(bool2 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.yyyx(bool2 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.yyyy(bool2 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xxxx(bool3 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xxxy(bool3 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xxxz(bool3 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.xxyx(bool3 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xxyy(bool3 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xxyz(bool3 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.xxzx(bool3 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xxzy(bool3 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xxzz(bool3 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.xyxx(bool3 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xyxy(bool3 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xyxz(bool3 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.xyyx(bool3 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xyyy(bool3 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xyyz(bool3 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.xyzx(bool3 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xyzy(bool3 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xyzz(bool3 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.xzxx(bool3 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xzxy(bool3 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xzxz(bool3 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.xzyx(bool3 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xzyy(bool3 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xzyz(bool3 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.xzzx(bool3 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xzzy(bool3 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xzzz(bool3 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.yxxx(bool3 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.yxxy(bool3 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.yxxz(bool3 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.yxyx(bool3 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.yxyy(bool3 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.yxyz(bool3 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.yxzx(bool3 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.yxzy(bool3 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.yxzz(bool3 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.yyxx(bool3 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.yyxy(bool3 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.yyxz(bool3 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.yyyx(bool3 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.yyyy(bool3 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.yyyz(bool3 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.yyzx(bool3 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.yyzy(bool3 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.yyzz(bool3 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.yzxx(bool3 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.yzxy(bool3 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.yzxz(bool3 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.yzyx(bool3 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.yzyy(bool3 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.yzyz(bool3 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.yzzx(bool3 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.yzzy(bool3 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.yzzz(bool3 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.zxxx(bool3 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.zxxy(bool3 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.zxxz(bool3 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.zxyx(bool3 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.zxyy(bool3 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.zxyz(bool3 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.zxzx(bool3 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.zxzy(bool3 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.zxzz(bool3 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.zyxx(bool3 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.zyxy(bool3 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.zyxz(bool3 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.zyyx(bool3 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.zyyy(bool3 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.zyyz(bool3 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.zyzx(bool3 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.zyzy(bool3 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.zyzz(bool3 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.zzxx(bool3 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.zzxy(bool3 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.zzxz(bool3 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.zzyx(bool3 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.zzyy(bool3 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.zzyz(bool3 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.zzzx(bool3 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.zzzy(bool3 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.zzzz(bool3 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.xxxx(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xxxy(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xxxz(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.xxxw(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.xxyx(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xxyy(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xxyz(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.xxyw(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.xxzx(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xxzy(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xxzz(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.xxzw(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.xxwx(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xxwy(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xxwz(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.xxww(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.xyxx(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xyxy(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xyxz(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.xyxw(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.xyyx(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xyyy(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xyyz(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.xyyw(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.xyzx(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xyzy(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xyzz(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.xyzw(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.xyzw=(bool4 v, bool4 c) { >+ bool4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ result.w = c.w; >+ return result; >+} >+bool4 operator.xywx(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xywy(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xywz(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.xywz=(bool4 v, bool4 c) { >+ bool4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ result.z = c.w; >+ return result; >+} >+bool4 operator.xyww(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.xzxx(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xzxy(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xzxz(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.xzxw(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.xzyx(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xzyy(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xzyz(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.xzyw(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.xzyw=(bool4 v, bool4 c) { >+ bool4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ result.w = c.w; >+ return result; >+} >+bool4 operator.xzzx(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xzzy(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xzzz(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.xzzw(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.xzwx(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xzwy(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xzwy=(bool4 v, bool4 c) { >+ bool4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ result.y = c.w; >+ return result; >+} >+bool4 operator.xzwz(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.xzww(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.xwxx(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xwxy(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xwxz(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.xwxw(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.xwyx(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xwyy(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xwyz(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.xwyz=(bool4 v, bool4 c) { >+ bool4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ result.z = c.w; >+ return result; >+} >+bool4 operator.xwyw(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.xwzx(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xwzy(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xwzy=(bool4 v, bool4 c) { >+ bool4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ result.y = c.w; >+ return result; >+} >+bool4 operator.xwzz(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.xwzw(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.xwwx(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.xwwy(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.xwwz(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.xwww(bool4 v) { >+ bool4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.yxxx(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.yxxy(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.yxxz(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.yxxw(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.yxyx(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.yxyy(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.yxyz(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.yxyw(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.yxzx(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.yxzy(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.yxzz(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.yxzw(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.yxzw=(bool4 v, bool4 c) { >+ bool4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ result.w = c.w; >+ return result; >+} >+bool4 operator.yxwx(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.yxwy(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.yxwz(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.yxwz=(bool4 v, bool4 c) { >+ bool4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ result.z = c.w; >+ return result; >+} >+bool4 operator.yxww(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.yyxx(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.yyxy(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.yyxz(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.yyxw(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.yyyx(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.yyyy(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.yyyz(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.yyyw(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.yyzx(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.yyzy(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.yyzz(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.yyzw(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.yywx(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.yywy(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.yywz(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.yyww(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.yzxx(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.yzxy(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.yzxz(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.yzxw(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.yzxw=(bool4 v, bool4 c) { >+ bool4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ result.w = c.w; >+ return result; >+} >+bool4 operator.yzyx(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.yzyy(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.yzyz(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.yzyw(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.yzzx(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.yzzy(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.yzzz(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.yzzw(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.yzwx(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.yzwx=(bool4 v, bool4 c) { >+ bool4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ result.x = c.w; >+ return result; >+} >+bool4 operator.yzwy(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.yzwz(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.yzww(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.ywxx(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.ywxy(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.ywxz(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.ywxz=(bool4 v, bool4 c) { >+ bool4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ result.z = c.w; >+ return result; >+} >+bool4 operator.ywxw(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.ywyx(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.ywyy(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.ywyz(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.ywyw(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.ywzx(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.ywzx=(bool4 v, bool4 c) { >+ bool4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ result.x = c.w; >+ return result; >+} >+bool4 operator.ywzy(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.ywzz(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.ywzw(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.ywwx(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.ywwy(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.ywwz(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.ywww(bool4 v) { >+ bool4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.zxxx(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.zxxy(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.zxxz(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.zxxw(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.zxyx(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.zxyy(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.zxyz(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.zxyw(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.zxyw=(bool4 v, bool4 c) { >+ bool4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ result.w = c.w; >+ return result; >+} >+bool4 operator.zxzx(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.zxzy(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.zxzz(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.zxzw(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.zxwx(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.zxwy(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.zxwy=(bool4 v, bool4 c) { >+ bool4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ result.y = c.w; >+ return result; >+} >+bool4 operator.zxwz(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.zxww(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.zyxx(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.zyxy(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.zyxz(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.zyxw(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.zyxw=(bool4 v, bool4 c) { >+ bool4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ result.w = c.w; >+ return result; >+} >+bool4 operator.zyyx(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.zyyy(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.zyyz(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.zyyw(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.zyzx(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.zyzy(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.zyzz(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.zyzw(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.zywx(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.zywx=(bool4 v, bool4 c) { >+ bool4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ result.x = c.w; >+ return result; >+} >+bool4 operator.zywy(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.zywz(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.zyww(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.zzxx(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.zzxy(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.zzxz(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.zzxw(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.zzyx(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.zzyy(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.zzyz(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.zzyw(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.zzzx(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.zzzy(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.zzzz(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.zzzw(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.zzwx(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.zzwy(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.zzwz(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.zzww(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.zwxx(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.zwxy(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.zwxy=(bool4 v, bool4 c) { >+ bool4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ result.y = c.w; >+ return result; >+} >+bool4 operator.zwxz(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.zwxw(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.zwyx(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.zwyx=(bool4 v, bool4 c) { >+ bool4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ result.x = c.w; >+ return result; >+} >+bool4 operator.zwyy(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.zwyz(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.zwyw(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.zwzx(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.zwzy(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.zwzz(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.zwzw(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.zwwx(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.zwwy(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.zwwz(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.zwww(bool4 v) { >+ bool4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.wxxx(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.wxxy(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.wxxz(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.wxxw(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.wxyx(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.wxyy(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.wxyz(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.wxyz=(bool4 v, bool4 c) { >+ bool4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ result.z = c.w; >+ return result; >+} >+bool4 operator.wxyw(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.wxzx(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.wxzy(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.wxzy=(bool4 v, bool4 c) { >+ bool4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ result.y = c.w; >+ return result; >+} >+bool4 operator.wxzz(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.wxzw(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.wxwx(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.wxwy(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.wxwz(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.wxww(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.wyxx(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.wyxy(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.wyxz(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.wyxz=(bool4 v, bool4 c) { >+ bool4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ result.z = c.w; >+ return result; >+} >+bool4 operator.wyxw(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.wyyx(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.wyyy(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.wyyz(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.wyyw(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.wyzx(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.wyzx=(bool4 v, bool4 c) { >+ bool4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ result.x = c.w; >+ return result; >+} >+bool4 operator.wyzy(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.wyzz(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.wyzw(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.wywx(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.wywy(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.wywz(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.wyww(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.wzxx(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.wzxy(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.wzxy=(bool4 v, bool4 c) { >+ bool4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ result.y = c.w; >+ return result; >+} >+bool4 operator.wzxz(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.wzxw(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.wzyx(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.wzyx=(bool4 v, bool4 c) { >+ bool4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ result.x = c.w; >+ return result; >+} >+bool4 operator.wzyy(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.wzyz(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.wzyw(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.wzzx(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.wzzy(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.wzzz(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.wzzw(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.wzwx(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.wzwy(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.wzwz(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.wzww(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.wwxx(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.wwxy(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.wwxz(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.wwxw(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.wwyx(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.wwyy(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.wwyz(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.wwyw(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.wwzx(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.wwzy(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.wwzz(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.wwzw(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+bool4 operator.wwwx(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+bool4 operator.wwwy(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+bool4 operator.wwwz(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+bool4 operator.wwww(bool4 v) { >+ bool4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uchar2 operator.xx(uchar2 v) { >+ uchar2 result; >+ result.x = v.x; >+ result.y = v.x; >+ return result; >+} >+uchar2 operator.xy(uchar2 v) { >+ uchar2 result; >+ result.x = v.x; >+ result.y = v.y; >+ return result; >+} >+uchar2 operator.xy=(uchar2 v, uchar2 c) { >+ uchar2 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ return result; >+} >+uchar2 operator.yx(uchar2 v) { >+ uchar2 result; >+ result.x = v.y; >+ result.y = v.x; >+ return result; >+} >+uchar2 operator.yx=(uchar2 v, uchar2 c) { >+ uchar2 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ return result; >+} >+uchar2 operator.yy(uchar2 v) { >+ uchar2 result; >+ result.x = v.y; >+ result.y = v.y; >+ return result; >+} >+uchar2 operator.xx(uchar3 v) { >+ uchar2 result; >+ result.x = v.x; >+ result.y = v.x; >+ return result; >+} >+uchar2 operator.xy(uchar3 v) { >+ uchar2 result; >+ result.x = v.x; >+ result.y = v.y; >+ return result; >+} >+uchar3 operator.xy=(uchar3 v, uchar2 c) { >+ uchar3 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ return result; >+} >+uchar2 operator.xz(uchar3 v) { >+ uchar2 result; >+ result.x = v.x; >+ result.y = v.z; >+ return result; >+} >+uchar3 operator.xz=(uchar3 v, uchar2 c) { >+ uchar3 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ return result; >+} >+uchar2 operator.yx(uchar3 v) { >+ uchar2 result; >+ result.x = v.y; >+ result.y = v.x; >+ return result; >+} >+uchar3 operator.yx=(uchar3 v, uchar2 c) { >+ uchar3 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ return result; >+} >+uchar2 operator.yy(uchar3 v) { >+ uchar2 result; >+ result.x = v.y; >+ result.y = v.y; >+ return result; >+} >+uchar2 operator.yz(uchar3 v) { >+ uchar2 result; >+ result.x = v.y; >+ result.y = v.z; >+ return result; >+} >+uchar3 operator.yz=(uchar3 v, uchar2 c) { >+ uchar3 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ return result; >+} >+uchar2 operator.zx(uchar3 v) { >+ uchar2 result; >+ result.x = v.z; >+ result.y = v.x; >+ return result; >+} >+uchar3 operator.zx=(uchar3 v, uchar2 c) { >+ uchar3 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ return result; >+} >+uchar2 operator.zy(uchar3 v) { >+ uchar2 result; >+ result.x = v.z; >+ result.y = v.y; >+ return result; >+} >+uchar3 operator.zy=(uchar3 v, uchar2 c) { >+ uchar3 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ return result; >+} >+uchar2 operator.zz(uchar3 v) { >+ uchar2 result; >+ result.x = v.z; >+ result.y = v.z; >+ return result; >+} >+uchar2 operator.xx(uchar4 v) { >+ uchar2 result; >+ result.x = v.x; >+ result.y = v.x; >+ return result; >+} >+uchar2 operator.xy(uchar4 v) { >+ uchar2 result; >+ result.x = v.x; >+ result.y = v.y; >+ return result; >+} >+uchar4 operator.xy=(uchar4 v, uchar2 c) { >+ uchar4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ return result; >+} >+uchar2 operator.xz(uchar4 v) { >+ uchar2 result; >+ result.x = v.x; >+ result.y = v.z; >+ return result; >+} >+uchar4 operator.xz=(uchar4 v, uchar2 c) { >+ uchar4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ return result; >+} >+uchar2 operator.xw(uchar4 v) { >+ uchar2 result; >+ result.x = v.x; >+ result.y = v.w; >+ return result; >+} >+uchar4 operator.xw=(uchar4 v, uchar2 c) { >+ uchar4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ return result; >+} >+uchar2 operator.yx(uchar4 v) { >+ uchar2 result; >+ result.x = v.y; >+ result.y = v.x; >+ return result; >+} >+uchar4 operator.yx=(uchar4 v, uchar2 c) { >+ uchar4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ return result; >+} >+uchar2 operator.yy(uchar4 v) { >+ uchar2 result; >+ result.x = v.y; >+ result.y = v.y; >+ return result; >+} >+uchar2 operator.yz(uchar4 v) { >+ uchar2 result; >+ result.x = v.y; >+ result.y = v.z; >+ return result; >+} >+uchar4 operator.yz=(uchar4 v, uchar2 c) { >+ uchar4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ return result; >+} >+uchar2 operator.yw(uchar4 v) { >+ uchar2 result; >+ result.x = v.y; >+ result.y = v.w; >+ return result; >+} >+uchar4 operator.yw=(uchar4 v, uchar2 c) { >+ uchar4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ return result; >+} >+uchar2 operator.zx(uchar4 v) { >+ uchar2 result; >+ result.x = v.z; >+ result.y = v.x; >+ return result; >+} >+uchar4 operator.zx=(uchar4 v, uchar2 c) { >+ uchar4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ return result; >+} >+uchar2 operator.zy(uchar4 v) { >+ uchar2 result; >+ result.x = v.z; >+ result.y = v.y; >+ return result; >+} >+uchar4 operator.zy=(uchar4 v, uchar2 c) { >+ uchar4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ return result; >+} >+uchar2 operator.zz(uchar4 v) { >+ uchar2 result; >+ result.x = v.z; >+ result.y = v.z; >+ return result; >+} >+uchar2 operator.zw(uchar4 v) { >+ uchar2 result; >+ result.x = v.z; >+ result.y = v.w; >+ return result; >+} >+uchar4 operator.zw=(uchar4 v, uchar2 c) { >+ uchar4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ return result; >+} >+uchar2 operator.wx(uchar4 v) { >+ uchar2 result; >+ result.x = v.w; >+ result.y = v.x; >+ return result; >+} >+uchar4 operator.wx=(uchar4 v, uchar2 c) { >+ uchar4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ return result; >+} >+uchar2 operator.wy(uchar4 v) { >+ uchar2 result; >+ result.x = v.w; >+ result.y = v.y; >+ return result; >+} >+uchar4 operator.wy=(uchar4 v, uchar2 c) { >+ uchar4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ return result; >+} >+uchar2 operator.wz(uchar4 v) { >+ uchar2 result; >+ result.x = v.w; >+ result.y = v.z; >+ return result; >+} >+uchar4 operator.wz=(uchar4 v, uchar2 c) { >+ uchar4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ return result; >+} >+uchar2 operator.ww(uchar4 v) { >+ uchar2 result; >+ result.x = v.w; >+ result.y = v.w; >+ return result; >+} >+uchar3 operator.xxx(uchar2 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+uchar3 operator.xxy(uchar2 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+uchar3 operator.xyx(uchar2 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+uchar3 operator.xyy(uchar2 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+uchar3 operator.yxx(uchar2 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+uchar3 operator.yxy(uchar2 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+uchar3 operator.yyx(uchar2 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+uchar3 operator.yyy(uchar2 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+uchar3 operator.xxx(uchar3 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+uchar3 operator.xxy(uchar3 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+uchar3 operator.xxz(uchar3 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+uchar3 operator.xyx(uchar3 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+uchar3 operator.xyy(uchar3 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+uchar3 operator.xyz(uchar3 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+uchar3 operator.xyz=(uchar3 v, uchar3 c) { >+ uchar3 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ return result; >+} >+uchar3 operator.xzx(uchar3 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+uchar3 operator.xzy(uchar3 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+uchar3 operator.xzy=(uchar3 v, uchar3 c) { >+ uchar3 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ return result; >+} >+uchar3 operator.xzz(uchar3 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+uchar3 operator.yxx(uchar3 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+uchar3 operator.yxy(uchar3 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+uchar3 operator.yxz(uchar3 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+uchar3 operator.yxz=(uchar3 v, uchar3 c) { >+ uchar3 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ return result; >+} >+uchar3 operator.yyx(uchar3 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+uchar3 operator.yyy(uchar3 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+uchar3 operator.yyz(uchar3 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+uchar3 operator.yzx(uchar3 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+uchar3 operator.yzx=(uchar3 v, uchar3 c) { >+ uchar3 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ return result; >+} >+uchar3 operator.yzy(uchar3 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+uchar3 operator.yzz(uchar3 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+uchar3 operator.zxx(uchar3 v) { >+ uchar3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+uchar3 operator.zxy(uchar3 v) { >+ uchar3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+uchar3 operator.zxy=(uchar3 v, uchar3 c) { >+ uchar3 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ return result; >+} >+uchar3 operator.zxz(uchar3 v) { >+ uchar3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+uchar3 operator.zyx(uchar3 v) { >+ uchar3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+uchar3 operator.zyx=(uchar3 v, uchar3 c) { >+ uchar3 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ return result; >+} >+uchar3 operator.zyy(uchar3 v) { >+ uchar3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+uchar3 operator.zyz(uchar3 v) { >+ uchar3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+uchar3 operator.zzx(uchar3 v) { >+ uchar3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+uchar3 operator.zzy(uchar3 v) { >+ uchar3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+uchar3 operator.zzz(uchar3 v) { >+ uchar3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+uchar3 operator.xxx(uchar4 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+uchar3 operator.xxy(uchar4 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+uchar3 operator.xxz(uchar4 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+uchar3 operator.xxw(uchar4 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+uchar3 operator.xyx(uchar4 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+uchar3 operator.xyy(uchar4 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+uchar3 operator.xyz(uchar4 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+uchar4 operator.xyz=(uchar4 v, uchar3 c) { >+ uchar4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ return result; >+} >+uchar3 operator.xyw(uchar4 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+uchar4 operator.xyw=(uchar4 v, uchar3 c) { >+ uchar4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ return result; >+} >+uchar3 operator.xzx(uchar4 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+uchar3 operator.xzy(uchar4 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+uchar4 operator.xzy=(uchar4 v, uchar3 c) { >+ uchar4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ return result; >+} >+uchar3 operator.xzz(uchar4 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+uchar3 operator.xzw(uchar4 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+uchar4 operator.xzw=(uchar4 v, uchar3 c) { >+ uchar4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ return result; >+} >+uchar3 operator.xwx(uchar4 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+uchar3 operator.xwy(uchar4 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+uchar4 operator.xwy=(uchar4 v, uchar3 c) { >+ uchar4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ return result; >+} >+uchar3 operator.xwz(uchar4 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+uchar4 operator.xwz=(uchar4 v, uchar3 c) { >+ uchar4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ return result; >+} >+uchar3 operator.xww(uchar4 v) { >+ uchar3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+uchar3 operator.yxx(uchar4 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+uchar3 operator.yxy(uchar4 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+uchar3 operator.yxz(uchar4 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+uchar4 operator.yxz=(uchar4 v, uchar3 c) { >+ uchar4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ return result; >+} >+uchar3 operator.yxw(uchar4 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+uchar4 operator.yxw=(uchar4 v, uchar3 c) { >+ uchar4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ return result; >+} >+uchar3 operator.yyx(uchar4 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+uchar3 operator.yyy(uchar4 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+uchar3 operator.yyz(uchar4 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+uchar3 operator.yyw(uchar4 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+uchar3 operator.yzx(uchar4 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+uchar4 operator.yzx=(uchar4 v, uchar3 c) { >+ uchar4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ return result; >+} >+uchar3 operator.yzy(uchar4 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+uchar3 operator.yzz(uchar4 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+uchar3 operator.yzw(uchar4 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+uchar4 operator.yzw=(uchar4 v, uchar3 c) { >+ uchar4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ return result; >+} >+uchar3 operator.ywx(uchar4 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+uchar4 operator.ywx=(uchar4 v, uchar3 c) { >+ uchar4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ return result; >+} >+uchar3 operator.ywy(uchar4 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+uchar3 operator.ywz(uchar4 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+uchar4 operator.ywz=(uchar4 v, uchar3 c) { >+ uchar4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ return result; >+} >+uchar3 operator.yww(uchar4 v) { >+ uchar3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+uchar3 operator.zxx(uchar4 v) { >+ uchar3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+uchar3 operator.zxy(uchar4 v) { >+ uchar3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+uchar4 operator.zxy=(uchar4 v, uchar3 c) { >+ uchar4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ return result; >+} >+uchar3 operator.zxz(uchar4 v) { >+ uchar3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+uchar3 operator.zxw(uchar4 v) { >+ uchar3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+uchar4 operator.zxw=(uchar4 v, uchar3 c) { >+ uchar4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ return result; >+} >+uchar3 operator.zyx(uchar4 v) { >+ uchar3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+uchar4 operator.zyx=(uchar4 v, uchar3 c) { >+ uchar4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ return result; >+} >+uchar3 operator.zyy(uchar4 v) { >+ uchar3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+uchar3 operator.zyz(uchar4 v) { >+ uchar3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+uchar3 operator.zyw(uchar4 v) { >+ uchar3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+uchar4 operator.zyw=(uchar4 v, uchar3 c) { >+ uchar4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ return result; >+} >+uchar3 operator.zzx(uchar4 v) { >+ uchar3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+uchar3 operator.zzy(uchar4 v) { >+ uchar3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+uchar3 operator.zzz(uchar4 v) { >+ uchar3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+uchar3 operator.zzw(uchar4 v) { >+ uchar3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+uchar3 operator.zwx(uchar4 v) { >+ uchar3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+uchar4 operator.zwx=(uchar4 v, uchar3 c) { >+ uchar4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ return result; >+} >+uchar3 operator.zwy(uchar4 v) { >+ uchar3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+uchar4 operator.zwy=(uchar4 v, uchar3 c) { >+ uchar4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ return result; >+} >+uchar3 operator.zwz(uchar4 v) { >+ uchar3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+uchar3 operator.zww(uchar4 v) { >+ uchar3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+uchar3 operator.wxx(uchar4 v) { >+ uchar3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+uchar3 operator.wxy(uchar4 v) { >+ uchar3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+uchar4 operator.wxy=(uchar4 v, uchar3 c) { >+ uchar4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ return result; >+} >+uchar3 operator.wxz(uchar4 v) { >+ uchar3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+uchar4 operator.wxz=(uchar4 v, uchar3 c) { >+ uchar4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ return result; >+} >+uchar3 operator.wxw(uchar4 v) { >+ uchar3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+uchar3 operator.wyx(uchar4 v) { >+ uchar3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+uchar4 operator.wyx=(uchar4 v, uchar3 c) { >+ uchar4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ return result; >+} >+uchar3 operator.wyy(uchar4 v) { >+ uchar3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+uchar3 operator.wyz(uchar4 v) { >+ uchar3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+uchar4 operator.wyz=(uchar4 v, uchar3 c) { >+ uchar4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ return result; >+} >+uchar3 operator.wyw(uchar4 v) { >+ uchar3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+uchar3 operator.wzx(uchar4 v) { >+ uchar3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+uchar4 operator.wzx=(uchar4 v, uchar3 c) { >+ uchar4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ return result; >+} >+uchar3 operator.wzy(uchar4 v) { >+ uchar3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+uchar4 operator.wzy=(uchar4 v, uchar3 c) { >+ uchar4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ return result; >+} >+uchar3 operator.wzz(uchar4 v) { >+ uchar3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+uchar3 operator.wzw(uchar4 v) { >+ uchar3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+uchar3 operator.wwx(uchar4 v) { >+ uchar3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+uchar3 operator.wwy(uchar4 v) { >+ uchar3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+uchar3 operator.wwz(uchar4 v) { >+ uchar3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+uchar3 operator.www(uchar4 v) { >+ uchar3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+uchar4 operator.xxxx(uchar2 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xxxy(uchar2 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xxyx(uchar2 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xxyy(uchar2 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xyxx(uchar2 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xyxy(uchar2 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xyyx(uchar2 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xyyy(uchar2 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.yxxx(uchar2 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.yxxy(uchar2 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.yxyx(uchar2 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.yxyy(uchar2 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.yyxx(uchar2 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.yyxy(uchar2 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.yyyx(uchar2 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.yyyy(uchar2 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xxxx(uchar3 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xxxy(uchar3 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xxxz(uchar3 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.xxyx(uchar3 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xxyy(uchar3 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xxyz(uchar3 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.xxzx(uchar3 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xxzy(uchar3 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xxzz(uchar3 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.xyxx(uchar3 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xyxy(uchar3 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xyxz(uchar3 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.xyyx(uchar3 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xyyy(uchar3 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xyyz(uchar3 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.xyzx(uchar3 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xyzy(uchar3 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xyzz(uchar3 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.xzxx(uchar3 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xzxy(uchar3 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xzxz(uchar3 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.xzyx(uchar3 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xzyy(uchar3 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xzyz(uchar3 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.xzzx(uchar3 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xzzy(uchar3 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xzzz(uchar3 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.yxxx(uchar3 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.yxxy(uchar3 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.yxxz(uchar3 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.yxyx(uchar3 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.yxyy(uchar3 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.yxyz(uchar3 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.yxzx(uchar3 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.yxzy(uchar3 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.yxzz(uchar3 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.yyxx(uchar3 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.yyxy(uchar3 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.yyxz(uchar3 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.yyyx(uchar3 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.yyyy(uchar3 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.yyyz(uchar3 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.yyzx(uchar3 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.yyzy(uchar3 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.yyzz(uchar3 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.yzxx(uchar3 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.yzxy(uchar3 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.yzxz(uchar3 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.yzyx(uchar3 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.yzyy(uchar3 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.yzyz(uchar3 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.yzzx(uchar3 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.yzzy(uchar3 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.yzzz(uchar3 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.zxxx(uchar3 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.zxxy(uchar3 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.zxxz(uchar3 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.zxyx(uchar3 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.zxyy(uchar3 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.zxyz(uchar3 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.zxzx(uchar3 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.zxzy(uchar3 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.zxzz(uchar3 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.zyxx(uchar3 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.zyxy(uchar3 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.zyxz(uchar3 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.zyyx(uchar3 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.zyyy(uchar3 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.zyyz(uchar3 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.zyzx(uchar3 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.zyzy(uchar3 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.zyzz(uchar3 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.zzxx(uchar3 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.zzxy(uchar3 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.zzxz(uchar3 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.zzyx(uchar3 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.zzyy(uchar3 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.zzyz(uchar3 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.zzzx(uchar3 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.zzzy(uchar3 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.zzzz(uchar3 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.xxxx(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xxxy(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xxxz(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.xxxw(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.xxyx(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xxyy(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xxyz(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.xxyw(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.xxzx(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xxzy(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xxzz(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.xxzw(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.xxwx(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xxwy(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xxwz(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.xxww(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.xyxx(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xyxy(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xyxz(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.xyxw(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.xyyx(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xyyy(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xyyz(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.xyyw(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.xyzx(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xyzy(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xyzz(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.xyzw(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.xyzw=(uchar4 v, uchar4 c) { >+ uchar4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ result.w = c.w; >+ return result; >+} >+uchar4 operator.xywx(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xywy(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xywz(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.xywz=(uchar4 v, uchar4 c) { >+ uchar4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ result.z = c.w; >+ return result; >+} >+uchar4 operator.xyww(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.xzxx(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xzxy(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xzxz(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.xzxw(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.xzyx(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xzyy(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xzyz(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.xzyw(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.xzyw=(uchar4 v, uchar4 c) { >+ uchar4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ result.w = c.w; >+ return result; >+} >+uchar4 operator.xzzx(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xzzy(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xzzz(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.xzzw(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.xzwx(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xzwy(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xzwy=(uchar4 v, uchar4 c) { >+ uchar4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ result.y = c.w; >+ return result; >+} >+uchar4 operator.xzwz(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.xzww(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.xwxx(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xwxy(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xwxz(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.xwxw(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.xwyx(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xwyy(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xwyz(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.xwyz=(uchar4 v, uchar4 c) { >+ uchar4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ result.z = c.w; >+ return result; >+} >+uchar4 operator.xwyw(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.xwzx(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xwzy(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xwzy=(uchar4 v, uchar4 c) { >+ uchar4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ result.y = c.w; >+ return result; >+} >+uchar4 operator.xwzz(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.xwzw(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.xwwx(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.xwwy(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.xwwz(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.xwww(uchar4 v) { >+ uchar4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.yxxx(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.yxxy(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.yxxz(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.yxxw(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.yxyx(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.yxyy(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.yxyz(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.yxyw(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.yxzx(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.yxzy(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.yxzz(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.yxzw(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.yxzw=(uchar4 v, uchar4 c) { >+ uchar4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ result.w = c.w; >+ return result; >+} >+uchar4 operator.yxwx(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.yxwy(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.yxwz(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.yxwz=(uchar4 v, uchar4 c) { >+ uchar4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ result.z = c.w; >+ return result; >+} >+uchar4 operator.yxww(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.yyxx(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.yyxy(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.yyxz(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.yyxw(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.yyyx(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.yyyy(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.yyyz(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.yyyw(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.yyzx(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.yyzy(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.yyzz(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.yyzw(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.yywx(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.yywy(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.yywz(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.yyww(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.yzxx(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.yzxy(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.yzxz(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.yzxw(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.yzxw=(uchar4 v, uchar4 c) { >+ uchar4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ result.w = c.w; >+ return result; >+} >+uchar4 operator.yzyx(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.yzyy(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.yzyz(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.yzyw(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.yzzx(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.yzzy(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.yzzz(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.yzzw(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.yzwx(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.yzwx=(uchar4 v, uchar4 c) { >+ uchar4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ result.x = c.w; >+ return result; >+} >+uchar4 operator.yzwy(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.yzwz(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.yzww(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.ywxx(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.ywxy(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.ywxz(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.ywxz=(uchar4 v, uchar4 c) { >+ uchar4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ result.z = c.w; >+ return result; >+} >+uchar4 operator.ywxw(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.ywyx(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.ywyy(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.ywyz(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.ywyw(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.ywzx(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.ywzx=(uchar4 v, uchar4 c) { >+ uchar4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ result.x = c.w; >+ return result; >+} >+uchar4 operator.ywzy(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.ywzz(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.ywzw(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.ywwx(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.ywwy(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.ywwz(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.ywww(uchar4 v) { >+ uchar4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.zxxx(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.zxxy(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.zxxz(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.zxxw(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.zxyx(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.zxyy(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.zxyz(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.zxyw(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.zxyw=(uchar4 v, uchar4 c) { >+ uchar4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ result.w = c.w; >+ return result; >+} >+uchar4 operator.zxzx(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.zxzy(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.zxzz(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.zxzw(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.zxwx(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.zxwy(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.zxwy=(uchar4 v, uchar4 c) { >+ uchar4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ result.y = c.w; >+ return result; >+} >+uchar4 operator.zxwz(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.zxww(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.zyxx(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.zyxy(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.zyxz(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.zyxw(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.zyxw=(uchar4 v, uchar4 c) { >+ uchar4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ result.w = c.w; >+ return result; >+} >+uchar4 operator.zyyx(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.zyyy(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.zyyz(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.zyyw(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.zyzx(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.zyzy(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.zyzz(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.zyzw(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.zywx(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.zywx=(uchar4 v, uchar4 c) { >+ uchar4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ result.x = c.w; >+ return result; >+} >+uchar4 operator.zywy(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.zywz(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.zyww(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.zzxx(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.zzxy(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.zzxz(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.zzxw(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.zzyx(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.zzyy(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.zzyz(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.zzyw(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.zzzx(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.zzzy(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.zzzz(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.zzzw(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.zzwx(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.zzwy(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.zzwz(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.zzww(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.zwxx(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.zwxy(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.zwxy=(uchar4 v, uchar4 c) { >+ uchar4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ result.y = c.w; >+ return result; >+} >+uchar4 operator.zwxz(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.zwxw(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.zwyx(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.zwyx=(uchar4 v, uchar4 c) { >+ uchar4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ result.x = c.w; >+ return result; >+} >+uchar4 operator.zwyy(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.zwyz(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.zwyw(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.zwzx(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.zwzy(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.zwzz(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.zwzw(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.zwwx(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.zwwy(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.zwwz(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.zwww(uchar4 v) { >+ uchar4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.wxxx(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.wxxy(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.wxxz(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.wxxw(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.wxyx(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.wxyy(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.wxyz(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.wxyz=(uchar4 v, uchar4 c) { >+ uchar4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ result.z = c.w; >+ return result; >+} >+uchar4 operator.wxyw(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.wxzx(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.wxzy(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.wxzy=(uchar4 v, uchar4 c) { >+ uchar4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ result.y = c.w; >+ return result; >+} >+uchar4 operator.wxzz(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.wxzw(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.wxwx(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.wxwy(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.wxwz(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.wxww(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.wyxx(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.wyxy(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.wyxz(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.wyxz=(uchar4 v, uchar4 c) { >+ uchar4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ result.z = c.w; >+ return result; >+} >+uchar4 operator.wyxw(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.wyyx(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.wyyy(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.wyyz(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.wyyw(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.wyzx(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.wyzx=(uchar4 v, uchar4 c) { >+ uchar4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ result.x = c.w; >+ return result; >+} >+uchar4 operator.wyzy(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.wyzz(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.wyzw(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.wywx(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.wywy(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.wywz(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.wyww(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.wzxx(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.wzxy(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.wzxy=(uchar4 v, uchar4 c) { >+ uchar4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ result.y = c.w; >+ return result; >+} >+uchar4 operator.wzxz(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.wzxw(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.wzyx(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.wzyx=(uchar4 v, uchar4 c) { >+ uchar4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ result.x = c.w; >+ return result; >+} >+uchar4 operator.wzyy(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.wzyz(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.wzyw(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.wzzx(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.wzzy(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.wzzz(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.wzzw(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.wzwx(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.wzwy(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.wzwz(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.wzww(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.wwxx(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.wwxy(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.wwxz(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.wwxw(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.wwyx(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.wwyy(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.wwyz(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.wwyw(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.wwzx(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.wwzy(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.wwzz(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.wwzw(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uchar4 operator.wwwx(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uchar4 operator.wwwy(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uchar4 operator.wwwz(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uchar4 operator.wwww(uchar4 v) { >+ uchar4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+ushort2 operator.xx(ushort2 v) { >+ ushort2 result; >+ result.x = v.x; >+ result.y = v.x; >+ return result; >+} >+ushort2 operator.xy(ushort2 v) { >+ ushort2 result; >+ result.x = v.x; >+ result.y = v.y; >+ return result; >+} >+ushort2 operator.xy=(ushort2 v, ushort2 c) { >+ ushort2 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ return result; >+} >+ushort2 operator.yx(ushort2 v) { >+ ushort2 result; >+ result.x = v.y; >+ result.y = v.x; >+ return result; >+} >+ushort2 operator.yx=(ushort2 v, ushort2 c) { >+ ushort2 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ return result; >+} >+ushort2 operator.yy(ushort2 v) { >+ ushort2 result; >+ result.x = v.y; >+ result.y = v.y; >+ return result; >+} >+ushort2 operator.xx(ushort3 v) { >+ ushort2 result; >+ result.x = v.x; >+ result.y = v.x; >+ return result; >+} >+ushort2 operator.xy(ushort3 v) { >+ ushort2 result; >+ result.x = v.x; >+ result.y = v.y; >+ return result; >+} >+ushort3 operator.xy=(ushort3 v, ushort2 c) { >+ ushort3 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ return result; >+} >+ushort2 operator.xz(ushort3 v) { >+ ushort2 result; >+ result.x = v.x; >+ result.y = v.z; >+ return result; >+} >+ushort3 operator.xz=(ushort3 v, ushort2 c) { >+ ushort3 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ return result; >+} >+ushort2 operator.yx(ushort3 v) { >+ ushort2 result; >+ result.x = v.y; >+ result.y = v.x; >+ return result; >+} >+ushort3 operator.yx=(ushort3 v, ushort2 c) { >+ ushort3 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ return result; >+} >+ushort2 operator.yy(ushort3 v) { >+ ushort2 result; >+ result.x = v.y; >+ result.y = v.y; >+ return result; >+} >+ushort2 operator.yz(ushort3 v) { >+ ushort2 result; >+ result.x = v.y; >+ result.y = v.z; >+ return result; >+} >+ushort3 operator.yz=(ushort3 v, ushort2 c) { >+ ushort3 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ return result; >+} >+ushort2 operator.zx(ushort3 v) { >+ ushort2 result; >+ result.x = v.z; >+ result.y = v.x; >+ return result; >+} >+ushort3 operator.zx=(ushort3 v, ushort2 c) { >+ ushort3 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ return result; >+} >+ushort2 operator.zy(ushort3 v) { >+ ushort2 result; >+ result.x = v.z; >+ result.y = v.y; >+ return result; >+} >+ushort3 operator.zy=(ushort3 v, ushort2 c) { >+ ushort3 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ return result; >+} >+ushort2 operator.zz(ushort3 v) { >+ ushort2 result; >+ result.x = v.z; >+ result.y = v.z; >+ return result; >+} >+ushort2 operator.xx(ushort4 v) { >+ ushort2 result; >+ result.x = v.x; >+ result.y = v.x; >+ return result; >+} >+ushort2 operator.xy(ushort4 v) { >+ ushort2 result; >+ result.x = v.x; >+ result.y = v.y; >+ return result; >+} >+ushort4 operator.xy=(ushort4 v, ushort2 c) { >+ ushort4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ return result; >+} >+ushort2 operator.xz(ushort4 v) { >+ ushort2 result; >+ result.x = v.x; >+ result.y = v.z; >+ return result; >+} >+ushort4 operator.xz=(ushort4 v, ushort2 c) { >+ ushort4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ return result; >+} >+ushort2 operator.xw(ushort4 v) { >+ ushort2 result; >+ result.x = v.x; >+ result.y = v.w; >+ return result; >+} >+ushort4 operator.xw=(ushort4 v, ushort2 c) { >+ ushort4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ return result; >+} >+ushort2 operator.yx(ushort4 v) { >+ ushort2 result; >+ result.x = v.y; >+ result.y = v.x; >+ return result; >+} >+ushort4 operator.yx=(ushort4 v, ushort2 c) { >+ ushort4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ return result; >+} >+ushort2 operator.yy(ushort4 v) { >+ ushort2 result; >+ result.x = v.y; >+ result.y = v.y; >+ return result; >+} >+ushort2 operator.yz(ushort4 v) { >+ ushort2 result; >+ result.x = v.y; >+ result.y = v.z; >+ return result; >+} >+ushort4 operator.yz=(ushort4 v, ushort2 c) { >+ ushort4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ return result; >+} >+ushort2 operator.yw(ushort4 v) { >+ ushort2 result; >+ result.x = v.y; >+ result.y = v.w; >+ return result; >+} >+ushort4 operator.yw=(ushort4 v, ushort2 c) { >+ ushort4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ return result; >+} >+ushort2 operator.zx(ushort4 v) { >+ ushort2 result; >+ result.x = v.z; >+ result.y = v.x; >+ return result; >+} >+ushort4 operator.zx=(ushort4 v, ushort2 c) { >+ ushort4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ return result; >+} >+ushort2 operator.zy(ushort4 v) { >+ ushort2 result; >+ result.x = v.z; >+ result.y = v.y; >+ return result; >+} >+ushort4 operator.zy=(ushort4 v, ushort2 c) { >+ ushort4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ return result; >+} >+ushort2 operator.zz(ushort4 v) { >+ ushort2 result; >+ result.x = v.z; >+ result.y = v.z; >+ return result; >+} >+ushort2 operator.zw(ushort4 v) { >+ ushort2 result; >+ result.x = v.z; >+ result.y = v.w; >+ return result; >+} >+ushort4 operator.zw=(ushort4 v, ushort2 c) { >+ ushort4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ return result; >+} >+ushort2 operator.wx(ushort4 v) { >+ ushort2 result; >+ result.x = v.w; >+ result.y = v.x; >+ return result; >+} >+ushort4 operator.wx=(ushort4 v, ushort2 c) { >+ ushort4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ return result; >+} >+ushort2 operator.wy(ushort4 v) { >+ ushort2 result; >+ result.x = v.w; >+ result.y = v.y; >+ return result; >+} >+ushort4 operator.wy=(ushort4 v, ushort2 c) { >+ ushort4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ return result; >+} >+ushort2 operator.wz(ushort4 v) { >+ ushort2 result; >+ result.x = v.w; >+ result.y = v.z; >+ return result; >+} >+ushort4 operator.wz=(ushort4 v, ushort2 c) { >+ ushort4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ return result; >+} >+ushort2 operator.ww(ushort4 v) { >+ ushort2 result; >+ result.x = v.w; >+ result.y = v.w; >+ return result; >+} >+ushort3 operator.xxx(ushort2 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+ushort3 operator.xxy(ushort2 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+ushort3 operator.xyx(ushort2 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+ushort3 operator.xyy(ushort2 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+ushort3 operator.yxx(ushort2 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+ushort3 operator.yxy(ushort2 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+ushort3 operator.yyx(ushort2 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+ushort3 operator.yyy(ushort2 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+ushort3 operator.xxx(ushort3 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+ushort3 operator.xxy(ushort3 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+ushort3 operator.xxz(ushort3 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+ushort3 operator.xyx(ushort3 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+ushort3 operator.xyy(ushort3 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+ushort3 operator.xyz(ushort3 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+ushort3 operator.xyz=(ushort3 v, ushort3 c) { >+ ushort3 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ return result; >+} >+ushort3 operator.xzx(ushort3 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+ushort3 operator.xzy(ushort3 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+ushort3 operator.xzy=(ushort3 v, ushort3 c) { >+ ushort3 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ return result; >+} >+ushort3 operator.xzz(ushort3 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+ushort3 operator.yxx(ushort3 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+ushort3 operator.yxy(ushort3 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+ushort3 operator.yxz(ushort3 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+ushort3 operator.yxz=(ushort3 v, ushort3 c) { >+ ushort3 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ return result; >+} >+ushort3 operator.yyx(ushort3 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+ushort3 operator.yyy(ushort3 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+ushort3 operator.yyz(ushort3 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+ushort3 operator.yzx(ushort3 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+ushort3 operator.yzx=(ushort3 v, ushort3 c) { >+ ushort3 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ return result; >+} >+ushort3 operator.yzy(ushort3 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+ushort3 operator.yzz(ushort3 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+ushort3 operator.zxx(ushort3 v) { >+ ushort3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+ushort3 operator.zxy(ushort3 v) { >+ ushort3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+ushort3 operator.zxy=(ushort3 v, ushort3 c) { >+ ushort3 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ return result; >+} >+ushort3 operator.zxz(ushort3 v) { >+ ushort3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+ushort3 operator.zyx(ushort3 v) { >+ ushort3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+ushort3 operator.zyx=(ushort3 v, ushort3 c) { >+ ushort3 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ return result; >+} >+ushort3 operator.zyy(ushort3 v) { >+ ushort3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+ushort3 operator.zyz(ushort3 v) { >+ ushort3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+ushort3 operator.zzx(ushort3 v) { >+ ushort3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+ushort3 operator.zzy(ushort3 v) { >+ ushort3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+ushort3 operator.zzz(ushort3 v) { >+ ushort3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+ushort3 operator.xxx(ushort4 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+ushort3 operator.xxy(ushort4 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+ushort3 operator.xxz(ushort4 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+ushort3 operator.xxw(ushort4 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+ushort3 operator.xyx(ushort4 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+ushort3 operator.xyy(ushort4 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+ushort3 operator.xyz(ushort4 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+ushort4 operator.xyz=(ushort4 v, ushort3 c) { >+ ushort4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ return result; >+} >+ushort3 operator.xyw(ushort4 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+ushort4 operator.xyw=(ushort4 v, ushort3 c) { >+ ushort4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ return result; >+} >+ushort3 operator.xzx(ushort4 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+ushort3 operator.xzy(ushort4 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+ushort4 operator.xzy=(ushort4 v, ushort3 c) { >+ ushort4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ return result; >+} >+ushort3 operator.xzz(ushort4 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+ushort3 operator.xzw(ushort4 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+ushort4 operator.xzw=(ushort4 v, ushort3 c) { >+ ushort4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ return result; >+} >+ushort3 operator.xwx(ushort4 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+ushort3 operator.xwy(ushort4 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+ushort4 operator.xwy=(ushort4 v, ushort3 c) { >+ ushort4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ return result; >+} >+ushort3 operator.xwz(ushort4 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+ushort4 operator.xwz=(ushort4 v, ushort3 c) { >+ ushort4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ return result; >+} >+ushort3 operator.xww(ushort4 v) { >+ ushort3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+ushort3 operator.yxx(ushort4 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+ushort3 operator.yxy(ushort4 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+ushort3 operator.yxz(ushort4 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+ushort4 operator.yxz=(ushort4 v, ushort3 c) { >+ ushort4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ return result; >+} >+ushort3 operator.yxw(ushort4 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+ushort4 operator.yxw=(ushort4 v, ushort3 c) { >+ ushort4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ return result; >+} >+ushort3 operator.yyx(ushort4 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+ushort3 operator.yyy(ushort4 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+ushort3 operator.yyz(ushort4 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+ushort3 operator.yyw(ushort4 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+ushort3 operator.yzx(ushort4 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+ushort4 operator.yzx=(ushort4 v, ushort3 c) { >+ ushort4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ return result; >+} >+ushort3 operator.yzy(ushort4 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+ushort3 operator.yzz(ushort4 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+ushort3 operator.yzw(ushort4 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+ushort4 operator.yzw=(ushort4 v, ushort3 c) { >+ ushort4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ return result; >+} >+ushort3 operator.ywx(ushort4 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+ushort4 operator.ywx=(ushort4 v, ushort3 c) { >+ ushort4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ return result; >+} >+ushort3 operator.ywy(ushort4 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+ushort3 operator.ywz(ushort4 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+ushort4 operator.ywz=(ushort4 v, ushort3 c) { >+ ushort4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ return result; >+} >+ushort3 operator.yww(ushort4 v) { >+ ushort3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+ushort3 operator.zxx(ushort4 v) { >+ ushort3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+ushort3 operator.zxy(ushort4 v) { >+ ushort3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+ushort4 operator.zxy=(ushort4 v, ushort3 c) { >+ ushort4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ return result; >+} >+ushort3 operator.zxz(ushort4 v) { >+ ushort3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+ushort3 operator.zxw(ushort4 v) { >+ ushort3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+ushort4 operator.zxw=(ushort4 v, ushort3 c) { >+ ushort4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ return result; >+} >+ushort3 operator.zyx(ushort4 v) { >+ ushort3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+ushort4 operator.zyx=(ushort4 v, ushort3 c) { >+ ushort4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ return result; >+} >+ushort3 operator.zyy(ushort4 v) { >+ ushort3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+ushort3 operator.zyz(ushort4 v) { >+ ushort3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+ushort3 operator.zyw(ushort4 v) { >+ ushort3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+ushort4 operator.zyw=(ushort4 v, ushort3 c) { >+ ushort4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ return result; >+} >+ushort3 operator.zzx(ushort4 v) { >+ ushort3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+ushort3 operator.zzy(ushort4 v) { >+ ushort3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+ushort3 operator.zzz(ushort4 v) { >+ ushort3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+ushort3 operator.zzw(ushort4 v) { >+ ushort3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+ushort3 operator.zwx(ushort4 v) { >+ ushort3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+ushort4 operator.zwx=(ushort4 v, ushort3 c) { >+ ushort4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ return result; >+} >+ushort3 operator.zwy(ushort4 v) { >+ ushort3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+ushort4 operator.zwy=(ushort4 v, ushort3 c) { >+ ushort4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ return result; >+} >+ushort3 operator.zwz(ushort4 v) { >+ ushort3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+ushort3 operator.zww(ushort4 v) { >+ ushort3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+ushort3 operator.wxx(ushort4 v) { >+ ushort3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+ushort3 operator.wxy(ushort4 v) { >+ ushort3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+ushort4 operator.wxy=(ushort4 v, ushort3 c) { >+ ushort4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ return result; >+} >+ushort3 operator.wxz(ushort4 v) { >+ ushort3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+ushort4 operator.wxz=(ushort4 v, ushort3 c) { >+ ushort4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ return result; >+} >+ushort3 operator.wxw(ushort4 v) { >+ ushort3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+ushort3 operator.wyx(ushort4 v) { >+ ushort3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+ushort4 operator.wyx=(ushort4 v, ushort3 c) { >+ ushort4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ return result; >+} >+ushort3 operator.wyy(ushort4 v) { >+ ushort3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+ushort3 operator.wyz(ushort4 v) { >+ ushort3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+ushort4 operator.wyz=(ushort4 v, ushort3 c) { >+ ushort4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ return result; >+} >+ushort3 operator.wyw(ushort4 v) { >+ ushort3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+ushort3 operator.wzx(ushort4 v) { >+ ushort3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+ushort4 operator.wzx=(ushort4 v, ushort3 c) { >+ ushort4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ return result; >+} >+ushort3 operator.wzy(ushort4 v) { >+ ushort3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+ushort4 operator.wzy=(ushort4 v, ushort3 c) { >+ ushort4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ return result; >+} >+ushort3 operator.wzz(ushort4 v) { >+ ushort3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+ushort3 operator.wzw(ushort4 v) { >+ ushort3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+ushort3 operator.wwx(ushort4 v) { >+ ushort3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+ushort3 operator.wwy(ushort4 v) { >+ ushort3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+ushort3 operator.wwz(ushort4 v) { >+ ushort3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+ushort3 operator.www(ushort4 v) { >+ ushort3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+ushort4 operator.xxxx(ushort2 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xxxy(ushort2 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xxyx(ushort2 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xxyy(ushort2 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xyxx(ushort2 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xyxy(ushort2 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xyyx(ushort2 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xyyy(ushort2 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.yxxx(ushort2 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.yxxy(ushort2 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.yxyx(ushort2 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.yxyy(ushort2 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.yyxx(ushort2 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.yyxy(ushort2 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.yyyx(ushort2 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.yyyy(ushort2 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xxxx(ushort3 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xxxy(ushort3 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xxxz(ushort3 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.xxyx(ushort3 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xxyy(ushort3 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xxyz(ushort3 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.xxzx(ushort3 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xxzy(ushort3 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xxzz(ushort3 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.xyxx(ushort3 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xyxy(ushort3 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xyxz(ushort3 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.xyyx(ushort3 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xyyy(ushort3 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xyyz(ushort3 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.xyzx(ushort3 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xyzy(ushort3 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xyzz(ushort3 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.xzxx(ushort3 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xzxy(ushort3 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xzxz(ushort3 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.xzyx(ushort3 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xzyy(ushort3 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xzyz(ushort3 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.xzzx(ushort3 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xzzy(ushort3 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xzzz(ushort3 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.yxxx(ushort3 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.yxxy(ushort3 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.yxxz(ushort3 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.yxyx(ushort3 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.yxyy(ushort3 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.yxyz(ushort3 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.yxzx(ushort3 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.yxzy(ushort3 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.yxzz(ushort3 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.yyxx(ushort3 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.yyxy(ushort3 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.yyxz(ushort3 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.yyyx(ushort3 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.yyyy(ushort3 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.yyyz(ushort3 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.yyzx(ushort3 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.yyzy(ushort3 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.yyzz(ushort3 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.yzxx(ushort3 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.yzxy(ushort3 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.yzxz(ushort3 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.yzyx(ushort3 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.yzyy(ushort3 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.yzyz(ushort3 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.yzzx(ushort3 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.yzzy(ushort3 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.yzzz(ushort3 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.zxxx(ushort3 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.zxxy(ushort3 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.zxxz(ushort3 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.zxyx(ushort3 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.zxyy(ushort3 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.zxyz(ushort3 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.zxzx(ushort3 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.zxzy(ushort3 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.zxzz(ushort3 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.zyxx(ushort3 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.zyxy(ushort3 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.zyxz(ushort3 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.zyyx(ushort3 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.zyyy(ushort3 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.zyyz(ushort3 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.zyzx(ushort3 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.zyzy(ushort3 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.zyzz(ushort3 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.zzxx(ushort3 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.zzxy(ushort3 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.zzxz(ushort3 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.zzyx(ushort3 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.zzyy(ushort3 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.zzyz(ushort3 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.zzzx(ushort3 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.zzzy(ushort3 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.zzzz(ushort3 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.xxxx(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xxxy(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xxxz(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.xxxw(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.xxyx(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xxyy(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xxyz(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.xxyw(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.xxzx(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xxzy(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xxzz(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.xxzw(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.xxwx(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xxwy(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xxwz(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.xxww(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.xyxx(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xyxy(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xyxz(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.xyxw(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.xyyx(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xyyy(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xyyz(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.xyyw(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.xyzx(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xyzy(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xyzz(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.xyzw(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.xyzw=(ushort4 v, ushort4 c) { >+ ushort4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ result.w = c.w; >+ return result; >+} >+ushort4 operator.xywx(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xywy(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xywz(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.xywz=(ushort4 v, ushort4 c) { >+ ushort4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ result.z = c.w; >+ return result; >+} >+ushort4 operator.xyww(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.xzxx(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xzxy(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xzxz(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.xzxw(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.xzyx(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xzyy(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xzyz(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.xzyw(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.xzyw=(ushort4 v, ushort4 c) { >+ ushort4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ result.w = c.w; >+ return result; >+} >+ushort4 operator.xzzx(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xzzy(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xzzz(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.xzzw(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.xzwx(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xzwy(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xzwy=(ushort4 v, ushort4 c) { >+ ushort4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ result.y = c.w; >+ return result; >+} >+ushort4 operator.xzwz(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.xzww(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.xwxx(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xwxy(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xwxz(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.xwxw(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.xwyx(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xwyy(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xwyz(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.xwyz=(ushort4 v, ushort4 c) { >+ ushort4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ result.z = c.w; >+ return result; >+} >+ushort4 operator.xwyw(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.xwzx(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xwzy(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xwzy=(ushort4 v, ushort4 c) { >+ ushort4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ result.y = c.w; >+ return result; >+} >+ushort4 operator.xwzz(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.xwzw(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.xwwx(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.xwwy(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.xwwz(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.xwww(ushort4 v) { >+ ushort4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.yxxx(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.yxxy(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.yxxz(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.yxxw(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.yxyx(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.yxyy(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.yxyz(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.yxyw(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.yxzx(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.yxzy(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.yxzz(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.yxzw(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.yxzw=(ushort4 v, ushort4 c) { >+ ushort4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ result.w = c.w; >+ return result; >+} >+ushort4 operator.yxwx(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.yxwy(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.yxwz(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.yxwz=(ushort4 v, ushort4 c) { >+ ushort4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ result.z = c.w; >+ return result; >+} >+ushort4 operator.yxww(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.yyxx(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.yyxy(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.yyxz(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.yyxw(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.yyyx(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.yyyy(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.yyyz(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.yyyw(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.yyzx(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.yyzy(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.yyzz(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.yyzw(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.yywx(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.yywy(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.yywz(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.yyww(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.yzxx(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.yzxy(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.yzxz(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.yzxw(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.yzxw=(ushort4 v, ushort4 c) { >+ ushort4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ result.w = c.w; >+ return result; >+} >+ushort4 operator.yzyx(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.yzyy(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.yzyz(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.yzyw(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.yzzx(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.yzzy(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.yzzz(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.yzzw(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.yzwx(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.yzwx=(ushort4 v, ushort4 c) { >+ ushort4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ result.x = c.w; >+ return result; >+} >+ushort4 operator.yzwy(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.yzwz(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.yzww(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.ywxx(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.ywxy(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.ywxz(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.ywxz=(ushort4 v, ushort4 c) { >+ ushort4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ result.z = c.w; >+ return result; >+} >+ushort4 operator.ywxw(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.ywyx(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.ywyy(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.ywyz(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.ywyw(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.ywzx(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.ywzx=(ushort4 v, ushort4 c) { >+ ushort4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ result.x = c.w; >+ return result; >+} >+ushort4 operator.ywzy(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.ywzz(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.ywzw(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.ywwx(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.ywwy(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.ywwz(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.ywww(ushort4 v) { >+ ushort4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.zxxx(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.zxxy(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.zxxz(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.zxxw(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.zxyx(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.zxyy(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.zxyz(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.zxyw(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.zxyw=(ushort4 v, ushort4 c) { >+ ushort4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ result.w = c.w; >+ return result; >+} >+ushort4 operator.zxzx(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.zxzy(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.zxzz(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.zxzw(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.zxwx(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.zxwy(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.zxwy=(ushort4 v, ushort4 c) { >+ ushort4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ result.y = c.w; >+ return result; >+} >+ushort4 operator.zxwz(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.zxww(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.zyxx(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.zyxy(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.zyxz(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.zyxw(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.zyxw=(ushort4 v, ushort4 c) { >+ ushort4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ result.w = c.w; >+ return result; >+} >+ushort4 operator.zyyx(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.zyyy(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.zyyz(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.zyyw(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.zyzx(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.zyzy(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.zyzz(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.zyzw(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.zywx(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.zywx=(ushort4 v, ushort4 c) { >+ ushort4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ result.x = c.w; >+ return result; >+} >+ushort4 operator.zywy(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.zywz(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.zyww(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.zzxx(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.zzxy(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.zzxz(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.zzxw(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.zzyx(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.zzyy(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.zzyz(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.zzyw(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.zzzx(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.zzzy(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.zzzz(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.zzzw(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.zzwx(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.zzwy(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.zzwz(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.zzww(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.zwxx(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.zwxy(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.zwxy=(ushort4 v, ushort4 c) { >+ ushort4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ result.y = c.w; >+ return result; >+} >+ushort4 operator.zwxz(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.zwxw(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.zwyx(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.zwyx=(ushort4 v, ushort4 c) { >+ ushort4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ result.x = c.w; >+ return result; >+} >+ushort4 operator.zwyy(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.zwyz(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.zwyw(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.zwzx(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.zwzy(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.zwzz(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.zwzw(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.zwwx(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.zwwy(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.zwwz(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.zwww(ushort4 v) { >+ ushort4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.wxxx(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.wxxy(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.wxxz(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.wxxw(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.wxyx(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.wxyy(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.wxyz(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.wxyz=(ushort4 v, ushort4 c) { >+ ushort4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ result.z = c.w; >+ return result; >+} >+ushort4 operator.wxyw(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.wxzx(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.wxzy(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.wxzy=(ushort4 v, ushort4 c) { >+ ushort4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ result.y = c.w; >+ return result; >+} >+ushort4 operator.wxzz(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.wxzw(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.wxwx(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.wxwy(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.wxwz(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.wxww(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.wyxx(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.wyxy(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.wyxz(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.wyxz=(ushort4 v, ushort4 c) { >+ ushort4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ result.z = c.w; >+ return result; >+} >+ushort4 operator.wyxw(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.wyyx(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.wyyy(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.wyyz(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.wyyw(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.wyzx(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.wyzx=(ushort4 v, ushort4 c) { >+ ushort4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ result.x = c.w; >+ return result; >+} >+ushort4 operator.wyzy(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.wyzz(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.wyzw(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.wywx(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.wywy(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.wywz(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.wyww(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.wzxx(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.wzxy(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.wzxy=(ushort4 v, ushort4 c) { >+ ushort4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ result.y = c.w; >+ return result; >+} >+ushort4 operator.wzxz(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.wzxw(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.wzyx(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.wzyx=(ushort4 v, ushort4 c) { >+ ushort4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ result.x = c.w; >+ return result; >+} >+ushort4 operator.wzyy(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.wzyz(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.wzyw(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.wzzx(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.wzzy(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.wzzz(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.wzzw(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.wzwx(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.wzwy(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.wzwz(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.wzww(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.wwxx(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.wwxy(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.wwxz(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.wwxw(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.wwyx(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.wwyy(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.wwyz(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.wwyw(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.wwzx(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.wwzy(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.wwzz(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.wwzw(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+ushort4 operator.wwwx(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+ushort4 operator.wwwy(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+ushort4 operator.wwwz(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+ushort4 operator.wwww(ushort4 v) { >+ ushort4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uint2 operator.xx(uint2 v) { >+ uint2 result; >+ result.x = v.x; >+ result.y = v.x; >+ return result; >+} >+uint2 operator.xy(uint2 v) { >+ uint2 result; >+ result.x = v.x; >+ result.y = v.y; >+ return result; >+} >+uint2 operator.xy=(uint2 v, uint2 c) { >+ uint2 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ return result; >+} >+uint2 operator.yx(uint2 v) { >+ uint2 result; >+ result.x = v.y; >+ result.y = v.x; >+ return result; >+} >+uint2 operator.yx=(uint2 v, uint2 c) { >+ uint2 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ return result; >+} >+uint2 operator.yy(uint2 v) { >+ uint2 result; >+ result.x = v.y; >+ result.y = v.y; >+ return result; >+} >+uint2 operator.xx(uint3 v) { >+ uint2 result; >+ result.x = v.x; >+ result.y = v.x; >+ return result; >+} >+uint2 operator.xy(uint3 v) { >+ uint2 result; >+ result.x = v.x; >+ result.y = v.y; >+ return result; >+} >+uint3 operator.xy=(uint3 v, uint2 c) { >+ uint3 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ return result; >+} >+uint2 operator.xz(uint3 v) { >+ uint2 result; >+ result.x = v.x; >+ result.y = v.z; >+ return result; >+} >+uint3 operator.xz=(uint3 v, uint2 c) { >+ uint3 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ return result; >+} >+uint2 operator.yx(uint3 v) { >+ uint2 result; >+ result.x = v.y; >+ result.y = v.x; >+ return result; >+} >+uint3 operator.yx=(uint3 v, uint2 c) { >+ uint3 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ return result; >+} >+uint2 operator.yy(uint3 v) { >+ uint2 result; >+ result.x = v.y; >+ result.y = v.y; >+ return result; >+} >+uint2 operator.yz(uint3 v) { >+ uint2 result; >+ result.x = v.y; >+ result.y = v.z; >+ return result; >+} >+uint3 operator.yz=(uint3 v, uint2 c) { >+ uint3 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ return result; >+} >+uint2 operator.zx(uint3 v) { >+ uint2 result; >+ result.x = v.z; >+ result.y = v.x; >+ return result; >+} >+uint3 operator.zx=(uint3 v, uint2 c) { >+ uint3 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ return result; >+} >+uint2 operator.zy(uint3 v) { >+ uint2 result; >+ result.x = v.z; >+ result.y = v.y; >+ return result; >+} >+uint3 operator.zy=(uint3 v, uint2 c) { >+ uint3 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ return result; >+} >+uint2 operator.zz(uint3 v) { >+ uint2 result; >+ result.x = v.z; >+ result.y = v.z; >+ return result; >+} >+uint2 operator.xx(uint4 v) { >+ uint2 result; >+ result.x = v.x; >+ result.y = v.x; >+ return result; >+} >+uint2 operator.xy(uint4 v) { >+ uint2 result; >+ result.x = v.x; >+ result.y = v.y; >+ return result; >+} >+uint4 operator.xy=(uint4 v, uint2 c) { >+ uint4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ return result; >+} >+uint2 operator.xz(uint4 v) { >+ uint2 result; >+ result.x = v.x; >+ result.y = v.z; >+ return result; >+} >+uint4 operator.xz=(uint4 v, uint2 c) { >+ uint4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ return result; >+} >+uint2 operator.xw(uint4 v) { >+ uint2 result; >+ result.x = v.x; >+ result.y = v.w; >+ return result; >+} >+uint4 operator.xw=(uint4 v, uint2 c) { >+ uint4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ return result; >+} >+uint2 operator.yx(uint4 v) { >+ uint2 result; >+ result.x = v.y; >+ result.y = v.x; >+ return result; >+} >+uint4 operator.yx=(uint4 v, uint2 c) { >+ uint4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ return result; >+} >+uint2 operator.yy(uint4 v) { >+ uint2 result; >+ result.x = v.y; >+ result.y = v.y; >+ return result; >+} >+uint2 operator.yz(uint4 v) { >+ uint2 result; >+ result.x = v.y; >+ result.y = v.z; >+ return result; >+} >+uint4 operator.yz=(uint4 v, uint2 c) { >+ uint4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ return result; >+} >+uint2 operator.yw(uint4 v) { >+ uint2 result; >+ result.x = v.y; >+ result.y = v.w; >+ return result; >+} >+uint4 operator.yw=(uint4 v, uint2 c) { >+ uint4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ return result; >+} >+uint2 operator.zx(uint4 v) { >+ uint2 result; >+ result.x = v.z; >+ result.y = v.x; >+ return result; >+} >+uint4 operator.zx=(uint4 v, uint2 c) { >+ uint4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ return result; >+} >+uint2 operator.zy(uint4 v) { >+ uint2 result; >+ result.x = v.z; >+ result.y = v.y; >+ return result; >+} >+uint4 operator.zy=(uint4 v, uint2 c) { >+ uint4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ return result; >+} >+uint2 operator.zz(uint4 v) { >+ uint2 result; >+ result.x = v.z; >+ result.y = v.z; >+ return result; >+} >+uint2 operator.zw(uint4 v) { >+ uint2 result; >+ result.x = v.z; >+ result.y = v.w; >+ return result; >+} >+uint4 operator.zw=(uint4 v, uint2 c) { >+ uint4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ return result; >+} >+uint2 operator.wx(uint4 v) { >+ uint2 result; >+ result.x = v.w; >+ result.y = v.x; >+ return result; >+} >+uint4 operator.wx=(uint4 v, uint2 c) { >+ uint4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ return result; >+} >+uint2 operator.wy(uint4 v) { >+ uint2 result; >+ result.x = v.w; >+ result.y = v.y; >+ return result; >+} >+uint4 operator.wy=(uint4 v, uint2 c) { >+ uint4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ return result; >+} >+uint2 operator.wz(uint4 v) { >+ uint2 result; >+ result.x = v.w; >+ result.y = v.z; >+ return result; >+} >+uint4 operator.wz=(uint4 v, uint2 c) { >+ uint4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ return result; >+} >+uint2 operator.ww(uint4 v) { >+ uint2 result; >+ result.x = v.w; >+ result.y = v.w; >+ return result; >+} >+uint3 operator.xxx(uint2 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+uint3 operator.xxy(uint2 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+uint3 operator.xyx(uint2 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+uint3 operator.xyy(uint2 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+uint3 operator.yxx(uint2 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+uint3 operator.yxy(uint2 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+uint3 operator.yyx(uint2 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+uint3 operator.yyy(uint2 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+uint3 operator.xxx(uint3 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+uint3 operator.xxy(uint3 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+uint3 operator.xxz(uint3 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+uint3 operator.xyx(uint3 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+uint3 operator.xyy(uint3 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+uint3 operator.xyz(uint3 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+uint3 operator.xyz=(uint3 v, uint3 c) { >+ uint3 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ return result; >+} >+uint3 operator.xzx(uint3 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+uint3 operator.xzy(uint3 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+uint3 operator.xzy=(uint3 v, uint3 c) { >+ uint3 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ return result; >+} >+uint3 operator.xzz(uint3 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+uint3 operator.yxx(uint3 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+uint3 operator.yxy(uint3 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+uint3 operator.yxz(uint3 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+uint3 operator.yxz=(uint3 v, uint3 c) { >+ uint3 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ return result; >+} >+uint3 operator.yyx(uint3 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+uint3 operator.yyy(uint3 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+uint3 operator.yyz(uint3 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+uint3 operator.yzx(uint3 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+uint3 operator.yzx=(uint3 v, uint3 c) { >+ uint3 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ return result; >+} >+uint3 operator.yzy(uint3 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+uint3 operator.yzz(uint3 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+uint3 operator.zxx(uint3 v) { >+ uint3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+uint3 operator.zxy(uint3 v) { >+ uint3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+uint3 operator.zxy=(uint3 v, uint3 c) { >+ uint3 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ return result; >+} >+uint3 operator.zxz(uint3 v) { >+ uint3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+uint3 operator.zyx(uint3 v) { >+ uint3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+uint3 operator.zyx=(uint3 v, uint3 c) { >+ uint3 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ return result; >+} >+uint3 operator.zyy(uint3 v) { >+ uint3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+uint3 operator.zyz(uint3 v) { >+ uint3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+uint3 operator.zzx(uint3 v) { >+ uint3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+uint3 operator.zzy(uint3 v) { >+ uint3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+uint3 operator.zzz(uint3 v) { >+ uint3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+uint3 operator.xxx(uint4 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+uint3 operator.xxy(uint4 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+uint3 operator.xxz(uint4 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+uint3 operator.xxw(uint4 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+uint3 operator.xyx(uint4 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+uint3 operator.xyy(uint4 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+uint3 operator.xyz(uint4 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+uint4 operator.xyz=(uint4 v, uint3 c) { >+ uint4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ return result; >+} >+uint3 operator.xyw(uint4 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+uint4 operator.xyw=(uint4 v, uint3 c) { >+ uint4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ return result; >+} >+uint3 operator.xzx(uint4 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+uint3 operator.xzy(uint4 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+uint4 operator.xzy=(uint4 v, uint3 c) { >+ uint4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ return result; >+} >+uint3 operator.xzz(uint4 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+uint3 operator.xzw(uint4 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+uint4 operator.xzw=(uint4 v, uint3 c) { >+ uint4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ return result; >+} >+uint3 operator.xwx(uint4 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+uint3 operator.xwy(uint4 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+uint4 operator.xwy=(uint4 v, uint3 c) { >+ uint4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ return result; >+} >+uint3 operator.xwz(uint4 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+uint4 operator.xwz=(uint4 v, uint3 c) { >+ uint4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ return result; >+} >+uint3 operator.xww(uint4 v) { >+ uint3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+uint3 operator.yxx(uint4 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+uint3 operator.yxy(uint4 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+uint3 operator.yxz(uint4 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+uint4 operator.yxz=(uint4 v, uint3 c) { >+ uint4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ return result; >+} >+uint3 operator.yxw(uint4 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+uint4 operator.yxw=(uint4 v, uint3 c) { >+ uint4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ return result; >+} >+uint3 operator.yyx(uint4 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+uint3 operator.yyy(uint4 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+uint3 operator.yyz(uint4 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+uint3 operator.yyw(uint4 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+uint3 operator.yzx(uint4 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+uint4 operator.yzx=(uint4 v, uint3 c) { >+ uint4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ return result; >+} >+uint3 operator.yzy(uint4 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+uint3 operator.yzz(uint4 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+uint3 operator.yzw(uint4 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+uint4 operator.yzw=(uint4 v, uint3 c) { >+ uint4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ return result; >+} >+uint3 operator.ywx(uint4 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+uint4 operator.ywx=(uint4 v, uint3 c) { >+ uint4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ return result; >+} >+uint3 operator.ywy(uint4 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+uint3 operator.ywz(uint4 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+uint4 operator.ywz=(uint4 v, uint3 c) { >+ uint4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ return result; >+} >+uint3 operator.yww(uint4 v) { >+ uint3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+uint3 operator.zxx(uint4 v) { >+ uint3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+uint3 operator.zxy(uint4 v) { >+ uint3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+uint4 operator.zxy=(uint4 v, uint3 c) { >+ uint4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ return result; >+} >+uint3 operator.zxz(uint4 v) { >+ uint3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+uint3 operator.zxw(uint4 v) { >+ uint3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+uint4 operator.zxw=(uint4 v, uint3 c) { >+ uint4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ return result; >+} >+uint3 operator.zyx(uint4 v) { >+ uint3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+uint4 operator.zyx=(uint4 v, uint3 c) { >+ uint4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ return result; >+} >+uint3 operator.zyy(uint4 v) { >+ uint3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+uint3 operator.zyz(uint4 v) { >+ uint3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+uint3 operator.zyw(uint4 v) { >+ uint3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+uint4 operator.zyw=(uint4 v, uint3 c) { >+ uint4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ return result; >+} >+uint3 operator.zzx(uint4 v) { >+ uint3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+uint3 operator.zzy(uint4 v) { >+ uint3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+uint3 operator.zzz(uint4 v) { >+ uint3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+uint3 operator.zzw(uint4 v) { >+ uint3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+uint3 operator.zwx(uint4 v) { >+ uint3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+uint4 operator.zwx=(uint4 v, uint3 c) { >+ uint4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ return result; >+} >+uint3 operator.zwy(uint4 v) { >+ uint3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+uint4 operator.zwy=(uint4 v, uint3 c) { >+ uint4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ return result; >+} >+uint3 operator.zwz(uint4 v) { >+ uint3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+uint3 operator.zww(uint4 v) { >+ uint3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+uint3 operator.wxx(uint4 v) { >+ uint3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+uint3 operator.wxy(uint4 v) { >+ uint3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+uint4 operator.wxy=(uint4 v, uint3 c) { >+ uint4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ return result; >+} >+uint3 operator.wxz(uint4 v) { >+ uint3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+uint4 operator.wxz=(uint4 v, uint3 c) { >+ uint4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ return result; >+} >+uint3 operator.wxw(uint4 v) { >+ uint3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+uint3 operator.wyx(uint4 v) { >+ uint3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+uint4 operator.wyx=(uint4 v, uint3 c) { >+ uint4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ return result; >+} >+uint3 operator.wyy(uint4 v) { >+ uint3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+uint3 operator.wyz(uint4 v) { >+ uint3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+uint4 operator.wyz=(uint4 v, uint3 c) { >+ uint4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ return result; >+} >+uint3 operator.wyw(uint4 v) { >+ uint3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+uint3 operator.wzx(uint4 v) { >+ uint3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+uint4 operator.wzx=(uint4 v, uint3 c) { >+ uint4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ return result; >+} >+uint3 operator.wzy(uint4 v) { >+ uint3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+uint4 operator.wzy=(uint4 v, uint3 c) { >+ uint4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ return result; >+} >+uint3 operator.wzz(uint4 v) { >+ uint3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+uint3 operator.wzw(uint4 v) { >+ uint3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+uint3 operator.wwx(uint4 v) { >+ uint3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+uint3 operator.wwy(uint4 v) { >+ uint3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+uint3 operator.wwz(uint4 v) { >+ uint3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+uint3 operator.www(uint4 v) { >+ uint3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+uint4 operator.xxxx(uint2 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xxxy(uint2 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xxyx(uint2 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xxyy(uint2 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xyxx(uint2 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xyxy(uint2 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xyyx(uint2 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xyyy(uint2 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.yxxx(uint2 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.yxxy(uint2 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.yxyx(uint2 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.yxyy(uint2 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.yyxx(uint2 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.yyxy(uint2 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.yyyx(uint2 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.yyyy(uint2 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xxxx(uint3 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xxxy(uint3 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xxxz(uint3 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.xxyx(uint3 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xxyy(uint3 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xxyz(uint3 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.xxzx(uint3 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xxzy(uint3 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xxzz(uint3 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.xyxx(uint3 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xyxy(uint3 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xyxz(uint3 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.xyyx(uint3 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xyyy(uint3 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xyyz(uint3 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.xyzx(uint3 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xyzy(uint3 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xyzz(uint3 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.xzxx(uint3 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xzxy(uint3 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xzxz(uint3 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.xzyx(uint3 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xzyy(uint3 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xzyz(uint3 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.xzzx(uint3 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xzzy(uint3 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xzzz(uint3 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.yxxx(uint3 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.yxxy(uint3 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.yxxz(uint3 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.yxyx(uint3 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.yxyy(uint3 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.yxyz(uint3 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.yxzx(uint3 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.yxzy(uint3 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.yxzz(uint3 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.yyxx(uint3 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.yyxy(uint3 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.yyxz(uint3 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.yyyx(uint3 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.yyyy(uint3 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.yyyz(uint3 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.yyzx(uint3 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.yyzy(uint3 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.yyzz(uint3 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.yzxx(uint3 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.yzxy(uint3 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.yzxz(uint3 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.yzyx(uint3 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.yzyy(uint3 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.yzyz(uint3 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.yzzx(uint3 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.yzzy(uint3 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.yzzz(uint3 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.zxxx(uint3 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.zxxy(uint3 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.zxxz(uint3 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.zxyx(uint3 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.zxyy(uint3 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.zxyz(uint3 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.zxzx(uint3 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.zxzy(uint3 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.zxzz(uint3 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.zyxx(uint3 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.zyxy(uint3 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.zyxz(uint3 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.zyyx(uint3 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.zyyy(uint3 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.zyyz(uint3 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.zyzx(uint3 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.zyzy(uint3 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.zyzz(uint3 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.zzxx(uint3 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.zzxy(uint3 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.zzxz(uint3 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.zzyx(uint3 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.zzyy(uint3 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.zzyz(uint3 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.zzzx(uint3 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.zzzy(uint3 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.zzzz(uint3 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.xxxx(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xxxy(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xxxz(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.xxxw(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.xxyx(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xxyy(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xxyz(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.xxyw(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.xxzx(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xxzy(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xxzz(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.xxzw(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.xxwx(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xxwy(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xxwz(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.xxww(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.xyxx(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xyxy(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xyxz(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.xyxw(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.xyyx(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xyyy(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xyyz(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.xyyw(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.xyzx(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xyzy(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xyzz(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.xyzw(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.xyzw=(uint4 v, uint4 c) { >+ uint4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ result.w = c.w; >+ return result; >+} >+uint4 operator.xywx(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xywy(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xywz(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.xywz=(uint4 v, uint4 c) { >+ uint4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ result.z = c.w; >+ return result; >+} >+uint4 operator.xyww(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.xzxx(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xzxy(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xzxz(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.xzxw(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.xzyx(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xzyy(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xzyz(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.xzyw(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.xzyw=(uint4 v, uint4 c) { >+ uint4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ result.w = c.w; >+ return result; >+} >+uint4 operator.xzzx(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xzzy(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xzzz(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.xzzw(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.xzwx(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xzwy(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xzwy=(uint4 v, uint4 c) { >+ uint4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ result.y = c.w; >+ return result; >+} >+uint4 operator.xzwz(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.xzww(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.xwxx(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xwxy(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xwxz(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.xwxw(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.xwyx(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xwyy(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xwyz(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.xwyz=(uint4 v, uint4 c) { >+ uint4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ result.z = c.w; >+ return result; >+} >+uint4 operator.xwyw(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.xwzx(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xwzy(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xwzy=(uint4 v, uint4 c) { >+ uint4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ result.y = c.w; >+ return result; >+} >+uint4 operator.xwzz(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.xwzw(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.xwwx(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.xwwy(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.xwwz(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.xwww(uint4 v) { >+ uint4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.yxxx(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.yxxy(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.yxxz(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.yxxw(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.yxyx(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.yxyy(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.yxyz(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.yxyw(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.yxzx(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.yxzy(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.yxzz(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.yxzw(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.yxzw=(uint4 v, uint4 c) { >+ uint4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ result.w = c.w; >+ return result; >+} >+uint4 operator.yxwx(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.yxwy(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.yxwz(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.yxwz=(uint4 v, uint4 c) { >+ uint4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ result.z = c.w; >+ return result; >+} >+uint4 operator.yxww(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.yyxx(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.yyxy(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.yyxz(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.yyxw(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.yyyx(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.yyyy(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.yyyz(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.yyyw(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.yyzx(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.yyzy(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.yyzz(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.yyzw(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.yywx(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.yywy(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.yywz(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.yyww(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.yzxx(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.yzxy(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.yzxz(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.yzxw(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.yzxw=(uint4 v, uint4 c) { >+ uint4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ result.w = c.w; >+ return result; >+} >+uint4 operator.yzyx(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.yzyy(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.yzyz(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.yzyw(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.yzzx(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.yzzy(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.yzzz(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.yzzw(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.yzwx(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.yzwx=(uint4 v, uint4 c) { >+ uint4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ result.x = c.w; >+ return result; >+} >+uint4 operator.yzwy(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.yzwz(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.yzww(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.ywxx(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.ywxy(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.ywxz(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.ywxz=(uint4 v, uint4 c) { >+ uint4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ result.z = c.w; >+ return result; >+} >+uint4 operator.ywxw(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.ywyx(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.ywyy(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.ywyz(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.ywyw(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.ywzx(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.ywzx=(uint4 v, uint4 c) { >+ uint4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ result.x = c.w; >+ return result; >+} >+uint4 operator.ywzy(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.ywzz(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.ywzw(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.ywwx(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.ywwy(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.ywwz(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.ywww(uint4 v) { >+ uint4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.zxxx(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.zxxy(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.zxxz(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.zxxw(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.zxyx(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.zxyy(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.zxyz(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.zxyw(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.zxyw=(uint4 v, uint4 c) { >+ uint4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ result.w = c.w; >+ return result; >+} >+uint4 operator.zxzx(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.zxzy(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.zxzz(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.zxzw(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.zxwx(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.zxwy(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.zxwy=(uint4 v, uint4 c) { >+ uint4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ result.y = c.w; >+ return result; >+} >+uint4 operator.zxwz(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.zxww(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.zyxx(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.zyxy(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.zyxz(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.zyxw(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.zyxw=(uint4 v, uint4 c) { >+ uint4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ result.w = c.w; >+ return result; >+} >+uint4 operator.zyyx(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.zyyy(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.zyyz(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.zyyw(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.zyzx(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.zyzy(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.zyzz(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.zyzw(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.zywx(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.zywx=(uint4 v, uint4 c) { >+ uint4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ result.x = c.w; >+ return result; >+} >+uint4 operator.zywy(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.zywz(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.zyww(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.zzxx(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.zzxy(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.zzxz(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.zzxw(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.zzyx(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.zzyy(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.zzyz(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.zzyw(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.zzzx(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.zzzy(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.zzzz(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.zzzw(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.zzwx(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.zzwy(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.zzwz(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.zzww(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.zwxx(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.zwxy(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.zwxy=(uint4 v, uint4 c) { >+ uint4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ result.y = c.w; >+ return result; >+} >+uint4 operator.zwxz(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.zwxw(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.zwyx(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.zwyx=(uint4 v, uint4 c) { >+ uint4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ result.x = c.w; >+ return result; >+} >+uint4 operator.zwyy(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.zwyz(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.zwyw(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.zwzx(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.zwzy(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.zwzz(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.zwzw(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.zwwx(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.zwwy(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.zwwz(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.zwww(uint4 v) { >+ uint4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.wxxx(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.wxxy(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.wxxz(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.wxxw(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.wxyx(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.wxyy(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.wxyz(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.wxyz=(uint4 v, uint4 c) { >+ uint4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ result.z = c.w; >+ return result; >+} >+uint4 operator.wxyw(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.wxzx(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.wxzy(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.wxzy=(uint4 v, uint4 c) { >+ uint4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ result.y = c.w; >+ return result; >+} >+uint4 operator.wxzz(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.wxzw(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.wxwx(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.wxwy(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.wxwz(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.wxww(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.wyxx(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.wyxy(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.wyxz(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.wyxz=(uint4 v, uint4 c) { >+ uint4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ result.z = c.w; >+ return result; >+} >+uint4 operator.wyxw(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.wyyx(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.wyyy(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.wyyz(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.wyyw(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.wyzx(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.wyzx=(uint4 v, uint4 c) { >+ uint4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ result.x = c.w; >+ return result; >+} >+uint4 operator.wyzy(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.wyzz(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.wyzw(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.wywx(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.wywy(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.wywz(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.wyww(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.wzxx(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.wzxy(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.wzxy=(uint4 v, uint4 c) { >+ uint4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ result.y = c.w; >+ return result; >+} >+uint4 operator.wzxz(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.wzxw(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.wzyx(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.wzyx=(uint4 v, uint4 c) { >+ uint4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ result.x = c.w; >+ return result; >+} >+uint4 operator.wzyy(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.wzyz(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.wzyw(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.wzzx(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.wzzy(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.wzzz(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.wzzw(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.wzwx(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.wzwy(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.wzwz(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.wzww(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.wwxx(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.wwxy(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.wwxz(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.wwxw(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.wwyx(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.wwyy(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.wwyz(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.wwyw(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.wwzx(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.wwzy(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.wwzz(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.wwzw(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+uint4 operator.wwwx(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+uint4 operator.wwwy(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+uint4 operator.wwwz(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+uint4 operator.wwww(uint4 v) { >+ uint4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+char2 operator.xx(char2 v) { >+ char2 result; >+ result.x = v.x; >+ result.y = v.x; >+ return result; >+} >+char2 operator.xy(char2 v) { >+ char2 result; >+ result.x = v.x; >+ result.y = v.y; >+ return result; >+} >+char2 operator.xy=(char2 v, char2 c) { >+ char2 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ return result; >+} >+char2 operator.yx(char2 v) { >+ char2 result; >+ result.x = v.y; >+ result.y = v.x; >+ return result; >+} >+char2 operator.yx=(char2 v, char2 c) { >+ char2 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ return result; >+} >+char2 operator.yy(char2 v) { >+ char2 result; >+ result.x = v.y; >+ result.y = v.y; >+ return result; >+} >+char2 operator.xx(char3 v) { >+ char2 result; >+ result.x = v.x; >+ result.y = v.x; >+ return result; >+} >+char2 operator.xy(char3 v) { >+ char2 result; >+ result.x = v.x; >+ result.y = v.y; >+ return result; >+} >+char3 operator.xy=(char3 v, char2 c) { >+ char3 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ return result; >+} >+char2 operator.xz(char3 v) { >+ char2 result; >+ result.x = v.x; >+ result.y = v.z; >+ return result; >+} >+char3 operator.xz=(char3 v, char2 c) { >+ char3 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ return result; >+} >+char2 operator.yx(char3 v) { >+ char2 result; >+ result.x = v.y; >+ result.y = v.x; >+ return result; >+} >+char3 operator.yx=(char3 v, char2 c) { >+ char3 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ return result; >+} >+char2 operator.yy(char3 v) { >+ char2 result; >+ result.x = v.y; >+ result.y = v.y; >+ return result; >+} >+char2 operator.yz(char3 v) { >+ char2 result; >+ result.x = v.y; >+ result.y = v.z; >+ return result; >+} >+char3 operator.yz=(char3 v, char2 c) { >+ char3 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ return result; >+} >+char2 operator.zx(char3 v) { >+ char2 result; >+ result.x = v.z; >+ result.y = v.x; >+ return result; >+} >+char3 operator.zx=(char3 v, char2 c) { >+ char3 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ return result; >+} >+char2 operator.zy(char3 v) { >+ char2 result; >+ result.x = v.z; >+ result.y = v.y; >+ return result; >+} >+char3 operator.zy=(char3 v, char2 c) { >+ char3 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ return result; >+} >+char2 operator.zz(char3 v) { >+ char2 result; >+ result.x = v.z; >+ result.y = v.z; >+ return result; >+} >+char2 operator.xx(char4 v) { >+ char2 result; >+ result.x = v.x; >+ result.y = v.x; >+ return result; >+} >+char2 operator.xy(char4 v) { >+ char2 result; >+ result.x = v.x; >+ result.y = v.y; >+ return result; >+} >+char4 operator.xy=(char4 v, char2 c) { >+ char4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ return result; >+} >+char2 operator.xz(char4 v) { >+ char2 result; >+ result.x = v.x; >+ result.y = v.z; >+ return result; >+} >+char4 operator.xz=(char4 v, char2 c) { >+ char4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ return result; >+} >+char2 operator.xw(char4 v) { >+ char2 result; >+ result.x = v.x; >+ result.y = v.w; >+ return result; >+} >+char4 operator.xw=(char4 v, char2 c) { >+ char4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ return result; >+} >+char2 operator.yx(char4 v) { >+ char2 result; >+ result.x = v.y; >+ result.y = v.x; >+ return result; >+} >+char4 operator.yx=(char4 v, char2 c) { >+ char4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ return result; >+} >+char2 operator.yy(char4 v) { >+ char2 result; >+ result.x = v.y; >+ result.y = v.y; >+ return result; >+} >+char2 operator.yz(char4 v) { >+ char2 result; >+ result.x = v.y; >+ result.y = v.z; >+ return result; >+} >+char4 operator.yz=(char4 v, char2 c) { >+ char4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ return result; >+} >+char2 operator.yw(char4 v) { >+ char2 result; >+ result.x = v.y; >+ result.y = v.w; >+ return result; >+} >+char4 operator.yw=(char4 v, char2 c) { >+ char4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ return result; >+} >+char2 operator.zx(char4 v) { >+ char2 result; >+ result.x = v.z; >+ result.y = v.x; >+ return result; >+} >+char4 operator.zx=(char4 v, char2 c) { >+ char4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ return result; >+} >+char2 operator.zy(char4 v) { >+ char2 result; >+ result.x = v.z; >+ result.y = v.y; >+ return result; >+} >+char4 operator.zy=(char4 v, char2 c) { >+ char4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ return result; >+} >+char2 operator.zz(char4 v) { >+ char2 result; >+ result.x = v.z; >+ result.y = v.z; >+ return result; >+} >+char2 operator.zw(char4 v) { >+ char2 result; >+ result.x = v.z; >+ result.y = v.w; >+ return result; >+} >+char4 operator.zw=(char4 v, char2 c) { >+ char4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ return result; >+} >+char2 operator.wx(char4 v) { >+ char2 result; >+ result.x = v.w; >+ result.y = v.x; >+ return result; >+} >+char4 operator.wx=(char4 v, char2 c) { >+ char4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ return result; >+} >+char2 operator.wy(char4 v) { >+ char2 result; >+ result.x = v.w; >+ result.y = v.y; >+ return result; >+} >+char4 operator.wy=(char4 v, char2 c) { >+ char4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ return result; >+} >+char2 operator.wz(char4 v) { >+ char2 result; >+ result.x = v.w; >+ result.y = v.z; >+ return result; >+} >+char4 operator.wz=(char4 v, char2 c) { >+ char4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ return result; >+} >+char2 operator.ww(char4 v) { >+ char2 result; >+ result.x = v.w; >+ result.y = v.w; >+ return result; >+} >+char3 operator.xxx(char2 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+char3 operator.xxy(char2 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+char3 operator.xyx(char2 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+char3 operator.xyy(char2 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+char3 operator.yxx(char2 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+char3 operator.yxy(char2 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+char3 operator.yyx(char2 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+char3 operator.yyy(char2 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+char3 operator.xxx(char3 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+char3 operator.xxy(char3 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+char3 operator.xxz(char3 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+char3 operator.xyx(char3 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+char3 operator.xyy(char3 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+char3 operator.xyz(char3 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+char3 operator.xyz=(char3 v, char3 c) { >+ char3 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ return result; >+} >+char3 operator.xzx(char3 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+char3 operator.xzy(char3 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+char3 operator.xzy=(char3 v, char3 c) { >+ char3 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ return result; >+} >+char3 operator.xzz(char3 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+char3 operator.yxx(char3 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+char3 operator.yxy(char3 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+char3 operator.yxz(char3 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+char3 operator.yxz=(char3 v, char3 c) { >+ char3 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ return result; >+} >+char3 operator.yyx(char3 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+char3 operator.yyy(char3 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+char3 operator.yyz(char3 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+char3 operator.yzx(char3 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+char3 operator.yzx=(char3 v, char3 c) { >+ char3 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ return result; >+} >+char3 operator.yzy(char3 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+char3 operator.yzz(char3 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+char3 operator.zxx(char3 v) { >+ char3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+char3 operator.zxy(char3 v) { >+ char3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+char3 operator.zxy=(char3 v, char3 c) { >+ char3 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ return result; >+} >+char3 operator.zxz(char3 v) { >+ char3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+char3 operator.zyx(char3 v) { >+ char3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+char3 operator.zyx=(char3 v, char3 c) { >+ char3 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ return result; >+} >+char3 operator.zyy(char3 v) { >+ char3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+char3 operator.zyz(char3 v) { >+ char3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+char3 operator.zzx(char3 v) { >+ char3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+char3 operator.zzy(char3 v) { >+ char3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+char3 operator.zzz(char3 v) { >+ char3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+char3 operator.xxx(char4 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+char3 operator.xxy(char4 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+char3 operator.xxz(char4 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+char3 operator.xxw(char4 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+char3 operator.xyx(char4 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+char3 operator.xyy(char4 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+char3 operator.xyz(char4 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+char4 operator.xyz=(char4 v, char3 c) { >+ char4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ return result; >+} >+char3 operator.xyw(char4 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+char4 operator.xyw=(char4 v, char3 c) { >+ char4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ return result; >+} >+char3 operator.xzx(char4 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+char3 operator.xzy(char4 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+char4 operator.xzy=(char4 v, char3 c) { >+ char4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ return result; >+} >+char3 operator.xzz(char4 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+char3 operator.xzw(char4 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+char4 operator.xzw=(char4 v, char3 c) { >+ char4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ return result; >+} >+char3 operator.xwx(char4 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+char3 operator.xwy(char4 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+char4 operator.xwy=(char4 v, char3 c) { >+ char4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ return result; >+} >+char3 operator.xwz(char4 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+char4 operator.xwz=(char4 v, char3 c) { >+ char4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ return result; >+} >+char3 operator.xww(char4 v) { >+ char3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+char3 operator.yxx(char4 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+char3 operator.yxy(char4 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+char3 operator.yxz(char4 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+char4 operator.yxz=(char4 v, char3 c) { >+ char4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ return result; >+} >+char3 operator.yxw(char4 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+char4 operator.yxw=(char4 v, char3 c) { >+ char4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ return result; >+} >+char3 operator.yyx(char4 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+char3 operator.yyy(char4 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+char3 operator.yyz(char4 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+char3 operator.yyw(char4 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+char3 operator.yzx(char4 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+char4 operator.yzx=(char4 v, char3 c) { >+ char4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ return result; >+} >+char3 operator.yzy(char4 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+char3 operator.yzz(char4 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+char3 operator.yzw(char4 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+char4 operator.yzw=(char4 v, char3 c) { >+ char4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ return result; >+} >+char3 operator.ywx(char4 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+char4 operator.ywx=(char4 v, char3 c) { >+ char4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ return result; >+} >+char3 operator.ywy(char4 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+char3 operator.ywz(char4 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+char4 operator.ywz=(char4 v, char3 c) { >+ char4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ return result; >+} >+char3 operator.yww(char4 v) { >+ char3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+char3 operator.zxx(char4 v) { >+ char3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+char3 operator.zxy(char4 v) { >+ char3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+char4 operator.zxy=(char4 v, char3 c) { >+ char4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ return result; >+} >+char3 operator.zxz(char4 v) { >+ char3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+char3 operator.zxw(char4 v) { >+ char3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+char4 operator.zxw=(char4 v, char3 c) { >+ char4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ return result; >+} >+char3 operator.zyx(char4 v) { >+ char3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+char4 operator.zyx=(char4 v, char3 c) { >+ char4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ return result; >+} >+char3 operator.zyy(char4 v) { >+ char3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+char3 operator.zyz(char4 v) { >+ char3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+char3 operator.zyw(char4 v) { >+ char3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+char4 operator.zyw=(char4 v, char3 c) { >+ char4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ return result; >+} >+char3 operator.zzx(char4 v) { >+ char3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+char3 operator.zzy(char4 v) { >+ char3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+char3 operator.zzz(char4 v) { >+ char3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+char3 operator.zzw(char4 v) { >+ char3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+char3 operator.zwx(char4 v) { >+ char3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+char4 operator.zwx=(char4 v, char3 c) { >+ char4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ return result; >+} >+char3 operator.zwy(char4 v) { >+ char3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+char4 operator.zwy=(char4 v, char3 c) { >+ char4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ return result; >+} >+char3 operator.zwz(char4 v) { >+ char3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+char3 operator.zww(char4 v) { >+ char3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+char3 operator.wxx(char4 v) { >+ char3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+char3 operator.wxy(char4 v) { >+ char3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+char4 operator.wxy=(char4 v, char3 c) { >+ char4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ return result; >+} >+char3 operator.wxz(char4 v) { >+ char3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+char4 operator.wxz=(char4 v, char3 c) { >+ char4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ return result; >+} >+char3 operator.wxw(char4 v) { >+ char3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+char3 operator.wyx(char4 v) { >+ char3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+char4 operator.wyx=(char4 v, char3 c) { >+ char4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ return result; >+} >+char3 operator.wyy(char4 v) { >+ char3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+char3 operator.wyz(char4 v) { >+ char3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+char4 operator.wyz=(char4 v, char3 c) { >+ char4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ return result; >+} >+char3 operator.wyw(char4 v) { >+ char3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+char3 operator.wzx(char4 v) { >+ char3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+char4 operator.wzx=(char4 v, char3 c) { >+ char4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ return result; >+} >+char3 operator.wzy(char4 v) { >+ char3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+char4 operator.wzy=(char4 v, char3 c) { >+ char4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ return result; >+} >+char3 operator.wzz(char4 v) { >+ char3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+char3 operator.wzw(char4 v) { >+ char3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+char3 operator.wwx(char4 v) { >+ char3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+char3 operator.wwy(char4 v) { >+ char3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+char3 operator.wwz(char4 v) { >+ char3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+char3 operator.www(char4 v) { >+ char3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+char4 operator.xxxx(char2 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xxxy(char2 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xxyx(char2 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xxyy(char2 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xyxx(char2 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xyxy(char2 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xyyx(char2 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xyyy(char2 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.yxxx(char2 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.yxxy(char2 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.yxyx(char2 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.yxyy(char2 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.yyxx(char2 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.yyxy(char2 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.yyyx(char2 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.yyyy(char2 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xxxx(char3 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xxxy(char3 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xxxz(char3 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+char4 operator.xxyx(char3 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xxyy(char3 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xxyz(char3 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+char4 operator.xxzx(char3 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xxzy(char3 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xxzz(char3 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+char4 operator.xyxx(char3 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xyxy(char3 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xyxz(char3 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+char4 operator.xyyx(char3 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xyyy(char3 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xyyz(char3 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+char4 operator.xyzx(char3 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xyzy(char3 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xyzz(char3 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+char4 operator.xzxx(char3 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xzxy(char3 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xzxz(char3 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+char4 operator.xzyx(char3 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xzyy(char3 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xzyz(char3 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+char4 operator.xzzx(char3 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xzzy(char3 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xzzz(char3 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+char4 operator.yxxx(char3 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.yxxy(char3 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.yxxz(char3 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+char4 operator.yxyx(char3 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.yxyy(char3 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.yxyz(char3 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+char4 operator.yxzx(char3 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+char4 operator.yxzy(char3 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+char4 operator.yxzz(char3 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+char4 operator.yyxx(char3 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.yyxy(char3 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.yyxz(char3 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+char4 operator.yyyx(char3 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.yyyy(char3 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.yyyz(char3 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+char4 operator.yyzx(char3 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+char4 operator.yyzy(char3 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+char4 operator.yyzz(char3 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+char4 operator.yzxx(char3 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.yzxy(char3 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.yzxz(char3 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+char4 operator.yzyx(char3 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.yzyy(char3 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.yzyz(char3 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+char4 operator.yzzx(char3 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+char4 operator.yzzy(char3 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+char4 operator.yzzz(char3 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+char4 operator.zxxx(char3 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.zxxy(char3 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.zxxz(char3 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+char4 operator.zxyx(char3 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.zxyy(char3 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.zxyz(char3 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+char4 operator.zxzx(char3 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+char4 operator.zxzy(char3 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+char4 operator.zxzz(char3 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+char4 operator.zyxx(char3 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.zyxy(char3 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.zyxz(char3 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+char4 operator.zyyx(char3 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.zyyy(char3 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.zyyz(char3 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+char4 operator.zyzx(char3 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+char4 operator.zyzy(char3 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+char4 operator.zyzz(char3 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+char4 operator.zzxx(char3 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.zzxy(char3 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.zzxz(char3 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+char4 operator.zzyx(char3 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.zzyy(char3 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.zzyz(char3 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+char4 operator.zzzx(char3 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+char4 operator.zzzy(char3 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+char4 operator.zzzz(char3 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+char4 operator.xxxx(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xxxy(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xxxz(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+char4 operator.xxxw(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+char4 operator.xxyx(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xxyy(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xxyz(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+char4 operator.xxyw(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+char4 operator.xxzx(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xxzy(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xxzz(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+char4 operator.xxzw(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+char4 operator.xxwx(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xxwy(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xxwz(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+char4 operator.xxww(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+char4 operator.xyxx(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xyxy(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xyxz(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+char4 operator.xyxw(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+char4 operator.xyyx(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xyyy(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xyyz(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+char4 operator.xyyw(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+char4 operator.xyzx(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xyzy(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xyzz(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+char4 operator.xyzw(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+char4 operator.xyzw=(char4 v, char4 c) { >+ char4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ result.w = c.w; >+ return result; >+} >+char4 operator.xywx(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xywy(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xywz(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+char4 operator.xywz=(char4 v, char4 c) { >+ char4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ result.z = c.w; >+ return result; >+} >+char4 operator.xyww(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+char4 operator.xzxx(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xzxy(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xzxz(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+char4 operator.xzxw(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+char4 operator.xzyx(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xzyy(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xzyz(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+char4 operator.xzyw(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+char4 operator.xzyw=(char4 v, char4 c) { >+ char4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ result.w = c.w; >+ return result; >+} >+char4 operator.xzzx(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xzzy(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xzzz(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+char4 operator.xzzw(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+char4 operator.xzwx(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xzwy(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xzwy=(char4 v, char4 c) { >+ char4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ result.y = c.w; >+ return result; >+} >+char4 operator.xzwz(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+char4 operator.xzww(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+char4 operator.xwxx(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xwxy(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xwxz(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+char4 operator.xwxw(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+char4 operator.xwyx(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xwyy(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xwyz(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+char4 operator.xwyz=(char4 v, char4 c) { >+ char4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ result.z = c.w; >+ return result; >+} >+char4 operator.xwyw(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+char4 operator.xwzx(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xwzy(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xwzy=(char4 v, char4 c) { >+ char4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ result.y = c.w; >+ return result; >+} >+char4 operator.xwzz(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+char4 operator.xwzw(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+char4 operator.xwwx(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+char4 operator.xwwy(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+char4 operator.xwwz(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+char4 operator.xwww(char4 v) { >+ char4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+char4 operator.yxxx(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.yxxy(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.yxxz(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+char4 operator.yxxw(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+char4 operator.yxyx(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.yxyy(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.yxyz(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+char4 operator.yxyw(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+char4 operator.yxzx(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+char4 operator.yxzy(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+char4 operator.yxzz(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+char4 operator.yxzw(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+char4 operator.yxzw=(char4 v, char4 c) { >+ char4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ result.w = c.w; >+ return result; >+} >+char4 operator.yxwx(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+char4 operator.yxwy(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+char4 operator.yxwz(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+char4 operator.yxwz=(char4 v, char4 c) { >+ char4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ result.z = c.w; >+ return result; >+} >+char4 operator.yxww(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+char4 operator.yyxx(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.yyxy(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.yyxz(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+char4 operator.yyxw(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+char4 operator.yyyx(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.yyyy(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.yyyz(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+char4 operator.yyyw(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+char4 operator.yyzx(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+char4 operator.yyzy(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+char4 operator.yyzz(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+char4 operator.yyzw(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+char4 operator.yywx(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+char4 operator.yywy(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+char4 operator.yywz(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+char4 operator.yyww(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+char4 operator.yzxx(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.yzxy(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.yzxz(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+char4 operator.yzxw(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+char4 operator.yzxw=(char4 v, char4 c) { >+ char4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ result.w = c.w; >+ return result; >+} >+char4 operator.yzyx(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.yzyy(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.yzyz(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+char4 operator.yzyw(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+char4 operator.yzzx(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+char4 operator.yzzy(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+char4 operator.yzzz(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+char4 operator.yzzw(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+char4 operator.yzwx(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+char4 operator.yzwx=(char4 v, char4 c) { >+ char4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ result.x = c.w; >+ return result; >+} >+char4 operator.yzwy(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+char4 operator.yzwz(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+char4 operator.yzww(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+char4 operator.ywxx(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.ywxy(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.ywxz(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+char4 operator.ywxz=(char4 v, char4 c) { >+ char4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ result.z = c.w; >+ return result; >+} >+char4 operator.ywxw(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+char4 operator.ywyx(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.ywyy(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.ywyz(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+char4 operator.ywyw(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+char4 operator.ywzx(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+char4 operator.ywzx=(char4 v, char4 c) { >+ char4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ result.x = c.w; >+ return result; >+} >+char4 operator.ywzy(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+char4 operator.ywzz(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+char4 operator.ywzw(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+char4 operator.ywwx(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+char4 operator.ywwy(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+char4 operator.ywwz(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+char4 operator.ywww(char4 v) { >+ char4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+char4 operator.zxxx(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.zxxy(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.zxxz(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+char4 operator.zxxw(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+char4 operator.zxyx(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.zxyy(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.zxyz(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+char4 operator.zxyw(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+char4 operator.zxyw=(char4 v, char4 c) { >+ char4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ result.w = c.w; >+ return result; >+} >+char4 operator.zxzx(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+char4 operator.zxzy(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+char4 operator.zxzz(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+char4 operator.zxzw(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+char4 operator.zxwx(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+char4 operator.zxwy(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+char4 operator.zxwy=(char4 v, char4 c) { >+ char4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ result.y = c.w; >+ return result; >+} >+char4 operator.zxwz(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+char4 operator.zxww(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+char4 operator.zyxx(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.zyxy(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.zyxz(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+char4 operator.zyxw(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+char4 operator.zyxw=(char4 v, char4 c) { >+ char4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ result.w = c.w; >+ return result; >+} >+char4 operator.zyyx(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.zyyy(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.zyyz(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+char4 operator.zyyw(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+char4 operator.zyzx(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+char4 operator.zyzy(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+char4 operator.zyzz(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+char4 operator.zyzw(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+char4 operator.zywx(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+char4 operator.zywx=(char4 v, char4 c) { >+ char4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ result.x = c.w; >+ return result; >+} >+char4 operator.zywy(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+char4 operator.zywz(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+char4 operator.zyww(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+char4 operator.zzxx(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.zzxy(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.zzxz(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+char4 operator.zzxw(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+char4 operator.zzyx(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.zzyy(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.zzyz(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+char4 operator.zzyw(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+char4 operator.zzzx(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+char4 operator.zzzy(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+char4 operator.zzzz(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+char4 operator.zzzw(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+char4 operator.zzwx(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+char4 operator.zzwy(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+char4 operator.zzwz(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+char4 operator.zzww(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+char4 operator.zwxx(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.zwxy(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.zwxy=(char4 v, char4 c) { >+ char4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ result.y = c.w; >+ return result; >+} >+char4 operator.zwxz(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+char4 operator.zwxw(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+char4 operator.zwyx(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.zwyx=(char4 v, char4 c) { >+ char4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ result.x = c.w; >+ return result; >+} >+char4 operator.zwyy(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.zwyz(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+char4 operator.zwyw(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+char4 operator.zwzx(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+char4 operator.zwzy(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+char4 operator.zwzz(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+char4 operator.zwzw(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+char4 operator.zwwx(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+char4 operator.zwwy(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+char4 operator.zwwz(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+char4 operator.zwww(char4 v) { >+ char4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+char4 operator.wxxx(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.wxxy(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.wxxz(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+char4 operator.wxxw(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+char4 operator.wxyx(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.wxyy(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.wxyz(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+char4 operator.wxyz=(char4 v, char4 c) { >+ char4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ result.z = c.w; >+ return result; >+} >+char4 operator.wxyw(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+char4 operator.wxzx(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+char4 operator.wxzy(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+char4 operator.wxzy=(char4 v, char4 c) { >+ char4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ result.y = c.w; >+ return result; >+} >+char4 operator.wxzz(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+char4 operator.wxzw(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+char4 operator.wxwx(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+char4 operator.wxwy(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+char4 operator.wxwz(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+char4 operator.wxww(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+char4 operator.wyxx(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.wyxy(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.wyxz(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+char4 operator.wyxz=(char4 v, char4 c) { >+ char4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ result.z = c.w; >+ return result; >+} >+char4 operator.wyxw(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+char4 operator.wyyx(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.wyyy(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.wyyz(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+char4 operator.wyyw(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+char4 operator.wyzx(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+char4 operator.wyzx=(char4 v, char4 c) { >+ char4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ result.x = c.w; >+ return result; >+} >+char4 operator.wyzy(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+char4 operator.wyzz(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+char4 operator.wyzw(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+char4 operator.wywx(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+char4 operator.wywy(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+char4 operator.wywz(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+char4 operator.wyww(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+char4 operator.wzxx(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.wzxy(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.wzxy=(char4 v, char4 c) { >+ char4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ result.y = c.w; >+ return result; >+} >+char4 operator.wzxz(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+char4 operator.wzxw(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+char4 operator.wzyx(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.wzyx=(char4 v, char4 c) { >+ char4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ result.x = c.w; >+ return result; >+} >+char4 operator.wzyy(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.wzyz(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+char4 operator.wzyw(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+char4 operator.wzzx(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+char4 operator.wzzy(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+char4 operator.wzzz(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+char4 operator.wzzw(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+char4 operator.wzwx(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+char4 operator.wzwy(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+char4 operator.wzwz(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+char4 operator.wzww(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+char4 operator.wwxx(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+char4 operator.wwxy(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+char4 operator.wwxz(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+char4 operator.wwxw(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+char4 operator.wwyx(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+char4 operator.wwyy(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+char4 operator.wwyz(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+char4 operator.wwyw(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+char4 operator.wwzx(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+char4 operator.wwzy(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+char4 operator.wwzz(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+char4 operator.wwzw(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+char4 operator.wwwx(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+char4 operator.wwwy(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+char4 operator.wwwz(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+char4 operator.wwww(char4 v) { >+ char4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+short2 operator.xx(short2 v) { >+ short2 result; >+ result.x = v.x; >+ result.y = v.x; >+ return result; >+} >+short2 operator.xy(short2 v) { >+ short2 result; >+ result.x = v.x; >+ result.y = v.y; >+ return result; >+} >+short2 operator.xy=(short2 v, short2 c) { >+ short2 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ return result; >+} >+short2 operator.yx(short2 v) { >+ short2 result; >+ result.x = v.y; >+ result.y = v.x; >+ return result; >+} >+short2 operator.yx=(short2 v, short2 c) { >+ short2 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ return result; >+} >+short2 operator.yy(short2 v) { >+ short2 result; >+ result.x = v.y; >+ result.y = v.y; >+ return result; >+} >+short2 operator.xx(short3 v) { >+ short2 result; >+ result.x = v.x; >+ result.y = v.x; >+ return result; >+} >+short2 operator.xy(short3 v) { >+ short2 result; >+ result.x = v.x; >+ result.y = v.y; >+ return result; >+} >+short3 operator.xy=(short3 v, short2 c) { >+ short3 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ return result; >+} >+short2 operator.xz(short3 v) { >+ short2 result; >+ result.x = v.x; >+ result.y = v.z; >+ return result; >+} >+short3 operator.xz=(short3 v, short2 c) { >+ short3 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ return result; >+} >+short2 operator.yx(short3 v) { >+ short2 result; >+ result.x = v.y; >+ result.y = v.x; >+ return result; >+} >+short3 operator.yx=(short3 v, short2 c) { >+ short3 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ return result; >+} >+short2 operator.yy(short3 v) { >+ short2 result; >+ result.x = v.y; >+ result.y = v.y; >+ return result; >+} >+short2 operator.yz(short3 v) { >+ short2 result; >+ result.x = v.y; >+ result.y = v.z; >+ return result; >+} >+short3 operator.yz=(short3 v, short2 c) { >+ short3 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ return result; >+} >+short2 operator.zx(short3 v) { >+ short2 result; >+ result.x = v.z; >+ result.y = v.x; >+ return result; >+} >+short3 operator.zx=(short3 v, short2 c) { >+ short3 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ return result; >+} >+short2 operator.zy(short3 v) { >+ short2 result; >+ result.x = v.z; >+ result.y = v.y; >+ return result; >+} >+short3 operator.zy=(short3 v, short2 c) { >+ short3 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ return result; >+} >+short2 operator.zz(short3 v) { >+ short2 result; >+ result.x = v.z; >+ result.y = v.z; >+ return result; >+} >+short2 operator.xx(short4 v) { >+ short2 result; >+ result.x = v.x; >+ result.y = v.x; >+ return result; >+} >+short2 operator.xy(short4 v) { >+ short2 result; >+ result.x = v.x; >+ result.y = v.y; >+ return result; >+} >+short4 operator.xy=(short4 v, short2 c) { >+ short4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ return result; >+} >+short2 operator.xz(short4 v) { >+ short2 result; >+ result.x = v.x; >+ result.y = v.z; >+ return result; >+} >+short4 operator.xz=(short4 v, short2 c) { >+ short4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ return result; >+} >+short2 operator.xw(short4 v) { >+ short2 result; >+ result.x = v.x; >+ result.y = v.w; >+ return result; >+} >+short4 operator.xw=(short4 v, short2 c) { >+ short4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ return result; >+} >+short2 operator.yx(short4 v) { >+ short2 result; >+ result.x = v.y; >+ result.y = v.x; >+ return result; >+} >+short4 operator.yx=(short4 v, short2 c) { >+ short4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ return result; >+} >+short2 operator.yy(short4 v) { >+ short2 result; >+ result.x = v.y; >+ result.y = v.y; >+ return result; >+} >+short2 operator.yz(short4 v) { >+ short2 result; >+ result.x = v.y; >+ result.y = v.z; >+ return result; >+} >+short4 operator.yz=(short4 v, short2 c) { >+ short4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ return result; >+} >+short2 operator.yw(short4 v) { >+ short2 result; >+ result.x = v.y; >+ result.y = v.w; >+ return result; >+} >+short4 operator.yw=(short4 v, short2 c) { >+ short4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ return result; >+} >+short2 operator.zx(short4 v) { >+ short2 result; >+ result.x = v.z; >+ result.y = v.x; >+ return result; >+} >+short4 operator.zx=(short4 v, short2 c) { >+ short4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ return result; >+} >+short2 operator.zy(short4 v) { >+ short2 result; >+ result.x = v.z; >+ result.y = v.y; >+ return result; >+} >+short4 operator.zy=(short4 v, short2 c) { >+ short4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ return result; >+} >+short2 operator.zz(short4 v) { >+ short2 result; >+ result.x = v.z; >+ result.y = v.z; >+ return result; >+} >+short2 operator.zw(short4 v) { >+ short2 result; >+ result.x = v.z; >+ result.y = v.w; >+ return result; >+} >+short4 operator.zw=(short4 v, short2 c) { >+ short4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ return result; >+} >+short2 operator.wx(short4 v) { >+ short2 result; >+ result.x = v.w; >+ result.y = v.x; >+ return result; >+} >+short4 operator.wx=(short4 v, short2 c) { >+ short4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ return result; >+} >+short2 operator.wy(short4 v) { >+ short2 result; >+ result.x = v.w; >+ result.y = v.y; >+ return result; >+} >+short4 operator.wy=(short4 v, short2 c) { >+ short4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ return result; >+} >+short2 operator.wz(short4 v) { >+ short2 result; >+ result.x = v.w; >+ result.y = v.z; >+ return result; >+} >+short4 operator.wz=(short4 v, short2 c) { >+ short4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ return result; >+} >+short2 operator.ww(short4 v) { >+ short2 result; >+ result.x = v.w; >+ result.y = v.w; >+ return result; >+} >+short3 operator.xxx(short2 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+short3 operator.xxy(short2 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+short3 operator.xyx(short2 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+short3 operator.xyy(short2 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+short3 operator.yxx(short2 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+short3 operator.yxy(short2 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+short3 operator.yyx(short2 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+short3 operator.yyy(short2 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+short3 operator.xxx(short3 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+short3 operator.xxy(short3 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+short3 operator.xxz(short3 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+short3 operator.xyx(short3 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+short3 operator.xyy(short3 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+short3 operator.xyz(short3 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+short3 operator.xyz=(short3 v, short3 c) { >+ short3 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ return result; >+} >+short3 operator.xzx(short3 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+short3 operator.xzy(short3 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+short3 operator.xzy=(short3 v, short3 c) { >+ short3 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ return result; >+} >+short3 operator.xzz(short3 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+short3 operator.yxx(short3 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+short3 operator.yxy(short3 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+short3 operator.yxz(short3 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+short3 operator.yxz=(short3 v, short3 c) { >+ short3 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ return result; >+} >+short3 operator.yyx(short3 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+short3 operator.yyy(short3 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+short3 operator.yyz(short3 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+short3 operator.yzx(short3 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+short3 operator.yzx=(short3 v, short3 c) { >+ short3 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ return result; >+} >+short3 operator.yzy(short3 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+short3 operator.yzz(short3 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+short3 operator.zxx(short3 v) { >+ short3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+short3 operator.zxy(short3 v) { >+ short3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+short3 operator.zxy=(short3 v, short3 c) { >+ short3 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ return result; >+} >+short3 operator.zxz(short3 v) { >+ short3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+short3 operator.zyx(short3 v) { >+ short3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+short3 operator.zyx=(short3 v, short3 c) { >+ short3 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ return result; >+} >+short3 operator.zyy(short3 v) { >+ short3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+short3 operator.zyz(short3 v) { >+ short3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+short3 operator.zzx(short3 v) { >+ short3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+short3 operator.zzy(short3 v) { >+ short3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+short3 operator.zzz(short3 v) { >+ short3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+short3 operator.xxx(short4 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+short3 operator.xxy(short4 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+short3 operator.xxz(short4 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+short3 operator.xxw(short4 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+short3 operator.xyx(short4 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+short3 operator.xyy(short4 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+short3 operator.xyz(short4 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+short4 operator.xyz=(short4 v, short3 c) { >+ short4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ return result; >+} >+short3 operator.xyw(short4 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+short4 operator.xyw=(short4 v, short3 c) { >+ short4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ return result; >+} >+short3 operator.xzx(short4 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+short3 operator.xzy(short4 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+short4 operator.xzy=(short4 v, short3 c) { >+ short4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ return result; >+} >+short3 operator.xzz(short4 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+short3 operator.xzw(short4 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+short4 operator.xzw=(short4 v, short3 c) { >+ short4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ return result; >+} >+short3 operator.xwx(short4 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+short3 operator.xwy(short4 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+short4 operator.xwy=(short4 v, short3 c) { >+ short4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ return result; >+} >+short3 operator.xwz(short4 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+short4 operator.xwz=(short4 v, short3 c) { >+ short4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ return result; >+} >+short3 operator.xww(short4 v) { >+ short3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+short3 operator.yxx(short4 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+short3 operator.yxy(short4 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+short3 operator.yxz(short4 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+short4 operator.yxz=(short4 v, short3 c) { >+ short4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ return result; >+} >+short3 operator.yxw(short4 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+short4 operator.yxw=(short4 v, short3 c) { >+ short4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ return result; >+} >+short3 operator.yyx(short4 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+short3 operator.yyy(short4 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+short3 operator.yyz(short4 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+short3 operator.yyw(short4 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+short3 operator.yzx(short4 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+short4 operator.yzx=(short4 v, short3 c) { >+ short4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ return result; >+} >+short3 operator.yzy(short4 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+short3 operator.yzz(short4 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+short3 operator.yzw(short4 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+short4 operator.yzw=(short4 v, short3 c) { >+ short4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ return result; >+} >+short3 operator.ywx(short4 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+short4 operator.ywx=(short4 v, short3 c) { >+ short4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ return result; >+} >+short3 operator.ywy(short4 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+short3 operator.ywz(short4 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+short4 operator.ywz=(short4 v, short3 c) { >+ short4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ return result; >+} >+short3 operator.yww(short4 v) { >+ short3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+short3 operator.zxx(short4 v) { >+ short3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+short3 operator.zxy(short4 v) { >+ short3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+short4 operator.zxy=(short4 v, short3 c) { >+ short4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ return result; >+} >+short3 operator.zxz(short4 v) { >+ short3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+short3 operator.zxw(short4 v) { >+ short3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+short4 operator.zxw=(short4 v, short3 c) { >+ short4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ return result; >+} >+short3 operator.zyx(short4 v) { >+ short3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+short4 operator.zyx=(short4 v, short3 c) { >+ short4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ return result; >+} >+short3 operator.zyy(short4 v) { >+ short3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+short3 operator.zyz(short4 v) { >+ short3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+short3 operator.zyw(short4 v) { >+ short3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+short4 operator.zyw=(short4 v, short3 c) { >+ short4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ return result; >+} >+short3 operator.zzx(short4 v) { >+ short3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+short3 operator.zzy(short4 v) { >+ short3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+short3 operator.zzz(short4 v) { >+ short3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+short3 operator.zzw(short4 v) { >+ short3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+short3 operator.zwx(short4 v) { >+ short3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+short4 operator.zwx=(short4 v, short3 c) { >+ short4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ return result; >+} >+short3 operator.zwy(short4 v) { >+ short3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+short4 operator.zwy=(short4 v, short3 c) { >+ short4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ return result; >+} >+short3 operator.zwz(short4 v) { >+ short3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+short3 operator.zww(short4 v) { >+ short3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+short3 operator.wxx(short4 v) { >+ short3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+short3 operator.wxy(short4 v) { >+ short3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+short4 operator.wxy=(short4 v, short3 c) { >+ short4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ return result; >+} >+short3 operator.wxz(short4 v) { >+ short3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+short4 operator.wxz=(short4 v, short3 c) { >+ short4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ return result; >+} >+short3 operator.wxw(short4 v) { >+ short3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+short3 operator.wyx(short4 v) { >+ short3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+short4 operator.wyx=(short4 v, short3 c) { >+ short4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ return result; >+} >+short3 operator.wyy(short4 v) { >+ short3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+short3 operator.wyz(short4 v) { >+ short3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+short4 operator.wyz=(short4 v, short3 c) { >+ short4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ return result; >+} >+short3 operator.wyw(short4 v) { >+ short3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+short3 operator.wzx(short4 v) { >+ short3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+short4 operator.wzx=(short4 v, short3 c) { >+ short4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ return result; >+} >+short3 operator.wzy(short4 v) { >+ short3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+short4 operator.wzy=(short4 v, short3 c) { >+ short4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ return result; >+} >+short3 operator.wzz(short4 v) { >+ short3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+short3 operator.wzw(short4 v) { >+ short3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+short3 operator.wwx(short4 v) { >+ short3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+short3 operator.wwy(short4 v) { >+ short3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+short3 operator.wwz(short4 v) { >+ short3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+short3 operator.www(short4 v) { >+ short3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+short4 operator.xxxx(short2 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xxxy(short2 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xxyx(short2 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xxyy(short2 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xyxx(short2 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xyxy(short2 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xyyx(short2 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xyyy(short2 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.yxxx(short2 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.yxxy(short2 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.yxyx(short2 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.yxyy(short2 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.yyxx(short2 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.yyxy(short2 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.yyyx(short2 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.yyyy(short2 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xxxx(short3 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xxxy(short3 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xxxz(short3 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+short4 operator.xxyx(short3 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xxyy(short3 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xxyz(short3 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+short4 operator.xxzx(short3 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xxzy(short3 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xxzz(short3 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+short4 operator.xyxx(short3 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xyxy(short3 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xyxz(short3 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+short4 operator.xyyx(short3 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xyyy(short3 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xyyz(short3 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+short4 operator.xyzx(short3 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xyzy(short3 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xyzz(short3 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+short4 operator.xzxx(short3 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xzxy(short3 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xzxz(short3 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+short4 operator.xzyx(short3 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xzyy(short3 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xzyz(short3 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+short4 operator.xzzx(short3 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xzzy(short3 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xzzz(short3 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+short4 operator.yxxx(short3 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.yxxy(short3 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.yxxz(short3 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+short4 operator.yxyx(short3 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.yxyy(short3 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.yxyz(short3 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+short4 operator.yxzx(short3 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+short4 operator.yxzy(short3 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+short4 operator.yxzz(short3 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+short4 operator.yyxx(short3 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.yyxy(short3 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.yyxz(short3 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+short4 operator.yyyx(short3 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.yyyy(short3 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.yyyz(short3 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+short4 operator.yyzx(short3 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+short4 operator.yyzy(short3 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+short4 operator.yyzz(short3 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+short4 operator.yzxx(short3 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.yzxy(short3 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.yzxz(short3 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+short4 operator.yzyx(short3 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.yzyy(short3 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.yzyz(short3 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+short4 operator.yzzx(short3 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+short4 operator.yzzy(short3 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+short4 operator.yzzz(short3 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+short4 operator.zxxx(short3 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.zxxy(short3 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.zxxz(short3 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+short4 operator.zxyx(short3 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.zxyy(short3 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.zxyz(short3 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+short4 operator.zxzx(short3 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+short4 operator.zxzy(short3 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+short4 operator.zxzz(short3 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+short4 operator.zyxx(short3 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.zyxy(short3 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.zyxz(short3 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+short4 operator.zyyx(short3 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.zyyy(short3 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.zyyz(short3 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+short4 operator.zyzx(short3 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+short4 operator.zyzy(short3 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+short4 operator.zyzz(short3 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+short4 operator.zzxx(short3 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.zzxy(short3 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.zzxz(short3 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+short4 operator.zzyx(short3 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.zzyy(short3 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.zzyz(short3 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+short4 operator.zzzx(short3 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+short4 operator.zzzy(short3 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+short4 operator.zzzz(short3 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+short4 operator.xxxx(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xxxy(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xxxz(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+short4 operator.xxxw(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+short4 operator.xxyx(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xxyy(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xxyz(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+short4 operator.xxyw(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+short4 operator.xxzx(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xxzy(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xxzz(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+short4 operator.xxzw(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+short4 operator.xxwx(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xxwy(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xxwz(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+short4 operator.xxww(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+short4 operator.xyxx(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xyxy(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xyxz(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+short4 operator.xyxw(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+short4 operator.xyyx(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xyyy(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xyyz(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+short4 operator.xyyw(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+short4 operator.xyzx(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xyzy(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xyzz(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+short4 operator.xyzw(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+short4 operator.xyzw=(short4 v, short4 c) { >+ short4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ result.w = c.w; >+ return result; >+} >+short4 operator.xywx(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xywy(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xywz(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+short4 operator.xywz=(short4 v, short4 c) { >+ short4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ result.z = c.w; >+ return result; >+} >+short4 operator.xyww(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+short4 operator.xzxx(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xzxy(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xzxz(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+short4 operator.xzxw(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+short4 operator.xzyx(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xzyy(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xzyz(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+short4 operator.xzyw(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+short4 operator.xzyw=(short4 v, short4 c) { >+ short4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ result.w = c.w; >+ return result; >+} >+short4 operator.xzzx(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xzzy(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xzzz(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+short4 operator.xzzw(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+short4 operator.xzwx(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xzwy(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xzwy=(short4 v, short4 c) { >+ short4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ result.y = c.w; >+ return result; >+} >+short4 operator.xzwz(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+short4 operator.xzww(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+short4 operator.xwxx(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xwxy(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xwxz(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+short4 operator.xwxw(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+short4 operator.xwyx(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xwyy(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xwyz(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+short4 operator.xwyz=(short4 v, short4 c) { >+ short4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ result.z = c.w; >+ return result; >+} >+short4 operator.xwyw(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+short4 operator.xwzx(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xwzy(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xwzy=(short4 v, short4 c) { >+ short4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ result.y = c.w; >+ return result; >+} >+short4 operator.xwzz(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+short4 operator.xwzw(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+short4 operator.xwwx(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+short4 operator.xwwy(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+short4 operator.xwwz(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+short4 operator.xwww(short4 v) { >+ short4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+short4 operator.yxxx(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.yxxy(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.yxxz(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+short4 operator.yxxw(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+short4 operator.yxyx(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.yxyy(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.yxyz(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+short4 operator.yxyw(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+short4 operator.yxzx(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+short4 operator.yxzy(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+short4 operator.yxzz(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+short4 operator.yxzw(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+short4 operator.yxzw=(short4 v, short4 c) { >+ short4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ result.w = c.w; >+ return result; >+} >+short4 operator.yxwx(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+short4 operator.yxwy(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+short4 operator.yxwz(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+short4 operator.yxwz=(short4 v, short4 c) { >+ short4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ result.z = c.w; >+ return result; >+} >+short4 operator.yxww(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+short4 operator.yyxx(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.yyxy(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.yyxz(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+short4 operator.yyxw(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+short4 operator.yyyx(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.yyyy(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.yyyz(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+short4 operator.yyyw(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+short4 operator.yyzx(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+short4 operator.yyzy(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+short4 operator.yyzz(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+short4 operator.yyzw(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+short4 operator.yywx(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+short4 operator.yywy(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+short4 operator.yywz(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+short4 operator.yyww(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+short4 operator.yzxx(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.yzxy(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.yzxz(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+short4 operator.yzxw(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+short4 operator.yzxw=(short4 v, short4 c) { >+ short4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ result.w = c.w; >+ return result; >+} >+short4 operator.yzyx(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.yzyy(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.yzyz(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+short4 operator.yzyw(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+short4 operator.yzzx(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+short4 operator.yzzy(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+short4 operator.yzzz(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+short4 operator.yzzw(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+short4 operator.yzwx(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+short4 operator.yzwx=(short4 v, short4 c) { >+ short4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ result.x = c.w; >+ return result; >+} >+short4 operator.yzwy(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+short4 operator.yzwz(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+short4 operator.yzww(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+short4 operator.ywxx(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.ywxy(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.ywxz(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+short4 operator.ywxz=(short4 v, short4 c) { >+ short4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ result.z = c.w; >+ return result; >+} >+short4 operator.ywxw(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+short4 operator.ywyx(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.ywyy(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.ywyz(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+short4 operator.ywyw(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+short4 operator.ywzx(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+short4 operator.ywzx=(short4 v, short4 c) { >+ short4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ result.x = c.w; >+ return result; >+} >+short4 operator.ywzy(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+short4 operator.ywzz(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+short4 operator.ywzw(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+short4 operator.ywwx(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+short4 operator.ywwy(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+short4 operator.ywwz(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+short4 operator.ywww(short4 v) { >+ short4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+short4 operator.zxxx(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.zxxy(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.zxxz(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+short4 operator.zxxw(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+short4 operator.zxyx(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.zxyy(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.zxyz(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+short4 operator.zxyw(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+short4 operator.zxyw=(short4 v, short4 c) { >+ short4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ result.w = c.w; >+ return result; >+} >+short4 operator.zxzx(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+short4 operator.zxzy(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+short4 operator.zxzz(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+short4 operator.zxzw(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+short4 operator.zxwx(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+short4 operator.zxwy(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+short4 operator.zxwy=(short4 v, short4 c) { >+ short4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ result.y = c.w; >+ return result; >+} >+short4 operator.zxwz(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+short4 operator.zxww(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+short4 operator.zyxx(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.zyxy(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.zyxz(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+short4 operator.zyxw(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+short4 operator.zyxw=(short4 v, short4 c) { >+ short4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ result.w = c.w; >+ return result; >+} >+short4 operator.zyyx(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.zyyy(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.zyyz(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+short4 operator.zyyw(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+short4 operator.zyzx(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+short4 operator.zyzy(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+short4 operator.zyzz(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+short4 operator.zyzw(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+short4 operator.zywx(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+short4 operator.zywx=(short4 v, short4 c) { >+ short4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ result.x = c.w; >+ return result; >+} >+short4 operator.zywy(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+short4 operator.zywz(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+short4 operator.zyww(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+short4 operator.zzxx(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.zzxy(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.zzxz(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+short4 operator.zzxw(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+short4 operator.zzyx(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.zzyy(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.zzyz(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+short4 operator.zzyw(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+short4 operator.zzzx(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+short4 operator.zzzy(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+short4 operator.zzzz(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+short4 operator.zzzw(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+short4 operator.zzwx(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+short4 operator.zzwy(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+short4 operator.zzwz(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+short4 operator.zzww(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+short4 operator.zwxx(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.zwxy(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.zwxy=(short4 v, short4 c) { >+ short4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ result.y = c.w; >+ return result; >+} >+short4 operator.zwxz(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+short4 operator.zwxw(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+short4 operator.zwyx(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.zwyx=(short4 v, short4 c) { >+ short4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ result.x = c.w; >+ return result; >+} >+short4 operator.zwyy(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.zwyz(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+short4 operator.zwyw(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+short4 operator.zwzx(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+short4 operator.zwzy(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+short4 operator.zwzz(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+short4 operator.zwzw(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+short4 operator.zwwx(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+short4 operator.zwwy(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+short4 operator.zwwz(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+short4 operator.zwww(short4 v) { >+ short4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+short4 operator.wxxx(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.wxxy(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.wxxz(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+short4 operator.wxxw(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+short4 operator.wxyx(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.wxyy(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.wxyz(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+short4 operator.wxyz=(short4 v, short4 c) { >+ short4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ result.z = c.w; >+ return result; >+} >+short4 operator.wxyw(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+short4 operator.wxzx(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+short4 operator.wxzy(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+short4 operator.wxzy=(short4 v, short4 c) { >+ short4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ result.y = c.w; >+ return result; >+} >+short4 operator.wxzz(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+short4 operator.wxzw(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+short4 operator.wxwx(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+short4 operator.wxwy(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+short4 operator.wxwz(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+short4 operator.wxww(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+short4 operator.wyxx(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.wyxy(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.wyxz(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+short4 operator.wyxz=(short4 v, short4 c) { >+ short4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ result.z = c.w; >+ return result; >+} >+short4 operator.wyxw(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+short4 operator.wyyx(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.wyyy(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.wyyz(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+short4 operator.wyyw(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+short4 operator.wyzx(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+short4 operator.wyzx=(short4 v, short4 c) { >+ short4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ result.x = c.w; >+ return result; >+} >+short4 operator.wyzy(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+short4 operator.wyzz(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+short4 operator.wyzw(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+short4 operator.wywx(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+short4 operator.wywy(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+short4 operator.wywz(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+short4 operator.wyww(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+short4 operator.wzxx(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.wzxy(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.wzxy=(short4 v, short4 c) { >+ short4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ result.y = c.w; >+ return result; >+} >+short4 operator.wzxz(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+short4 operator.wzxw(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+short4 operator.wzyx(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.wzyx=(short4 v, short4 c) { >+ short4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ result.x = c.w; >+ return result; >+} >+short4 operator.wzyy(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.wzyz(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+short4 operator.wzyw(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+short4 operator.wzzx(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+short4 operator.wzzy(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+short4 operator.wzzz(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+short4 operator.wzzw(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+short4 operator.wzwx(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+short4 operator.wzwy(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+short4 operator.wzwz(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+short4 operator.wzww(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+short4 operator.wwxx(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+short4 operator.wwxy(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+short4 operator.wwxz(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+short4 operator.wwxw(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+short4 operator.wwyx(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+short4 operator.wwyy(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+short4 operator.wwyz(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+short4 operator.wwyw(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+short4 operator.wwzx(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+short4 operator.wwzy(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+short4 operator.wwzz(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+short4 operator.wwzw(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+short4 operator.wwwx(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+short4 operator.wwwy(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+short4 operator.wwwz(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+short4 operator.wwww(short4 v) { >+ short4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+int2 operator.xx(int2 v) { >+ int2 result; >+ result.x = v.x; >+ result.y = v.x; >+ return result; >+} >+int2 operator.xy(int2 v) { >+ int2 result; >+ result.x = v.x; >+ result.y = v.y; >+ return result; >+} >+int2 operator.xy=(int2 v, int2 c) { >+ int2 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ return result; >+} >+int2 operator.yx(int2 v) { >+ int2 result; >+ result.x = v.y; >+ result.y = v.x; >+ return result; >+} >+int2 operator.yx=(int2 v, int2 c) { >+ int2 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ return result; >+} >+int2 operator.yy(int2 v) { >+ int2 result; >+ result.x = v.y; >+ result.y = v.y; >+ return result; >+} >+int2 operator.xx(int3 v) { >+ int2 result; >+ result.x = v.x; >+ result.y = v.x; >+ return result; >+} >+int2 operator.xy(int3 v) { >+ int2 result; >+ result.x = v.x; >+ result.y = v.y; >+ return result; >+} >+int3 operator.xy=(int3 v, int2 c) { >+ int3 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ return result; >+} >+int2 operator.xz(int3 v) { >+ int2 result; >+ result.x = v.x; >+ result.y = v.z; >+ return result; >+} >+int3 operator.xz=(int3 v, int2 c) { >+ int3 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ return result; >+} >+int2 operator.yx(int3 v) { >+ int2 result; >+ result.x = v.y; >+ result.y = v.x; >+ return result; >+} >+int3 operator.yx=(int3 v, int2 c) { >+ int3 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ return result; >+} >+int2 operator.yy(int3 v) { >+ int2 result; >+ result.x = v.y; >+ result.y = v.y; >+ return result; >+} >+int2 operator.yz(int3 v) { >+ int2 result; >+ result.x = v.y; >+ result.y = v.z; >+ return result; >+} >+int3 operator.yz=(int3 v, int2 c) { >+ int3 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ return result; >+} >+int2 operator.zx(int3 v) { >+ int2 result; >+ result.x = v.z; >+ result.y = v.x; >+ return result; >+} >+int3 operator.zx=(int3 v, int2 c) { >+ int3 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ return result; >+} >+int2 operator.zy(int3 v) { >+ int2 result; >+ result.x = v.z; >+ result.y = v.y; >+ return result; >+} >+int3 operator.zy=(int3 v, int2 c) { >+ int3 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ return result; >+} >+int2 operator.zz(int3 v) { >+ int2 result; >+ result.x = v.z; >+ result.y = v.z; >+ return result; >+} >+int2 operator.xx(int4 v) { >+ int2 result; >+ result.x = v.x; >+ result.y = v.x; >+ return result; >+} >+int2 operator.xy(int4 v) { >+ int2 result; >+ result.x = v.x; >+ result.y = v.y; >+ return result; >+} >+int4 operator.xy=(int4 v, int2 c) { >+ int4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ return result; >+} >+int2 operator.xz(int4 v) { >+ int2 result; >+ result.x = v.x; >+ result.y = v.z; >+ return result; >+} >+int4 operator.xz=(int4 v, int2 c) { >+ int4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ return result; >+} >+int2 operator.xw(int4 v) { >+ int2 result; >+ result.x = v.x; >+ result.y = v.w; >+ return result; >+} >+int4 operator.xw=(int4 v, int2 c) { >+ int4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ return result; >+} >+int2 operator.yx(int4 v) { >+ int2 result; >+ result.x = v.y; >+ result.y = v.x; >+ return result; >+} >+int4 operator.yx=(int4 v, int2 c) { >+ int4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ return result; >+} >+int2 operator.yy(int4 v) { >+ int2 result; >+ result.x = v.y; >+ result.y = v.y; >+ return result; >+} >+int2 operator.yz(int4 v) { >+ int2 result; >+ result.x = v.y; >+ result.y = v.z; >+ return result; >+} >+int4 operator.yz=(int4 v, int2 c) { >+ int4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ return result; >+} >+int2 operator.yw(int4 v) { >+ int2 result; >+ result.x = v.y; >+ result.y = v.w; >+ return result; >+} >+int4 operator.yw=(int4 v, int2 c) { >+ int4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ return result; >+} >+int2 operator.zx(int4 v) { >+ int2 result; >+ result.x = v.z; >+ result.y = v.x; >+ return result; >+} >+int4 operator.zx=(int4 v, int2 c) { >+ int4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ return result; >+} >+int2 operator.zy(int4 v) { >+ int2 result; >+ result.x = v.z; >+ result.y = v.y; >+ return result; >+} >+int4 operator.zy=(int4 v, int2 c) { >+ int4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ return result; >+} >+int2 operator.zz(int4 v) { >+ int2 result; >+ result.x = v.z; >+ result.y = v.z; >+ return result; >+} >+int2 operator.zw(int4 v) { >+ int2 result; >+ result.x = v.z; >+ result.y = v.w; >+ return result; >+} >+int4 operator.zw=(int4 v, int2 c) { >+ int4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ return result; >+} >+int2 operator.wx(int4 v) { >+ int2 result; >+ result.x = v.w; >+ result.y = v.x; >+ return result; >+} >+int4 operator.wx=(int4 v, int2 c) { >+ int4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ return result; >+} >+int2 operator.wy(int4 v) { >+ int2 result; >+ result.x = v.w; >+ result.y = v.y; >+ return result; >+} >+int4 operator.wy=(int4 v, int2 c) { >+ int4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ return result; >+} >+int2 operator.wz(int4 v) { >+ int2 result; >+ result.x = v.w; >+ result.y = v.z; >+ return result; >+} >+int4 operator.wz=(int4 v, int2 c) { >+ int4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ return result; >+} >+int2 operator.ww(int4 v) { >+ int2 result; >+ result.x = v.w; >+ result.y = v.w; >+ return result; >+} >+int3 operator.xxx(int2 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+int3 operator.xxy(int2 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+int3 operator.xyx(int2 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+int3 operator.xyy(int2 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+int3 operator.yxx(int2 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+int3 operator.yxy(int2 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+int3 operator.yyx(int2 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+int3 operator.yyy(int2 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+int3 operator.xxx(int3 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+int3 operator.xxy(int3 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+int3 operator.xxz(int3 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+int3 operator.xyx(int3 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+int3 operator.xyy(int3 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+int3 operator.xyz(int3 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+int3 operator.xyz=(int3 v, int3 c) { >+ int3 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ return result; >+} >+int3 operator.xzx(int3 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+int3 operator.xzy(int3 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+int3 operator.xzy=(int3 v, int3 c) { >+ int3 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ return result; >+} >+int3 operator.xzz(int3 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+int3 operator.yxx(int3 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+int3 operator.yxy(int3 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+int3 operator.yxz(int3 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+int3 operator.yxz=(int3 v, int3 c) { >+ int3 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ return result; >+} >+int3 operator.yyx(int3 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+int3 operator.yyy(int3 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+int3 operator.yyz(int3 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+int3 operator.yzx(int3 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+int3 operator.yzx=(int3 v, int3 c) { >+ int3 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ return result; >+} >+int3 operator.yzy(int3 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+int3 operator.yzz(int3 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+int3 operator.zxx(int3 v) { >+ int3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+int3 operator.zxy(int3 v) { >+ int3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+int3 operator.zxy=(int3 v, int3 c) { >+ int3 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ return result; >+} >+int3 operator.zxz(int3 v) { >+ int3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+int3 operator.zyx(int3 v) { >+ int3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+int3 operator.zyx=(int3 v, int3 c) { >+ int3 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ return result; >+} >+int3 operator.zyy(int3 v) { >+ int3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+int3 operator.zyz(int3 v) { >+ int3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+int3 operator.zzx(int3 v) { >+ int3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+int3 operator.zzy(int3 v) { >+ int3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+int3 operator.zzz(int3 v) { >+ int3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+int3 operator.xxx(int4 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+int3 operator.xxy(int4 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+int3 operator.xxz(int4 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+int3 operator.xxw(int4 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+int3 operator.xyx(int4 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+int3 operator.xyy(int4 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+int3 operator.xyz(int4 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+int4 operator.xyz=(int4 v, int3 c) { >+ int4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ return result; >+} >+int3 operator.xyw(int4 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+int4 operator.xyw=(int4 v, int3 c) { >+ int4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ return result; >+} >+int3 operator.xzx(int4 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+int3 operator.xzy(int4 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+int4 operator.xzy=(int4 v, int3 c) { >+ int4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ return result; >+} >+int3 operator.xzz(int4 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+int3 operator.xzw(int4 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+int4 operator.xzw=(int4 v, int3 c) { >+ int4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ return result; >+} >+int3 operator.xwx(int4 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+int3 operator.xwy(int4 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+int4 operator.xwy=(int4 v, int3 c) { >+ int4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ return result; >+} >+int3 operator.xwz(int4 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+int4 operator.xwz=(int4 v, int3 c) { >+ int4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ return result; >+} >+int3 operator.xww(int4 v) { >+ int3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+int3 operator.yxx(int4 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+int3 operator.yxy(int4 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+int3 operator.yxz(int4 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+int4 operator.yxz=(int4 v, int3 c) { >+ int4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ return result; >+} >+int3 operator.yxw(int4 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+int4 operator.yxw=(int4 v, int3 c) { >+ int4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ return result; >+} >+int3 operator.yyx(int4 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+int3 operator.yyy(int4 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+int3 operator.yyz(int4 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+int3 operator.yyw(int4 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+int3 operator.yzx(int4 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+int4 operator.yzx=(int4 v, int3 c) { >+ int4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ return result; >+} >+int3 operator.yzy(int4 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+int3 operator.yzz(int4 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+int3 operator.yzw(int4 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+int4 operator.yzw=(int4 v, int3 c) { >+ int4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ return result; >+} >+int3 operator.ywx(int4 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+int4 operator.ywx=(int4 v, int3 c) { >+ int4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ return result; >+} >+int3 operator.ywy(int4 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+int3 operator.ywz(int4 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+int4 operator.ywz=(int4 v, int3 c) { >+ int4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ return result; >+} >+int3 operator.yww(int4 v) { >+ int3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+int3 operator.zxx(int4 v) { >+ int3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+int3 operator.zxy(int4 v) { >+ int3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+int4 operator.zxy=(int4 v, int3 c) { >+ int4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ return result; >+} >+int3 operator.zxz(int4 v) { >+ int3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+int3 operator.zxw(int4 v) { >+ int3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+int4 operator.zxw=(int4 v, int3 c) { >+ int4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ return result; >+} >+int3 operator.zyx(int4 v) { >+ int3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+int4 operator.zyx=(int4 v, int3 c) { >+ int4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ return result; >+} >+int3 operator.zyy(int4 v) { >+ int3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+int3 operator.zyz(int4 v) { >+ int3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+int3 operator.zyw(int4 v) { >+ int3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+int4 operator.zyw=(int4 v, int3 c) { >+ int4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ return result; >+} >+int3 operator.zzx(int4 v) { >+ int3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+int3 operator.zzy(int4 v) { >+ int3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+int3 operator.zzz(int4 v) { >+ int3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+int3 operator.zzw(int4 v) { >+ int3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+int3 operator.zwx(int4 v) { >+ int3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+int4 operator.zwx=(int4 v, int3 c) { >+ int4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ return result; >+} >+int3 operator.zwy(int4 v) { >+ int3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+int4 operator.zwy=(int4 v, int3 c) { >+ int4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ return result; >+} >+int3 operator.zwz(int4 v) { >+ int3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+int3 operator.zww(int4 v) { >+ int3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+int3 operator.wxx(int4 v) { >+ int3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+int3 operator.wxy(int4 v) { >+ int3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+int4 operator.wxy=(int4 v, int3 c) { >+ int4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ return result; >+} >+int3 operator.wxz(int4 v) { >+ int3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+int4 operator.wxz=(int4 v, int3 c) { >+ int4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ return result; >+} >+int3 operator.wxw(int4 v) { >+ int3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+int3 operator.wyx(int4 v) { >+ int3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+int4 operator.wyx=(int4 v, int3 c) { >+ int4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ return result; >+} >+int3 operator.wyy(int4 v) { >+ int3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+int3 operator.wyz(int4 v) { >+ int3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+int4 operator.wyz=(int4 v, int3 c) { >+ int4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ return result; >+} >+int3 operator.wyw(int4 v) { >+ int3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+int3 operator.wzx(int4 v) { >+ int3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+int4 operator.wzx=(int4 v, int3 c) { >+ int4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ return result; >+} >+int3 operator.wzy(int4 v) { >+ int3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+int4 operator.wzy=(int4 v, int3 c) { >+ int4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ return result; >+} >+int3 operator.wzz(int4 v) { >+ int3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+int3 operator.wzw(int4 v) { >+ int3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+int3 operator.wwx(int4 v) { >+ int3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+int3 operator.wwy(int4 v) { >+ int3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+int3 operator.wwz(int4 v) { >+ int3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+int3 operator.www(int4 v) { >+ int3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+int4 operator.xxxx(int2 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xxxy(int2 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xxyx(int2 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xxyy(int2 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xyxx(int2 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xyxy(int2 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xyyx(int2 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xyyy(int2 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.yxxx(int2 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.yxxy(int2 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.yxyx(int2 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.yxyy(int2 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.yyxx(int2 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.yyxy(int2 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.yyyx(int2 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.yyyy(int2 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xxxx(int3 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xxxy(int3 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xxxz(int3 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+int4 operator.xxyx(int3 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xxyy(int3 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xxyz(int3 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+int4 operator.xxzx(int3 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xxzy(int3 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xxzz(int3 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+int4 operator.xyxx(int3 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xyxy(int3 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xyxz(int3 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+int4 operator.xyyx(int3 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xyyy(int3 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xyyz(int3 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+int4 operator.xyzx(int3 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xyzy(int3 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xyzz(int3 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+int4 operator.xzxx(int3 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xzxy(int3 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xzxz(int3 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+int4 operator.xzyx(int3 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xzyy(int3 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xzyz(int3 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+int4 operator.xzzx(int3 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xzzy(int3 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xzzz(int3 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+int4 operator.yxxx(int3 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.yxxy(int3 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.yxxz(int3 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+int4 operator.yxyx(int3 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.yxyy(int3 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.yxyz(int3 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+int4 operator.yxzx(int3 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+int4 operator.yxzy(int3 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+int4 operator.yxzz(int3 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+int4 operator.yyxx(int3 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.yyxy(int3 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.yyxz(int3 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+int4 operator.yyyx(int3 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.yyyy(int3 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.yyyz(int3 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+int4 operator.yyzx(int3 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+int4 operator.yyzy(int3 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+int4 operator.yyzz(int3 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+int4 operator.yzxx(int3 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.yzxy(int3 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.yzxz(int3 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+int4 operator.yzyx(int3 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.yzyy(int3 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.yzyz(int3 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+int4 operator.yzzx(int3 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+int4 operator.yzzy(int3 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+int4 operator.yzzz(int3 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+int4 operator.zxxx(int3 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.zxxy(int3 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.zxxz(int3 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+int4 operator.zxyx(int3 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.zxyy(int3 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.zxyz(int3 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+int4 operator.zxzx(int3 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+int4 operator.zxzy(int3 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+int4 operator.zxzz(int3 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+int4 operator.zyxx(int3 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.zyxy(int3 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.zyxz(int3 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+int4 operator.zyyx(int3 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.zyyy(int3 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.zyyz(int3 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+int4 operator.zyzx(int3 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+int4 operator.zyzy(int3 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+int4 operator.zyzz(int3 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+int4 operator.zzxx(int3 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.zzxy(int3 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.zzxz(int3 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+int4 operator.zzyx(int3 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.zzyy(int3 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.zzyz(int3 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+int4 operator.zzzx(int3 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+int4 operator.zzzy(int3 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+int4 operator.zzzz(int3 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+int4 operator.xxxx(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xxxy(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xxxz(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+int4 operator.xxxw(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+int4 operator.xxyx(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xxyy(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xxyz(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+int4 operator.xxyw(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+int4 operator.xxzx(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xxzy(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xxzz(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+int4 operator.xxzw(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+int4 operator.xxwx(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xxwy(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xxwz(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+int4 operator.xxww(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+int4 operator.xyxx(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xyxy(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xyxz(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+int4 operator.xyxw(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+int4 operator.xyyx(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xyyy(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xyyz(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+int4 operator.xyyw(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+int4 operator.xyzx(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xyzy(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xyzz(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+int4 operator.xyzw(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+int4 operator.xyzw=(int4 v, int4 c) { >+ int4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ result.w = c.w; >+ return result; >+} >+int4 operator.xywx(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xywy(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xywz(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+int4 operator.xywz=(int4 v, int4 c) { >+ int4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ result.z = c.w; >+ return result; >+} >+int4 operator.xyww(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+int4 operator.xzxx(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xzxy(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xzxz(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+int4 operator.xzxw(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+int4 operator.xzyx(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xzyy(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xzyz(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+int4 operator.xzyw(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+int4 operator.xzyw=(int4 v, int4 c) { >+ int4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ result.w = c.w; >+ return result; >+} >+int4 operator.xzzx(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xzzy(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xzzz(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+int4 operator.xzzw(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+int4 operator.xzwx(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xzwy(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xzwy=(int4 v, int4 c) { >+ int4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ result.y = c.w; >+ return result; >+} >+int4 operator.xzwz(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+int4 operator.xzww(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+int4 operator.xwxx(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xwxy(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xwxz(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+int4 operator.xwxw(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+int4 operator.xwyx(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xwyy(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xwyz(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+int4 operator.xwyz=(int4 v, int4 c) { >+ int4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ result.z = c.w; >+ return result; >+} >+int4 operator.xwyw(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+int4 operator.xwzx(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xwzy(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xwzy=(int4 v, int4 c) { >+ int4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ result.y = c.w; >+ return result; >+} >+int4 operator.xwzz(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+int4 operator.xwzw(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+int4 operator.xwwx(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+int4 operator.xwwy(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+int4 operator.xwwz(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+int4 operator.xwww(int4 v) { >+ int4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+int4 operator.yxxx(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.yxxy(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.yxxz(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+int4 operator.yxxw(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+int4 operator.yxyx(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.yxyy(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.yxyz(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+int4 operator.yxyw(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+int4 operator.yxzx(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+int4 operator.yxzy(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+int4 operator.yxzz(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+int4 operator.yxzw(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+int4 operator.yxzw=(int4 v, int4 c) { >+ int4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ result.w = c.w; >+ return result; >+} >+int4 operator.yxwx(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+int4 operator.yxwy(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+int4 operator.yxwz(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+int4 operator.yxwz=(int4 v, int4 c) { >+ int4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ result.z = c.w; >+ return result; >+} >+int4 operator.yxww(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+int4 operator.yyxx(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.yyxy(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.yyxz(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+int4 operator.yyxw(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+int4 operator.yyyx(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.yyyy(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.yyyz(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+int4 operator.yyyw(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+int4 operator.yyzx(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+int4 operator.yyzy(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+int4 operator.yyzz(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+int4 operator.yyzw(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+int4 operator.yywx(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+int4 operator.yywy(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+int4 operator.yywz(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+int4 operator.yyww(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+int4 operator.yzxx(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.yzxy(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.yzxz(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+int4 operator.yzxw(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+int4 operator.yzxw=(int4 v, int4 c) { >+ int4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ result.w = c.w; >+ return result; >+} >+int4 operator.yzyx(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.yzyy(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.yzyz(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+int4 operator.yzyw(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+int4 operator.yzzx(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+int4 operator.yzzy(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+int4 operator.yzzz(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+int4 operator.yzzw(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+int4 operator.yzwx(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+int4 operator.yzwx=(int4 v, int4 c) { >+ int4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ result.x = c.w; >+ return result; >+} >+int4 operator.yzwy(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+int4 operator.yzwz(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+int4 operator.yzww(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+int4 operator.ywxx(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.ywxy(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.ywxz(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+int4 operator.ywxz=(int4 v, int4 c) { >+ int4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ result.z = c.w; >+ return result; >+} >+int4 operator.ywxw(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+int4 operator.ywyx(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.ywyy(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.ywyz(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+int4 operator.ywyw(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+int4 operator.ywzx(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+int4 operator.ywzx=(int4 v, int4 c) { >+ int4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ result.x = c.w; >+ return result; >+} >+int4 operator.ywzy(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+int4 operator.ywzz(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+int4 operator.ywzw(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+int4 operator.ywwx(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+int4 operator.ywwy(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+int4 operator.ywwz(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+int4 operator.ywww(int4 v) { >+ int4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+int4 operator.zxxx(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.zxxy(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.zxxz(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+int4 operator.zxxw(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+int4 operator.zxyx(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.zxyy(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.zxyz(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+int4 operator.zxyw(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+int4 operator.zxyw=(int4 v, int4 c) { >+ int4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ result.w = c.w; >+ return result; >+} >+int4 operator.zxzx(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+int4 operator.zxzy(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+int4 operator.zxzz(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+int4 operator.zxzw(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+int4 operator.zxwx(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+int4 operator.zxwy(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+int4 operator.zxwy=(int4 v, int4 c) { >+ int4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ result.y = c.w; >+ return result; >+} >+int4 operator.zxwz(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+int4 operator.zxww(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+int4 operator.zyxx(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.zyxy(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.zyxz(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+int4 operator.zyxw(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+int4 operator.zyxw=(int4 v, int4 c) { >+ int4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ result.w = c.w; >+ return result; >+} >+int4 operator.zyyx(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.zyyy(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.zyyz(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+int4 operator.zyyw(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+int4 operator.zyzx(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+int4 operator.zyzy(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+int4 operator.zyzz(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+int4 operator.zyzw(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+int4 operator.zywx(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+int4 operator.zywx=(int4 v, int4 c) { >+ int4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ result.x = c.w; >+ return result; >+} >+int4 operator.zywy(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+int4 operator.zywz(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+int4 operator.zyww(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+int4 operator.zzxx(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.zzxy(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.zzxz(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+int4 operator.zzxw(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+int4 operator.zzyx(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.zzyy(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.zzyz(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+int4 operator.zzyw(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+int4 operator.zzzx(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+int4 operator.zzzy(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+int4 operator.zzzz(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+int4 operator.zzzw(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+int4 operator.zzwx(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+int4 operator.zzwy(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+int4 operator.zzwz(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+int4 operator.zzww(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+int4 operator.zwxx(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.zwxy(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.zwxy=(int4 v, int4 c) { >+ int4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ result.y = c.w; >+ return result; >+} >+int4 operator.zwxz(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+int4 operator.zwxw(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+int4 operator.zwyx(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.zwyx=(int4 v, int4 c) { >+ int4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ result.x = c.w; >+ return result; >+} >+int4 operator.zwyy(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.zwyz(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+int4 operator.zwyw(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+int4 operator.zwzx(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+int4 operator.zwzy(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+int4 operator.zwzz(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+int4 operator.zwzw(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+int4 operator.zwwx(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+int4 operator.zwwy(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+int4 operator.zwwz(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+int4 operator.zwww(int4 v) { >+ int4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+int4 operator.wxxx(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.wxxy(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.wxxz(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+int4 operator.wxxw(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+int4 operator.wxyx(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.wxyy(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.wxyz(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+int4 operator.wxyz=(int4 v, int4 c) { >+ int4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ result.z = c.w; >+ return result; >+} >+int4 operator.wxyw(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+int4 operator.wxzx(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+int4 operator.wxzy(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+int4 operator.wxzy=(int4 v, int4 c) { >+ int4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ result.y = c.w; >+ return result; >+} >+int4 operator.wxzz(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+int4 operator.wxzw(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+int4 operator.wxwx(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+int4 operator.wxwy(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+int4 operator.wxwz(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+int4 operator.wxww(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+int4 operator.wyxx(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.wyxy(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.wyxz(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+int4 operator.wyxz=(int4 v, int4 c) { >+ int4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ result.z = c.w; >+ return result; >+} >+int4 operator.wyxw(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+int4 operator.wyyx(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.wyyy(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.wyyz(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+int4 operator.wyyw(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+int4 operator.wyzx(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+int4 operator.wyzx=(int4 v, int4 c) { >+ int4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ result.x = c.w; >+ return result; >+} >+int4 operator.wyzy(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+int4 operator.wyzz(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+int4 operator.wyzw(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+int4 operator.wywx(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+int4 operator.wywy(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+int4 operator.wywz(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+int4 operator.wyww(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+int4 operator.wzxx(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.wzxy(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.wzxy=(int4 v, int4 c) { >+ int4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ result.y = c.w; >+ return result; >+} >+int4 operator.wzxz(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+int4 operator.wzxw(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+int4 operator.wzyx(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.wzyx=(int4 v, int4 c) { >+ int4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ result.x = c.w; >+ return result; >+} >+int4 operator.wzyy(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.wzyz(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+int4 operator.wzyw(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+int4 operator.wzzx(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+int4 operator.wzzy(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+int4 operator.wzzz(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+int4 operator.wzzw(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+int4 operator.wzwx(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+int4 operator.wzwy(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+int4 operator.wzwz(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+int4 operator.wzww(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+int4 operator.wwxx(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+int4 operator.wwxy(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+int4 operator.wwxz(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+int4 operator.wwxw(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+int4 operator.wwyx(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+int4 operator.wwyy(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+int4 operator.wwyz(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+int4 operator.wwyw(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+int4 operator.wwzx(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+int4 operator.wwzy(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+int4 operator.wwzz(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+int4 operator.wwzw(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+int4 operator.wwwx(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+int4 operator.wwwy(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+int4 operator.wwwz(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+int4 operator.wwww(int4 v) { >+ int4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+half2 operator.xx(half2 v) { >+ half2 result; >+ result.x = v.x; >+ result.y = v.x; >+ return result; >+} >+half2 operator.xy(half2 v) { >+ half2 result; >+ result.x = v.x; >+ result.y = v.y; >+ return result; >+} >+half2 operator.xy=(half2 v, half2 c) { >+ half2 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ return result; >+} >+half2 operator.yx(half2 v) { >+ half2 result; >+ result.x = v.y; >+ result.y = v.x; >+ return result; >+} >+half2 operator.yx=(half2 v, half2 c) { >+ half2 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ return result; >+} >+half2 operator.yy(half2 v) { >+ half2 result; >+ result.x = v.y; >+ result.y = v.y; >+ return result; >+} >+half2 operator.xx(half3 v) { >+ half2 result; >+ result.x = v.x; >+ result.y = v.x; >+ return result; >+} >+half2 operator.xy(half3 v) { >+ half2 result; >+ result.x = v.x; >+ result.y = v.y; >+ return result; >+} >+half3 operator.xy=(half3 v, half2 c) { >+ half3 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ return result; >+} >+half2 operator.xz(half3 v) { >+ half2 result; >+ result.x = v.x; >+ result.y = v.z; >+ return result; >+} >+half3 operator.xz=(half3 v, half2 c) { >+ half3 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ return result; >+} >+half2 operator.yx(half3 v) { >+ half2 result; >+ result.x = v.y; >+ result.y = v.x; >+ return result; >+} >+half3 operator.yx=(half3 v, half2 c) { >+ half3 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ return result; >+} >+half2 operator.yy(half3 v) { >+ half2 result; >+ result.x = v.y; >+ result.y = v.y; >+ return result; >+} >+half2 operator.yz(half3 v) { >+ half2 result; >+ result.x = v.y; >+ result.y = v.z; >+ return result; >+} >+half3 operator.yz=(half3 v, half2 c) { >+ half3 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ return result; >+} >+half2 operator.zx(half3 v) { >+ half2 result; >+ result.x = v.z; >+ result.y = v.x; >+ return result; >+} >+half3 operator.zx=(half3 v, half2 c) { >+ half3 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ return result; >+} >+half2 operator.zy(half3 v) { >+ half2 result; >+ result.x = v.z; >+ result.y = v.y; >+ return result; >+} >+half3 operator.zy=(half3 v, half2 c) { >+ half3 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ return result; >+} >+half2 operator.zz(half3 v) { >+ half2 result; >+ result.x = v.z; >+ result.y = v.z; >+ return result; >+} >+half2 operator.xx(half4 v) { >+ half2 result; >+ result.x = v.x; >+ result.y = v.x; >+ return result; >+} >+half2 operator.xy(half4 v) { >+ half2 result; >+ result.x = v.x; >+ result.y = v.y; >+ return result; >+} >+half4 operator.xy=(half4 v, half2 c) { >+ half4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ return result; >+} >+half2 operator.xz(half4 v) { >+ half2 result; >+ result.x = v.x; >+ result.y = v.z; >+ return result; >+} >+half4 operator.xz=(half4 v, half2 c) { >+ half4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ return result; >+} >+half2 operator.xw(half4 v) { >+ half2 result; >+ result.x = v.x; >+ result.y = v.w; >+ return result; >+} >+half4 operator.xw=(half4 v, half2 c) { >+ half4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ return result; >+} >+half2 operator.yx(half4 v) { >+ half2 result; >+ result.x = v.y; >+ result.y = v.x; >+ return result; >+} >+half4 operator.yx=(half4 v, half2 c) { >+ half4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ return result; >+} >+half2 operator.yy(half4 v) { >+ half2 result; >+ result.x = v.y; >+ result.y = v.y; >+ return result; >+} >+half2 operator.yz(half4 v) { >+ half2 result; >+ result.x = v.y; >+ result.y = v.z; >+ return result; >+} >+half4 operator.yz=(half4 v, half2 c) { >+ half4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ return result; >+} >+half2 operator.yw(half4 v) { >+ half2 result; >+ result.x = v.y; >+ result.y = v.w; >+ return result; >+} >+half4 operator.yw=(half4 v, half2 c) { >+ half4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ return result; >+} >+half2 operator.zx(half4 v) { >+ half2 result; >+ result.x = v.z; >+ result.y = v.x; >+ return result; >+} >+half4 operator.zx=(half4 v, half2 c) { >+ half4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ return result; >+} >+half2 operator.zy(half4 v) { >+ half2 result; >+ result.x = v.z; >+ result.y = v.y; >+ return result; >+} >+half4 operator.zy=(half4 v, half2 c) { >+ half4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ return result; >+} >+half2 operator.zz(half4 v) { >+ half2 result; >+ result.x = v.z; >+ result.y = v.z; >+ return result; >+} >+half2 operator.zw(half4 v) { >+ half2 result; >+ result.x = v.z; >+ result.y = v.w; >+ return result; >+} >+half4 operator.zw=(half4 v, half2 c) { >+ half4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ return result; >+} >+half2 operator.wx(half4 v) { >+ half2 result; >+ result.x = v.w; >+ result.y = v.x; >+ return result; >+} >+half4 operator.wx=(half4 v, half2 c) { >+ half4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ return result; >+} >+half2 operator.wy(half4 v) { >+ half2 result; >+ result.x = v.w; >+ result.y = v.y; >+ return result; >+} >+half4 operator.wy=(half4 v, half2 c) { >+ half4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ return result; >+} >+half2 operator.wz(half4 v) { >+ half2 result; >+ result.x = v.w; >+ result.y = v.z; >+ return result; >+} >+half4 operator.wz=(half4 v, half2 c) { >+ half4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ return result; >+} >+half2 operator.ww(half4 v) { >+ half2 result; >+ result.x = v.w; >+ result.y = v.w; >+ return result; >+} >+half3 operator.xxx(half2 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+half3 operator.xxy(half2 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+half3 operator.xyx(half2 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+half3 operator.xyy(half2 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+half3 operator.yxx(half2 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+half3 operator.yxy(half2 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+half3 operator.yyx(half2 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+half3 operator.yyy(half2 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+half3 operator.xxx(half3 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+half3 operator.xxy(half3 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+half3 operator.xxz(half3 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+half3 operator.xyx(half3 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+half3 operator.xyy(half3 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+half3 operator.xyz(half3 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+half3 operator.xyz=(half3 v, half3 c) { >+ half3 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ return result; >+} >+half3 operator.xzx(half3 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+half3 operator.xzy(half3 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+half3 operator.xzy=(half3 v, half3 c) { >+ half3 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ return result; >+} >+half3 operator.xzz(half3 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+half3 operator.yxx(half3 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+half3 operator.yxy(half3 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+half3 operator.yxz(half3 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+half3 operator.yxz=(half3 v, half3 c) { >+ half3 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ return result; >+} >+half3 operator.yyx(half3 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+half3 operator.yyy(half3 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+half3 operator.yyz(half3 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+half3 operator.yzx(half3 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+half3 operator.yzx=(half3 v, half3 c) { >+ half3 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ return result; >+} >+half3 operator.yzy(half3 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+half3 operator.yzz(half3 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+half3 operator.zxx(half3 v) { >+ half3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+half3 operator.zxy(half3 v) { >+ half3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+half3 operator.zxy=(half3 v, half3 c) { >+ half3 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ return result; >+} >+half3 operator.zxz(half3 v) { >+ half3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+half3 operator.zyx(half3 v) { >+ half3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+half3 operator.zyx=(half3 v, half3 c) { >+ half3 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ return result; >+} >+half3 operator.zyy(half3 v) { >+ half3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+half3 operator.zyz(half3 v) { >+ half3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+half3 operator.zzx(half3 v) { >+ half3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+half3 operator.zzy(half3 v) { >+ half3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+half3 operator.zzz(half3 v) { >+ half3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+half3 operator.xxx(half4 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+half3 operator.xxy(half4 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+half3 operator.xxz(half4 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+half3 operator.xxw(half4 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+half3 operator.xyx(half4 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+half3 operator.xyy(half4 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+half3 operator.xyz(half4 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+half4 operator.xyz=(half4 v, half3 c) { >+ half4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ return result; >+} >+half3 operator.xyw(half4 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+half4 operator.xyw=(half4 v, half3 c) { >+ half4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ return result; >+} >+half3 operator.xzx(half4 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+half3 operator.xzy(half4 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+half4 operator.xzy=(half4 v, half3 c) { >+ half4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ return result; >+} >+half3 operator.xzz(half4 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+half3 operator.xzw(half4 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+half4 operator.xzw=(half4 v, half3 c) { >+ half4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ return result; >+} >+half3 operator.xwx(half4 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+half3 operator.xwy(half4 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+half4 operator.xwy=(half4 v, half3 c) { >+ half4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ return result; >+} >+half3 operator.xwz(half4 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+half4 operator.xwz=(half4 v, half3 c) { >+ half4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ return result; >+} >+half3 operator.xww(half4 v) { >+ half3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+half3 operator.yxx(half4 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+half3 operator.yxy(half4 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+half3 operator.yxz(half4 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+half4 operator.yxz=(half4 v, half3 c) { >+ half4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ return result; >+} >+half3 operator.yxw(half4 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+half4 operator.yxw=(half4 v, half3 c) { >+ half4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ return result; >+} >+half3 operator.yyx(half4 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+half3 operator.yyy(half4 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+half3 operator.yyz(half4 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+half3 operator.yyw(half4 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+half3 operator.yzx(half4 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+half4 operator.yzx=(half4 v, half3 c) { >+ half4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ return result; >+} >+half3 operator.yzy(half4 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+half3 operator.yzz(half4 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+half3 operator.yzw(half4 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+half4 operator.yzw=(half4 v, half3 c) { >+ half4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ return result; >+} >+half3 operator.ywx(half4 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+half4 operator.ywx=(half4 v, half3 c) { >+ half4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ return result; >+} >+half3 operator.ywy(half4 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+half3 operator.ywz(half4 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+half4 operator.ywz=(half4 v, half3 c) { >+ half4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ return result; >+} >+half3 operator.yww(half4 v) { >+ half3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+half3 operator.zxx(half4 v) { >+ half3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+half3 operator.zxy(half4 v) { >+ half3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+half4 operator.zxy=(half4 v, half3 c) { >+ half4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ return result; >+} >+half3 operator.zxz(half4 v) { >+ half3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+half3 operator.zxw(half4 v) { >+ half3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+half4 operator.zxw=(half4 v, half3 c) { >+ half4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ return result; >+} >+half3 operator.zyx(half4 v) { >+ half3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+half4 operator.zyx=(half4 v, half3 c) { >+ half4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ return result; >+} >+half3 operator.zyy(half4 v) { >+ half3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+half3 operator.zyz(half4 v) { >+ half3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+half3 operator.zyw(half4 v) { >+ half3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+half4 operator.zyw=(half4 v, half3 c) { >+ half4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ return result; >+} >+half3 operator.zzx(half4 v) { >+ half3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+half3 operator.zzy(half4 v) { >+ half3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+half3 operator.zzz(half4 v) { >+ half3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+half3 operator.zzw(half4 v) { >+ half3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+half3 operator.zwx(half4 v) { >+ half3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+half4 operator.zwx=(half4 v, half3 c) { >+ half4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ return result; >+} >+half3 operator.zwy(half4 v) { >+ half3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+half4 operator.zwy=(half4 v, half3 c) { >+ half4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ return result; >+} >+half3 operator.zwz(half4 v) { >+ half3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+half3 operator.zww(half4 v) { >+ half3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+half3 operator.wxx(half4 v) { >+ half3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+half3 operator.wxy(half4 v) { >+ half3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+half4 operator.wxy=(half4 v, half3 c) { >+ half4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ return result; >+} >+half3 operator.wxz(half4 v) { >+ half3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+half4 operator.wxz=(half4 v, half3 c) { >+ half4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ return result; >+} >+half3 operator.wxw(half4 v) { >+ half3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+half3 operator.wyx(half4 v) { >+ half3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+half4 operator.wyx=(half4 v, half3 c) { >+ half4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ return result; >+} >+half3 operator.wyy(half4 v) { >+ half3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+half3 operator.wyz(half4 v) { >+ half3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+half4 operator.wyz=(half4 v, half3 c) { >+ half4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ return result; >+} >+half3 operator.wyw(half4 v) { >+ half3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+half3 operator.wzx(half4 v) { >+ half3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+half4 operator.wzx=(half4 v, half3 c) { >+ half4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ return result; >+} >+half3 operator.wzy(half4 v) { >+ half3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+half4 operator.wzy=(half4 v, half3 c) { >+ half4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ return result; >+} >+half3 operator.wzz(half4 v) { >+ half3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+half3 operator.wzw(half4 v) { >+ half3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+half3 operator.wwx(half4 v) { >+ half3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+half3 operator.wwy(half4 v) { >+ half3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+half3 operator.wwz(half4 v) { >+ half3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+half3 operator.www(half4 v) { >+ half3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+half4 operator.xxxx(half2 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xxxy(half2 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xxyx(half2 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xxyy(half2 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xyxx(half2 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xyxy(half2 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xyyx(half2 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xyyy(half2 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.yxxx(half2 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.yxxy(half2 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.yxyx(half2 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.yxyy(half2 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.yyxx(half2 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.yyxy(half2 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.yyyx(half2 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.yyyy(half2 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xxxx(half3 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xxxy(half3 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xxxz(half3 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+half4 operator.xxyx(half3 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xxyy(half3 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xxyz(half3 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+half4 operator.xxzx(half3 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xxzy(half3 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xxzz(half3 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+half4 operator.xyxx(half3 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xyxy(half3 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xyxz(half3 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+half4 operator.xyyx(half3 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xyyy(half3 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xyyz(half3 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+half4 operator.xyzx(half3 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xyzy(half3 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xyzz(half3 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+half4 operator.xzxx(half3 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xzxy(half3 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xzxz(half3 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+half4 operator.xzyx(half3 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xzyy(half3 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xzyz(half3 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+half4 operator.xzzx(half3 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xzzy(half3 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xzzz(half3 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+half4 operator.yxxx(half3 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.yxxy(half3 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.yxxz(half3 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+half4 operator.yxyx(half3 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.yxyy(half3 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.yxyz(half3 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+half4 operator.yxzx(half3 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+half4 operator.yxzy(half3 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+half4 operator.yxzz(half3 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+half4 operator.yyxx(half3 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.yyxy(half3 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.yyxz(half3 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+half4 operator.yyyx(half3 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.yyyy(half3 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.yyyz(half3 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+half4 operator.yyzx(half3 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+half4 operator.yyzy(half3 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+half4 operator.yyzz(half3 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+half4 operator.yzxx(half3 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.yzxy(half3 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.yzxz(half3 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+half4 operator.yzyx(half3 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.yzyy(half3 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.yzyz(half3 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+half4 operator.yzzx(half3 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+half4 operator.yzzy(half3 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+half4 operator.yzzz(half3 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+half4 operator.zxxx(half3 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.zxxy(half3 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.zxxz(half3 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+half4 operator.zxyx(half3 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.zxyy(half3 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.zxyz(half3 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+half4 operator.zxzx(half3 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+half4 operator.zxzy(half3 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+half4 operator.zxzz(half3 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+half4 operator.zyxx(half3 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.zyxy(half3 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.zyxz(half3 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+half4 operator.zyyx(half3 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.zyyy(half3 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.zyyz(half3 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+half4 operator.zyzx(half3 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+half4 operator.zyzy(half3 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+half4 operator.zyzz(half3 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+half4 operator.zzxx(half3 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.zzxy(half3 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.zzxz(half3 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+half4 operator.zzyx(half3 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.zzyy(half3 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.zzyz(half3 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+half4 operator.zzzx(half3 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+half4 operator.zzzy(half3 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+half4 operator.zzzz(half3 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+half4 operator.xxxx(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xxxy(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xxxz(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+half4 operator.xxxw(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+half4 operator.xxyx(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xxyy(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xxyz(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+half4 operator.xxyw(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+half4 operator.xxzx(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xxzy(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xxzz(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+half4 operator.xxzw(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+half4 operator.xxwx(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xxwy(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xxwz(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+half4 operator.xxww(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+half4 operator.xyxx(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xyxy(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xyxz(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+half4 operator.xyxw(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+half4 operator.xyyx(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xyyy(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xyyz(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+half4 operator.xyyw(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+half4 operator.xyzx(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xyzy(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xyzz(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+half4 operator.xyzw(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+half4 operator.xyzw=(half4 v, half4 c) { >+ half4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ result.w = c.w; >+ return result; >+} >+half4 operator.xywx(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xywy(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xywz(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+half4 operator.xywz=(half4 v, half4 c) { >+ half4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ result.z = c.w; >+ return result; >+} >+half4 operator.xyww(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+half4 operator.xzxx(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xzxy(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xzxz(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+half4 operator.xzxw(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+half4 operator.xzyx(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xzyy(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xzyz(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+half4 operator.xzyw(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+half4 operator.xzyw=(half4 v, half4 c) { >+ half4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ result.w = c.w; >+ return result; >+} >+half4 operator.xzzx(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xzzy(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xzzz(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+half4 operator.xzzw(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+half4 operator.xzwx(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xzwy(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xzwy=(half4 v, half4 c) { >+ half4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ result.y = c.w; >+ return result; >+} >+half4 operator.xzwz(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+half4 operator.xzww(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+half4 operator.xwxx(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xwxy(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xwxz(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+half4 operator.xwxw(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+half4 operator.xwyx(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xwyy(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xwyz(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+half4 operator.xwyz=(half4 v, half4 c) { >+ half4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ result.z = c.w; >+ return result; >+} >+half4 operator.xwyw(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+half4 operator.xwzx(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xwzy(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xwzy=(half4 v, half4 c) { >+ half4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ result.y = c.w; >+ return result; >+} >+half4 operator.xwzz(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+half4 operator.xwzw(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+half4 operator.xwwx(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+half4 operator.xwwy(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+half4 operator.xwwz(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+half4 operator.xwww(half4 v) { >+ half4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+half4 operator.yxxx(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.yxxy(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.yxxz(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+half4 operator.yxxw(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+half4 operator.yxyx(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.yxyy(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.yxyz(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+half4 operator.yxyw(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+half4 operator.yxzx(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+half4 operator.yxzy(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+half4 operator.yxzz(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+half4 operator.yxzw(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+half4 operator.yxzw=(half4 v, half4 c) { >+ half4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ result.w = c.w; >+ return result; >+} >+half4 operator.yxwx(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+half4 operator.yxwy(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+half4 operator.yxwz(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+half4 operator.yxwz=(half4 v, half4 c) { >+ half4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ result.z = c.w; >+ return result; >+} >+half4 operator.yxww(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+half4 operator.yyxx(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.yyxy(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.yyxz(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+half4 operator.yyxw(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+half4 operator.yyyx(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.yyyy(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.yyyz(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+half4 operator.yyyw(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+half4 operator.yyzx(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+half4 operator.yyzy(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+half4 operator.yyzz(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+half4 operator.yyzw(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+half4 operator.yywx(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+half4 operator.yywy(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+half4 operator.yywz(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+half4 operator.yyww(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+half4 operator.yzxx(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.yzxy(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.yzxz(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+half4 operator.yzxw(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+half4 operator.yzxw=(half4 v, half4 c) { >+ half4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ result.w = c.w; >+ return result; >+} >+half4 operator.yzyx(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.yzyy(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.yzyz(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+half4 operator.yzyw(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+half4 operator.yzzx(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+half4 operator.yzzy(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+half4 operator.yzzz(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+half4 operator.yzzw(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+half4 operator.yzwx(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+half4 operator.yzwx=(half4 v, half4 c) { >+ half4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ result.x = c.w; >+ return result; >+} >+half4 operator.yzwy(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+half4 operator.yzwz(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+half4 operator.yzww(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+half4 operator.ywxx(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.ywxy(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.ywxz(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+half4 operator.ywxz=(half4 v, half4 c) { >+ half4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ result.z = c.w; >+ return result; >+} >+half4 operator.ywxw(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+half4 operator.ywyx(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.ywyy(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.ywyz(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+half4 operator.ywyw(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+half4 operator.ywzx(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+half4 operator.ywzx=(half4 v, half4 c) { >+ half4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ result.x = c.w; >+ return result; >+} >+half4 operator.ywzy(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+half4 operator.ywzz(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+half4 operator.ywzw(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+half4 operator.ywwx(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+half4 operator.ywwy(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+half4 operator.ywwz(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+half4 operator.ywww(half4 v) { >+ half4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+half4 operator.zxxx(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.zxxy(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.zxxz(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+half4 operator.zxxw(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+half4 operator.zxyx(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.zxyy(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.zxyz(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+half4 operator.zxyw(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+half4 operator.zxyw=(half4 v, half4 c) { >+ half4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ result.w = c.w; >+ return result; >+} >+half4 operator.zxzx(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+half4 operator.zxzy(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+half4 operator.zxzz(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+half4 operator.zxzw(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+half4 operator.zxwx(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+half4 operator.zxwy(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+half4 operator.zxwy=(half4 v, half4 c) { >+ half4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ result.y = c.w; >+ return result; >+} >+half4 operator.zxwz(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+half4 operator.zxww(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+half4 operator.zyxx(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.zyxy(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.zyxz(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+half4 operator.zyxw(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+half4 operator.zyxw=(half4 v, half4 c) { >+ half4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ result.w = c.w; >+ return result; >+} >+half4 operator.zyyx(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.zyyy(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.zyyz(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+half4 operator.zyyw(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+half4 operator.zyzx(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+half4 operator.zyzy(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+half4 operator.zyzz(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+half4 operator.zyzw(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+half4 operator.zywx(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+half4 operator.zywx=(half4 v, half4 c) { >+ half4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ result.x = c.w; >+ return result; >+} >+half4 operator.zywy(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+half4 operator.zywz(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+half4 operator.zyww(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+half4 operator.zzxx(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.zzxy(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.zzxz(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+half4 operator.zzxw(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+half4 operator.zzyx(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.zzyy(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.zzyz(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+half4 operator.zzyw(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+half4 operator.zzzx(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+half4 operator.zzzy(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+half4 operator.zzzz(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+half4 operator.zzzw(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+half4 operator.zzwx(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+half4 operator.zzwy(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+half4 operator.zzwz(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+half4 operator.zzww(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+half4 operator.zwxx(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.zwxy(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.zwxy=(half4 v, half4 c) { >+ half4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ result.y = c.w; >+ return result; >+} >+half4 operator.zwxz(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+half4 operator.zwxw(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+half4 operator.zwyx(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.zwyx=(half4 v, half4 c) { >+ half4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ result.x = c.w; >+ return result; >+} >+half4 operator.zwyy(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.zwyz(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+half4 operator.zwyw(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+half4 operator.zwzx(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+half4 operator.zwzy(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+half4 operator.zwzz(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+half4 operator.zwzw(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+half4 operator.zwwx(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+half4 operator.zwwy(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+half4 operator.zwwz(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+half4 operator.zwww(half4 v) { >+ half4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+half4 operator.wxxx(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.wxxy(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.wxxz(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+half4 operator.wxxw(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+half4 operator.wxyx(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.wxyy(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.wxyz(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+half4 operator.wxyz=(half4 v, half4 c) { >+ half4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ result.z = c.w; >+ return result; >+} >+half4 operator.wxyw(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+half4 operator.wxzx(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+half4 operator.wxzy(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+half4 operator.wxzy=(half4 v, half4 c) { >+ half4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ result.y = c.w; >+ return result; >+} >+half4 operator.wxzz(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+half4 operator.wxzw(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+half4 operator.wxwx(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+half4 operator.wxwy(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+half4 operator.wxwz(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+half4 operator.wxww(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+half4 operator.wyxx(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.wyxy(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.wyxz(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+half4 operator.wyxz=(half4 v, half4 c) { >+ half4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ result.z = c.w; >+ return result; >+} >+half4 operator.wyxw(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+half4 operator.wyyx(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.wyyy(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.wyyz(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+half4 operator.wyyw(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+half4 operator.wyzx(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+half4 operator.wyzx=(half4 v, half4 c) { >+ half4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ result.x = c.w; >+ return result; >+} >+half4 operator.wyzy(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+half4 operator.wyzz(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+half4 operator.wyzw(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+half4 operator.wywx(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+half4 operator.wywy(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+half4 operator.wywz(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+half4 operator.wyww(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+half4 operator.wzxx(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.wzxy(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.wzxy=(half4 v, half4 c) { >+ half4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ result.y = c.w; >+ return result; >+} >+half4 operator.wzxz(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+half4 operator.wzxw(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+half4 operator.wzyx(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.wzyx=(half4 v, half4 c) { >+ half4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ result.x = c.w; >+ return result; >+} >+half4 operator.wzyy(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.wzyz(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+half4 operator.wzyw(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+half4 operator.wzzx(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+half4 operator.wzzy(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+half4 operator.wzzz(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+half4 operator.wzzw(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+half4 operator.wzwx(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+half4 operator.wzwy(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+half4 operator.wzwz(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+half4 operator.wzww(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+half4 operator.wwxx(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+half4 operator.wwxy(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+half4 operator.wwxz(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+half4 operator.wwxw(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+half4 operator.wwyx(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+half4 operator.wwyy(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+half4 operator.wwyz(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+half4 operator.wwyw(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+half4 operator.wwzx(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+half4 operator.wwzy(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+half4 operator.wwzz(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+half4 operator.wwzw(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+half4 operator.wwwx(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+half4 operator.wwwy(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+half4 operator.wwwz(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+half4 operator.wwww(half4 v) { >+ half4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+float2 operator.xx(float2 v) { >+ float2 result; >+ result.x = v.x; >+ result.y = v.x; >+ return result; >+} >+float2 operator.xy(float2 v) { >+ float2 result; >+ result.x = v.x; >+ result.y = v.y; >+ return result; >+} >+float2 operator.xy=(float2 v, float2 c) { >+ float2 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ return result; >+} >+float2 operator.yx(float2 v) { >+ float2 result; >+ result.x = v.y; >+ result.y = v.x; >+ return result; >+} >+float2 operator.yx=(float2 v, float2 c) { >+ float2 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ return result; >+} >+float2 operator.yy(float2 v) { >+ float2 result; >+ result.x = v.y; >+ result.y = v.y; >+ return result; >+} >+float2 operator.xx(float3 v) { >+ float2 result; >+ result.x = v.x; >+ result.y = v.x; >+ return result; >+} >+float2 operator.xy(float3 v) { >+ float2 result; >+ result.x = v.x; >+ result.y = v.y; >+ return result; >+} >+float3 operator.xy=(float3 v, float2 c) { >+ float3 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ return result; >+} >+float2 operator.xz(float3 v) { >+ float2 result; >+ result.x = v.x; >+ result.y = v.z; >+ return result; >+} >+float3 operator.xz=(float3 v, float2 c) { >+ float3 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ return result; >+} >+float2 operator.yx(float3 v) { >+ float2 result; >+ result.x = v.y; >+ result.y = v.x; >+ return result; >+} >+float3 operator.yx=(float3 v, float2 c) { >+ float3 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ return result; >+} >+float2 operator.yy(float3 v) { >+ float2 result; >+ result.x = v.y; >+ result.y = v.y; >+ return result; >+} >+float2 operator.yz(float3 v) { >+ float2 result; >+ result.x = v.y; >+ result.y = v.z; >+ return result; >+} >+float3 operator.yz=(float3 v, float2 c) { >+ float3 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ return result; >+} >+float2 operator.zx(float3 v) { >+ float2 result; >+ result.x = v.z; >+ result.y = v.x; >+ return result; >+} >+float3 operator.zx=(float3 v, float2 c) { >+ float3 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ return result; >+} >+float2 operator.zy(float3 v) { >+ float2 result; >+ result.x = v.z; >+ result.y = v.y; >+ return result; >+} >+float3 operator.zy=(float3 v, float2 c) { >+ float3 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ return result; >+} >+float2 operator.zz(float3 v) { >+ float2 result; >+ result.x = v.z; >+ result.y = v.z; >+ return result; >+} >+float2 operator.xx(float4 v) { >+ float2 result; >+ result.x = v.x; >+ result.y = v.x; >+ return result; >+} >+float2 operator.xy(float4 v) { >+ float2 result; >+ result.x = v.x; >+ result.y = v.y; >+ return result; >+} >+float4 operator.xy=(float4 v, float2 c) { >+ float4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ return result; >+} >+float2 operator.xz(float4 v) { >+ float2 result; >+ result.x = v.x; >+ result.y = v.z; >+ return result; >+} >+float4 operator.xz=(float4 v, float2 c) { >+ float4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ return result; >+} >+float2 operator.xw(float4 v) { >+ float2 result; >+ result.x = v.x; >+ result.y = v.w; >+ return result; >+} >+float4 operator.xw=(float4 v, float2 c) { >+ float4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ return result; >+} >+float2 operator.yx(float4 v) { >+ float2 result; >+ result.x = v.y; >+ result.y = v.x; >+ return result; >+} >+float4 operator.yx=(float4 v, float2 c) { >+ float4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ return result; >+} >+float2 operator.yy(float4 v) { >+ float2 result; >+ result.x = v.y; >+ result.y = v.y; >+ return result; >+} >+float2 operator.yz(float4 v) { >+ float2 result; >+ result.x = v.y; >+ result.y = v.z; >+ return result; >+} >+float4 operator.yz=(float4 v, float2 c) { >+ float4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ return result; >+} >+float2 operator.yw(float4 v) { >+ float2 result; >+ result.x = v.y; >+ result.y = v.w; >+ return result; >+} >+float4 operator.yw=(float4 v, float2 c) { >+ float4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ return result; >+} >+float2 operator.zx(float4 v) { >+ float2 result; >+ result.x = v.z; >+ result.y = v.x; >+ return result; >+} >+float4 operator.zx=(float4 v, float2 c) { >+ float4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ return result; >+} >+float2 operator.zy(float4 v) { >+ float2 result; >+ result.x = v.z; >+ result.y = v.y; >+ return result; >+} >+float4 operator.zy=(float4 v, float2 c) { >+ float4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ return result; >+} >+float2 operator.zz(float4 v) { >+ float2 result; >+ result.x = v.z; >+ result.y = v.z; >+ return result; >+} >+float2 operator.zw(float4 v) { >+ float2 result; >+ result.x = v.z; >+ result.y = v.w; >+ return result; >+} >+float4 operator.zw=(float4 v, float2 c) { >+ float4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ return result; >+} >+float2 operator.wx(float4 v) { >+ float2 result; >+ result.x = v.w; >+ result.y = v.x; >+ return result; >+} >+float4 operator.wx=(float4 v, float2 c) { >+ float4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ return result; >+} >+float2 operator.wy(float4 v) { >+ float2 result; >+ result.x = v.w; >+ result.y = v.y; >+ return result; >+} >+float4 operator.wy=(float4 v, float2 c) { >+ float4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ return result; >+} >+float2 operator.wz(float4 v) { >+ float2 result; >+ result.x = v.w; >+ result.y = v.z; >+ return result; >+} >+float4 operator.wz=(float4 v, float2 c) { >+ float4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ return result; >+} >+float2 operator.ww(float4 v) { >+ float2 result; >+ result.x = v.w; >+ result.y = v.w; >+ return result; >+} >+float3 operator.xxx(float2 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+float3 operator.xxy(float2 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+float3 operator.xyx(float2 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+float3 operator.xyy(float2 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+float3 operator.yxx(float2 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+float3 operator.yxy(float2 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+float3 operator.yyx(float2 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+float3 operator.yyy(float2 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+float3 operator.xxx(float3 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+float3 operator.xxy(float3 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+float3 operator.xxz(float3 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+float3 operator.xyx(float3 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+float3 operator.xyy(float3 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+float3 operator.xyz(float3 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+float3 operator.xyz=(float3 v, float3 c) { >+ float3 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ return result; >+} >+float3 operator.xzx(float3 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+float3 operator.xzy(float3 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+float3 operator.xzy=(float3 v, float3 c) { >+ float3 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ return result; >+} >+float3 operator.xzz(float3 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+float3 operator.yxx(float3 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+float3 operator.yxy(float3 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+float3 operator.yxz(float3 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+float3 operator.yxz=(float3 v, float3 c) { >+ float3 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ return result; >+} >+float3 operator.yyx(float3 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+float3 operator.yyy(float3 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+float3 operator.yyz(float3 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+float3 operator.yzx(float3 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+float3 operator.yzx=(float3 v, float3 c) { >+ float3 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ return result; >+} >+float3 operator.yzy(float3 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+float3 operator.yzz(float3 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+float3 operator.zxx(float3 v) { >+ float3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+float3 operator.zxy(float3 v) { >+ float3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+float3 operator.zxy=(float3 v, float3 c) { >+ float3 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ return result; >+} >+float3 operator.zxz(float3 v) { >+ float3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+float3 operator.zyx(float3 v) { >+ float3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+float3 operator.zyx=(float3 v, float3 c) { >+ float3 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ return result; >+} >+float3 operator.zyy(float3 v) { >+ float3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+float3 operator.zyz(float3 v) { >+ float3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+float3 operator.zzx(float3 v) { >+ float3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+float3 operator.zzy(float3 v) { >+ float3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+float3 operator.zzz(float3 v) { >+ float3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+float3 operator.xxx(float4 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+float3 operator.xxy(float4 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+float3 operator.xxz(float4 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+float3 operator.xxw(float4 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+float3 operator.xyx(float4 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+float3 operator.xyy(float4 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+float3 operator.xyz(float4 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+float4 operator.xyz=(float4 v, float3 c) { >+ float4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ return result; >+} >+float3 operator.xyw(float4 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+float4 operator.xyw=(float4 v, float3 c) { >+ float4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ return result; >+} >+float3 operator.xzx(float4 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+float3 operator.xzy(float4 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+float4 operator.xzy=(float4 v, float3 c) { >+ float4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ return result; >+} >+float3 operator.xzz(float4 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+float3 operator.xzw(float4 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+float4 operator.xzw=(float4 v, float3 c) { >+ float4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ return result; >+} >+float3 operator.xwx(float4 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+float3 operator.xwy(float4 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+float4 operator.xwy=(float4 v, float3 c) { >+ float4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ return result; >+} >+float3 operator.xwz(float4 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+float4 operator.xwz=(float4 v, float3 c) { >+ float4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ return result; >+} >+float3 operator.xww(float4 v) { >+ float3 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+float3 operator.yxx(float4 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+float3 operator.yxy(float4 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+float3 operator.yxz(float4 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+float4 operator.yxz=(float4 v, float3 c) { >+ float4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ return result; >+} >+float3 operator.yxw(float4 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+float4 operator.yxw=(float4 v, float3 c) { >+ float4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ return result; >+} >+float3 operator.yyx(float4 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+float3 operator.yyy(float4 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+float3 operator.yyz(float4 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+float3 operator.yyw(float4 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+float3 operator.yzx(float4 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+float4 operator.yzx=(float4 v, float3 c) { >+ float4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ return result; >+} >+float3 operator.yzy(float4 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+float3 operator.yzz(float4 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+float3 operator.yzw(float4 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+float4 operator.yzw=(float4 v, float3 c) { >+ float4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ return result; >+} >+float3 operator.ywx(float4 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+float4 operator.ywx=(float4 v, float3 c) { >+ float4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ return result; >+} >+float3 operator.ywy(float4 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+float3 operator.ywz(float4 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+float4 operator.ywz=(float4 v, float3 c) { >+ float4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ return result; >+} >+float3 operator.yww(float4 v) { >+ float3 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+float3 operator.zxx(float4 v) { >+ float3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+float3 operator.zxy(float4 v) { >+ float3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+float4 operator.zxy=(float4 v, float3 c) { >+ float4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ return result; >+} >+float3 operator.zxz(float4 v) { >+ float3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+float3 operator.zxw(float4 v) { >+ float3 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+float4 operator.zxw=(float4 v, float3 c) { >+ float4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ return result; >+} >+float3 operator.zyx(float4 v) { >+ float3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+float4 operator.zyx=(float4 v, float3 c) { >+ float4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ return result; >+} >+float3 operator.zyy(float4 v) { >+ float3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+float3 operator.zyz(float4 v) { >+ float3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+float3 operator.zyw(float4 v) { >+ float3 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+float4 operator.zyw=(float4 v, float3 c) { >+ float4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ return result; >+} >+float3 operator.zzx(float4 v) { >+ float3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+float3 operator.zzy(float4 v) { >+ float3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+float3 operator.zzz(float4 v) { >+ float3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+float3 operator.zzw(float4 v) { >+ float3 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+float3 operator.zwx(float4 v) { >+ float3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+float4 operator.zwx=(float4 v, float3 c) { >+ float4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ return result; >+} >+float3 operator.zwy(float4 v) { >+ float3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+float4 operator.zwy=(float4 v, float3 c) { >+ float4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ return result; >+} >+float3 operator.zwz(float4 v) { >+ float3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+float3 operator.zww(float4 v) { >+ float3 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+float3 operator.wxx(float4 v) { >+ float3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ return result; >+} >+float3 operator.wxy(float4 v) { >+ float3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ return result; >+} >+float4 operator.wxy=(float4 v, float3 c) { >+ float4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ return result; >+} >+float3 operator.wxz(float4 v) { >+ float3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ return result; >+} >+float4 operator.wxz=(float4 v, float3 c) { >+ float4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ return result; >+} >+float3 operator.wxw(float4 v) { >+ float3 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ return result; >+} >+float3 operator.wyx(float4 v) { >+ float3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ return result; >+} >+float4 operator.wyx=(float4 v, float3 c) { >+ float4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ return result; >+} >+float3 operator.wyy(float4 v) { >+ float3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ return result; >+} >+float3 operator.wyz(float4 v) { >+ float3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ return result; >+} >+float4 operator.wyz=(float4 v, float3 c) { >+ float4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ return result; >+} >+float3 operator.wyw(float4 v) { >+ float3 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ return result; >+} >+float3 operator.wzx(float4 v) { >+ float3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ return result; >+} >+float4 operator.wzx=(float4 v, float3 c) { >+ float4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ return result; >+} >+float3 operator.wzy(float4 v) { >+ float3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ return result; >+} >+float4 operator.wzy=(float4 v, float3 c) { >+ float4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ return result; >+} >+float3 operator.wzz(float4 v) { >+ float3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ return result; >+} >+float3 operator.wzw(float4 v) { >+ float3 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ return result; >+} >+float3 operator.wwx(float4 v) { >+ float3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ return result; >+} >+float3 operator.wwy(float4 v) { >+ float3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ return result; >+} >+float3 operator.wwz(float4 v) { >+ float3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ return result; >+} >+float3 operator.www(float4 v) { >+ float3 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ return result; >+} >+float4 operator.xxxx(float2 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xxxy(float2 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xxyx(float2 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xxyy(float2 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xyxx(float2 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xyxy(float2 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xyyx(float2 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xyyy(float2 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.yxxx(float2 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.yxxy(float2 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.yxyx(float2 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.yxyy(float2 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.yyxx(float2 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.yyxy(float2 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.yyyx(float2 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.yyyy(float2 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xxxx(float3 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xxxy(float3 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xxxz(float3 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+float4 operator.xxyx(float3 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xxyy(float3 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xxyz(float3 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+float4 operator.xxzx(float3 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xxzy(float3 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xxzz(float3 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+float4 operator.xyxx(float3 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xyxy(float3 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xyxz(float3 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+float4 operator.xyyx(float3 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xyyy(float3 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xyyz(float3 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+float4 operator.xyzx(float3 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xyzy(float3 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xyzz(float3 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+float4 operator.xzxx(float3 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xzxy(float3 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xzxz(float3 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+float4 operator.xzyx(float3 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xzyy(float3 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xzyz(float3 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+float4 operator.xzzx(float3 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xzzy(float3 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xzzz(float3 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+float4 operator.yxxx(float3 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.yxxy(float3 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.yxxz(float3 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+float4 operator.yxyx(float3 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.yxyy(float3 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.yxyz(float3 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+float4 operator.yxzx(float3 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+float4 operator.yxzy(float3 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+float4 operator.yxzz(float3 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+float4 operator.yyxx(float3 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.yyxy(float3 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.yyxz(float3 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+float4 operator.yyyx(float3 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.yyyy(float3 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.yyyz(float3 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+float4 operator.yyzx(float3 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+float4 operator.yyzy(float3 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+float4 operator.yyzz(float3 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+float4 operator.yzxx(float3 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.yzxy(float3 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.yzxz(float3 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+float4 operator.yzyx(float3 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.yzyy(float3 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.yzyz(float3 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+float4 operator.yzzx(float3 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+float4 operator.yzzy(float3 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+float4 operator.yzzz(float3 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+float4 operator.zxxx(float3 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.zxxy(float3 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.zxxz(float3 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+float4 operator.zxyx(float3 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.zxyy(float3 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.zxyz(float3 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+float4 operator.zxzx(float3 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+float4 operator.zxzy(float3 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+float4 operator.zxzz(float3 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+float4 operator.zyxx(float3 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.zyxy(float3 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.zyxz(float3 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+float4 operator.zyyx(float3 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.zyyy(float3 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.zyyz(float3 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+float4 operator.zyzx(float3 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+float4 operator.zyzy(float3 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+float4 operator.zyzz(float3 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+float4 operator.zzxx(float3 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.zzxy(float3 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.zzxz(float3 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+float4 operator.zzyx(float3 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.zzyy(float3 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.zzyz(float3 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+float4 operator.zzzx(float3 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+float4 operator.zzzy(float3 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+float4 operator.zzzz(float3 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+float4 operator.xxxx(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xxxy(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xxxz(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+float4 operator.xxxw(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+float4 operator.xxyx(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xxyy(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xxyz(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+float4 operator.xxyw(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+float4 operator.xxzx(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xxzy(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xxzz(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+float4 operator.xxzw(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+float4 operator.xxwx(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xxwy(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xxwz(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+float4 operator.xxww(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+float4 operator.xyxx(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xyxy(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xyxz(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+float4 operator.xyxw(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+float4 operator.xyyx(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xyyy(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xyyz(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+float4 operator.xyyw(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+float4 operator.xyzx(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xyzy(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xyzz(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+float4 operator.xyzw(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+float4 operator.xyzw=(float4 v, float4 c) { >+ float4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ result.w = c.w; >+ return result; >+} >+float4 operator.xywx(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xywy(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xywz(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+float4 operator.xywz=(float4 v, float4 c) { >+ float4 result = v; >+ result.x = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ result.z = c.w; >+ return result; >+} >+float4 operator.xyww(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+float4 operator.xzxx(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xzxy(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xzxz(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+float4 operator.xzxw(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+float4 operator.xzyx(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xzyy(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xzyz(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+float4 operator.xzyw(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+float4 operator.xzyw=(float4 v, float4 c) { >+ float4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ result.w = c.w; >+ return result; >+} >+float4 operator.xzzx(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xzzy(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xzzz(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+float4 operator.xzzw(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+float4 operator.xzwx(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xzwy(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xzwy=(float4 v, float4 c) { >+ float4 result = v; >+ result.x = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ result.y = c.w; >+ return result; >+} >+float4 operator.xzwz(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+float4 operator.xzww(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+float4 operator.xwxx(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xwxy(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xwxz(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+float4 operator.xwxw(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+float4 operator.xwyx(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xwyy(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xwyz(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+float4 operator.xwyz=(float4 v, float4 c) { >+ float4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ result.z = c.w; >+ return result; >+} >+float4 operator.xwyw(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+float4 operator.xwzx(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xwzy(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xwzy=(float4 v, float4 c) { >+ float4 result = v; >+ result.x = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ result.y = c.w; >+ return result; >+} >+float4 operator.xwzz(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+float4 operator.xwzw(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+float4 operator.xwwx(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+float4 operator.xwwy(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+float4 operator.xwwz(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+float4 operator.xwww(float4 v) { >+ float4 result; >+ result.x = v.x; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+float4 operator.yxxx(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.yxxy(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.yxxz(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+float4 operator.yxxw(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+float4 operator.yxyx(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.yxyy(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.yxyz(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+float4 operator.yxyw(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+float4 operator.yxzx(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+float4 operator.yxzy(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+float4 operator.yxzz(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+float4 operator.yxzw(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+float4 operator.yxzw=(float4 v, float4 c) { >+ float4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ result.w = c.w; >+ return result; >+} >+float4 operator.yxwx(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+float4 operator.yxwy(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+float4 operator.yxwz(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+float4 operator.yxwz=(float4 v, float4 c) { >+ float4 result = v; >+ result.y = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ result.z = c.w; >+ return result; >+} >+float4 operator.yxww(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+float4 operator.yyxx(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.yyxy(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.yyxz(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+float4 operator.yyxw(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+float4 operator.yyyx(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.yyyy(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.yyyz(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+float4 operator.yyyw(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+float4 operator.yyzx(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+float4 operator.yyzy(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+float4 operator.yyzz(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+float4 operator.yyzw(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+float4 operator.yywx(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+float4 operator.yywy(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+float4 operator.yywz(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+float4 operator.yyww(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+float4 operator.yzxx(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.yzxy(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.yzxz(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+float4 operator.yzxw(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+float4 operator.yzxw=(float4 v, float4 c) { >+ float4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ result.w = c.w; >+ return result; >+} >+float4 operator.yzyx(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.yzyy(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.yzyz(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+float4 operator.yzyw(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+float4 operator.yzzx(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+float4 operator.yzzy(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+float4 operator.yzzz(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+float4 operator.yzzw(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+float4 operator.yzwx(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+float4 operator.yzwx=(float4 v, float4 c) { >+ float4 result = v; >+ result.y = c.x; >+ result.z = c.y; >+ result.w = c.z; >+ result.x = c.w; >+ return result; >+} >+float4 operator.yzwy(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+float4 operator.yzwz(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+float4 operator.yzww(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+float4 operator.ywxx(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.ywxy(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.ywxz(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+float4 operator.ywxz=(float4 v, float4 c) { >+ float4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ result.z = c.w; >+ return result; >+} >+float4 operator.ywxw(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+float4 operator.ywyx(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.ywyy(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.ywyz(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+float4 operator.ywyw(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+float4 operator.ywzx(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+float4 operator.ywzx=(float4 v, float4 c) { >+ float4 result = v; >+ result.y = c.x; >+ result.w = c.y; >+ result.z = c.z; >+ result.x = c.w; >+ return result; >+} >+float4 operator.ywzy(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+float4 operator.ywzz(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+float4 operator.ywzw(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+float4 operator.ywwx(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+float4 operator.ywwy(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+float4 operator.ywwz(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+float4 operator.ywww(float4 v) { >+ float4 result; >+ result.x = v.y; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+float4 operator.zxxx(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.zxxy(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.zxxz(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+float4 operator.zxxw(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+float4 operator.zxyx(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.zxyy(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.zxyz(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+float4 operator.zxyw(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+float4 operator.zxyw=(float4 v, float4 c) { >+ float4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ result.w = c.w; >+ return result; >+} >+float4 operator.zxzx(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+float4 operator.zxzy(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+float4 operator.zxzz(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+float4 operator.zxzw(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+float4 operator.zxwx(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+float4 operator.zxwy(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+float4 operator.zxwy=(float4 v, float4 c) { >+ float4 result = v; >+ result.z = c.x; >+ result.x = c.y; >+ result.w = c.z; >+ result.y = c.w; >+ return result; >+} >+float4 operator.zxwz(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+float4 operator.zxww(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+float4 operator.zyxx(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.zyxy(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.zyxz(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+float4 operator.zyxw(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+float4 operator.zyxw=(float4 v, float4 c) { >+ float4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ result.w = c.w; >+ return result; >+} >+float4 operator.zyyx(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.zyyy(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.zyyz(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+float4 operator.zyyw(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+float4 operator.zyzx(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+float4 operator.zyzy(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+float4 operator.zyzz(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+float4 operator.zyzw(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+float4 operator.zywx(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+float4 operator.zywx=(float4 v, float4 c) { >+ float4 result = v; >+ result.z = c.x; >+ result.y = c.y; >+ result.w = c.z; >+ result.x = c.w; >+ return result; >+} >+float4 operator.zywy(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+float4 operator.zywz(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+float4 operator.zyww(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+float4 operator.zzxx(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.zzxy(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.zzxz(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+float4 operator.zzxw(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+float4 operator.zzyx(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.zzyy(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.zzyz(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+float4 operator.zzyw(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+float4 operator.zzzx(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+float4 operator.zzzy(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+float4 operator.zzzz(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+float4 operator.zzzw(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+float4 operator.zzwx(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+float4 operator.zzwy(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+float4 operator.zzwz(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+float4 operator.zzww(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+float4 operator.zwxx(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.zwxy(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.zwxy=(float4 v, float4 c) { >+ float4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.x = c.z; >+ result.y = c.w; >+ return result; >+} >+float4 operator.zwxz(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+float4 operator.zwxw(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+float4 operator.zwyx(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.zwyx=(float4 v, float4 c) { >+ float4 result = v; >+ result.z = c.x; >+ result.w = c.y; >+ result.y = c.z; >+ result.x = c.w; >+ return result; >+} >+float4 operator.zwyy(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.zwyz(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+float4 operator.zwyw(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+float4 operator.zwzx(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+float4 operator.zwzy(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+float4 operator.zwzz(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+float4 operator.zwzw(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+float4 operator.zwwx(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+float4 operator.zwwy(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+float4 operator.zwwz(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+float4 operator.zwww(float4 v) { >+ float4 result; >+ result.x = v.z; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+float4 operator.wxxx(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.wxxy(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.wxxz(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+float4 operator.wxxw(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+float4 operator.wxyx(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.wxyy(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.wxyz(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+float4 operator.wxyz=(float4 v, float4 c) { >+ float4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.y = c.z; >+ result.z = c.w; >+ return result; >+} >+float4 operator.wxyw(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+float4 operator.wxzx(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+float4 operator.wxzy(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+float4 operator.wxzy=(float4 v, float4 c) { >+ float4 result = v; >+ result.w = c.x; >+ result.x = c.y; >+ result.z = c.z; >+ result.y = c.w; >+ return result; >+} >+float4 operator.wxzz(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+float4 operator.wxzw(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+float4 operator.wxwx(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+float4 operator.wxwy(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+float4 operator.wxwz(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+float4 operator.wxww(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.x; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+float4 operator.wyxx(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.wyxy(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.wyxz(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+float4 operator.wyxz=(float4 v, float4 c) { >+ float4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.x = c.z; >+ result.z = c.w; >+ return result; >+} >+float4 operator.wyxw(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+float4 operator.wyyx(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.wyyy(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.wyyz(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+float4 operator.wyyw(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+float4 operator.wyzx(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+float4 operator.wyzx=(float4 v, float4 c) { >+ float4 result = v; >+ result.w = c.x; >+ result.y = c.y; >+ result.z = c.z; >+ result.x = c.w; >+ return result; >+} >+float4 operator.wyzy(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+float4 operator.wyzz(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+float4 operator.wyzw(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+float4 operator.wywx(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+float4 operator.wywy(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+float4 operator.wywz(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+float4 operator.wyww(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.y; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+float4 operator.wzxx(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.wzxy(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.wzxy=(float4 v, float4 c) { >+ float4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.x = c.z; >+ result.y = c.w; >+ return result; >+} >+float4 operator.wzxz(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+float4 operator.wzxw(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+float4 operator.wzyx(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.wzyx=(float4 v, float4 c) { >+ float4 result = v; >+ result.w = c.x; >+ result.z = c.y; >+ result.y = c.z; >+ result.x = c.w; >+ return result; >+} >+float4 operator.wzyy(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.wzyz(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+float4 operator.wzyw(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+float4 operator.wzzx(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+float4 operator.wzzy(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+float4 operator.wzzz(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+float4 operator.wzzw(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+float4 operator.wzwx(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+float4 operator.wzwy(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+float4 operator.wzwz(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+float4 operator.wzww(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.z; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+float4 operator.wwxx(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.x; >+ return result; >+} >+float4 operator.wwxy(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.y; >+ return result; >+} >+float4 operator.wwxz(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.z; >+ return result; >+} >+float4 operator.wwxw(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.x; >+ result.w = v.w; >+ return result; >+} >+float4 operator.wwyx(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.x; >+ return result; >+} >+float4 operator.wwyy(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.y; >+ return result; >+} >+float4 operator.wwyz(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.z; >+ return result; >+} >+float4 operator.wwyw(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.y; >+ result.w = v.w; >+ return result; >+} >+float4 operator.wwzx(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.x; >+ return result; >+} >+float4 operator.wwzy(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.y; >+ return result; >+} >+float4 operator.wwzz(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.z; >+ return result; >+} >+float4 operator.wwzw(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.z; >+ result.w = v.w; >+ return result; >+} >+float4 operator.wwwx(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.x; >+ return result; >+} >+float4 operator.wwwy(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.y; >+ return result; >+} >+float4 operator.wwwz(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.z; >+ return result; >+} >+float4 operator.wwww(float4 v) { >+ float4 result; >+ result.x = v.w; >+ result.y = v.w; >+ result.z = v.w; >+ result.w = v.w; >+ return result; >+} >+native float cos(float); >+half cos(half x) { >+ return half(cos(float(x))); >+} >+native float sin(float); >+half sin(half x) { >+ return half(sin(float(x))); >+} >+native float tan(float); >+half tan(half x) { >+ return half(tan(float(x))); >+} >+native float acos(float); >+half acos(half x) { >+ return half(acos(float(x))); >+} >+native float asin(float); >+half asin(half x) { >+ return half(asin(float(x))); >+} >+native float atan(float); >+half atan(half x) { >+ return half(atan(float(x))); >+} >+native float cosh(float); >+half cosh(half x) { >+ return half(cosh(float(x))); >+} >+native float sinh(float); >+half sinh(half x) { >+ return half(sinh(float(x))); >+} >+native float tanh(float); >+half tanh(half x) { >+ return half(tanh(float(x))); >+} >+native float ceil(float); >+half ceil(half x) { >+ return half(ceil(float(x))); >+} >+native float exp(float); >+half exp(half x) { >+ return half(exp(float(x))); >+} >+native float floor(float); >+half floor(half x) { >+ return half(floor(float(x))); >+} >+native float log(float); >+half log(half x) { >+ return half(log(float(x))); >+} >+native float round(float); >+half round(half x) { >+ return half(round(float(x))); >+} >+native float trunc(float); >+half trunc(half x) { >+ return half(trunc(float(x))); >+} >+native fragment float ddx(float); >+half ddx(half x) { >+ return half(ddx(float(x))); >+} >+native fragment float ddy(float); >+half ddy(half x) { >+ return half(ddy(float(x))); >+} >+half sqrt(half x) { >+ return pow(x, 0.5); >+} >+half log2(half x) { >+ return log(x) / log(half(2)); >+} >+half log10(half x) { >+ return log(x) / log(half(10)); >+} >+half frac(half x) { >+ return x - floor(x); >+} >+half exp2(half x) { >+ return exp(x * log(half(2))); >+} >+half degrees(half x) { >+ return x * 180 / 3.14159; >+} >+half radians(half x) { >+ return x * 3.14159 / 180; >+} >+half rcp(half x) { >+ return 1 / x; >+} >+half rsqrt(half x) { >+ return 1 / sqrt(x); >+} >+half saturate(half x) { >+ return clamp(x, 0, 1); >+} >+half ddx_coarse(half x) { >+ return ddx(x); >+} >+half ddx_fine(half x) { >+ return ddx(x); >+} >+half ddy_coarse(half x) { >+ return ddy(x); >+} >+half ddy_fine(half x) { >+ return ddy(x); >+} >+half fwidth(half x) { >+ return abs(ddx(x)) + abs(ddy(x)); >+} >+half2 cos(half2 x) { >+ half2 result; >+ result[0] = cos(x[0]); >+ result[1] = cos(x[1]); >+ return result; >+} >+ >+half3 cos(half3 x) { >+ half3 result; >+ result[0] = cos(x[0]); >+ result[1] = cos(x[1]); >+ result[2] = cos(x[2]); >+ return result; >+} >+half4 cos(half4 x) { >+ half4 result; >+ result[0] = cos(x[0]); >+ result[1] = cos(x[1]); >+ result[2] = cos(x[2]); >+ result[3] = cos(x[3]); >+ return result; >+} >+half2x2 cos(half2x2 x) { >+ half2x2 result; >+ result[0][0] = cos(x[0][0]); >+ result[0][1] = cos(x[0][1]); >+ result[1][0] = cos(x[1][0]); >+ result[1][1] = cos(x[1][1]); >+ return result; >+} >+half2x3 cos(half2x3 x) { >+ half2x3 result; >+ result[0][0] = cos(x[0][0]); >+ result[0][1] = cos(x[0][1]); >+ result[0][2] = cos(x[0][2]); >+ result[1][0] = cos(x[1][0]); >+ result[1][1] = cos(x[1][1]); >+ result[1][2] = cos(x[1][2]); >+ return result; >+} >+half2x4 cos(half2x4 x) { >+ half2x4 result; >+ result[0][0] = cos(x[0][0]); >+ result[0][1] = cos(x[0][1]); >+ result[0][2] = cos(x[0][2]); >+ result[0][3] = cos(x[0][3]); >+ result[1][0] = cos(x[1][0]); >+ result[1][1] = cos(x[1][1]); >+ result[1][2] = cos(x[1][2]); >+ result[1][3] = cos(x[1][3]); >+ return result; >+} >+half3x2 cos(half3x2 x) { >+ half3x2 result; >+ result[0][0] = cos(x[0][0]); >+ result[0][1] = cos(x[0][1]); >+ result[1][0] = cos(x[1][0]); >+ result[1][1] = cos(x[1][1]); >+ result[2][0] = cos(x[2][0]); >+ result[2][1] = cos(x[2][1]); >+ return result; >+} >+half3x3 cos(half3x3 x) { >+ half3x3 result; >+ result[0][0] = cos(x[0][0]); >+ result[0][1] = cos(x[0][1]); >+ result[0][2] = cos(x[0][2]); >+ result[1][0] = cos(x[1][0]); >+ result[1][1] = cos(x[1][1]); >+ result[1][2] = cos(x[1][2]); >+ result[2][0] = cos(x[2][0]); >+ result[2][1] = cos(x[2][1]); >+ result[2][2] = cos(x[2][2]); >+ return result; >+} >+half3x4 cos(half3x4 x) { >+ half3x4 result; >+ result[0][0] = cos(x[0][0]); >+ result[0][1] = cos(x[0][1]); >+ result[0][2] = cos(x[0][2]); >+ result[0][3] = cos(x[0][3]); >+ result[1][0] = cos(x[1][0]); >+ result[1][1] = cos(x[1][1]); >+ result[1][2] = cos(x[1][2]); >+ result[1][3] = cos(x[1][3]); >+ result[2][0] = cos(x[2][0]); >+ result[2][1] = cos(x[2][1]); >+ result[2][2] = cos(x[2][2]); >+ result[2][3] = cos(x[2][3]); >+ return result; >+} >+half4x2 cos(half4x2 x) { >+ half4x2 result; >+ result[0][0] = cos(x[0][0]); >+ result[0][1] = cos(x[0][1]); >+ result[1][0] = cos(x[1][0]); >+ result[1][1] = cos(x[1][1]); >+ result[2][0] = cos(x[2][0]); >+ result[2][1] = cos(x[2][1]); >+ result[3][0] = cos(x[3][0]); >+ result[3][1] = cos(x[3][1]); >+ return result; >+} >+half4x3 cos(half4x3 x) { >+ half4x3 result; >+ result[0][0] = cos(x[0][0]); >+ result[0][1] = cos(x[0][1]); >+ result[0][2] = cos(x[0][2]); >+ result[1][0] = cos(x[1][0]); >+ result[1][1] = cos(x[1][1]); >+ result[1][2] = cos(x[1][2]); >+ result[2][0] = cos(x[2][0]); >+ result[2][1] = cos(x[2][1]); >+ result[2][2] = cos(x[2][2]); >+ result[3][0] = cos(x[3][0]); >+ result[3][1] = cos(x[3][1]); >+ result[3][2] = cos(x[3][2]); >+ return result; >+} >+half4x4 cos(half4x4 x) { >+ half4x4 result; >+ result[0][0] = cos(x[0][0]); >+ result[0][1] = cos(x[0][1]); >+ result[0][2] = cos(x[0][2]); >+ result[0][3] = cos(x[0][3]); >+ result[1][0] = cos(x[1][0]); >+ result[1][1] = cos(x[1][1]); >+ result[1][2] = cos(x[1][2]); >+ result[1][3] = cos(x[1][3]); >+ result[2][0] = cos(x[2][0]); >+ result[2][1] = cos(x[2][1]); >+ result[2][2] = cos(x[2][2]); >+ result[2][3] = cos(x[2][3]); >+ result[3][0] = cos(x[3][0]); >+ result[3][1] = cos(x[3][1]); >+ result[3][2] = cos(x[3][2]); >+ result[3][3] = cos(x[3][3]); >+ return result; >+} >+half2 sin(half2 x) { >+ half2 result; >+ result[0] = sin(x[0]); >+ result[1] = sin(x[1]); >+ return result; >+} >+half3 sin(half3 x) { >+ half3 result; >+ result[0] = sin(x[0]); >+ result[1] = sin(x[1]); >+ result[2] = sin(x[2]); >+ return result; >+} >+half4 sin(half4 x) { >+ half4 result; >+ result[0] = sin(x[0]); >+ result[1] = sin(x[1]); >+ result[2] = sin(x[2]); >+ result[3] = sin(x[3]); >+ return result; >+} >+half2x2 sin(half2x2 x) { >+ half2x2 result; >+ result[0][0] = sin(x[0][0]); >+ result[0][1] = sin(x[0][1]); >+ result[1][0] = sin(x[1][0]); >+ result[1][1] = sin(x[1][1]); >+ return result; >+} >+half2x3 sin(half2x3 x) { >+ half2x3 result; >+ result[0][0] = sin(x[0][0]); >+ result[0][1] = sin(x[0][1]); >+ result[0][2] = sin(x[0][2]); >+ result[1][0] = sin(x[1][0]); >+ result[1][1] = sin(x[1][1]); >+ result[1][2] = sin(x[1][2]); >+ return result; >+} >+half2x4 sin(half2x4 x) { >+ half2x4 result; >+ result[0][0] = sin(x[0][0]); >+ result[0][1] = sin(x[0][1]); >+ result[0][2] = sin(x[0][2]); >+ result[0][3] = sin(x[0][3]); >+ result[1][0] = sin(x[1][0]); >+ result[1][1] = sin(x[1][1]); >+ result[1][2] = sin(x[1][2]); >+ result[1][3] = sin(x[1][3]); >+ return result; >+} >+half3x2 sin(half3x2 x) { >+ half3x2 result; >+ result[0][0] = sin(x[0][0]); >+ result[0][1] = sin(x[0][1]); >+ result[1][0] = sin(x[1][0]); >+ result[1][1] = sin(x[1][1]); >+ result[2][0] = sin(x[2][0]); >+ result[2][1] = sin(x[2][1]); >+ return result; >+} >+half3x3 sin(half3x3 x) { >+ half3x3 result; >+ result[0][0] = sin(x[0][0]); >+ result[0][1] = sin(x[0][1]); >+ result[0][2] = sin(x[0][2]); >+ result[1][0] = sin(x[1][0]); >+ result[1][1] = sin(x[1][1]); >+ result[1][2] = sin(x[1][2]); >+ result[2][0] = sin(x[2][0]); >+ result[2][1] = sin(x[2][1]); >+ result[2][2] = sin(x[2][2]); >+ return result; >+} >+half3x4 sin(half3x4 x) { >+ half3x4 result; >+ result[0][0] = sin(x[0][0]); >+ result[0][1] = sin(x[0][1]); >+ result[0][2] = sin(x[0][2]); >+ result[0][3] = sin(x[0][3]); >+ result[1][0] = sin(x[1][0]); >+ result[1][1] = sin(x[1][1]); >+ result[1][2] = sin(x[1][2]); >+ result[1][3] = sin(x[1][3]); >+ result[2][0] = sin(x[2][0]); >+ result[2][1] = sin(x[2][1]); >+ result[2][2] = sin(x[2][2]); >+ result[2][3] = sin(x[2][3]); >+ return result; >+} >+half4x2 sin(half4x2 x) { >+ half4x2 result; >+ result[0][0] = sin(x[0][0]); >+ result[0][1] = sin(x[0][1]); >+ result[1][0] = sin(x[1][0]); >+ result[1][1] = sin(x[1][1]); >+ result[2][0] = sin(x[2][0]); >+ result[2][1] = sin(x[2][1]); >+ result[3][0] = sin(x[3][0]); >+ result[3][1] = sin(x[3][1]); >+ return result; >+} >+half4x3 sin(half4x3 x) { >+ half4x3 result; >+ result[0][0] = sin(x[0][0]); >+ result[0][1] = sin(x[0][1]); >+ result[0][2] = sin(x[0][2]); >+ result[1][0] = sin(x[1][0]); >+ result[1][1] = sin(x[1][1]); >+ result[1][2] = sin(x[1][2]); >+ result[2][0] = sin(x[2][0]); >+ result[2][1] = sin(x[2][1]); >+ result[2][2] = sin(x[2][2]); >+ result[3][0] = sin(x[3][0]); >+ result[3][1] = sin(x[3][1]); >+ result[3][2] = sin(x[3][2]); >+ return result; >+} >+half4x4 sin(half4x4 x) { >+ half4x4 result; >+ result[0][0] = sin(x[0][0]); >+ result[0][1] = sin(x[0][1]); >+ result[0][2] = sin(x[0][2]); >+ result[0][3] = sin(x[0][3]); >+ result[1][0] = sin(x[1][0]); >+ result[1][1] = sin(x[1][1]); >+ result[1][2] = sin(x[1][2]); >+ result[1][3] = sin(x[1][3]); >+ result[2][0] = sin(x[2][0]); >+ result[2][1] = sin(x[2][1]); >+ result[2][2] = sin(x[2][2]); >+ result[2][3] = sin(x[2][3]); >+ result[3][0] = sin(x[3][0]); >+ result[3][1] = sin(x[3][1]); >+ result[3][2] = sin(x[3][2]); >+ result[3][3] = sin(x[3][3]); >+ return result; >+} >+half2 tan(half2 x) { >+ half2 result; >+ result[0] = tan(x[0]); >+ result[1] = tan(x[1]); >+ return result; >+} >+half3 tan(half3 x) { >+ half3 result; >+ result[0] = tan(x[0]); >+ result[1] = tan(x[1]); >+ result[2] = tan(x[2]); >+ return result; >+} >+half4 tan(half4 x) { >+ half4 result; >+ result[0] = tan(x[0]); >+ result[1] = tan(x[1]); >+ result[2] = tan(x[2]); >+ result[3] = tan(x[3]); >+ return result; >+} >+half2x2 tan(half2x2 x) { >+ half2x2 result; >+ result[0][0] = tan(x[0][0]); >+ result[0][1] = tan(x[0][1]); >+ result[1][0] = tan(x[1][0]); >+ result[1][1] = tan(x[1][1]); >+ return result; >+} >+half2x3 tan(half2x3 x) { >+ half2x3 result; >+ result[0][0] = tan(x[0][0]); >+ result[0][1] = tan(x[0][1]); >+ result[0][2] = tan(x[0][2]); >+ result[1][0] = tan(x[1][0]); >+ result[1][1] = tan(x[1][1]); >+ result[1][2] = tan(x[1][2]); >+ return result; >+} >+half2x4 tan(half2x4 x) { >+ half2x4 result; >+ result[0][0] = tan(x[0][0]); >+ result[0][1] = tan(x[0][1]); >+ result[0][2] = tan(x[0][2]); >+ result[0][3] = tan(x[0][3]); >+ result[1][0] = tan(x[1][0]); >+ result[1][1] = tan(x[1][1]); >+ result[1][2] = tan(x[1][2]); >+ result[1][3] = tan(x[1][3]); >+ return result; >+} >+half3x2 tan(half3x2 x) { >+ half3x2 result; >+ result[0][0] = tan(x[0][0]); >+ result[0][1] = tan(x[0][1]); >+ result[1][0] = tan(x[1][0]); >+ result[1][1] = tan(x[1][1]); >+ result[2][0] = tan(x[2][0]); >+ result[2][1] = tan(x[2][1]); >+ return result; >+} >+half3x3 tan(half3x3 x) { >+ half3x3 result; >+ result[0][0] = tan(x[0][0]); >+ result[0][1] = tan(x[0][1]); >+ result[0][2] = tan(x[0][2]); >+ result[1][0] = tan(x[1][0]); >+ result[1][1] = tan(x[1][1]); >+ result[1][2] = tan(x[1][2]); >+ result[2][0] = tan(x[2][0]); >+ result[2][1] = tan(x[2][1]); >+ result[2][2] = tan(x[2][2]); >+ return result; >+} >+half3x4 tan(half3x4 x) { >+ half3x4 result; >+ result[0][0] = tan(x[0][0]); >+ result[0][1] = tan(x[0][1]); >+ result[0][2] = tan(x[0][2]); >+ result[0][3] = tan(x[0][3]); >+ result[1][0] = tan(x[1][0]); >+ result[1][1] = tan(x[1][1]); >+ result[1][2] = tan(x[1][2]); >+ result[1][3] = tan(x[1][3]); >+ result[2][0] = tan(x[2][0]); >+ result[2][1] = tan(x[2][1]); >+ result[2][2] = tan(x[2][2]); >+ result[2][3] = tan(x[2][3]); >+ return result; >+} >+half4x2 tan(half4x2 x) { >+ half4x2 result; >+ result[0][0] = tan(x[0][0]); >+ result[0][1] = tan(x[0][1]); >+ result[1][0] = tan(x[1][0]); >+ result[1][1] = tan(x[1][1]); >+ result[2][0] = tan(x[2][0]); >+ result[2][1] = tan(x[2][1]); >+ result[3][0] = tan(x[3][0]); >+ result[3][1] = tan(x[3][1]); >+ return result; >+} >+half4x3 tan(half4x3 x) { >+ half4x3 result; >+ result[0][0] = tan(x[0][0]); >+ result[0][1] = tan(x[0][1]); >+ result[0][2] = tan(x[0][2]); >+ result[1][0] = tan(x[1][0]); >+ result[1][1] = tan(x[1][1]); >+ result[1][2] = tan(x[1][2]); >+ result[2][0] = tan(x[2][0]); >+ result[2][1] = tan(x[2][1]); >+ result[2][2] = tan(x[2][2]); >+ result[3][0] = tan(x[3][0]); >+ result[3][1] = tan(x[3][1]); >+ result[3][2] = tan(x[3][2]); >+ return result; >+} >+half4x4 tan(half4x4 x) { >+ half4x4 result; >+ result[0][0] = tan(x[0][0]); >+ result[0][1] = tan(x[0][1]); >+ result[0][2] = tan(x[0][2]); >+ result[0][3] = tan(x[0][3]); >+ result[1][0] = tan(x[1][0]); >+ result[1][1] = tan(x[1][1]); >+ result[1][2] = tan(x[1][2]); >+ result[1][3] = tan(x[1][3]); >+ result[2][0] = tan(x[2][0]); >+ result[2][1] = tan(x[2][1]); >+ result[2][2] = tan(x[2][2]); >+ result[2][3] = tan(x[2][3]); >+ result[3][0] = tan(x[3][0]); >+ result[3][1] = tan(x[3][1]); >+ result[3][2] = tan(x[3][2]); >+ result[3][3] = tan(x[3][3]); >+ return result; >+} >+half2 acos(half2 x) { >+ half2 result; >+ result[0] = acos(x[0]); >+ result[1] = acos(x[1]); >+ return result; >+} >+half3 acos(half3 x) { >+ half3 result; >+ result[0] = acos(x[0]); >+ result[1] = acos(x[1]); >+ result[2] = acos(x[2]); >+ return result; >+} >+half4 acos(half4 x) { >+ half4 result; >+ result[0] = acos(x[0]); >+ result[1] = acos(x[1]); >+ result[2] = acos(x[2]); >+ result[3] = acos(x[3]); >+ return result; >+} >+half2x2 acos(half2x2 x) { >+ half2x2 result; >+ result[0][0] = acos(x[0][0]); >+ result[0][1] = acos(x[0][1]); >+ result[1][0] = acos(x[1][0]); >+ result[1][1] = acos(x[1][1]); >+ return result; >+} >+half2x3 acos(half2x3 x) { >+ half2x3 result; >+ result[0][0] = acos(x[0][0]); >+ result[0][1] = acos(x[0][1]); >+ result[0][2] = acos(x[0][2]); >+ result[1][0] = acos(x[1][0]); >+ result[1][1] = acos(x[1][1]); >+ result[1][2] = acos(x[1][2]); >+ return result; >+} >+half2x4 acos(half2x4 x) { >+ half2x4 result; >+ result[0][0] = acos(x[0][0]); >+ result[0][1] = acos(x[0][1]); >+ result[0][2] = acos(x[0][2]); >+ result[0][3] = acos(x[0][3]); >+ result[1][0] = acos(x[1][0]); >+ result[1][1] = acos(x[1][1]); >+ result[1][2] = acos(x[1][2]); >+ result[1][3] = acos(x[1][3]); >+ return result; >+} >+half3x2 acos(half3x2 x) { >+ half3x2 result; >+ result[0][0] = acos(x[0][0]); >+ result[0][1] = acos(x[0][1]); >+ result[1][0] = acos(x[1][0]); >+ result[1][1] = acos(x[1][1]); >+ result[2][0] = acos(x[2][0]); >+ result[2][1] = acos(x[2][1]); >+ return result; >+} >+half3x3 acos(half3x3 x) { >+ half3x3 result; >+ result[0][0] = acos(x[0][0]); >+ result[0][1] = acos(x[0][1]); >+ result[0][2] = acos(x[0][2]); >+ result[1][0] = acos(x[1][0]); >+ result[1][1] = acos(x[1][1]); >+ result[1][2] = acos(x[1][2]); >+ result[2][0] = acos(x[2][0]); >+ result[2][1] = acos(x[2][1]); >+ result[2][2] = acos(x[2][2]); >+ return result; >+} >+half3x4 acos(half3x4 x) { >+ half3x4 result; >+ result[0][0] = acos(x[0][0]); >+ result[0][1] = acos(x[0][1]); >+ result[0][2] = acos(x[0][2]); >+ result[0][3] = acos(x[0][3]); >+ result[1][0] = acos(x[1][0]); >+ result[1][1] = acos(x[1][1]); >+ result[1][2] = acos(x[1][2]); >+ result[1][3] = acos(x[1][3]); >+ result[2][0] = acos(x[2][0]); >+ result[2][1] = acos(x[2][1]); >+ result[2][2] = acos(x[2][2]); >+ result[2][3] = acos(x[2][3]); >+ return result; >+} >+half4x2 acos(half4x2 x) { >+ half4x2 result; >+ result[0][0] = acos(x[0][0]); >+ result[0][1] = acos(x[0][1]); >+ result[1][0] = acos(x[1][0]); >+ result[1][1] = acos(x[1][1]); >+ result[2][0] = acos(x[2][0]); >+ result[2][1] = acos(x[2][1]); >+ result[3][0] = acos(x[3][0]); >+ result[3][1] = acos(x[3][1]); >+ return result; >+} >+half4x3 acos(half4x3 x) { >+ half4x3 result; >+ result[0][0] = acos(x[0][0]); >+ result[0][1] = acos(x[0][1]); >+ result[0][2] = acos(x[0][2]); >+ result[1][0] = acos(x[1][0]); >+ result[1][1] = acos(x[1][1]); >+ result[1][2] = acos(x[1][2]); >+ result[2][0] = acos(x[2][0]); >+ result[2][1] = acos(x[2][1]); >+ result[2][2] = acos(x[2][2]); >+ result[3][0] = acos(x[3][0]); >+ result[3][1] = acos(x[3][1]); >+ result[3][2] = acos(x[3][2]); >+ return result; >+} >+half4x4 acos(half4x4 x) { >+ half4x4 result; >+ result[0][0] = acos(x[0][0]); >+ result[0][1] = acos(x[0][1]); >+ result[0][2] = acos(x[0][2]); >+ result[0][3] = acos(x[0][3]); >+ result[1][0] = acos(x[1][0]); >+ result[1][1] = acos(x[1][1]); >+ result[1][2] = acos(x[1][2]); >+ result[1][3] = acos(x[1][3]); >+ result[2][0] = acos(x[2][0]); >+ result[2][1] = acos(x[2][1]); >+ result[2][2] = acos(x[2][2]); >+ result[2][3] = acos(x[2][3]); >+ result[3][0] = acos(x[3][0]); >+ result[3][1] = acos(x[3][1]); >+ result[3][2] = acos(x[3][2]); >+ result[3][3] = acos(x[3][3]); >+ return result; >+} >+half2 asin(half2 x) { >+ half2 result; >+ result[0] = asin(x[0]); >+ result[1] = asin(x[1]); >+ return result; >+} >+half3 asin(half3 x) { >+ half3 result; >+ result[0] = asin(x[0]); >+ result[1] = asin(x[1]); >+ result[2] = asin(x[2]); >+ return result; >+} >+half4 asin(half4 x) { >+ half4 result; >+ result[0] = asin(x[0]); >+ result[1] = asin(x[1]); >+ result[2] = asin(x[2]); >+ result[3] = asin(x[3]); >+ return result; >+} >+half2x2 asin(half2x2 x) { >+ half2x2 result; >+ result[0][0] = asin(x[0][0]); >+ result[0][1] = asin(x[0][1]); >+ result[1][0] = asin(x[1][0]); >+ result[1][1] = asin(x[1][1]); >+ return result; >+} >+half2x3 asin(half2x3 x) { >+ half2x3 result; >+ result[0][0] = asin(x[0][0]); >+ result[0][1] = asin(x[0][1]); >+ result[0][2] = asin(x[0][2]); >+ result[1][0] = asin(x[1][0]); >+ result[1][1] = asin(x[1][1]); >+ result[1][2] = asin(x[1][2]); >+ return result; >+} >+half2x4 asin(half2x4 x) { >+ half2x4 result; >+ result[0][0] = asin(x[0][0]); >+ result[0][1] = asin(x[0][1]); >+ result[0][2] = asin(x[0][2]); >+ result[0][3] = asin(x[0][3]); >+ result[1][0] = asin(x[1][0]); >+ result[1][1] = asin(x[1][1]); >+ result[1][2] = asin(x[1][2]); >+ result[1][3] = asin(x[1][3]); >+ return result; >+} >+half3x2 asin(half3x2 x) { >+ half3x2 result; >+ result[0][0] = asin(x[0][0]); >+ result[0][1] = asin(x[0][1]); >+ result[1][0] = asin(x[1][0]); >+ result[1][1] = asin(x[1][1]); >+ result[2][0] = asin(x[2][0]); >+ result[2][1] = asin(x[2][1]); >+ return result; >+} >+half3x3 asin(half3x3 x) { >+ half3x3 result; >+ result[0][0] = asin(x[0][0]); >+ result[0][1] = asin(x[0][1]); >+ result[0][2] = asin(x[0][2]); >+ result[1][0] = asin(x[1][0]); >+ result[1][1] = asin(x[1][1]); >+ result[1][2] = asin(x[1][2]); >+ result[2][0] = asin(x[2][0]); >+ result[2][1] = asin(x[2][1]); >+ result[2][2] = asin(x[2][2]); >+ return result; >+} >+half3x4 asin(half3x4 x) { >+ half3x4 result; >+ result[0][0] = asin(x[0][0]); >+ result[0][1] = asin(x[0][1]); >+ result[0][2] = asin(x[0][2]); >+ result[0][3] = asin(x[0][3]); >+ result[1][0] = asin(x[1][0]); >+ result[1][1] = asin(x[1][1]); >+ result[1][2] = asin(x[1][2]); >+ result[1][3] = asin(x[1][3]); >+ result[2][0] = asin(x[2][0]); >+ result[2][1] = asin(x[2][1]); >+ result[2][2] = asin(x[2][2]); >+ result[2][3] = asin(x[2][3]); >+ return result; >+} >+half4x2 asin(half4x2 x) { >+ half4x2 result; >+ result[0][0] = asin(x[0][0]); >+ result[0][1] = asin(x[0][1]); >+ result[1][0] = asin(x[1][0]); >+ result[1][1] = asin(x[1][1]); >+ result[2][0] = asin(x[2][0]); >+ result[2][1] = asin(x[2][1]); >+ result[3][0] = asin(x[3][0]); >+ result[3][1] = asin(x[3][1]); >+ return result; >+} >+half4x3 asin(half4x3 x) { >+ half4x3 result; >+ result[0][0] = asin(x[0][0]); >+ result[0][1] = asin(x[0][1]); >+ result[0][2] = asin(x[0][2]); >+ result[1][0] = asin(x[1][0]); >+ result[1][1] = asin(x[1][1]); >+ result[1][2] = asin(x[1][2]); >+ result[2][0] = asin(x[2][0]); >+ result[2][1] = asin(x[2][1]); >+ result[2][2] = asin(x[2][2]); >+ result[3][0] = asin(x[3][0]); >+ result[3][1] = asin(x[3][1]); >+ result[3][2] = asin(x[3][2]); >+ return result; >+} >+half4x4 asin(half4x4 x) { >+ half4x4 result; >+ result[0][0] = asin(x[0][0]); >+ result[0][1] = asin(x[0][1]); >+ result[0][2] = asin(x[0][2]); >+ result[0][3] = asin(x[0][3]); >+ result[1][0] = asin(x[1][0]); >+ result[1][1] = asin(x[1][1]); >+ result[1][2] = asin(x[1][2]); >+ result[1][3] = asin(x[1][3]); >+ result[2][0] = asin(x[2][0]); >+ result[2][1] = asin(x[2][1]); >+ result[2][2] = asin(x[2][2]); >+ result[2][3] = asin(x[2][3]); >+ result[3][0] = asin(x[3][0]); >+ result[3][1] = asin(x[3][1]); >+ result[3][2] = asin(x[3][2]); >+ result[3][3] = asin(x[3][3]); >+ return result; >+} >+half2 atan(half2 x) { >+ half2 result; >+ result[0] = atan(x[0]); >+ result[1] = atan(x[1]); >+ return result; >+} >+half3 atan(half3 x) { >+ half3 result; >+ result[0] = atan(x[0]); >+ result[1] = atan(x[1]); >+ result[2] = atan(x[2]); >+ return result; >+} >+half4 atan(half4 x) { >+ half4 result; >+ result[0] = atan(x[0]); >+ result[1] = atan(x[1]); >+ result[2] = atan(x[2]); >+ result[3] = atan(x[3]); >+ return result; >+} >+half2x2 atan(half2x2 x) { >+ half2x2 result; >+ result[0][0] = atan(x[0][0]); >+ result[0][1] = atan(x[0][1]); >+ result[1][0] = atan(x[1][0]); >+ result[1][1] = atan(x[1][1]); >+ return result; >+} >+half2x3 atan(half2x3 x) { >+ half2x3 result; >+ result[0][0] = atan(x[0][0]); >+ result[0][1] = atan(x[0][1]); >+ result[0][2] = atan(x[0][2]); >+ result[1][0] = atan(x[1][0]); >+ result[1][1] = atan(x[1][1]); >+ result[1][2] = atan(x[1][2]); >+ return result; >+} >+half2x4 atan(half2x4 x) { >+ half2x4 result; >+ result[0][0] = atan(x[0][0]); >+ result[0][1] = atan(x[0][1]); >+ result[0][2] = atan(x[0][2]); >+ result[0][3] = atan(x[0][3]); >+ result[1][0] = atan(x[1][0]); >+ result[1][1] = atan(x[1][1]); >+ result[1][2] = atan(x[1][2]); >+ result[1][3] = atan(x[1][3]); >+ return result; >+} >+half3x2 atan(half3x2 x) { >+ half3x2 result; >+ result[0][0] = atan(x[0][0]); >+ result[0][1] = atan(x[0][1]); >+ result[1][0] = atan(x[1][0]); >+ result[1][1] = atan(x[1][1]); >+ result[2][0] = atan(x[2][0]); >+ result[2][1] = atan(x[2][1]); >+ return result; >+} >+half3x3 atan(half3x3 x) { >+ half3x3 result; >+ result[0][0] = atan(x[0][0]); >+ result[0][1] = atan(x[0][1]); >+ result[0][2] = atan(x[0][2]); >+ result[1][0] = atan(x[1][0]); >+ result[1][1] = atan(x[1][1]); >+ result[1][2] = atan(x[1][2]); >+ result[2][0] = atan(x[2][0]); >+ result[2][1] = atan(x[2][1]); >+ result[2][2] = atan(x[2][2]); >+ return result; >+} >+half3x4 atan(half3x4 x) { >+ half3x4 result; >+ result[0][0] = atan(x[0][0]); >+ result[0][1] = atan(x[0][1]); >+ result[0][2] = atan(x[0][2]); >+ result[0][3] = atan(x[0][3]); >+ result[1][0] = atan(x[1][0]); >+ result[1][1] = atan(x[1][1]); >+ result[1][2] = atan(x[1][2]); >+ result[1][3] = atan(x[1][3]); >+ result[2][0] = atan(x[2][0]); >+ result[2][1] = atan(x[2][1]); >+ result[2][2] = atan(x[2][2]); >+ result[2][3] = atan(x[2][3]); >+ return result; >+} >+half4x2 atan(half4x2 x) { >+ half4x2 result; >+ result[0][0] = atan(x[0][0]); >+ result[0][1] = atan(x[0][1]); >+ result[1][0] = atan(x[1][0]); >+ result[1][1] = atan(x[1][1]); >+ result[2][0] = atan(x[2][0]); >+ result[2][1] = atan(x[2][1]); >+ result[3][0] = atan(x[3][0]); >+ result[3][1] = atan(x[3][1]); >+ return result; >+} >+half4x3 atan(half4x3 x) { >+ half4x3 result; >+ result[0][0] = atan(x[0][0]); >+ result[0][1] = atan(x[0][1]); >+ result[0][2] = atan(x[0][2]); >+ result[1][0] = atan(x[1][0]); >+ result[1][1] = atan(x[1][1]); >+ result[1][2] = atan(x[1][2]); >+ result[2][0] = atan(x[2][0]); >+ result[2][1] = atan(x[2][1]); >+ result[2][2] = atan(x[2][2]); >+ result[3][0] = atan(x[3][0]); >+ result[3][1] = atan(x[3][1]); >+ result[3][2] = atan(x[3][2]); >+ return result; >+} >+half4x4 atan(half4x4 x) { >+ half4x4 result; >+ result[0][0] = atan(x[0][0]); >+ result[0][1] = atan(x[0][1]); >+ result[0][2] = atan(x[0][2]); >+ result[0][3] = atan(x[0][3]); >+ result[1][0] = atan(x[1][0]); >+ result[1][1] = atan(x[1][1]); >+ result[1][2] = atan(x[1][2]); >+ result[1][3] = atan(x[1][3]); >+ result[2][0] = atan(x[2][0]); >+ result[2][1] = atan(x[2][1]); >+ result[2][2] = atan(x[2][2]); >+ result[2][3] = atan(x[2][3]); >+ result[3][0] = atan(x[3][0]); >+ result[3][1] = atan(x[3][1]); >+ result[3][2] = atan(x[3][2]); >+ result[3][3] = atan(x[3][3]); >+ return result; >+} >+half2 cosh(half2 x) { >+ half2 result; >+ result[0] = cosh(x[0]); >+ result[1] = cosh(x[1]); >+ return result; >+} >+half3 cosh(half3 x) { >+ half3 result; >+ result[0] = cosh(x[0]); >+ result[1] = cosh(x[1]); >+ result[2] = cosh(x[2]); >+ return result; >+} >+half4 cosh(half4 x) { >+ half4 result; >+ result[0] = cosh(x[0]); >+ result[1] = cosh(x[1]); >+ result[2] = cosh(x[2]); >+ result[3] = cosh(x[3]); >+ return result; >+} >+half2x2 cosh(half2x2 x) { >+ half2x2 result; >+ result[0][0] = cosh(x[0][0]); >+ result[0][1] = cosh(x[0][1]); >+ result[1][0] = cosh(x[1][0]); >+ result[1][1] = cosh(x[1][1]); >+ return result; >+} >+half2x3 cosh(half2x3 x) { >+ half2x3 result; >+ result[0][0] = cosh(x[0][0]); >+ result[0][1] = cosh(x[0][1]); >+ result[0][2] = cosh(x[0][2]); >+ result[1][0] = cosh(x[1][0]); >+ result[1][1] = cosh(x[1][1]); >+ result[1][2] = cosh(x[1][2]); >+ return result; >+} >+half2x4 cosh(half2x4 x) { >+ half2x4 result; >+ result[0][0] = cosh(x[0][0]); >+ result[0][1] = cosh(x[0][1]); >+ result[0][2] = cosh(x[0][2]); >+ result[0][3] = cosh(x[0][3]); >+ result[1][0] = cosh(x[1][0]); >+ result[1][1] = cosh(x[1][1]); >+ result[1][2] = cosh(x[1][2]); >+ result[1][3] = cosh(x[1][3]); >+ return result; >+} >+half3x2 cosh(half3x2 x) { >+ half3x2 result; >+ result[0][0] = cosh(x[0][0]); >+ result[0][1] = cosh(x[0][1]); >+ result[1][0] = cosh(x[1][0]); >+ result[1][1] = cosh(x[1][1]); >+ result[2][0] = cosh(x[2][0]); >+ result[2][1] = cosh(x[2][1]); >+ return result; >+} >+half3x3 cosh(half3x3 x) { >+ half3x3 result; >+ result[0][0] = cosh(x[0][0]); >+ result[0][1] = cosh(x[0][1]); >+ result[0][2] = cosh(x[0][2]); >+ result[1][0] = cosh(x[1][0]); >+ result[1][1] = cosh(x[1][1]); >+ result[1][2] = cosh(x[1][2]); >+ result[2][0] = cosh(x[2][0]); >+ result[2][1] = cosh(x[2][1]); >+ result[2][2] = cosh(x[2][2]); >+ return result; >+} >+half3x4 cosh(half3x4 x) { >+ half3x4 result; >+ result[0][0] = cosh(x[0][0]); >+ result[0][1] = cosh(x[0][1]); >+ result[0][2] = cosh(x[0][2]); >+ result[0][3] = cosh(x[0][3]); >+ result[1][0] = cosh(x[1][0]); >+ result[1][1] = cosh(x[1][1]); >+ result[1][2] = cosh(x[1][2]); >+ result[1][3] = cosh(x[1][3]); >+ result[2][0] = cosh(x[2][0]); >+ result[2][1] = cosh(x[2][1]); >+ result[2][2] = cosh(x[2][2]); >+ result[2][3] = cosh(x[2][3]); >+ return result; >+} >+half4x2 cosh(half4x2 x) { >+ half4x2 result; >+ result[0][0] = cosh(x[0][0]); >+ result[0][1] = cosh(x[0][1]); >+ result[1][0] = cosh(x[1][0]); >+ result[1][1] = cosh(x[1][1]); >+ result[2][0] = cosh(x[2][0]); >+ result[2][1] = cosh(x[2][1]); >+ result[3][0] = cosh(x[3][0]); >+ result[3][1] = cosh(x[3][1]); >+ return result; >+} >+half4x3 cosh(half4x3 x) { >+ half4x3 result; >+ result[0][0] = cosh(x[0][0]); >+ result[0][1] = cosh(x[0][1]); >+ result[0][2] = cosh(x[0][2]); >+ result[1][0] = cosh(x[1][0]); >+ result[1][1] = cosh(x[1][1]); >+ result[1][2] = cosh(x[1][2]); >+ result[2][0] = cosh(x[2][0]); >+ result[2][1] = cosh(x[2][1]); >+ result[2][2] = cosh(x[2][2]); >+ result[3][0] = cosh(x[3][0]); >+ result[3][1] = cosh(x[3][1]); >+ result[3][2] = cosh(x[3][2]); >+ return result; >+} >+half4x4 cosh(half4x4 x) { >+ half4x4 result; >+ result[0][0] = cosh(x[0][0]); >+ result[0][1] = cosh(x[0][1]); >+ result[0][2] = cosh(x[0][2]); >+ result[0][3] = cosh(x[0][3]); >+ result[1][0] = cosh(x[1][0]); >+ result[1][1] = cosh(x[1][1]); >+ result[1][2] = cosh(x[1][2]); >+ result[1][3] = cosh(x[1][3]); >+ result[2][0] = cosh(x[2][0]); >+ result[2][1] = cosh(x[2][1]); >+ result[2][2] = cosh(x[2][2]); >+ result[2][3] = cosh(x[2][3]); >+ result[3][0] = cosh(x[3][0]); >+ result[3][1] = cosh(x[3][1]); >+ result[3][2] = cosh(x[3][2]); >+ result[3][3] = cosh(x[3][3]); >+ return result; >+} >+half2 sinh(half2 x) { >+ half2 result; >+ result[0] = sinh(x[0]); >+ result[1] = sinh(x[1]); >+ return result; >+} >+half3 sinh(half3 x) { >+ half3 result; >+ result[0] = sinh(x[0]); >+ result[1] = sinh(x[1]); >+ result[2] = sinh(x[2]); >+ return result; >+} >+half4 sinh(half4 x) { >+ half4 result; >+ result[0] = sinh(x[0]); >+ result[1] = sinh(x[1]); >+ result[2] = sinh(x[2]); >+ result[3] = sinh(x[3]); >+ return result; >+} >+half2x2 sinh(half2x2 x) { >+ half2x2 result; >+ result[0][0] = sinh(x[0][0]); >+ result[0][1] = sinh(x[0][1]); >+ result[1][0] = sinh(x[1][0]); >+ result[1][1] = sinh(x[1][1]); >+ return result; >+} >+half2x3 sinh(half2x3 x) { >+ half2x3 result; >+ result[0][0] = sinh(x[0][0]); >+ result[0][1] = sinh(x[0][1]); >+ result[0][2] = sinh(x[0][2]); >+ result[1][0] = sinh(x[1][0]); >+ result[1][1] = sinh(x[1][1]); >+ result[1][2] = sinh(x[1][2]); >+ return result; >+} >+half2x4 sinh(half2x4 x) { >+ half2x4 result; >+ result[0][0] = sinh(x[0][0]); >+ result[0][1] = sinh(x[0][1]); >+ result[0][2] = sinh(x[0][2]); >+ result[0][3] = sinh(x[0][3]); >+ result[1][0] = sinh(x[1][0]); >+ result[1][1] = sinh(x[1][1]); >+ result[1][2] = sinh(x[1][2]); >+ result[1][3] = sinh(x[1][3]); >+ return result; >+} >+half3x2 sinh(half3x2 x) { >+ half3x2 result; >+ result[0][0] = sinh(x[0][0]); >+ result[0][1] = sinh(x[0][1]); >+ result[1][0] = sinh(x[1][0]); >+ result[1][1] = sinh(x[1][1]); >+ result[2][0] = sinh(x[2][0]); >+ result[2][1] = sinh(x[2][1]); >+ return result; >+} >+half3x3 sinh(half3x3 x) { >+ half3x3 result; >+ result[0][0] = sinh(x[0][0]); >+ result[0][1] = sinh(x[0][1]); >+ result[0][2] = sinh(x[0][2]); >+ result[1][0] = sinh(x[1][0]); >+ result[1][1] = sinh(x[1][1]); >+ result[1][2] = sinh(x[1][2]); >+ result[2][0] = sinh(x[2][0]); >+ result[2][1] = sinh(x[2][1]); >+ result[2][2] = sinh(x[2][2]); >+ return result; >+} >+half3x4 sinh(half3x4 x) { >+ half3x4 result; >+ result[0][0] = sinh(x[0][0]); >+ result[0][1] = sinh(x[0][1]); >+ result[0][2] = sinh(x[0][2]); >+ result[0][3] = sinh(x[0][3]); >+ result[1][0] = sinh(x[1][0]); >+ result[1][1] = sinh(x[1][1]); >+ result[1][2] = sinh(x[1][2]); >+ result[1][3] = sinh(x[1][3]); >+ result[2][0] = sinh(x[2][0]); >+ result[2][1] = sinh(x[2][1]); >+ result[2][2] = sinh(x[2][2]); >+ result[2][3] = sinh(x[2][3]); >+ return result; >+} >+half4x2 sinh(half4x2 x) { >+ half4x2 result; >+ result[0][0] = sinh(x[0][0]); >+ result[0][1] = sinh(x[0][1]); >+ result[1][0] = sinh(x[1][0]); >+ result[1][1] = sinh(x[1][1]); >+ result[2][0] = sinh(x[2][0]); >+ result[2][1] = sinh(x[2][1]); >+ result[3][0] = sinh(x[3][0]); >+ result[3][1] = sinh(x[3][1]); >+ return result; >+} >+half4x3 sinh(half4x3 x) { >+ half4x3 result; >+ result[0][0] = sinh(x[0][0]); >+ result[0][1] = sinh(x[0][1]); >+ result[0][2] = sinh(x[0][2]); >+ result[1][0] = sinh(x[1][0]); >+ result[1][1] = sinh(x[1][1]); >+ result[1][2] = sinh(x[1][2]); >+ result[2][0] = sinh(x[2][0]); >+ result[2][1] = sinh(x[2][1]); >+ result[2][2] = sinh(x[2][2]); >+ result[3][0] = sinh(x[3][0]); >+ result[3][1] = sinh(x[3][1]); >+ result[3][2] = sinh(x[3][2]); >+ return result; >+} >+half4x4 sinh(half4x4 x) { >+ half4x4 result; >+ result[0][0] = sinh(x[0][0]); >+ result[0][1] = sinh(x[0][1]); >+ result[0][2] = sinh(x[0][2]); >+ result[0][3] = sinh(x[0][3]); >+ result[1][0] = sinh(x[1][0]); >+ result[1][1] = sinh(x[1][1]); >+ result[1][2] = sinh(x[1][2]); >+ result[1][3] = sinh(x[1][3]); >+ result[2][0] = sinh(x[2][0]); >+ result[2][1] = sinh(x[2][1]); >+ result[2][2] = sinh(x[2][2]); >+ result[2][3] = sinh(x[2][3]); >+ result[3][0] = sinh(x[3][0]); >+ result[3][1] = sinh(x[3][1]); >+ result[3][2] = sinh(x[3][2]); >+ result[3][3] = sinh(x[3][3]); >+ return result; >+} >+half2 tanh(half2 x) { >+ half2 result; >+ result[0] = tanh(x[0]); >+ result[1] = tanh(x[1]); >+ return result; >+} >+half3 tanh(half3 x) { >+ half3 result; >+ result[0] = tanh(x[0]); >+ result[1] = tanh(x[1]); >+ result[2] = tanh(x[2]); >+ return result; >+} >+half4 tanh(half4 x) { >+ half4 result; >+ result[0] = tanh(x[0]); >+ result[1] = tanh(x[1]); >+ result[2] = tanh(x[2]); >+ result[3] = tanh(x[3]); >+ return result; >+} >+half2x2 tanh(half2x2 x) { >+ half2x2 result; >+ result[0][0] = tanh(x[0][0]); >+ result[0][1] = tanh(x[0][1]); >+ result[1][0] = tanh(x[1][0]); >+ result[1][1] = tanh(x[1][1]); >+ return result; >+} >+half2x3 tanh(half2x3 x) { >+ half2x3 result; >+ result[0][0] = tanh(x[0][0]); >+ result[0][1] = tanh(x[0][1]); >+ result[0][2] = tanh(x[0][2]); >+ result[1][0] = tanh(x[1][0]); >+ result[1][1] = tanh(x[1][1]); >+ result[1][2] = tanh(x[1][2]); >+ return result; >+} >+half2x4 tanh(half2x4 x) { >+ half2x4 result; >+ result[0][0] = tanh(x[0][0]); >+ result[0][1] = tanh(x[0][1]); >+ result[0][2] = tanh(x[0][2]); >+ result[0][3] = tanh(x[0][3]); >+ result[1][0] = tanh(x[1][0]); >+ result[1][1] = tanh(x[1][1]); >+ result[1][2] = tanh(x[1][2]); >+ result[1][3] = tanh(x[1][3]); >+ return result; >+} >+half3x2 tanh(half3x2 x) { >+ half3x2 result; >+ result[0][0] = tanh(x[0][0]); >+ result[0][1] = tanh(x[0][1]); >+ result[1][0] = tanh(x[1][0]); >+ result[1][1] = tanh(x[1][1]); >+ result[2][0] = tanh(x[2][0]); >+ result[2][1] = tanh(x[2][1]); >+ return result; >+} >+half3x3 tanh(half3x3 x) { >+ half3x3 result; >+ result[0][0] = tanh(x[0][0]); >+ result[0][1] = tanh(x[0][1]); >+ result[0][2] = tanh(x[0][2]); >+ result[1][0] = tanh(x[1][0]); >+ result[1][1] = tanh(x[1][1]); >+ result[1][2] = tanh(x[1][2]); >+ result[2][0] = tanh(x[2][0]); >+ result[2][1] = tanh(x[2][1]); >+ result[2][2] = tanh(x[2][2]); >+ return result; >+} >+half3x4 tanh(half3x4 x) { >+ half3x4 result; >+ result[0][0] = tanh(x[0][0]); >+ result[0][1] = tanh(x[0][1]); >+ result[0][2] = tanh(x[0][2]); >+ result[0][3] = tanh(x[0][3]); >+ result[1][0] = tanh(x[1][0]); >+ result[1][1] = tanh(x[1][1]); >+ result[1][2] = tanh(x[1][2]); >+ result[1][3] = tanh(x[1][3]); >+ result[2][0] = tanh(x[2][0]); >+ result[2][1] = tanh(x[2][1]); >+ result[2][2] = tanh(x[2][2]); >+ result[2][3] = tanh(x[2][3]); >+ return result; >+} >+half4x2 tanh(half4x2 x) { >+ half4x2 result; >+ result[0][0] = tanh(x[0][0]); >+ result[0][1] = tanh(x[0][1]); >+ result[1][0] = tanh(x[1][0]); >+ result[1][1] = tanh(x[1][1]); >+ result[2][0] = tanh(x[2][0]); >+ result[2][1] = tanh(x[2][1]); >+ result[3][0] = tanh(x[3][0]); >+ result[3][1] = tanh(x[3][1]); >+ return result; >+} >+half4x3 tanh(half4x3 x) { >+ half4x3 result; >+ result[0][0] = tanh(x[0][0]); >+ result[0][1] = tanh(x[0][1]); >+ result[0][2] = tanh(x[0][2]); >+ result[1][0] = tanh(x[1][0]); >+ result[1][1] = tanh(x[1][1]); >+ result[1][2] = tanh(x[1][2]); >+ result[2][0] = tanh(x[2][0]); >+ result[2][1] = tanh(x[2][1]); >+ result[2][2] = tanh(x[2][2]); >+ result[3][0] = tanh(x[3][0]); >+ result[3][1] = tanh(x[3][1]); >+ result[3][2] = tanh(x[3][2]); >+ return result; >+} >+half4x4 tanh(half4x4 x) { >+ half4x4 result; >+ result[0][0] = tanh(x[0][0]); >+ result[0][1] = tanh(x[0][1]); >+ result[0][2] = tanh(x[0][2]); >+ result[0][3] = tanh(x[0][3]); >+ result[1][0] = tanh(x[1][0]); >+ result[1][1] = tanh(x[1][1]); >+ result[1][2] = tanh(x[1][2]); >+ result[1][3] = tanh(x[1][3]); >+ result[2][0] = tanh(x[2][0]); >+ result[2][1] = tanh(x[2][1]); >+ result[2][2] = tanh(x[2][2]); >+ result[2][3] = tanh(x[2][3]); >+ result[3][0] = tanh(x[3][0]); >+ result[3][1] = tanh(x[3][1]); >+ result[3][2] = tanh(x[3][2]); >+ result[3][3] = tanh(x[3][3]); >+ return result; >+} >+half2 ceil(half2 x) { >+ half2 result; >+ result[0] = ceil(x[0]); >+ result[1] = ceil(x[1]); >+ return result; >+} >+half3 ceil(half3 x) { >+ half3 result; >+ result[0] = ceil(x[0]); >+ result[1] = ceil(x[1]); >+ result[2] = ceil(x[2]); >+ return result; >+} >+half4 ceil(half4 x) { >+ half4 result; >+ result[0] = ceil(x[0]); >+ result[1] = ceil(x[1]); >+ result[2] = ceil(x[2]); >+ result[3] = ceil(x[3]); >+ return result; >+} >+half2x2 ceil(half2x2 x) { >+ half2x2 result; >+ result[0][0] = ceil(x[0][0]); >+ result[0][1] = ceil(x[0][1]); >+ result[1][0] = ceil(x[1][0]); >+ result[1][1] = ceil(x[1][1]); >+ return result; >+} >+half2x3 ceil(half2x3 x) { >+ half2x3 result; >+ result[0][0] = ceil(x[0][0]); >+ result[0][1] = ceil(x[0][1]); >+ result[0][2] = ceil(x[0][2]); >+ result[1][0] = ceil(x[1][0]); >+ result[1][1] = ceil(x[1][1]); >+ result[1][2] = ceil(x[1][2]); >+ return result; >+} >+half2x4 ceil(half2x4 x) { >+ half2x4 result; >+ result[0][0] = ceil(x[0][0]); >+ result[0][1] = ceil(x[0][1]); >+ result[0][2] = ceil(x[0][2]); >+ result[0][3] = ceil(x[0][3]); >+ result[1][0] = ceil(x[1][0]); >+ result[1][1] = ceil(x[1][1]); >+ result[1][2] = ceil(x[1][2]); >+ result[1][3] = ceil(x[1][3]); >+ return result; >+} >+half3x2 ceil(half3x2 x) { >+ half3x2 result; >+ result[0][0] = ceil(x[0][0]); >+ result[0][1] = ceil(x[0][1]); >+ result[1][0] = ceil(x[1][0]); >+ result[1][1] = ceil(x[1][1]); >+ result[2][0] = ceil(x[2][0]); >+ result[2][1] = ceil(x[2][1]); >+ return result; >+} >+half3x3 ceil(half3x3 x) { >+ half3x3 result; >+ result[0][0] = ceil(x[0][0]); >+ result[0][1] = ceil(x[0][1]); >+ result[0][2] = ceil(x[0][2]); >+ result[1][0] = ceil(x[1][0]); >+ result[1][1] = ceil(x[1][1]); >+ result[1][2] = ceil(x[1][2]); >+ result[2][0] = ceil(x[2][0]); >+ result[2][1] = ceil(x[2][1]); >+ result[2][2] = ceil(x[2][2]); >+ return result; >+} >+half3x4 ceil(half3x4 x) { >+ half3x4 result; >+ result[0][0] = ceil(x[0][0]); >+ result[0][1] = ceil(x[0][1]); >+ result[0][2] = ceil(x[0][2]); >+ result[0][3] = ceil(x[0][3]); >+ result[1][0] = ceil(x[1][0]); >+ result[1][1] = ceil(x[1][1]); >+ result[1][2] = ceil(x[1][2]); >+ result[1][3] = ceil(x[1][3]); >+ result[2][0] = ceil(x[2][0]); >+ result[2][1] = ceil(x[2][1]); >+ result[2][2] = ceil(x[2][2]); >+ result[2][3] = ceil(x[2][3]); >+ return result; >+} >+half4x2 ceil(half4x2 x) { >+ half4x2 result; >+ result[0][0] = ceil(x[0][0]); >+ result[0][1] = ceil(x[0][1]); >+ result[1][0] = ceil(x[1][0]); >+ result[1][1] = ceil(x[1][1]); >+ result[2][0] = ceil(x[2][0]); >+ result[2][1] = ceil(x[2][1]); >+ result[3][0] = ceil(x[3][0]); >+ result[3][1] = ceil(x[3][1]); >+ return result; >+} >+half4x3 ceil(half4x3 x) { >+ half4x3 result; >+ result[0][0] = ceil(x[0][0]); >+ result[0][1] = ceil(x[0][1]); >+ result[0][2] = ceil(x[0][2]); >+ result[1][0] = ceil(x[1][0]); >+ result[1][1] = ceil(x[1][1]); >+ result[1][2] = ceil(x[1][2]); >+ result[2][0] = ceil(x[2][0]); >+ result[2][1] = ceil(x[2][1]); >+ result[2][2] = ceil(x[2][2]); >+ result[3][0] = ceil(x[3][0]); >+ result[3][1] = ceil(x[3][1]); >+ result[3][2] = ceil(x[3][2]); >+ return result; >+} >+half4x4 ceil(half4x4 x) { >+ half4x4 result; >+ result[0][0] = ceil(x[0][0]); >+ result[0][1] = ceil(x[0][1]); >+ result[0][2] = ceil(x[0][2]); >+ result[0][3] = ceil(x[0][3]); >+ result[1][0] = ceil(x[1][0]); >+ result[1][1] = ceil(x[1][1]); >+ result[1][2] = ceil(x[1][2]); >+ result[1][3] = ceil(x[1][3]); >+ result[2][0] = ceil(x[2][0]); >+ result[2][1] = ceil(x[2][1]); >+ result[2][2] = ceil(x[2][2]); >+ result[2][3] = ceil(x[2][3]); >+ result[3][0] = ceil(x[3][0]); >+ result[3][1] = ceil(x[3][1]); >+ result[3][2] = ceil(x[3][2]); >+ result[3][3] = ceil(x[3][3]); >+ return result; >+} >+half2 exp(half2 x) { >+ half2 result; >+ result[0] = exp(x[0]); >+ result[1] = exp(x[1]); >+ return result; >+} >+half3 exp(half3 x) { >+ half3 result; >+ result[0] = exp(x[0]); >+ result[1] = exp(x[1]); >+ result[2] = exp(x[2]); >+ return result; >+} >+half4 exp(half4 x) { >+ half4 result; >+ result[0] = exp(x[0]); >+ result[1] = exp(x[1]); >+ result[2] = exp(x[2]); >+ result[3] = exp(x[3]); >+ return result; >+} >+half2x2 exp(half2x2 x) { >+ half2x2 result; >+ result[0][0] = exp(x[0][0]); >+ result[0][1] = exp(x[0][1]); >+ result[1][0] = exp(x[1][0]); >+ result[1][1] = exp(x[1][1]); >+ return result; >+} >+half2x3 exp(half2x3 x) { >+ half2x3 result; >+ result[0][0] = exp(x[0][0]); >+ result[0][1] = exp(x[0][1]); >+ result[0][2] = exp(x[0][2]); >+ result[1][0] = exp(x[1][0]); >+ result[1][1] = exp(x[1][1]); >+ result[1][2] = exp(x[1][2]); >+ return result; >+} >+half2x4 exp(half2x4 x) { >+ half2x4 result; >+ result[0][0] = exp(x[0][0]); >+ result[0][1] = exp(x[0][1]); >+ result[0][2] = exp(x[0][2]); >+ result[0][3] = exp(x[0][3]); >+ result[1][0] = exp(x[1][0]); >+ result[1][1] = exp(x[1][1]); >+ result[1][2] = exp(x[1][2]); >+ result[1][3] = exp(x[1][3]); >+ return result; >+} >+half3x2 exp(half3x2 x) { >+ half3x2 result; >+ result[0][0] = exp(x[0][0]); >+ result[0][1] = exp(x[0][1]); >+ result[1][0] = exp(x[1][0]); >+ result[1][1] = exp(x[1][1]); >+ result[2][0] = exp(x[2][0]); >+ result[2][1] = exp(x[2][1]); >+ return result; >+} >+half3x3 exp(half3x3 x) { >+ half3x3 result; >+ result[0][0] = exp(x[0][0]); >+ result[0][1] = exp(x[0][1]); >+ result[0][2] = exp(x[0][2]); >+ result[1][0] = exp(x[1][0]); >+ result[1][1] = exp(x[1][1]); >+ result[1][2] = exp(x[1][2]); >+ result[2][0] = exp(x[2][0]); >+ result[2][1] = exp(x[2][1]); >+ result[2][2] = exp(x[2][2]); >+ return result; >+} >+half3x4 exp(half3x4 x) { >+ half3x4 result; >+ result[0][0] = exp(x[0][0]); >+ result[0][1] = exp(x[0][1]); >+ result[0][2] = exp(x[0][2]); >+ result[0][3] = exp(x[0][3]); >+ result[1][0] = exp(x[1][0]); >+ result[1][1] = exp(x[1][1]); >+ result[1][2] = exp(x[1][2]); >+ result[1][3] = exp(x[1][3]); >+ result[2][0] = exp(x[2][0]); >+ result[2][1] = exp(x[2][1]); >+ result[2][2] = exp(x[2][2]); >+ result[2][3] = exp(x[2][3]); >+ return result; >+} >+half4x2 exp(half4x2 x) { >+ half4x2 result; >+ result[0][0] = exp(x[0][0]); >+ result[0][1] = exp(x[0][1]); >+ result[1][0] = exp(x[1][0]); >+ result[1][1] = exp(x[1][1]); >+ result[2][0] = exp(x[2][0]); >+ result[2][1] = exp(x[2][1]); >+ result[3][0] = exp(x[3][0]); >+ result[3][1] = exp(x[3][1]); >+ return result; >+} >+half4x3 exp(half4x3 x) { >+ half4x3 result; >+ result[0][0] = exp(x[0][0]); >+ result[0][1] = exp(x[0][1]); >+ result[0][2] = exp(x[0][2]); >+ result[1][0] = exp(x[1][0]); >+ result[1][1] = exp(x[1][1]); >+ result[1][2] = exp(x[1][2]); >+ result[2][0] = exp(x[2][0]); >+ result[2][1] = exp(x[2][1]); >+ result[2][2] = exp(x[2][2]); >+ result[3][0] = exp(x[3][0]); >+ result[3][1] = exp(x[3][1]); >+ result[3][2] = exp(x[3][2]); >+ return result; >+} >+half4x4 exp(half4x4 x) { >+ half4x4 result; >+ result[0][0] = exp(x[0][0]); >+ result[0][1] = exp(x[0][1]); >+ result[0][2] = exp(x[0][2]); >+ result[0][3] = exp(x[0][3]); >+ result[1][0] = exp(x[1][0]); >+ result[1][1] = exp(x[1][1]); >+ result[1][2] = exp(x[1][2]); >+ result[1][3] = exp(x[1][3]); >+ result[2][0] = exp(x[2][0]); >+ result[2][1] = exp(x[2][1]); >+ result[2][2] = exp(x[2][2]); >+ result[2][3] = exp(x[2][3]); >+ result[3][0] = exp(x[3][0]); >+ result[3][1] = exp(x[3][1]); >+ result[3][2] = exp(x[3][2]); >+ result[3][3] = exp(x[3][3]); >+ return result; >+} >+half2 floor(half2 x) { >+ half2 result; >+ result[0] = floor(x[0]); >+ result[1] = floor(x[1]); >+ return result; >+} >+half3 floor(half3 x) { >+ half3 result; >+ result[0] = floor(x[0]); >+ result[1] = floor(x[1]); >+ result[2] = floor(x[2]); >+ return result; >+} >+half4 floor(half4 x) { >+ half4 result; >+ result[0] = floor(x[0]); >+ result[1] = floor(x[1]); >+ result[2] = floor(x[2]); >+ result[3] = floor(x[3]); >+ return result; >+} >+half2x2 floor(half2x2 x) { >+ half2x2 result; >+ result[0][0] = floor(x[0][0]); >+ result[0][1] = floor(x[0][1]); >+ result[1][0] = floor(x[1][0]); >+ result[1][1] = floor(x[1][1]); >+ return result; >+} >+half2x3 floor(half2x3 x) { >+ half2x3 result; >+ result[0][0] = floor(x[0][0]); >+ result[0][1] = floor(x[0][1]); >+ result[0][2] = floor(x[0][2]); >+ result[1][0] = floor(x[1][0]); >+ result[1][1] = floor(x[1][1]); >+ result[1][2] = floor(x[1][2]); >+ return result; >+} >+half2x4 floor(half2x4 x) { >+ half2x4 result; >+ result[0][0] = floor(x[0][0]); >+ result[0][1] = floor(x[0][1]); >+ result[0][2] = floor(x[0][2]); >+ result[0][3] = floor(x[0][3]); >+ result[1][0] = floor(x[1][0]); >+ result[1][1] = floor(x[1][1]); >+ result[1][2] = floor(x[1][2]); >+ result[1][3] = floor(x[1][3]); >+ return result; >+} >+half3x2 floor(half3x2 x) { >+ half3x2 result; >+ result[0][0] = floor(x[0][0]); >+ result[0][1] = floor(x[0][1]); >+ result[1][0] = floor(x[1][0]); >+ result[1][1] = floor(x[1][1]); >+ result[2][0] = floor(x[2][0]); >+ result[2][1] = floor(x[2][1]); >+ return result; >+} >+half3x3 floor(half3x3 x) { >+ half3x3 result; >+ result[0][0] = floor(x[0][0]); >+ result[0][1] = floor(x[0][1]); >+ result[0][2] = floor(x[0][2]); >+ result[1][0] = floor(x[1][0]); >+ result[1][1] = floor(x[1][1]); >+ result[1][2] = floor(x[1][2]); >+ result[2][0] = floor(x[2][0]); >+ result[2][1] = floor(x[2][1]); >+ result[2][2] = floor(x[2][2]); >+ return result; >+} >+half3x4 floor(half3x4 x) { >+ half3x4 result; >+ result[0][0] = floor(x[0][0]); >+ result[0][1] = floor(x[0][1]); >+ result[0][2] = floor(x[0][2]); >+ result[0][3] = floor(x[0][3]); >+ result[1][0] = floor(x[1][0]); >+ result[1][1] = floor(x[1][1]); >+ result[1][2] = floor(x[1][2]); >+ result[1][3] = floor(x[1][3]); >+ result[2][0] = floor(x[2][0]); >+ result[2][1] = floor(x[2][1]); >+ result[2][2] = floor(x[2][2]); >+ result[2][3] = floor(x[2][3]); >+ return result; >+} >+half4x2 floor(half4x2 x) { >+ half4x2 result; >+ result[0][0] = floor(x[0][0]); >+ result[0][1] = floor(x[0][1]); >+ result[1][0] = floor(x[1][0]); >+ result[1][1] = floor(x[1][1]); >+ result[2][0] = floor(x[2][0]); >+ result[2][1] = floor(x[2][1]); >+ result[3][0] = floor(x[3][0]); >+ result[3][1] = floor(x[3][1]); >+ return result; >+} >+half4x3 floor(half4x3 x) { >+ half4x3 result; >+ result[0][0] = floor(x[0][0]); >+ result[0][1] = floor(x[0][1]); >+ result[0][2] = floor(x[0][2]); >+ result[1][0] = floor(x[1][0]); >+ result[1][1] = floor(x[1][1]); >+ result[1][2] = floor(x[1][2]); >+ result[2][0] = floor(x[2][0]); >+ result[2][1] = floor(x[2][1]); >+ result[2][2] = floor(x[2][2]); >+ result[3][0] = floor(x[3][0]); >+ result[3][1] = floor(x[3][1]); >+ result[3][2] = floor(x[3][2]); >+ return result; >+} >+half4x4 floor(half4x4 x) { >+ half4x4 result; >+ result[0][0] = floor(x[0][0]); >+ result[0][1] = floor(x[0][1]); >+ result[0][2] = floor(x[0][2]); >+ result[0][3] = floor(x[0][3]); >+ result[1][0] = floor(x[1][0]); >+ result[1][1] = floor(x[1][1]); >+ result[1][2] = floor(x[1][2]); >+ result[1][3] = floor(x[1][3]); >+ result[2][0] = floor(x[2][0]); >+ result[2][1] = floor(x[2][1]); >+ result[2][2] = floor(x[2][2]); >+ result[2][3] = floor(x[2][3]); >+ result[3][0] = floor(x[3][0]); >+ result[3][1] = floor(x[3][1]); >+ result[3][2] = floor(x[3][2]); >+ result[3][3] = floor(x[3][3]); >+ return result; >+} >+half2 log(half2 x) { >+ half2 result; >+ result[0] = log(x[0]); >+ result[1] = log(x[1]); >+ return result; >+} >+half3 log(half3 x) { >+ half3 result; >+ result[0] = log(x[0]); >+ result[1] = log(x[1]); >+ result[2] = log(x[2]); >+ return result; >+} >+half4 log(half4 x) { >+ half4 result; >+ result[0] = log(x[0]); >+ result[1] = log(x[1]); >+ result[2] = log(x[2]); >+ result[3] = log(x[3]); >+ return result; >+} >+half2x2 log(half2x2 x) { >+ half2x2 result; >+ result[0][0] = log(x[0][0]); >+ result[0][1] = log(x[0][1]); >+ result[1][0] = log(x[1][0]); >+ result[1][1] = log(x[1][1]); >+ return result; >+} >+half2x3 log(half2x3 x) { >+ half2x3 result; >+ result[0][0] = log(x[0][0]); >+ result[0][1] = log(x[0][1]); >+ result[0][2] = log(x[0][2]); >+ result[1][0] = log(x[1][0]); >+ result[1][1] = log(x[1][1]); >+ result[1][2] = log(x[1][2]); >+ return result; >+} >+half2x4 log(half2x4 x) { >+ half2x4 result; >+ result[0][0] = log(x[0][0]); >+ result[0][1] = log(x[0][1]); >+ result[0][2] = log(x[0][2]); >+ result[0][3] = log(x[0][3]); >+ result[1][0] = log(x[1][0]); >+ result[1][1] = log(x[1][1]); >+ result[1][2] = log(x[1][2]); >+ result[1][3] = log(x[1][3]); >+ return result; >+} >+half3x2 log(half3x2 x) { >+ half3x2 result; >+ result[0][0] = log(x[0][0]); >+ result[0][1] = log(x[0][1]); >+ result[1][0] = log(x[1][0]); >+ result[1][1] = log(x[1][1]); >+ result[2][0] = log(x[2][0]); >+ result[2][1] = log(x[2][1]); >+ return result; >+} >+half3x3 log(half3x3 x) { >+ half3x3 result; >+ result[0][0] = log(x[0][0]); >+ result[0][1] = log(x[0][1]); >+ result[0][2] = log(x[0][2]); >+ result[1][0] = log(x[1][0]); >+ result[1][1] = log(x[1][1]); >+ result[1][2] = log(x[1][2]); >+ result[2][0] = log(x[2][0]); >+ result[2][1] = log(x[2][1]); >+ result[2][2] = log(x[2][2]); >+ return result; >+} >+half3x4 log(half3x4 x) { >+ half3x4 result; >+ result[0][0] = log(x[0][0]); >+ result[0][1] = log(x[0][1]); >+ result[0][2] = log(x[0][2]); >+ result[0][3] = log(x[0][3]); >+ result[1][0] = log(x[1][0]); >+ result[1][1] = log(x[1][1]); >+ result[1][2] = log(x[1][2]); >+ result[1][3] = log(x[1][3]); >+ result[2][0] = log(x[2][0]); >+ result[2][1] = log(x[2][1]); >+ result[2][2] = log(x[2][2]); >+ result[2][3] = log(x[2][3]); >+ return result; >+} >+half4x2 log(half4x2 x) { >+ half4x2 result; >+ result[0][0] = log(x[0][0]); >+ result[0][1] = log(x[0][1]); >+ result[1][0] = log(x[1][0]); >+ result[1][1] = log(x[1][1]); >+ result[2][0] = log(x[2][0]); >+ result[2][1] = log(x[2][1]); >+ result[3][0] = log(x[3][0]); >+ result[3][1] = log(x[3][1]); >+ return result; >+} >+half4x3 log(half4x3 x) { >+ half4x3 result; >+ result[0][0] = log(x[0][0]); >+ result[0][1] = log(x[0][1]); >+ result[0][2] = log(x[0][2]); >+ result[1][0] = log(x[1][0]); >+ result[1][1] = log(x[1][1]); >+ result[1][2] = log(x[1][2]); >+ result[2][0] = log(x[2][0]); >+ result[2][1] = log(x[2][1]); >+ result[2][2] = log(x[2][2]); >+ result[3][0] = log(x[3][0]); >+ result[3][1] = log(x[3][1]); >+ result[3][2] = log(x[3][2]); >+ return result; >+} >+half4x4 log(half4x4 x) { >+ half4x4 result; >+ result[0][0] = log(x[0][0]); >+ result[0][1] = log(x[0][1]); >+ result[0][2] = log(x[0][2]); >+ result[0][3] = log(x[0][3]); >+ result[1][0] = log(x[1][0]); >+ result[1][1] = log(x[1][1]); >+ result[1][2] = log(x[1][2]); >+ result[1][3] = log(x[1][3]); >+ result[2][0] = log(x[2][0]); >+ result[2][1] = log(x[2][1]); >+ result[2][2] = log(x[2][2]); >+ result[2][3] = log(x[2][3]); >+ result[3][0] = log(x[3][0]); >+ result[3][1] = log(x[3][1]); >+ result[3][2] = log(x[3][2]); >+ result[3][3] = log(x[3][3]); >+ return result; >+} >+half2 round(half2 x) { >+ half2 result; >+ result[0] = round(x[0]); >+ result[1] = round(x[1]); >+ return result; >+} >+half3 round(half3 x) { >+ half3 result; >+ result[0] = round(x[0]); >+ result[1] = round(x[1]); >+ result[2] = round(x[2]); >+ return result; >+} >+half4 round(half4 x) { >+ half4 result; >+ result[0] = round(x[0]); >+ result[1] = round(x[1]); >+ result[2] = round(x[2]); >+ result[3] = round(x[3]); >+ return result; >+} >+half2x2 round(half2x2 x) { >+ half2x2 result; >+ result[0][0] = round(x[0][0]); >+ result[0][1] = round(x[0][1]); >+ result[1][0] = round(x[1][0]); >+ result[1][1] = round(x[1][1]); >+ return result; >+} >+half2x3 round(half2x3 x) { >+ half2x3 result; >+ result[0][0] = round(x[0][0]); >+ result[0][1] = round(x[0][1]); >+ result[0][2] = round(x[0][2]); >+ result[1][0] = round(x[1][0]); >+ result[1][1] = round(x[1][1]); >+ result[1][2] = round(x[1][2]); >+ return result; >+} >+half2x4 round(half2x4 x) { >+ half2x4 result; >+ result[0][0] = round(x[0][0]); >+ result[0][1] = round(x[0][1]); >+ result[0][2] = round(x[0][2]); >+ result[0][3] = round(x[0][3]); >+ result[1][0] = round(x[1][0]); >+ result[1][1] = round(x[1][1]); >+ result[1][2] = round(x[1][2]); >+ result[1][3] = round(x[1][3]); >+ return result; >+} >+half3x2 round(half3x2 x) { >+ half3x2 result; >+ result[0][0] = round(x[0][0]); >+ result[0][1] = round(x[0][1]); >+ result[1][0] = round(x[1][0]); >+ result[1][1] = round(x[1][1]); >+ result[2][0] = round(x[2][0]); >+ result[2][1] = round(x[2][1]); >+ return result; >+} >+half3x3 round(half3x3 x) { >+ half3x3 result; >+ result[0][0] = round(x[0][0]); >+ result[0][1] = round(x[0][1]); >+ result[0][2] = round(x[0][2]); >+ result[1][0] = round(x[1][0]); >+ result[1][1] = round(x[1][1]); >+ result[1][2] = round(x[1][2]); >+ result[2][0] = round(x[2][0]); >+ result[2][1] = round(x[2][1]); >+ result[2][2] = round(x[2][2]); >+ return result; >+} >+half3x4 round(half3x4 x) { >+ half3x4 result; >+ result[0][0] = round(x[0][0]); >+ result[0][1] = round(x[0][1]); >+ result[0][2] = round(x[0][2]); >+ result[0][3] = round(x[0][3]); >+ result[1][0] = round(x[1][0]); >+ result[1][1] = round(x[1][1]); >+ result[1][2] = round(x[1][2]); >+ result[1][3] = round(x[1][3]); >+ result[2][0] = round(x[2][0]); >+ result[2][1] = round(x[2][1]); >+ result[2][2] = round(x[2][2]); >+ result[2][3] = round(x[2][3]); >+ return result; >+} >+half4x2 round(half4x2 x) { >+ half4x2 result; >+ result[0][0] = round(x[0][0]); >+ result[0][1] = round(x[0][1]); >+ result[1][0] = round(x[1][0]); >+ result[1][1] = round(x[1][1]); >+ result[2][0] = round(x[2][0]); >+ result[2][1] = round(x[2][1]); >+ result[3][0] = round(x[3][0]); >+ result[3][1] = round(x[3][1]); >+ return result; >+} >+half4x3 round(half4x3 x) { >+ half4x3 result; >+ result[0][0] = round(x[0][0]); >+ result[0][1] = round(x[0][1]); >+ result[0][2] = round(x[0][2]); >+ result[1][0] = round(x[1][0]); >+ result[1][1] = round(x[1][1]); >+ result[1][2] = round(x[1][2]); >+ result[2][0] = round(x[2][0]); >+ result[2][1] = round(x[2][1]); >+ result[2][2] = round(x[2][2]); >+ result[3][0] = round(x[3][0]); >+ result[3][1] = round(x[3][1]); >+ result[3][2] = round(x[3][2]); >+ return result; >+} >+half4x4 round(half4x4 x) { >+ half4x4 result; >+ result[0][0] = round(x[0][0]); >+ result[0][1] = round(x[0][1]); >+ result[0][2] = round(x[0][2]); >+ result[0][3] = round(x[0][3]); >+ result[1][0] = round(x[1][0]); >+ result[1][1] = round(x[1][1]); >+ result[1][2] = round(x[1][2]); >+ result[1][3] = round(x[1][3]); >+ result[2][0] = round(x[2][0]); >+ result[2][1] = round(x[2][1]); >+ result[2][2] = round(x[2][2]); >+ result[2][3] = round(x[2][3]); >+ result[3][0] = round(x[3][0]); >+ result[3][1] = round(x[3][1]); >+ result[3][2] = round(x[3][2]); >+ result[3][3] = round(x[3][3]); >+ return result; >+} >+half2 trunc(half2 x) { >+ half2 result; >+ result[0] = trunc(x[0]); >+ result[1] = trunc(x[1]); >+ return result; >+} >+half3 trunc(half3 x) { >+ half3 result; >+ result[0] = trunc(x[0]); >+ result[1] = trunc(x[1]); >+ result[2] = trunc(x[2]); >+ return result; >+} >+half4 trunc(half4 x) { >+ half4 result; >+ result[0] = trunc(x[0]); >+ result[1] = trunc(x[1]); >+ result[2] = trunc(x[2]); >+ result[3] = trunc(x[3]); >+ return result; >+} >+half2x2 trunc(half2x2 x) { >+ half2x2 result; >+ result[0][0] = trunc(x[0][0]); >+ result[0][1] = trunc(x[0][1]); >+ result[1][0] = trunc(x[1][0]); >+ result[1][1] = trunc(x[1][1]); >+ return result; >+} >+half2x3 trunc(half2x3 x) { >+ half2x3 result; >+ result[0][0] = trunc(x[0][0]); >+ result[0][1] = trunc(x[0][1]); >+ result[0][2] = trunc(x[0][2]); >+ result[1][0] = trunc(x[1][0]); >+ result[1][1] = trunc(x[1][1]); >+ result[1][2] = trunc(x[1][2]); >+ return result; >+} >+half2x4 trunc(half2x4 x) { >+ half2x4 result; >+ result[0][0] = trunc(x[0][0]); >+ result[0][1] = trunc(x[0][1]); >+ result[0][2] = trunc(x[0][2]); >+ result[0][3] = trunc(x[0][3]); >+ result[1][0] = trunc(x[1][0]); >+ result[1][1] = trunc(x[1][1]); >+ result[1][2] = trunc(x[1][2]); >+ result[1][3] = trunc(x[1][3]); >+ return result; >+} >+half3x2 trunc(half3x2 x) { >+ half3x2 result; >+ result[0][0] = trunc(x[0][0]); >+ result[0][1] = trunc(x[0][1]); >+ result[1][0] = trunc(x[1][0]); >+ result[1][1] = trunc(x[1][1]); >+ result[2][0] = trunc(x[2][0]); >+ result[2][1] = trunc(x[2][1]); >+ return result; >+} >+half3x3 trunc(half3x3 x) { >+ half3x3 result; >+ result[0][0] = trunc(x[0][0]); >+ result[0][1] = trunc(x[0][1]); >+ result[0][2] = trunc(x[0][2]); >+ result[1][0] = trunc(x[1][0]); >+ result[1][1] = trunc(x[1][1]); >+ result[1][2] = trunc(x[1][2]); >+ result[2][0] = trunc(x[2][0]); >+ result[2][1] = trunc(x[2][1]); >+ result[2][2] = trunc(x[2][2]); >+ return result; >+} >+half3x4 trunc(half3x4 x) { >+ half3x4 result; >+ result[0][0] = trunc(x[0][0]); >+ result[0][1] = trunc(x[0][1]); >+ result[0][2] = trunc(x[0][2]); >+ result[0][3] = trunc(x[0][3]); >+ result[1][0] = trunc(x[1][0]); >+ result[1][1] = trunc(x[1][1]); >+ result[1][2] = trunc(x[1][2]); >+ result[1][3] = trunc(x[1][3]); >+ result[2][0] = trunc(x[2][0]); >+ result[2][1] = trunc(x[2][1]); >+ result[2][2] = trunc(x[2][2]); >+ result[2][3] = trunc(x[2][3]); >+ return result; >+} >+half4x2 trunc(half4x2 x) { >+ half4x2 result; >+ result[0][0] = trunc(x[0][0]); >+ result[0][1] = trunc(x[0][1]); >+ result[1][0] = trunc(x[1][0]); >+ result[1][1] = trunc(x[1][1]); >+ result[2][0] = trunc(x[2][0]); >+ result[2][1] = trunc(x[2][1]); >+ result[3][0] = trunc(x[3][0]); >+ result[3][1] = trunc(x[3][1]); >+ return result; >+} >+half4x3 trunc(half4x3 x) { >+ half4x3 result; >+ result[0][0] = trunc(x[0][0]); >+ result[0][1] = trunc(x[0][1]); >+ result[0][2] = trunc(x[0][2]); >+ result[1][0] = trunc(x[1][0]); >+ result[1][1] = trunc(x[1][1]); >+ result[1][2] = trunc(x[1][2]); >+ result[2][0] = trunc(x[2][0]); >+ result[2][1] = trunc(x[2][1]); >+ result[2][2] = trunc(x[2][2]); >+ result[3][0] = trunc(x[3][0]); >+ result[3][1] = trunc(x[3][1]); >+ result[3][2] = trunc(x[3][2]); >+ return result; >+} >+half4x4 trunc(half4x4 x) { >+ half4x4 result; >+ result[0][0] = trunc(x[0][0]); >+ result[0][1] = trunc(x[0][1]); >+ result[0][2] = trunc(x[0][2]); >+ result[0][3] = trunc(x[0][3]); >+ result[1][0] = trunc(x[1][0]); >+ result[1][1] = trunc(x[1][1]); >+ result[1][2] = trunc(x[1][2]); >+ result[1][3] = trunc(x[1][3]); >+ result[2][0] = trunc(x[2][0]); >+ result[2][1] = trunc(x[2][1]); >+ result[2][2] = trunc(x[2][2]); >+ result[2][3] = trunc(x[2][3]); >+ result[3][0] = trunc(x[3][0]); >+ result[3][1] = trunc(x[3][1]); >+ result[3][2] = trunc(x[3][2]); >+ result[3][3] = trunc(x[3][3]); >+ return result; >+} >+half2 ddx(half2 x) { >+ half2 result; >+ result[0] = ddx(x[0]); >+ result[1] = ddx(x[1]); >+ return result; >+} >+half3 ddx(half3 x) { >+ half3 result; >+ result[0] = ddx(x[0]); >+ result[1] = ddx(x[1]); >+ result[2] = ddx(x[2]); >+ return result; >+} >+half4 ddx(half4 x) { >+ half4 result; >+ result[0] = ddx(x[0]); >+ result[1] = ddx(x[1]); >+ result[2] = ddx(x[2]); >+ result[3] = ddx(x[3]); >+ return result; >+} >+half2x2 ddx(half2x2 x) { >+ half2x2 result; >+ result[0][0] = ddx(x[0][0]); >+ result[0][1] = ddx(x[0][1]); >+ result[1][0] = ddx(x[1][0]); >+ result[1][1] = ddx(x[1][1]); >+ return result; >+} >+half2x3 ddx(half2x3 x) { >+ half2x3 result; >+ result[0][0] = ddx(x[0][0]); >+ result[0][1] = ddx(x[0][1]); >+ result[0][2] = ddx(x[0][2]); >+ result[1][0] = ddx(x[1][0]); >+ result[1][1] = ddx(x[1][1]); >+ result[1][2] = ddx(x[1][2]); >+ return result; >+} >+half2x4 ddx(half2x4 x) { >+ half2x4 result; >+ result[0][0] = ddx(x[0][0]); >+ result[0][1] = ddx(x[0][1]); >+ result[0][2] = ddx(x[0][2]); >+ result[0][3] = ddx(x[0][3]); >+ result[1][0] = ddx(x[1][0]); >+ result[1][1] = ddx(x[1][1]); >+ result[1][2] = ddx(x[1][2]); >+ result[1][3] = ddx(x[1][3]); >+ return result; >+} >+half3x2 ddx(half3x2 x) { >+ half3x2 result; >+ result[0][0] = ddx(x[0][0]); >+ result[0][1] = ddx(x[0][1]); >+ result[1][0] = ddx(x[1][0]); >+ result[1][1] = ddx(x[1][1]); >+ result[2][0] = ddx(x[2][0]); >+ result[2][1] = ddx(x[2][1]); >+ return result; >+} >+half3x3 ddx(half3x3 x) { >+ half3x3 result; >+ result[0][0] = ddx(x[0][0]); >+ result[0][1] = ddx(x[0][1]); >+ result[0][2] = ddx(x[0][2]); >+ result[1][0] = ddx(x[1][0]); >+ result[1][1] = ddx(x[1][1]); >+ result[1][2] = ddx(x[1][2]); >+ result[2][0] = ddx(x[2][0]); >+ result[2][1] = ddx(x[2][1]); >+ result[2][2] = ddx(x[2][2]); >+ return result; >+} >+half3x4 ddx(half3x4 x) { >+ half3x4 result; >+ result[0][0] = ddx(x[0][0]); >+ result[0][1] = ddx(x[0][1]); >+ result[0][2] = ddx(x[0][2]); >+ result[0][3] = ddx(x[0][3]); >+ result[1][0] = ddx(x[1][0]); >+ result[1][1] = ddx(x[1][1]); >+ result[1][2] = ddx(x[1][2]); >+ result[1][3] = ddx(x[1][3]); >+ result[2][0] = ddx(x[2][0]); >+ result[2][1] = ddx(x[2][1]); >+ result[2][2] = ddx(x[2][2]); >+ result[2][3] = ddx(x[2][3]); >+ return result; >+} >+half4x2 ddx(half4x2 x) { >+ half4x2 result; >+ result[0][0] = ddx(x[0][0]); >+ result[0][1] = ddx(x[0][1]); >+ result[1][0] = ddx(x[1][0]); >+ result[1][1] = ddx(x[1][1]); >+ result[2][0] = ddx(x[2][0]); >+ result[2][1] = ddx(x[2][1]); >+ result[3][0] = ddx(x[3][0]); >+ result[3][1] = ddx(x[3][1]); >+ return result; >+} >+half4x3 ddx(half4x3 x) { >+ half4x3 result; >+ result[0][0] = ddx(x[0][0]); >+ result[0][1] = ddx(x[0][1]); >+ result[0][2] = ddx(x[0][2]); >+ result[1][0] = ddx(x[1][0]); >+ result[1][1] = ddx(x[1][1]); >+ result[1][2] = ddx(x[1][2]); >+ result[2][0] = ddx(x[2][0]); >+ result[2][1] = ddx(x[2][1]); >+ result[2][2] = ddx(x[2][2]); >+ result[3][0] = ddx(x[3][0]); >+ result[3][1] = ddx(x[3][1]); >+ result[3][2] = ddx(x[3][2]); >+ return result; >+} >+half4x4 ddx(half4x4 x) { >+ half4x4 result; >+ result[0][0] = ddx(x[0][0]); >+ result[0][1] = ddx(x[0][1]); >+ result[0][2] = ddx(x[0][2]); >+ result[0][3] = ddx(x[0][3]); >+ result[1][0] = ddx(x[1][0]); >+ result[1][1] = ddx(x[1][1]); >+ result[1][2] = ddx(x[1][2]); >+ result[1][3] = ddx(x[1][3]); >+ result[2][0] = ddx(x[2][0]); >+ result[2][1] = ddx(x[2][1]); >+ result[2][2] = ddx(x[2][2]); >+ result[2][3] = ddx(x[2][3]); >+ result[3][0] = ddx(x[3][0]); >+ result[3][1] = ddx(x[3][1]); >+ result[3][2] = ddx(x[3][2]); >+ result[3][3] = ddx(x[3][3]); >+ return result; >+} >+half2 ddy(half2 x) { >+ half2 result; >+ result[0] = ddy(x[0]); >+ result[1] = ddy(x[1]); >+ return result; >+} >+half3 ddy(half3 x) { >+ half3 result; >+ result[0] = ddy(x[0]); >+ result[1] = ddy(x[1]); >+ result[2] = ddy(x[2]); >+ return result; >+} >+half4 ddy(half4 x) { >+ half4 result; >+ result[0] = ddy(x[0]); >+ result[1] = ddy(x[1]); >+ result[2] = ddy(x[2]); >+ result[3] = ddy(x[3]); >+ return result; >+} >+half2x2 ddy(half2x2 x) { >+ half2x2 result; >+ result[0][0] = ddy(x[0][0]); >+ result[0][1] = ddy(x[0][1]); >+ result[1][0] = ddy(x[1][0]); >+ result[1][1] = ddy(x[1][1]); >+ return result; >+} >+half2x3 ddy(half2x3 x) { >+ half2x3 result; >+ result[0][0] = ddy(x[0][0]); >+ result[0][1] = ddy(x[0][1]); >+ result[0][2] = ddy(x[0][2]); >+ result[1][0] = ddy(x[1][0]); >+ result[1][1] = ddy(x[1][1]); >+ result[1][2] = ddy(x[1][2]); >+ return result; >+} >+half2x4 ddy(half2x4 x) { >+ half2x4 result; >+ result[0][0] = ddy(x[0][0]); >+ result[0][1] = ddy(x[0][1]); >+ result[0][2] = ddy(x[0][2]); >+ result[0][3] = ddy(x[0][3]); >+ result[1][0] = ddy(x[1][0]); >+ result[1][1] = ddy(x[1][1]); >+ result[1][2] = ddy(x[1][2]); >+ result[1][3] = ddy(x[1][3]); >+ return result; >+} >+half3x2 ddy(half3x2 x) { >+ half3x2 result; >+ result[0][0] = ddy(x[0][0]); >+ result[0][1] = ddy(x[0][1]); >+ result[1][0] = ddy(x[1][0]); >+ result[1][1] = ddy(x[1][1]); >+ result[2][0] = ddy(x[2][0]); >+ result[2][1] = ddy(x[2][1]); >+ return result; >+} >+half3x3 ddy(half3x3 x) { >+ half3x3 result; >+ result[0][0] = ddy(x[0][0]); >+ result[0][1] = ddy(x[0][1]); >+ result[0][2] = ddy(x[0][2]); >+ result[1][0] = ddy(x[1][0]); >+ result[1][1] = ddy(x[1][1]); >+ result[1][2] = ddy(x[1][2]); >+ result[2][0] = ddy(x[2][0]); >+ result[2][1] = ddy(x[2][1]); >+ result[2][2] = ddy(x[2][2]); >+ return result; >+} >+half3x4 ddy(half3x4 x) { >+ half3x4 result; >+ result[0][0] = ddy(x[0][0]); >+ result[0][1] = ddy(x[0][1]); >+ result[0][2] = ddy(x[0][2]); >+ result[0][3] = ddy(x[0][3]); >+ result[1][0] = ddy(x[1][0]); >+ result[1][1] = ddy(x[1][1]); >+ result[1][2] = ddy(x[1][2]); >+ result[1][3] = ddy(x[1][3]); >+ result[2][0] = ddy(x[2][0]); >+ result[2][1] = ddy(x[2][1]); >+ result[2][2] = ddy(x[2][2]); >+ result[2][3] = ddy(x[2][3]); >+ return result; >+} >+half4x2 ddy(half4x2 x) { >+ half4x2 result; >+ result[0][0] = ddy(x[0][0]); >+ result[0][1] = ddy(x[0][1]); >+ result[1][0] = ddy(x[1][0]); >+ result[1][1] = ddy(x[1][1]); >+ result[2][0] = ddy(x[2][0]); >+ result[2][1] = ddy(x[2][1]); >+ result[3][0] = ddy(x[3][0]); >+ result[3][1] = ddy(x[3][1]); >+ return result; >+} >+half4x3 ddy(half4x3 x) { >+ half4x3 result; >+ result[0][0] = ddy(x[0][0]); >+ result[0][1] = ddy(x[0][1]); >+ result[0][2] = ddy(x[0][2]); >+ result[1][0] = ddy(x[1][0]); >+ result[1][1] = ddy(x[1][1]); >+ result[1][2] = ddy(x[1][2]); >+ result[2][0] = ddy(x[2][0]); >+ result[2][1] = ddy(x[2][1]); >+ result[2][2] = ddy(x[2][2]); >+ result[3][0] = ddy(x[3][0]); >+ result[3][1] = ddy(x[3][1]); >+ result[3][2] = ddy(x[3][2]); >+ return result; >+} >+half4x4 ddy(half4x4 x) { >+ half4x4 result; >+ result[0][0] = ddy(x[0][0]); >+ result[0][1] = ddy(x[0][1]); >+ result[0][2] = ddy(x[0][2]); >+ result[0][3] = ddy(x[0][3]); >+ result[1][0] = ddy(x[1][0]); >+ result[1][1] = ddy(x[1][1]); >+ result[1][2] = ddy(x[1][2]); >+ result[1][3] = ddy(x[1][3]); >+ result[2][0] = ddy(x[2][0]); >+ result[2][1] = ddy(x[2][1]); >+ result[2][2] = ddy(x[2][2]); >+ result[2][3] = ddy(x[2][3]); >+ result[3][0] = ddy(x[3][0]); >+ result[3][1] = ddy(x[3][1]); >+ result[3][2] = ddy(x[3][2]); >+ result[3][3] = ddy(x[3][3]); >+ return result; >+} >+half2 sqrt(half2 x) { >+ half2 result; >+ result[0] = sqrt(x[0]); >+ result[1] = sqrt(x[1]); >+ return result; >+} >+half3 sqrt(half3 x) { >+ half3 result; >+ result[0] = sqrt(x[0]); >+ result[1] = sqrt(x[1]); >+ result[2] = sqrt(x[2]); >+ return result; >+} >+half4 sqrt(half4 x) { >+ half4 result; >+ result[0] = sqrt(x[0]); >+ result[1] = sqrt(x[1]); >+ result[2] = sqrt(x[2]); >+ result[3] = sqrt(x[3]); >+ return result; >+} >+half2x2 sqrt(half2x2 x) { >+ half2x2 result; >+ result[0][0] = sqrt(x[0][0]); >+ result[0][1] = sqrt(x[0][1]); >+ result[1][0] = sqrt(x[1][0]); >+ result[1][1] = sqrt(x[1][1]); >+ return result; >+} >+half2x3 sqrt(half2x3 x) { >+ half2x3 result; >+ result[0][0] = sqrt(x[0][0]); >+ result[0][1] = sqrt(x[0][1]); >+ result[0][2] = sqrt(x[0][2]); >+ result[1][0] = sqrt(x[1][0]); >+ result[1][1] = sqrt(x[1][1]); >+ result[1][2] = sqrt(x[1][2]); >+ return result; >+} >+half2x4 sqrt(half2x4 x) { >+ half2x4 result; >+ result[0][0] = sqrt(x[0][0]); >+ result[0][1] = sqrt(x[0][1]); >+ result[0][2] = sqrt(x[0][2]); >+ result[0][3] = sqrt(x[0][3]); >+ result[1][0] = sqrt(x[1][0]); >+ result[1][1] = sqrt(x[1][1]); >+ result[1][2] = sqrt(x[1][2]); >+ result[1][3] = sqrt(x[1][3]); >+ return result; >+} >+half3x2 sqrt(half3x2 x) { >+ half3x2 result; >+ result[0][0] = sqrt(x[0][0]); >+ result[0][1] = sqrt(x[0][1]); >+ result[1][0] = sqrt(x[1][0]); >+ result[1][1] = sqrt(x[1][1]); >+ result[2][0] = sqrt(x[2][0]); >+ result[2][1] = sqrt(x[2][1]); >+ return result; >+} >+half3x3 sqrt(half3x3 x) { >+ half3x3 result; >+ result[0][0] = sqrt(x[0][0]); >+ result[0][1] = sqrt(x[0][1]); >+ result[0][2] = sqrt(x[0][2]); >+ result[1][0] = sqrt(x[1][0]); >+ result[1][1] = sqrt(x[1][1]); >+ result[1][2] = sqrt(x[1][2]); >+ result[2][0] = sqrt(x[2][0]); >+ result[2][1] = sqrt(x[2][1]); >+ result[2][2] = sqrt(x[2][2]); >+ return result; >+} >+half3x4 sqrt(half3x4 x) { >+ half3x4 result; >+ result[0][0] = sqrt(x[0][0]); >+ result[0][1] = sqrt(x[0][1]); >+ result[0][2] = sqrt(x[0][2]); >+ result[0][3] = sqrt(x[0][3]); >+ result[1][0] = sqrt(x[1][0]); >+ result[1][1] = sqrt(x[1][1]); >+ result[1][2] = sqrt(x[1][2]); >+ result[1][3] = sqrt(x[1][3]); >+ result[2][0] = sqrt(x[2][0]); >+ result[2][1] = sqrt(x[2][1]); >+ result[2][2] = sqrt(x[2][2]); >+ result[2][3] = sqrt(x[2][3]); >+ return result; >+} >+half4x2 sqrt(half4x2 x) { >+ half4x2 result; >+ result[0][0] = sqrt(x[0][0]); >+ result[0][1] = sqrt(x[0][1]); >+ result[1][0] = sqrt(x[1][0]); >+ result[1][1] = sqrt(x[1][1]); >+ result[2][0] = sqrt(x[2][0]); >+ result[2][1] = sqrt(x[2][1]); >+ result[3][0] = sqrt(x[3][0]); >+ result[3][1] = sqrt(x[3][1]); >+ return result; >+} >+half4x3 sqrt(half4x3 x) { >+ half4x3 result; >+ result[0][0] = sqrt(x[0][0]); >+ result[0][1] = sqrt(x[0][1]); >+ result[0][2] = sqrt(x[0][2]); >+ result[1][0] = sqrt(x[1][0]); >+ result[1][1] = sqrt(x[1][1]); >+ result[1][2] = sqrt(x[1][2]); >+ result[2][0] = sqrt(x[2][0]); >+ result[2][1] = sqrt(x[2][1]); >+ result[2][2] = sqrt(x[2][2]); >+ result[3][0] = sqrt(x[3][0]); >+ result[3][1] = sqrt(x[3][1]); >+ result[3][2] = sqrt(x[3][2]); >+ return result; >+} >+half4x4 sqrt(half4x4 x) { >+ half4x4 result; >+ result[0][0] = sqrt(x[0][0]); >+ result[0][1] = sqrt(x[0][1]); >+ result[0][2] = sqrt(x[0][2]); >+ result[0][3] = sqrt(x[0][3]); >+ result[1][0] = sqrt(x[1][0]); >+ result[1][1] = sqrt(x[1][1]); >+ result[1][2] = sqrt(x[1][2]); >+ result[1][3] = sqrt(x[1][3]); >+ result[2][0] = sqrt(x[2][0]); >+ result[2][1] = sqrt(x[2][1]); >+ result[2][2] = sqrt(x[2][2]); >+ result[2][3] = sqrt(x[2][3]); >+ result[3][0] = sqrt(x[3][0]); >+ result[3][1] = sqrt(x[3][1]); >+ result[3][2] = sqrt(x[3][2]); >+ result[3][3] = sqrt(x[3][3]); >+ return result; >+} >+half2 log2(half2 x) { >+ half2 result; >+ result[0] = log2(x[0]); >+ result[1] = log2(x[1]); >+ return result; >+} >+half3 log2(half3 x) { >+ half3 result; >+ result[0] = log2(x[0]); >+ result[1] = log2(x[1]); >+ result[2] = log2(x[2]); >+ return result; >+} >+half4 log2(half4 x) { >+ half4 result; >+ result[0] = log2(x[0]); >+ result[1] = log2(x[1]); >+ result[2] = log2(x[2]); >+ result[3] = log2(x[3]); >+ return result; >+} >+half2x2 log2(half2x2 x) { >+ half2x2 result; >+ result[0][0] = log2(x[0][0]); >+ result[0][1] = log2(x[0][1]); >+ result[1][0] = log2(x[1][0]); >+ result[1][1] = log2(x[1][1]); >+ return result; >+} >+half2x3 log2(half2x3 x) { >+ half2x3 result; >+ result[0][0] = log2(x[0][0]); >+ result[0][1] = log2(x[0][1]); >+ result[0][2] = log2(x[0][2]); >+ result[1][0] = log2(x[1][0]); >+ result[1][1] = log2(x[1][1]); >+ result[1][2] = log2(x[1][2]); >+ return result; >+} >+half2x4 log2(half2x4 x) { >+ half2x4 result; >+ result[0][0] = log2(x[0][0]); >+ result[0][1] = log2(x[0][1]); >+ result[0][2] = log2(x[0][2]); >+ result[0][3] = log2(x[0][3]); >+ result[1][0] = log2(x[1][0]); >+ result[1][1] = log2(x[1][1]); >+ result[1][2] = log2(x[1][2]); >+ result[1][3] = log2(x[1][3]); >+ return result; >+} >+half3x2 log2(half3x2 x) { >+ half3x2 result; >+ result[0][0] = log2(x[0][0]); >+ result[0][1] = log2(x[0][1]); >+ result[1][0] = log2(x[1][0]); >+ result[1][1] = log2(x[1][1]); >+ result[2][0] = log2(x[2][0]); >+ result[2][1] = log2(x[2][1]); >+ return result; >+} >+half3x3 log2(half3x3 x) { >+ half3x3 result; >+ result[0][0] = log2(x[0][0]); >+ result[0][1] = log2(x[0][1]); >+ result[0][2] = log2(x[0][2]); >+ result[1][0] = log2(x[1][0]); >+ result[1][1] = log2(x[1][1]); >+ result[1][2] = log2(x[1][2]); >+ result[2][0] = log2(x[2][0]); >+ result[2][1] = log2(x[2][1]); >+ result[2][2] = log2(x[2][2]); >+ return result; >+} >+half3x4 log2(half3x4 x) { >+ half3x4 result; >+ result[0][0] = log2(x[0][0]); >+ result[0][1] = log2(x[0][1]); >+ result[0][2] = log2(x[0][2]); >+ result[0][3] = log2(x[0][3]); >+ result[1][0] = log2(x[1][0]); >+ result[1][1] = log2(x[1][1]); >+ result[1][2] = log2(x[1][2]); >+ result[1][3] = log2(x[1][3]); >+ result[2][0] = log2(x[2][0]); >+ result[2][1] = log2(x[2][1]); >+ result[2][2] = log2(x[2][2]); >+ result[2][3] = log2(x[2][3]); >+ return result; >+} >+half4x2 log2(half4x2 x) { >+ half4x2 result; >+ result[0][0] = log2(x[0][0]); >+ result[0][1] = log2(x[0][1]); >+ result[1][0] = log2(x[1][0]); >+ result[1][1] = log2(x[1][1]); >+ result[2][0] = log2(x[2][0]); >+ result[2][1] = log2(x[2][1]); >+ result[3][0] = log2(x[3][0]); >+ result[3][1] = log2(x[3][1]); >+ return result; >+} >+half4x3 log2(half4x3 x) { >+ half4x3 result; >+ result[0][0] = log2(x[0][0]); >+ result[0][1] = log2(x[0][1]); >+ result[0][2] = log2(x[0][2]); >+ result[1][0] = log2(x[1][0]); >+ result[1][1] = log2(x[1][1]); >+ result[1][2] = log2(x[1][2]); >+ result[2][0] = log2(x[2][0]); >+ result[2][1] = log2(x[2][1]); >+ result[2][2] = log2(x[2][2]); >+ result[3][0] = log2(x[3][0]); >+ result[3][1] = log2(x[3][1]); >+ result[3][2] = log2(x[3][2]); >+ return result; >+} >+half4x4 log2(half4x4 x) { >+ half4x4 result; >+ result[0][0] = log2(x[0][0]); >+ result[0][1] = log2(x[0][1]); >+ result[0][2] = log2(x[0][2]); >+ result[0][3] = log2(x[0][3]); >+ result[1][0] = log2(x[1][0]); >+ result[1][1] = log2(x[1][1]); >+ result[1][2] = log2(x[1][2]); >+ result[1][3] = log2(x[1][3]); >+ result[2][0] = log2(x[2][0]); >+ result[2][1] = log2(x[2][1]); >+ result[2][2] = log2(x[2][2]); >+ result[2][3] = log2(x[2][3]); >+ result[3][0] = log2(x[3][0]); >+ result[3][1] = log2(x[3][1]); >+ result[3][2] = log2(x[3][2]); >+ result[3][3] = log2(x[3][3]); >+ return result; >+} >+half2 log10(half2 x) { >+ half2 result; >+ result[0] = log10(x[0]); >+ result[1] = log10(x[1]); >+ return result; >+} >+half3 log10(half3 x) { >+ half3 result; >+ result[0] = log10(x[0]); >+ result[1] = log10(x[1]); >+ result[2] = log10(x[2]); >+ return result; >+} >+half4 log10(half4 x) { >+ half4 result; >+ result[0] = log10(x[0]); >+ result[1] = log10(x[1]); >+ result[2] = log10(x[2]); >+ result[3] = log10(x[3]); >+ return result; >+} >+half2x2 log10(half2x2 x) { >+ half2x2 result; >+ result[0][0] = log10(x[0][0]); >+ result[0][1] = log10(x[0][1]); >+ result[1][0] = log10(x[1][0]); >+ result[1][1] = log10(x[1][1]); >+ return result; >+} >+half2x3 log10(half2x3 x) { >+ half2x3 result; >+ result[0][0] = log10(x[0][0]); >+ result[0][1] = log10(x[0][1]); >+ result[0][2] = log10(x[0][2]); >+ result[1][0] = log10(x[1][0]); >+ result[1][1] = log10(x[1][1]); >+ result[1][2] = log10(x[1][2]); >+ return result; >+} >+half2x4 log10(half2x4 x) { >+ half2x4 result; >+ result[0][0] = log10(x[0][0]); >+ result[0][1] = log10(x[0][1]); >+ result[0][2] = log10(x[0][2]); >+ result[0][3] = log10(x[0][3]); >+ result[1][0] = log10(x[1][0]); >+ result[1][1] = log10(x[1][1]); >+ result[1][2] = log10(x[1][2]); >+ result[1][3] = log10(x[1][3]); >+ return result; >+} >+half3x2 log10(half3x2 x) { >+ half3x2 result; >+ result[0][0] = log10(x[0][0]); >+ result[0][1] = log10(x[0][1]); >+ result[1][0] = log10(x[1][0]); >+ result[1][1] = log10(x[1][1]); >+ result[2][0] = log10(x[2][0]); >+ result[2][1] = log10(x[2][1]); >+ return result; >+} >+half3x3 log10(half3x3 x) { >+ half3x3 result; >+ result[0][0] = log10(x[0][0]); >+ result[0][1] = log10(x[0][1]); >+ result[0][2] = log10(x[0][2]); >+ result[1][0] = log10(x[1][0]); >+ result[1][1] = log10(x[1][1]); >+ result[1][2] = log10(x[1][2]); >+ result[2][0] = log10(x[2][0]); >+ result[2][1] = log10(x[2][1]); >+ result[2][2] = log10(x[2][2]); >+ return result; >+} >+half3x4 log10(half3x4 x) { >+ half3x4 result; >+ result[0][0] = log10(x[0][0]); >+ result[0][1] = log10(x[0][1]); >+ result[0][2] = log10(x[0][2]); >+ result[0][3] = log10(x[0][3]); >+ result[1][0] = log10(x[1][0]); >+ result[1][1] = log10(x[1][1]); >+ result[1][2] = log10(x[1][2]); >+ result[1][3] = log10(x[1][3]); >+ result[2][0] = log10(x[2][0]); >+ result[2][1] = log10(x[2][1]); >+ result[2][2] = log10(x[2][2]); >+ result[2][3] = log10(x[2][3]); >+ return result; >+} >+half4x2 log10(half4x2 x) { >+ half4x2 result; >+ result[0][0] = log10(x[0][0]); >+ result[0][1] = log10(x[0][1]); >+ result[1][0] = log10(x[1][0]); >+ result[1][1] = log10(x[1][1]); >+ result[2][0] = log10(x[2][0]); >+ result[2][1] = log10(x[2][1]); >+ result[3][0] = log10(x[3][0]); >+ result[3][1] = log10(x[3][1]); >+ return result; >+} >+half4x3 log10(half4x3 x) { >+ half4x3 result; >+ result[0][0] = log10(x[0][0]); >+ result[0][1] = log10(x[0][1]); >+ result[0][2] = log10(x[0][2]); >+ result[1][0] = log10(x[1][0]); >+ result[1][1] = log10(x[1][1]); >+ result[1][2] = log10(x[1][2]); >+ result[2][0] = log10(x[2][0]); >+ result[2][1] = log10(x[2][1]); >+ result[2][2] = log10(x[2][2]); >+ result[3][0] = log10(x[3][0]); >+ result[3][1] = log10(x[3][1]); >+ result[3][2] = log10(x[3][2]); >+ return result; >+} >+half4x4 log10(half4x4 x) { >+ half4x4 result; >+ result[0][0] = log10(x[0][0]); >+ result[0][1] = log10(x[0][1]); >+ result[0][2] = log10(x[0][2]); >+ result[0][3] = log10(x[0][3]); >+ result[1][0] = log10(x[1][0]); >+ result[1][1] = log10(x[1][1]); >+ result[1][2] = log10(x[1][2]); >+ result[1][3] = log10(x[1][3]); >+ result[2][0] = log10(x[2][0]); >+ result[2][1] = log10(x[2][1]); >+ result[2][2] = log10(x[2][2]); >+ result[2][3] = log10(x[2][3]); >+ result[3][0] = log10(x[3][0]); >+ result[3][1] = log10(x[3][1]); >+ result[3][2] = log10(x[3][2]); >+ result[3][3] = log10(x[3][3]); >+ return result; >+} >+half2 frac(half2 x) { >+ half2 result; >+ result[0] = frac(x[0]); >+ result[1] = frac(x[1]); >+ return result; >+} >+half3 frac(half3 x) { >+ half3 result; >+ result[0] = frac(x[0]); >+ result[1] = frac(x[1]); >+ result[2] = frac(x[2]); >+ return result; >+} >+half4 frac(half4 x) { >+ half4 result; >+ result[0] = frac(x[0]); >+ result[1] = frac(x[1]); >+ result[2] = frac(x[2]); >+ result[3] = frac(x[3]); >+ return result; >+} >+half2x2 frac(half2x2 x) { >+ half2x2 result; >+ result[0][0] = frac(x[0][0]); >+ result[0][1] = frac(x[0][1]); >+ result[1][0] = frac(x[1][0]); >+ result[1][1] = frac(x[1][1]); >+ return result; >+} >+half2x3 frac(half2x3 x) { >+ half2x3 result; >+ result[0][0] = frac(x[0][0]); >+ result[0][1] = frac(x[0][1]); >+ result[0][2] = frac(x[0][2]); >+ result[1][0] = frac(x[1][0]); >+ result[1][1] = frac(x[1][1]); >+ result[1][2] = frac(x[1][2]); >+ return result; >+} >+half2x4 frac(half2x4 x) { >+ half2x4 result; >+ result[0][0] = frac(x[0][0]); >+ result[0][1] = frac(x[0][1]); >+ result[0][2] = frac(x[0][2]); >+ result[0][3] = frac(x[0][3]); >+ result[1][0] = frac(x[1][0]); >+ result[1][1] = frac(x[1][1]); >+ result[1][2] = frac(x[1][2]); >+ result[1][3] = frac(x[1][3]); >+ return result; >+} >+half3x2 frac(half3x2 x) { >+ half3x2 result; >+ result[0][0] = frac(x[0][0]); >+ result[0][1] = frac(x[0][1]); >+ result[1][0] = frac(x[1][0]); >+ result[1][1] = frac(x[1][1]); >+ result[2][0] = frac(x[2][0]); >+ result[2][1] = frac(x[2][1]); >+ return result; >+} >+half3x3 frac(half3x3 x) { >+ half3x3 result; >+ result[0][0] = frac(x[0][0]); >+ result[0][1] = frac(x[0][1]); >+ result[0][2] = frac(x[0][2]); >+ result[1][0] = frac(x[1][0]); >+ result[1][1] = frac(x[1][1]); >+ result[1][2] = frac(x[1][2]); >+ result[2][0] = frac(x[2][0]); >+ result[2][1] = frac(x[2][1]); >+ result[2][2] = frac(x[2][2]); >+ return result; >+} >+half3x4 frac(half3x4 x) { >+ half3x4 result; >+ result[0][0] = frac(x[0][0]); >+ result[0][1] = frac(x[0][1]); >+ result[0][2] = frac(x[0][2]); >+ result[0][3] = frac(x[0][3]); >+ result[1][0] = frac(x[1][0]); >+ result[1][1] = frac(x[1][1]); >+ result[1][2] = frac(x[1][2]); >+ result[1][3] = frac(x[1][3]); >+ result[2][0] = frac(x[2][0]); >+ result[2][1] = frac(x[2][1]); >+ result[2][2] = frac(x[2][2]); >+ result[2][3] = frac(x[2][3]); >+ return result; >+} >+half4x2 frac(half4x2 x) { >+ half4x2 result; >+ result[0][0] = frac(x[0][0]); >+ result[0][1] = frac(x[0][1]); >+ result[1][0] = frac(x[1][0]); >+ result[1][1] = frac(x[1][1]); >+ result[2][0] = frac(x[2][0]); >+ result[2][1] = frac(x[2][1]); >+ result[3][0] = frac(x[3][0]); >+ result[3][1] = frac(x[3][1]); >+ return result; >+} >+half4x3 frac(half4x3 x) { >+ half4x3 result; >+ result[0][0] = frac(x[0][0]); >+ result[0][1] = frac(x[0][1]); >+ result[0][2] = frac(x[0][2]); >+ result[1][0] = frac(x[1][0]); >+ result[1][1] = frac(x[1][1]); >+ result[1][2] = frac(x[1][2]); >+ result[2][0] = frac(x[2][0]); >+ result[2][1] = frac(x[2][1]); >+ result[2][2] = frac(x[2][2]); >+ result[3][0] = frac(x[3][0]); >+ result[3][1] = frac(x[3][1]); >+ result[3][2] = frac(x[3][2]); >+ return result; >+} >+half4x4 frac(half4x4 x) { >+ half4x4 result; >+ result[0][0] = frac(x[0][0]); >+ result[0][1] = frac(x[0][1]); >+ result[0][2] = frac(x[0][2]); >+ result[0][3] = frac(x[0][3]); >+ result[1][0] = frac(x[1][0]); >+ result[1][1] = frac(x[1][1]); >+ result[1][2] = frac(x[1][2]); >+ result[1][3] = frac(x[1][3]); >+ result[2][0] = frac(x[2][0]); >+ result[2][1] = frac(x[2][1]); >+ result[2][2] = frac(x[2][2]); >+ result[2][3] = frac(x[2][3]); >+ result[3][0] = frac(x[3][0]); >+ result[3][1] = frac(x[3][1]); >+ result[3][2] = frac(x[3][2]); >+ result[3][3] = frac(x[3][3]); >+ return result; >+} >+half2 exp2(half2 x) { >+ half2 result; >+ result[0] = exp2(x[0]); >+ result[1] = exp2(x[1]); >+ return result; >+} >+half3 exp2(half3 x) { >+ half3 result; >+ result[0] = exp2(x[0]); >+ result[1] = exp2(x[1]); >+ result[2] = exp2(x[2]); >+ return result; >+} >+half4 exp2(half4 x) { >+ half4 result; >+ result[0] = exp2(x[0]); >+ result[1] = exp2(x[1]); >+ result[2] = exp2(x[2]); >+ result[3] = exp2(x[3]); >+ return result; >+} >+half2x2 exp2(half2x2 x) { >+ half2x2 result; >+ result[0][0] = exp2(x[0][0]); >+ result[0][1] = exp2(x[0][1]); >+ result[1][0] = exp2(x[1][0]); >+ result[1][1] = exp2(x[1][1]); >+ return result; >+} >+half2x3 exp2(half2x3 x) { >+ half2x3 result; >+ result[0][0] = exp2(x[0][0]); >+ result[0][1] = exp2(x[0][1]); >+ result[0][2] = exp2(x[0][2]); >+ result[1][0] = exp2(x[1][0]); >+ result[1][1] = exp2(x[1][1]); >+ result[1][2] = exp2(x[1][2]); >+ return result; >+} >+half2x4 exp2(half2x4 x) { >+ half2x4 result; >+ result[0][0] = exp2(x[0][0]); >+ result[0][1] = exp2(x[0][1]); >+ result[0][2] = exp2(x[0][2]); >+ result[0][3] = exp2(x[0][3]); >+ result[1][0] = exp2(x[1][0]); >+ result[1][1] = exp2(x[1][1]); >+ result[1][2] = exp2(x[1][2]); >+ result[1][3] = exp2(x[1][3]); >+ return result; >+} >+half3x2 exp2(half3x2 x) { >+ half3x2 result; >+ result[0][0] = exp2(x[0][0]); >+ result[0][1] = exp2(x[0][1]); >+ result[1][0] = exp2(x[1][0]); >+ result[1][1] = exp2(x[1][1]); >+ result[2][0] = exp2(x[2][0]); >+ result[2][1] = exp2(x[2][1]); >+ return result; >+} >+half3x3 exp2(half3x3 x) { >+ half3x3 result; >+ result[0][0] = exp2(x[0][0]); >+ result[0][1] = exp2(x[0][1]); >+ result[0][2] = exp2(x[0][2]); >+ result[1][0] = exp2(x[1][0]); >+ result[1][1] = exp2(x[1][1]); >+ result[1][2] = exp2(x[1][2]); >+ result[2][0] = exp2(x[2][0]); >+ result[2][1] = exp2(x[2][1]); >+ result[2][2] = exp2(x[2][2]); >+ return result; >+} >+half3x4 exp2(half3x4 x) { >+ half3x4 result; >+ result[0][0] = exp2(x[0][0]); >+ result[0][1] = exp2(x[0][1]); >+ result[0][2] = exp2(x[0][2]); >+ result[0][3] = exp2(x[0][3]); >+ result[1][0] = exp2(x[1][0]); >+ result[1][1] = exp2(x[1][1]); >+ result[1][2] = exp2(x[1][2]); >+ result[1][3] = exp2(x[1][3]); >+ result[2][0] = exp2(x[2][0]); >+ result[2][1] = exp2(x[2][1]); >+ result[2][2] = exp2(x[2][2]); >+ result[2][3] = exp2(x[2][3]); >+ return result; >+} >+half4x2 exp2(half4x2 x) { >+ half4x2 result; >+ result[0][0] = exp2(x[0][0]); >+ result[0][1] = exp2(x[0][1]); >+ result[1][0] = exp2(x[1][0]); >+ result[1][1] = exp2(x[1][1]); >+ result[2][0] = exp2(x[2][0]); >+ result[2][1] = exp2(x[2][1]); >+ result[3][0] = exp2(x[3][0]); >+ result[3][1] = exp2(x[3][1]); >+ return result; >+} >+half4x3 exp2(half4x3 x) { >+ half4x3 result; >+ result[0][0] = exp2(x[0][0]); >+ result[0][1] = exp2(x[0][1]); >+ result[0][2] = exp2(x[0][2]); >+ result[1][0] = exp2(x[1][0]); >+ result[1][1] = exp2(x[1][1]); >+ result[1][2] = exp2(x[1][2]); >+ result[2][0] = exp2(x[2][0]); >+ result[2][1] = exp2(x[2][1]); >+ result[2][2] = exp2(x[2][2]); >+ result[3][0] = exp2(x[3][0]); >+ result[3][1] = exp2(x[3][1]); >+ result[3][2] = exp2(x[3][2]); >+ return result; >+} >+half4x4 exp2(half4x4 x) { >+ half4x4 result; >+ result[0][0] = exp2(x[0][0]); >+ result[0][1] = exp2(x[0][1]); >+ result[0][2] = exp2(x[0][2]); >+ result[0][3] = exp2(x[0][3]); >+ result[1][0] = exp2(x[1][0]); >+ result[1][1] = exp2(x[1][1]); >+ result[1][2] = exp2(x[1][2]); >+ result[1][3] = exp2(x[1][3]); >+ result[2][0] = exp2(x[2][0]); >+ result[2][1] = exp2(x[2][1]); >+ result[2][2] = exp2(x[2][2]); >+ result[2][3] = exp2(x[2][3]); >+ result[3][0] = exp2(x[3][0]); >+ result[3][1] = exp2(x[3][1]); >+ result[3][2] = exp2(x[3][2]); >+ result[3][3] = exp2(x[3][3]); >+ return result; >+} >+half2 degrees(half2 x) { >+ half2 result; >+ result[0] = degrees(x[0]); >+ result[1] = degrees(x[1]); >+ return result; >+} >+half3 degrees(half3 x) { >+ half3 result; >+ result[0] = degrees(x[0]); >+ result[1] = degrees(x[1]); >+ result[2] = degrees(x[2]); >+ return result; >+} >+half4 degrees(half4 x) { >+ half4 result; >+ result[0] = degrees(x[0]); >+ result[1] = degrees(x[1]); >+ result[2] = degrees(x[2]); >+ result[3] = degrees(x[3]); >+ return result; >+} >+half2x2 degrees(half2x2 x) { >+ half2x2 result; >+ result[0][0] = degrees(x[0][0]); >+ result[0][1] = degrees(x[0][1]); >+ result[1][0] = degrees(x[1][0]); >+ result[1][1] = degrees(x[1][1]); >+ return result; >+} >+half2x3 degrees(half2x3 x) { >+ half2x3 result; >+ result[0][0] = degrees(x[0][0]); >+ result[0][1] = degrees(x[0][1]); >+ result[0][2] = degrees(x[0][2]); >+ result[1][0] = degrees(x[1][0]); >+ result[1][1] = degrees(x[1][1]); >+ result[1][2] = degrees(x[1][2]); >+ return result; >+} >+half2x4 degrees(half2x4 x) { >+ half2x4 result; >+ result[0][0] = degrees(x[0][0]); >+ result[0][1] = degrees(x[0][1]); >+ result[0][2] = degrees(x[0][2]); >+ result[0][3] = degrees(x[0][3]); >+ result[1][0] = degrees(x[1][0]); >+ result[1][1] = degrees(x[1][1]); >+ result[1][2] = degrees(x[1][2]); >+ result[1][3] = degrees(x[1][3]); >+ return result; >+} >+half3x2 degrees(half3x2 x) { >+ half3x2 result; >+ result[0][0] = degrees(x[0][0]); >+ result[0][1] = degrees(x[0][1]); >+ result[1][0] = degrees(x[1][0]); >+ result[1][1] = degrees(x[1][1]); >+ result[2][0] = degrees(x[2][0]); >+ result[2][1] = degrees(x[2][1]); >+ return result; >+} >+half3x3 degrees(half3x3 x) { >+ half3x3 result; >+ result[0][0] = degrees(x[0][0]); >+ result[0][1] = degrees(x[0][1]); >+ result[0][2] = degrees(x[0][2]); >+ result[1][0] = degrees(x[1][0]); >+ result[1][1] = degrees(x[1][1]); >+ result[1][2] = degrees(x[1][2]); >+ result[2][0] = degrees(x[2][0]); >+ result[2][1] = degrees(x[2][1]); >+ result[2][2] = degrees(x[2][2]); >+ return result; >+} >+half3x4 degrees(half3x4 x) { >+ half3x4 result; >+ result[0][0] = degrees(x[0][0]); >+ result[0][1] = degrees(x[0][1]); >+ result[0][2] = degrees(x[0][2]); >+ result[0][3] = degrees(x[0][3]); >+ result[1][0] = degrees(x[1][0]); >+ result[1][1] = degrees(x[1][1]); >+ result[1][2] = degrees(x[1][2]); >+ result[1][3] = degrees(x[1][3]); >+ result[2][0] = degrees(x[2][0]); >+ result[2][1] = degrees(x[2][1]); >+ result[2][2] = degrees(x[2][2]); >+ result[2][3] = degrees(x[2][3]); >+ return result; >+} >+half4x2 degrees(half4x2 x) { >+ half4x2 result; >+ result[0][0] = degrees(x[0][0]); >+ result[0][1] = degrees(x[0][1]); >+ result[1][0] = degrees(x[1][0]); >+ result[1][1] = degrees(x[1][1]); >+ result[2][0] = degrees(x[2][0]); >+ result[2][1] = degrees(x[2][1]); >+ result[3][0] = degrees(x[3][0]); >+ result[3][1] = degrees(x[3][1]); >+ return result; >+} >+half4x3 degrees(half4x3 x) { >+ half4x3 result; >+ result[0][0] = degrees(x[0][0]); >+ result[0][1] = degrees(x[0][1]); >+ result[0][2] = degrees(x[0][2]); >+ result[1][0] = degrees(x[1][0]); >+ result[1][1] = degrees(x[1][1]); >+ result[1][2] = degrees(x[1][2]); >+ result[2][0] = degrees(x[2][0]); >+ result[2][1] = degrees(x[2][1]); >+ result[2][2] = degrees(x[2][2]); >+ result[3][0] = degrees(x[3][0]); >+ result[3][1] = degrees(x[3][1]); >+ result[3][2] = degrees(x[3][2]); >+ return result; >+} >+half4x4 degrees(half4x4 x) { >+ half4x4 result; >+ result[0][0] = degrees(x[0][0]); >+ result[0][1] = degrees(x[0][1]); >+ result[0][2] = degrees(x[0][2]); >+ result[0][3] = degrees(x[0][3]); >+ result[1][0] = degrees(x[1][0]); >+ result[1][1] = degrees(x[1][1]); >+ result[1][2] = degrees(x[1][2]); >+ result[1][3] = degrees(x[1][3]); >+ result[2][0] = degrees(x[2][0]); >+ result[2][1] = degrees(x[2][1]); >+ result[2][2] = degrees(x[2][2]); >+ result[2][3] = degrees(x[2][3]); >+ result[3][0] = degrees(x[3][0]); >+ result[3][1] = degrees(x[3][1]); >+ result[3][2] = degrees(x[3][2]); >+ result[3][3] = degrees(x[3][3]); >+ return result; >+} >+half2 radians(half2 x) { >+ half2 result; >+ result[0] = radians(x[0]); >+ result[1] = radians(x[1]); >+ return result; >+} >+half3 radians(half3 x) { >+ half3 result; >+ result[0] = radians(x[0]); >+ result[1] = radians(x[1]); >+ result[2] = radians(x[2]); >+ return result; >+} >+half4 radians(half4 x) { >+ half4 result; >+ result[0] = radians(x[0]); >+ result[1] = radians(x[1]); >+ result[2] = radians(x[2]); >+ result[3] = radians(x[3]); >+ return result; >+} >+half2x2 radians(half2x2 x) { >+ half2x2 result; >+ result[0][0] = radians(x[0][0]); >+ result[0][1] = radians(x[0][1]); >+ result[1][0] = radians(x[1][0]); >+ result[1][1] = radians(x[1][1]); >+ return result; >+} >+half2x3 radians(half2x3 x) { >+ half2x3 result; >+ result[0][0] = radians(x[0][0]); >+ result[0][1] = radians(x[0][1]); >+ result[0][2] = radians(x[0][2]); >+ result[1][0] = radians(x[1][0]); >+ result[1][1] = radians(x[1][1]); >+ result[1][2] = radians(x[1][2]); >+ return result; >+} >+half2x4 radians(half2x4 x) { >+ half2x4 result; >+ result[0][0] = radians(x[0][0]); >+ result[0][1] = radians(x[0][1]); >+ result[0][2] = radians(x[0][2]); >+ result[0][3] = radians(x[0][3]); >+ result[1][0] = radians(x[1][0]); >+ result[1][1] = radians(x[1][1]); >+ result[1][2] = radians(x[1][2]); >+ result[1][3] = radians(x[1][3]); >+ return result; >+} >+half3x2 radians(half3x2 x) { >+ half3x2 result; >+ result[0][0] = radians(x[0][0]); >+ result[0][1] = radians(x[0][1]); >+ result[1][0] = radians(x[1][0]); >+ result[1][1] = radians(x[1][1]); >+ result[2][0] = radians(x[2][0]); >+ result[2][1] = radians(x[2][1]); >+ return result; >+} >+half3x3 radians(half3x3 x) { >+ half3x3 result; >+ result[0][0] = radians(x[0][0]); >+ result[0][1] = radians(x[0][1]); >+ result[0][2] = radians(x[0][2]); >+ result[1][0] = radians(x[1][0]); >+ result[1][1] = radians(x[1][1]); >+ result[1][2] = radians(x[1][2]); >+ result[2][0] = radians(x[2][0]); >+ result[2][1] = radians(x[2][1]); >+ result[2][2] = radians(x[2][2]); >+ return result; >+} >+half3x4 radians(half3x4 x) { >+ half3x4 result; >+ result[0][0] = radians(x[0][0]); >+ result[0][1] = radians(x[0][1]); >+ result[0][2] = radians(x[0][2]); >+ result[0][3] = radians(x[0][3]); >+ result[1][0] = radians(x[1][0]); >+ result[1][1] = radians(x[1][1]); >+ result[1][2] = radians(x[1][2]); >+ result[1][3] = radians(x[1][3]); >+ result[2][0] = radians(x[2][0]); >+ result[2][1] = radians(x[2][1]); >+ result[2][2] = radians(x[2][2]); >+ result[2][3] = radians(x[2][3]); >+ return result; >+} >+half4x2 radians(half4x2 x) { >+ half4x2 result; >+ result[0][0] = radians(x[0][0]); >+ result[0][1] = radians(x[0][1]); >+ result[1][0] = radians(x[1][0]); >+ result[1][1] = radians(x[1][1]); >+ result[2][0] = radians(x[2][0]); >+ result[2][1] = radians(x[2][1]); >+ result[3][0] = radians(x[3][0]); >+ result[3][1] = radians(x[3][1]); >+ return result; >+} >+half4x3 radians(half4x3 x) { >+ half4x3 result; >+ result[0][0] = radians(x[0][0]); >+ result[0][1] = radians(x[0][1]); >+ result[0][2] = radians(x[0][2]); >+ result[1][0] = radians(x[1][0]); >+ result[1][1] = radians(x[1][1]); >+ result[1][2] = radians(x[1][2]); >+ result[2][0] = radians(x[2][0]); >+ result[2][1] = radians(x[2][1]); >+ result[2][2] = radians(x[2][2]); >+ result[3][0] = radians(x[3][0]); >+ result[3][1] = radians(x[3][1]); >+ result[3][2] = radians(x[3][2]); >+ return result; >+} >+half4x4 radians(half4x4 x) { >+ half4x4 result; >+ result[0][0] = radians(x[0][0]); >+ result[0][1] = radians(x[0][1]); >+ result[0][2] = radians(x[0][2]); >+ result[0][3] = radians(x[0][3]); >+ result[1][0] = radians(x[1][0]); >+ result[1][1] = radians(x[1][1]); >+ result[1][2] = radians(x[1][2]); >+ result[1][3] = radians(x[1][3]); >+ result[2][0] = radians(x[2][0]); >+ result[2][1] = radians(x[2][1]); >+ result[2][2] = radians(x[2][2]); >+ result[2][3] = radians(x[2][3]); >+ result[3][0] = radians(x[3][0]); >+ result[3][1] = radians(x[3][1]); >+ result[3][2] = radians(x[3][2]); >+ result[3][3] = radians(x[3][3]); >+ return result; >+} >+half2 rcp(half2 x) { >+ half2 result; >+ result[0] = rcp(x[0]); >+ result[1] = rcp(x[1]); >+ return result; >+} >+half3 rcp(half3 x) { >+ half3 result; >+ result[0] = rcp(x[0]); >+ result[1] = rcp(x[1]); >+ result[2] = rcp(x[2]); >+ return result; >+} >+half4 rcp(half4 x) { >+ half4 result; >+ result[0] = rcp(x[0]); >+ result[1] = rcp(x[1]); >+ result[2] = rcp(x[2]); >+ result[3] = rcp(x[3]); >+ return result; >+} >+half2x2 rcp(half2x2 x) { >+ half2x2 result; >+ result[0][0] = rcp(x[0][0]); >+ result[0][1] = rcp(x[0][1]); >+ result[1][0] = rcp(x[1][0]); >+ result[1][1] = rcp(x[1][1]); >+ return result; >+} >+half2x3 rcp(half2x3 x) { >+ half2x3 result; >+ result[0][0] = rcp(x[0][0]); >+ result[0][1] = rcp(x[0][1]); >+ result[0][2] = rcp(x[0][2]); >+ result[1][0] = rcp(x[1][0]); >+ result[1][1] = rcp(x[1][1]); >+ result[1][2] = rcp(x[1][2]); >+ return result; >+} >+half2x4 rcp(half2x4 x) { >+ half2x4 result; >+ result[0][0] = rcp(x[0][0]); >+ result[0][1] = rcp(x[0][1]); >+ result[0][2] = rcp(x[0][2]); >+ result[0][3] = rcp(x[0][3]); >+ result[1][0] = rcp(x[1][0]); >+ result[1][1] = rcp(x[1][1]); >+ result[1][2] = rcp(x[1][2]); >+ result[1][3] = rcp(x[1][3]); >+ return result; >+} >+half3x2 rcp(half3x2 x) { >+ half3x2 result; >+ result[0][0] = rcp(x[0][0]); >+ result[0][1] = rcp(x[0][1]); >+ result[1][0] = rcp(x[1][0]); >+ result[1][1] = rcp(x[1][1]); >+ result[2][0] = rcp(x[2][0]); >+ result[2][1] = rcp(x[2][1]); >+ return result; >+} >+half3x3 rcp(half3x3 x) { >+ half3x3 result; >+ result[0][0] = rcp(x[0][0]); >+ result[0][1] = rcp(x[0][1]); >+ result[0][2] = rcp(x[0][2]); >+ result[1][0] = rcp(x[1][0]); >+ result[1][1] = rcp(x[1][1]); >+ result[1][2] = rcp(x[1][2]); >+ result[2][0] = rcp(x[2][0]); >+ result[2][1] = rcp(x[2][1]); >+ result[2][2] = rcp(x[2][2]); >+ return result; >+} >+half3x4 rcp(half3x4 x) { >+ half3x4 result; >+ result[0][0] = rcp(x[0][0]); >+ result[0][1] = rcp(x[0][1]); >+ result[0][2] = rcp(x[0][2]); >+ result[0][3] = rcp(x[0][3]); >+ result[1][0] = rcp(x[1][0]); >+ result[1][1] = rcp(x[1][1]); >+ result[1][2] = rcp(x[1][2]); >+ result[1][3] = rcp(x[1][3]); >+ result[2][0] = rcp(x[2][0]); >+ result[2][1] = rcp(x[2][1]); >+ result[2][2] = rcp(x[2][2]); >+ result[2][3] = rcp(x[2][3]); >+ return result; >+} >+half4x2 rcp(half4x2 x) { >+ half4x2 result; >+ result[0][0] = rcp(x[0][0]); >+ result[0][1] = rcp(x[0][1]); >+ result[1][0] = rcp(x[1][0]); >+ result[1][1] = rcp(x[1][1]); >+ result[2][0] = rcp(x[2][0]); >+ result[2][1] = rcp(x[2][1]); >+ result[3][0] = rcp(x[3][0]); >+ result[3][1] = rcp(x[3][1]); >+ return result; >+} >+half4x3 rcp(half4x3 x) { >+ half4x3 result; >+ result[0][0] = rcp(x[0][0]); >+ result[0][1] = rcp(x[0][1]); >+ result[0][2] = rcp(x[0][2]); >+ result[1][0] = rcp(x[1][0]); >+ result[1][1] = rcp(x[1][1]); >+ result[1][2] = rcp(x[1][2]); >+ result[2][0] = rcp(x[2][0]); >+ result[2][1] = rcp(x[2][1]); >+ result[2][2] = rcp(x[2][2]); >+ result[3][0] = rcp(x[3][0]); >+ result[3][1] = rcp(x[3][1]); >+ result[3][2] = rcp(x[3][2]); >+ return result; >+} >+half4x4 rcp(half4x4 x) { >+ half4x4 result; >+ result[0][0] = rcp(x[0][0]); >+ result[0][1] = rcp(x[0][1]); >+ result[0][2] = rcp(x[0][2]); >+ result[0][3] = rcp(x[0][3]); >+ result[1][0] = rcp(x[1][0]); >+ result[1][1] = rcp(x[1][1]); >+ result[1][2] = rcp(x[1][2]); >+ result[1][3] = rcp(x[1][3]); >+ result[2][0] = rcp(x[2][0]); >+ result[2][1] = rcp(x[2][1]); >+ result[2][2] = rcp(x[2][2]); >+ result[2][3] = rcp(x[2][3]); >+ result[3][0] = rcp(x[3][0]); >+ result[3][1] = rcp(x[3][1]); >+ result[3][2] = rcp(x[3][2]); >+ result[3][3] = rcp(x[3][3]); >+ return result; >+} >+half2 rsqrt(half2 x) { >+ half2 result; >+ result[0] = rsqrt(x[0]); >+ result[1] = rsqrt(x[1]); >+ return result; >+} >+half3 rsqrt(half3 x) { >+ half3 result; >+ result[0] = rsqrt(x[0]); >+ result[1] = rsqrt(x[1]); >+ result[2] = rsqrt(x[2]); >+ return result; >+} >+half4 rsqrt(half4 x) { >+ half4 result; >+ result[0] = rsqrt(x[0]); >+ result[1] = rsqrt(x[1]); >+ result[2] = rsqrt(x[2]); >+ result[3] = rsqrt(x[3]); >+ return result; >+} >+half2x2 rsqrt(half2x2 x) { >+ half2x2 result; >+ result[0][0] = rsqrt(x[0][0]); >+ result[0][1] = rsqrt(x[0][1]); >+ result[1][0] = rsqrt(x[1][0]); >+ result[1][1] = rsqrt(x[1][1]); >+ return result; >+} >+half2x3 rsqrt(half2x3 x) { >+ half2x3 result; >+ result[0][0] = rsqrt(x[0][0]); >+ result[0][1] = rsqrt(x[0][1]); >+ result[0][2] = rsqrt(x[0][2]); >+ result[1][0] = rsqrt(x[1][0]); >+ result[1][1] = rsqrt(x[1][1]); >+ result[1][2] = rsqrt(x[1][2]); >+ return result; >+} >+half2x4 rsqrt(half2x4 x) { >+ half2x4 result; >+ result[0][0] = rsqrt(x[0][0]); >+ result[0][1] = rsqrt(x[0][1]); >+ result[0][2] = rsqrt(x[0][2]); >+ result[0][3] = rsqrt(x[0][3]); >+ result[1][0] = rsqrt(x[1][0]); >+ result[1][1] = rsqrt(x[1][1]); >+ result[1][2] = rsqrt(x[1][2]); >+ result[1][3] = rsqrt(x[1][3]); >+ return result; >+} >+half3x2 rsqrt(half3x2 x) { >+ half3x2 result; >+ result[0][0] = rsqrt(x[0][0]); >+ result[0][1] = rsqrt(x[0][1]); >+ result[1][0] = rsqrt(x[1][0]); >+ result[1][1] = rsqrt(x[1][1]); >+ result[2][0] = rsqrt(x[2][0]); >+ result[2][1] = rsqrt(x[2][1]); >+ return result; >+} >+half3x3 rsqrt(half3x3 x) { >+ half3x3 result; >+ result[0][0] = rsqrt(x[0][0]); >+ result[0][1] = rsqrt(x[0][1]); >+ result[0][2] = rsqrt(x[0][2]); >+ result[1][0] = rsqrt(x[1][0]); >+ result[1][1] = rsqrt(x[1][1]); >+ result[1][2] = rsqrt(x[1][2]); >+ result[2][0] = rsqrt(x[2][0]); >+ result[2][1] = rsqrt(x[2][1]); >+ result[2][2] = rsqrt(x[2][2]); >+ return result; >+} >+half3x4 rsqrt(half3x4 x) { >+ half3x4 result; >+ result[0][0] = rsqrt(x[0][0]); >+ result[0][1] = rsqrt(x[0][1]); >+ result[0][2] = rsqrt(x[0][2]); >+ result[0][3] = rsqrt(x[0][3]); >+ result[1][0] = rsqrt(x[1][0]); >+ result[1][1] = rsqrt(x[1][1]); >+ result[1][2] = rsqrt(x[1][2]); >+ result[1][3] = rsqrt(x[1][3]); >+ result[2][0] = rsqrt(x[2][0]); >+ result[2][1] = rsqrt(x[2][1]); >+ result[2][2] = rsqrt(x[2][2]); >+ result[2][3] = rsqrt(x[2][3]); >+ return result; >+} >+half4x2 rsqrt(half4x2 x) { >+ half4x2 result; >+ result[0][0] = rsqrt(x[0][0]); >+ result[0][1] = rsqrt(x[0][1]); >+ result[1][0] = rsqrt(x[1][0]); >+ result[1][1] = rsqrt(x[1][1]); >+ result[2][0] = rsqrt(x[2][0]); >+ result[2][1] = rsqrt(x[2][1]); >+ result[3][0] = rsqrt(x[3][0]); >+ result[3][1] = rsqrt(x[3][1]); >+ return result; >+} >+half4x3 rsqrt(half4x3 x) { >+ half4x3 result; >+ result[0][0] = rsqrt(x[0][0]); >+ result[0][1] = rsqrt(x[0][1]); >+ result[0][2] = rsqrt(x[0][2]); >+ result[1][0] = rsqrt(x[1][0]); >+ result[1][1] = rsqrt(x[1][1]); >+ result[1][2] = rsqrt(x[1][2]); >+ result[2][0] = rsqrt(x[2][0]); >+ result[2][1] = rsqrt(x[2][1]); >+ result[2][2] = rsqrt(x[2][2]); >+ result[3][0] = rsqrt(x[3][0]); >+ result[3][1] = rsqrt(x[3][1]); >+ result[3][2] = rsqrt(x[3][2]); >+ return result; >+} >+half4x4 rsqrt(half4x4 x) { >+ half4x4 result; >+ result[0][0] = rsqrt(x[0][0]); >+ result[0][1] = rsqrt(x[0][1]); >+ result[0][2] = rsqrt(x[0][2]); >+ result[0][3] = rsqrt(x[0][3]); >+ result[1][0] = rsqrt(x[1][0]); >+ result[1][1] = rsqrt(x[1][1]); >+ result[1][2] = rsqrt(x[1][2]); >+ result[1][3] = rsqrt(x[1][3]); >+ result[2][0] = rsqrt(x[2][0]); >+ result[2][1] = rsqrt(x[2][1]); >+ result[2][2] = rsqrt(x[2][2]); >+ result[2][3] = rsqrt(x[2][3]); >+ result[3][0] = rsqrt(x[3][0]); >+ result[3][1] = rsqrt(x[3][1]); >+ result[3][2] = rsqrt(x[3][2]); >+ result[3][3] = rsqrt(x[3][3]); >+ return result; >+} >+half2 saturate(half2 x) { >+ half2 result; >+ result[0] = saturate(x[0]); >+ result[1] = saturate(x[1]); >+ return result; >+} >+half3 saturate(half3 x) { >+ half3 result; >+ result[0] = saturate(x[0]); >+ result[1] = saturate(x[1]); >+ result[2] = saturate(x[2]); >+ return result; >+} >+half4 saturate(half4 x) { >+ half4 result; >+ result[0] = saturate(x[0]); >+ result[1] = saturate(x[1]); >+ result[2] = saturate(x[2]); >+ result[3] = saturate(x[3]); >+ return result; >+} >+half2x2 saturate(half2x2 x) { >+ half2x2 result; >+ result[0][0] = saturate(x[0][0]); >+ result[0][1] = saturate(x[0][1]); >+ result[1][0] = saturate(x[1][0]); >+ result[1][1] = saturate(x[1][1]); >+ return result; >+} >+half2x3 saturate(half2x3 x) { >+ half2x3 result; >+ result[0][0] = saturate(x[0][0]); >+ result[0][1] = saturate(x[0][1]); >+ result[0][2] = saturate(x[0][2]); >+ result[1][0] = saturate(x[1][0]); >+ result[1][1] = saturate(x[1][1]); >+ result[1][2] = saturate(x[1][2]); >+ return result; >+} >+half2x4 saturate(half2x4 x) { >+ half2x4 result; >+ result[0][0] = saturate(x[0][0]); >+ result[0][1] = saturate(x[0][1]); >+ result[0][2] = saturate(x[0][2]); >+ result[0][3] = saturate(x[0][3]); >+ result[1][0] = saturate(x[1][0]); >+ result[1][1] = saturate(x[1][1]); >+ result[1][2] = saturate(x[1][2]); >+ result[1][3] = saturate(x[1][3]); >+ return result; >+} >+half3x2 saturate(half3x2 x) { >+ half3x2 result; >+ result[0][0] = saturate(x[0][0]); >+ result[0][1] = saturate(x[0][1]); >+ result[1][0] = saturate(x[1][0]); >+ result[1][1] = saturate(x[1][1]); >+ result[2][0] = saturate(x[2][0]); >+ result[2][1] = saturate(x[2][1]); >+ return result; >+} >+half3x3 saturate(half3x3 x) { >+ half3x3 result; >+ result[0][0] = saturate(x[0][0]); >+ result[0][1] = saturate(x[0][1]); >+ result[0][2] = saturate(x[0][2]); >+ result[1][0] = saturate(x[1][0]); >+ result[1][1] = saturate(x[1][1]); >+ result[1][2] = saturate(x[1][2]); >+ result[2][0] = saturate(x[2][0]); >+ result[2][1] = saturate(x[2][1]); >+ result[2][2] = saturate(x[2][2]); >+ return result; >+} >+half3x4 saturate(half3x4 x) { >+ half3x4 result; >+ result[0][0] = saturate(x[0][0]); >+ result[0][1] = saturate(x[0][1]); >+ result[0][2] = saturate(x[0][2]); >+ result[0][3] = saturate(x[0][3]); >+ result[1][0] = saturate(x[1][0]); >+ result[1][1] = saturate(x[1][1]); >+ result[1][2] = saturate(x[1][2]); >+ result[1][3] = saturate(x[1][3]); >+ result[2][0] = saturate(x[2][0]); >+ result[2][1] = saturate(x[2][1]); >+ result[2][2] = saturate(x[2][2]); >+ result[2][3] = saturate(x[2][3]); >+ return result; >+} >+half4x2 saturate(half4x2 x) { >+ half4x2 result; >+ result[0][0] = saturate(x[0][0]); >+ result[0][1] = saturate(x[0][1]); >+ result[1][0] = saturate(x[1][0]); >+ result[1][1] = saturate(x[1][1]); >+ result[2][0] = saturate(x[2][0]); >+ result[2][1] = saturate(x[2][1]); >+ result[3][0] = saturate(x[3][0]); >+ result[3][1] = saturate(x[3][1]); >+ return result; >+} >+half4x3 saturate(half4x3 x) { >+ half4x3 result; >+ result[0][0] = saturate(x[0][0]); >+ result[0][1] = saturate(x[0][1]); >+ result[0][2] = saturate(x[0][2]); >+ result[1][0] = saturate(x[1][0]); >+ result[1][1] = saturate(x[1][1]); >+ result[1][2] = saturate(x[1][2]); >+ result[2][0] = saturate(x[2][0]); >+ result[2][1] = saturate(x[2][1]); >+ result[2][2] = saturate(x[2][2]); >+ result[3][0] = saturate(x[3][0]); >+ result[3][1] = saturate(x[3][1]); >+ result[3][2] = saturate(x[3][2]); >+ return result; >+} >+half4x4 saturate(half4x4 x) { >+ half4x4 result; >+ result[0][0] = saturate(x[0][0]); >+ result[0][1] = saturate(x[0][1]); >+ result[0][2] = saturate(x[0][2]); >+ result[0][3] = saturate(x[0][3]); >+ result[1][0] = saturate(x[1][0]); >+ result[1][1] = saturate(x[1][1]); >+ result[1][2] = saturate(x[1][2]); >+ result[1][3] = saturate(x[1][3]); >+ result[2][0] = saturate(x[2][0]); >+ result[2][1] = saturate(x[2][1]); >+ result[2][2] = saturate(x[2][2]); >+ result[2][3] = saturate(x[2][3]); >+ result[3][0] = saturate(x[3][0]); >+ result[3][1] = saturate(x[3][1]); >+ result[3][2] = saturate(x[3][2]); >+ result[3][3] = saturate(x[3][3]); >+ return result; >+} >+half2 ddx_coarse(half2 x) { >+ half2 result; >+ result[0] = ddx_coarse(x[0]); >+ result[1] = ddx_coarse(x[1]); >+ return result; >+} >+half3 ddx_coarse(half3 x) { >+ half3 result; >+ result[0] = ddx_coarse(x[0]); >+ result[1] = ddx_coarse(x[1]); >+ result[2] = ddx_coarse(x[2]); >+ return result; >+} >+half4 ddx_coarse(half4 x) { >+ half4 result; >+ result[0] = ddx_coarse(x[0]); >+ result[1] = ddx_coarse(x[1]); >+ result[2] = ddx_coarse(x[2]); >+ result[3] = ddx_coarse(x[3]); >+ return result; >+} >+half2x2 ddx_coarse(half2x2 x) { >+ half2x2 result; >+ result[0][0] = ddx_coarse(x[0][0]); >+ result[0][1] = ddx_coarse(x[0][1]); >+ result[1][0] = ddx_coarse(x[1][0]); >+ result[1][1] = ddx_coarse(x[1][1]); >+ return result; >+} >+half2x3 ddx_coarse(half2x3 x) { >+ half2x3 result; >+ result[0][0] = ddx_coarse(x[0][0]); >+ result[0][1] = ddx_coarse(x[0][1]); >+ result[0][2] = ddx_coarse(x[0][2]); >+ result[1][0] = ddx_coarse(x[1][0]); >+ result[1][1] = ddx_coarse(x[1][1]); >+ result[1][2] = ddx_coarse(x[1][2]); >+ return result; >+} >+half2x4 ddx_coarse(half2x4 x) { >+ half2x4 result; >+ result[0][0] = ddx_coarse(x[0][0]); >+ result[0][1] = ddx_coarse(x[0][1]); >+ result[0][2] = ddx_coarse(x[0][2]); >+ result[0][3] = ddx_coarse(x[0][3]); >+ result[1][0] = ddx_coarse(x[1][0]); >+ result[1][1] = ddx_coarse(x[1][1]); >+ result[1][2] = ddx_coarse(x[1][2]); >+ result[1][3] = ddx_coarse(x[1][3]); >+ return result; >+} >+half3x2 ddx_coarse(half3x2 x) { >+ half3x2 result; >+ result[0][0] = ddx_coarse(x[0][0]); >+ result[0][1] = ddx_coarse(x[0][1]); >+ result[1][0] = ddx_coarse(x[1][0]); >+ result[1][1] = ddx_coarse(x[1][1]); >+ result[2][0] = ddx_coarse(x[2][0]); >+ result[2][1] = ddx_coarse(x[2][1]); >+ return result; >+} >+half3x3 ddx_coarse(half3x3 x) { >+ half3x3 result; >+ result[0][0] = ddx_coarse(x[0][0]); >+ result[0][1] = ddx_coarse(x[0][1]); >+ result[0][2] = ddx_coarse(x[0][2]); >+ result[1][0] = ddx_coarse(x[1][0]); >+ result[1][1] = ddx_coarse(x[1][1]); >+ result[1][2] = ddx_coarse(x[1][2]); >+ result[2][0] = ddx_coarse(x[2][0]); >+ result[2][1] = ddx_coarse(x[2][1]); >+ result[2][2] = ddx_coarse(x[2][2]); >+ return result; >+} >+half3x4 ddx_coarse(half3x4 x) { >+ half3x4 result; >+ result[0][0] = ddx_coarse(x[0][0]); >+ result[0][1] = ddx_coarse(x[0][1]); >+ result[0][2] = ddx_coarse(x[0][2]); >+ result[0][3] = ddx_coarse(x[0][3]); >+ result[1][0] = ddx_coarse(x[1][0]); >+ result[1][1] = ddx_coarse(x[1][1]); >+ result[1][2] = ddx_coarse(x[1][2]); >+ result[1][3] = ddx_coarse(x[1][3]); >+ result[2][0] = ddx_coarse(x[2][0]); >+ result[2][1] = ddx_coarse(x[2][1]); >+ result[2][2] = ddx_coarse(x[2][2]); >+ result[2][3] = ddx_coarse(x[2][3]); >+ return result; >+} >+half4x2 ddx_coarse(half4x2 x) { >+ half4x2 result; >+ result[0][0] = ddx_coarse(x[0][0]); >+ result[0][1] = ddx_coarse(x[0][1]); >+ result[1][0] = ddx_coarse(x[1][0]); >+ result[1][1] = ddx_coarse(x[1][1]); >+ result[2][0] = ddx_coarse(x[2][0]); >+ result[2][1] = ddx_coarse(x[2][1]); >+ result[3][0] = ddx_coarse(x[3][0]); >+ result[3][1] = ddx_coarse(x[3][1]); >+ return result; >+} >+half4x3 ddx_coarse(half4x3 x) { >+ half4x3 result; >+ result[0][0] = ddx_coarse(x[0][0]); >+ result[0][1] = ddx_coarse(x[0][1]); >+ result[0][2] = ddx_coarse(x[0][2]); >+ result[1][0] = ddx_coarse(x[1][0]); >+ result[1][1] = ddx_coarse(x[1][1]); >+ result[1][2] = ddx_coarse(x[1][2]); >+ result[2][0] = ddx_coarse(x[2][0]); >+ result[2][1] = ddx_coarse(x[2][1]); >+ result[2][2] = ddx_coarse(x[2][2]); >+ result[3][0] = ddx_coarse(x[3][0]); >+ result[3][1] = ddx_coarse(x[3][1]); >+ result[3][2] = ddx_coarse(x[3][2]); >+ return result; >+} >+half4x4 ddx_coarse(half4x4 x) { >+ half4x4 result; >+ result[0][0] = ddx_coarse(x[0][0]); >+ result[0][1] = ddx_coarse(x[0][1]); >+ result[0][2] = ddx_coarse(x[0][2]); >+ result[0][3] = ddx_coarse(x[0][3]); >+ result[1][0] = ddx_coarse(x[1][0]); >+ result[1][1] = ddx_coarse(x[1][1]); >+ result[1][2] = ddx_coarse(x[1][2]); >+ result[1][3] = ddx_coarse(x[1][3]); >+ result[2][0] = ddx_coarse(x[2][0]); >+ result[2][1] = ddx_coarse(x[2][1]); >+ result[2][2] = ddx_coarse(x[2][2]); >+ result[2][3] = ddx_coarse(x[2][3]); >+ result[3][0] = ddx_coarse(x[3][0]); >+ result[3][1] = ddx_coarse(x[3][1]); >+ result[3][2] = ddx_coarse(x[3][2]); >+ result[3][3] = ddx_coarse(x[3][3]); >+ return result; >+} >+half2 ddx_fine(half2 x) { >+ half2 result; >+ result[0] = ddx_fine(x[0]); >+ result[1] = ddx_fine(x[1]); >+ return result; >+} >+half3 ddx_fine(half3 x) { >+ half3 result; >+ result[0] = ddx_fine(x[0]); >+ result[1] = ddx_fine(x[1]); >+ result[2] = ddx_fine(x[2]); >+ return result; >+} >+half4 ddx_fine(half4 x) { >+ half4 result; >+ result[0] = ddx_fine(x[0]); >+ result[1] = ddx_fine(x[1]); >+ result[2] = ddx_fine(x[2]); >+ result[3] = ddx_fine(x[3]); >+ return result; >+} >+half2x2 ddx_fine(half2x2 x) { >+ half2x2 result; >+ result[0][0] = ddx_fine(x[0][0]); >+ result[0][1] = ddx_fine(x[0][1]); >+ result[1][0] = ddx_fine(x[1][0]); >+ result[1][1] = ddx_fine(x[1][1]); >+ return result; >+} >+half2x3 ddx_fine(half2x3 x) { >+ half2x3 result; >+ result[0][0] = ddx_fine(x[0][0]); >+ result[0][1] = ddx_fine(x[0][1]); >+ result[0][2] = ddx_fine(x[0][2]); >+ result[1][0] = ddx_fine(x[1][0]); >+ result[1][1] = ddx_fine(x[1][1]); >+ result[1][2] = ddx_fine(x[1][2]); >+ return result; >+} >+half2x4 ddx_fine(half2x4 x) { >+ half2x4 result; >+ result[0][0] = ddx_fine(x[0][0]); >+ result[0][1] = ddx_fine(x[0][1]); >+ result[0][2] = ddx_fine(x[0][2]); >+ result[0][3] = ddx_fine(x[0][3]); >+ result[1][0] = ddx_fine(x[1][0]); >+ result[1][1] = ddx_fine(x[1][1]); >+ result[1][2] = ddx_fine(x[1][2]); >+ result[1][3] = ddx_fine(x[1][3]); >+ return result; >+} >+half3x2 ddx_fine(half3x2 x) { >+ half3x2 result; >+ result[0][0] = ddx_fine(x[0][0]); >+ result[0][1] = ddx_fine(x[0][1]); >+ result[1][0] = ddx_fine(x[1][0]); >+ result[1][1] = ddx_fine(x[1][1]); >+ result[2][0] = ddx_fine(x[2][0]); >+ result[2][1] = ddx_fine(x[2][1]); >+ return result; >+} >+half3x3 ddx_fine(half3x3 x) { >+ half3x3 result; >+ result[0][0] = ddx_fine(x[0][0]); >+ result[0][1] = ddx_fine(x[0][1]); >+ result[0][2] = ddx_fine(x[0][2]); >+ result[1][0] = ddx_fine(x[1][0]); >+ result[1][1] = ddx_fine(x[1][1]); >+ result[1][2] = ddx_fine(x[1][2]); >+ result[2][0] = ddx_fine(x[2][0]); >+ result[2][1] = ddx_fine(x[2][1]); >+ result[2][2] = ddx_fine(x[2][2]); >+ return result; >+} >+half3x4 ddx_fine(half3x4 x) { >+ half3x4 result; >+ result[0][0] = ddx_fine(x[0][0]); >+ result[0][1] = ddx_fine(x[0][1]); >+ result[0][2] = ddx_fine(x[0][2]); >+ result[0][3] = ddx_fine(x[0][3]); >+ result[1][0] = ddx_fine(x[1][0]); >+ result[1][1] = ddx_fine(x[1][1]); >+ result[1][2] = ddx_fine(x[1][2]); >+ result[1][3] = ddx_fine(x[1][3]); >+ result[2][0] = ddx_fine(x[2][0]); >+ result[2][1] = ddx_fine(x[2][1]); >+ result[2][2] = ddx_fine(x[2][2]); >+ result[2][3] = ddx_fine(x[2][3]); >+ return result; >+} >+half4x2 ddx_fine(half4x2 x) { >+ half4x2 result; >+ result[0][0] = ddx_fine(x[0][0]); >+ result[0][1] = ddx_fine(x[0][1]); >+ result[1][0] = ddx_fine(x[1][0]); >+ result[1][1] = ddx_fine(x[1][1]); >+ result[2][0] = ddx_fine(x[2][0]); >+ result[2][1] = ddx_fine(x[2][1]); >+ result[3][0] = ddx_fine(x[3][0]); >+ result[3][1] = ddx_fine(x[3][1]); >+ return result; >+} >+half4x3 ddx_fine(half4x3 x) { >+ half4x3 result; >+ result[0][0] = ddx_fine(x[0][0]); >+ result[0][1] = ddx_fine(x[0][1]); >+ result[0][2] = ddx_fine(x[0][2]); >+ result[1][0] = ddx_fine(x[1][0]); >+ result[1][1] = ddx_fine(x[1][1]); >+ result[1][2] = ddx_fine(x[1][2]); >+ result[2][0] = ddx_fine(x[2][0]); >+ result[2][1] = ddx_fine(x[2][1]); >+ result[2][2] = ddx_fine(x[2][2]); >+ result[3][0] = ddx_fine(x[3][0]); >+ result[3][1] = ddx_fine(x[3][1]); >+ result[3][2] = ddx_fine(x[3][2]); >+ return result; >+} >+half4x4 ddx_fine(half4x4 x) { >+ half4x4 result; >+ result[0][0] = ddx_fine(x[0][0]); >+ result[0][1] = ddx_fine(x[0][1]); >+ result[0][2] = ddx_fine(x[0][2]); >+ result[0][3] = ddx_fine(x[0][3]); >+ result[1][0] = ddx_fine(x[1][0]); >+ result[1][1] = ddx_fine(x[1][1]); >+ result[1][2] = ddx_fine(x[1][2]); >+ result[1][3] = ddx_fine(x[1][3]); >+ result[2][0] = ddx_fine(x[2][0]); >+ result[2][1] = ddx_fine(x[2][1]); >+ result[2][2] = ddx_fine(x[2][2]); >+ result[2][3] = ddx_fine(x[2][3]); >+ result[3][0] = ddx_fine(x[3][0]); >+ result[3][1] = ddx_fine(x[3][1]); >+ result[3][2] = ddx_fine(x[3][2]); >+ result[3][3] = ddx_fine(x[3][3]); >+ return result; >+} >+half2 ddy_coarse(half2 x) { >+ half2 result; >+ result[0] = ddy_coarse(x[0]); >+ result[1] = ddy_coarse(x[1]); >+ return result; >+} >+half3 ddy_coarse(half3 x) { >+ half3 result; >+ result[0] = ddy_coarse(x[0]); >+ result[1] = ddy_coarse(x[1]); >+ result[2] = ddy_coarse(x[2]); >+ return result; >+} >+half4 ddy_coarse(half4 x) { >+ half4 result; >+ result[0] = ddy_coarse(x[0]); >+ result[1] = ddy_coarse(x[1]); >+ result[2] = ddy_coarse(x[2]); >+ result[3] = ddy_coarse(x[3]); >+ return result; >+} >+half2x2 ddy_coarse(half2x2 x) { >+ half2x2 result; >+ result[0][0] = ddy_coarse(x[0][0]); >+ result[0][1] = ddy_coarse(x[0][1]); >+ result[1][0] = ddy_coarse(x[1][0]); >+ result[1][1] = ddy_coarse(x[1][1]); >+ return result; >+} >+half2x3 ddy_coarse(half2x3 x) { >+ half2x3 result; >+ result[0][0] = ddy_coarse(x[0][0]); >+ result[0][1] = ddy_coarse(x[0][1]); >+ result[0][2] = ddy_coarse(x[0][2]); >+ result[1][0] = ddy_coarse(x[1][0]); >+ result[1][1] = ddy_coarse(x[1][1]); >+ result[1][2] = ddy_coarse(x[1][2]); >+ return result; >+} >+half2x4 ddy_coarse(half2x4 x) { >+ half2x4 result; >+ result[0][0] = ddy_coarse(x[0][0]); >+ result[0][1] = ddy_coarse(x[0][1]); >+ result[0][2] = ddy_coarse(x[0][2]); >+ result[0][3] = ddy_coarse(x[0][3]); >+ result[1][0] = ddy_coarse(x[1][0]); >+ result[1][1] = ddy_coarse(x[1][1]); >+ result[1][2] = ddy_coarse(x[1][2]); >+ result[1][3] = ddy_coarse(x[1][3]); >+ return result; >+} >+half3x2 ddy_coarse(half3x2 x) { >+ half3x2 result; >+ result[0][0] = ddy_coarse(x[0][0]); >+ result[0][1] = ddy_coarse(x[0][1]); >+ result[1][0] = ddy_coarse(x[1][0]); >+ result[1][1] = ddy_coarse(x[1][1]); >+ result[2][0] = ddy_coarse(x[2][0]); >+ result[2][1] = ddy_coarse(x[2][1]); >+ return result; >+} >+half3x3 ddy_coarse(half3x3 x) { >+ half3x3 result; >+ result[0][0] = ddy_coarse(x[0][0]); >+ result[0][1] = ddy_coarse(x[0][1]); >+ result[0][2] = ddy_coarse(x[0][2]); >+ result[1][0] = ddy_coarse(x[1][0]); >+ result[1][1] = ddy_coarse(x[1][1]); >+ result[1][2] = ddy_coarse(x[1][2]); >+ result[2][0] = ddy_coarse(x[2][0]); >+ result[2][1] = ddy_coarse(x[2][1]); >+ result[2][2] = ddy_coarse(x[2][2]); >+ return result; >+} >+half3x4 ddy_coarse(half3x4 x) { >+ half3x4 result; >+ result[0][0] = ddy_coarse(x[0][0]); >+ result[0][1] = ddy_coarse(x[0][1]); >+ result[0][2] = ddy_coarse(x[0][2]); >+ result[0][3] = ddy_coarse(x[0][3]); >+ result[1][0] = ddy_coarse(x[1][0]); >+ result[1][1] = ddy_coarse(x[1][1]); >+ result[1][2] = ddy_coarse(x[1][2]); >+ result[1][3] = ddy_coarse(x[1][3]); >+ result[2][0] = ddy_coarse(x[2][0]); >+ result[2][1] = ddy_coarse(x[2][1]); >+ result[2][2] = ddy_coarse(x[2][2]); >+ result[2][3] = ddy_coarse(x[2][3]); >+ return result; >+} >+half4x2 ddy_coarse(half4x2 x) { >+ half4x2 result; >+ result[0][0] = ddy_coarse(x[0][0]); >+ result[0][1] = ddy_coarse(x[0][1]); >+ result[1][0] = ddy_coarse(x[1][0]); >+ result[1][1] = ddy_coarse(x[1][1]); >+ result[2][0] = ddy_coarse(x[2][0]); >+ result[2][1] = ddy_coarse(x[2][1]); >+ result[3][0] = ddy_coarse(x[3][0]); >+ result[3][1] = ddy_coarse(x[3][1]); >+ return result; >+} >+half4x3 ddy_coarse(half4x3 x) { >+ half4x3 result; >+ result[0][0] = ddy_coarse(x[0][0]); >+ result[0][1] = ddy_coarse(x[0][1]); >+ result[0][2] = ddy_coarse(x[0][2]); >+ result[1][0] = ddy_coarse(x[1][0]); >+ result[1][1] = ddy_coarse(x[1][1]); >+ result[1][2] = ddy_coarse(x[1][2]); >+ result[2][0] = ddy_coarse(x[2][0]); >+ result[2][1] = ddy_coarse(x[2][1]); >+ result[2][2] = ddy_coarse(x[2][2]); >+ result[3][0] = ddy_coarse(x[3][0]); >+ result[3][1] = ddy_coarse(x[3][1]); >+ result[3][2] = ddy_coarse(x[3][2]); >+ return result; >+} >+half4x4 ddy_coarse(half4x4 x) { >+ half4x4 result; >+ result[0][0] = ddy_coarse(x[0][0]); >+ result[0][1] = ddy_coarse(x[0][1]); >+ result[0][2] = ddy_coarse(x[0][2]); >+ result[0][3] = ddy_coarse(x[0][3]); >+ result[1][0] = ddy_coarse(x[1][0]); >+ result[1][1] = ddy_coarse(x[1][1]); >+ result[1][2] = ddy_coarse(x[1][2]); >+ result[1][3] = ddy_coarse(x[1][3]); >+ result[2][0] = ddy_coarse(x[2][0]); >+ result[2][1] = ddy_coarse(x[2][1]); >+ result[2][2] = ddy_coarse(x[2][2]); >+ result[2][3] = ddy_coarse(x[2][3]); >+ result[3][0] = ddy_coarse(x[3][0]); >+ result[3][1] = ddy_coarse(x[3][1]); >+ result[3][2] = ddy_coarse(x[3][2]); >+ result[3][3] = ddy_coarse(x[3][3]); >+ return result; >+} >+half2 ddy_fine(half2 x) { >+ half2 result; >+ result[0] = ddy_fine(x[0]); >+ result[1] = ddy_fine(x[1]); >+ return result; >+} >+half3 ddy_fine(half3 x) { >+ half3 result; >+ result[0] = ddy_fine(x[0]); >+ result[1] = ddy_fine(x[1]); >+ result[2] = ddy_fine(x[2]); >+ return result; >+} >+half4 ddy_fine(half4 x) { >+ half4 result; >+ result[0] = ddy_fine(x[0]); >+ result[1] = ddy_fine(x[1]); >+ result[2] = ddy_fine(x[2]); >+ result[3] = ddy_fine(x[3]); >+ return result; >+} >+half2x2 ddy_fine(half2x2 x) { >+ half2x2 result; >+ result[0][0] = ddy_fine(x[0][0]); >+ result[0][1] = ddy_fine(x[0][1]); >+ result[1][0] = ddy_fine(x[1][0]); >+ result[1][1] = ddy_fine(x[1][1]); >+ return result; >+} >+half2x3 ddy_fine(half2x3 x) { >+ half2x3 result; >+ result[0][0] = ddy_fine(x[0][0]); >+ result[0][1] = ddy_fine(x[0][1]); >+ result[0][2] = ddy_fine(x[0][2]); >+ result[1][0] = ddy_fine(x[1][0]); >+ result[1][1] = ddy_fine(x[1][1]); >+ result[1][2] = ddy_fine(x[1][2]); >+ return result; >+} >+half2x4 ddy_fine(half2x4 x) { >+ half2x4 result; >+ result[0][0] = ddy_fine(x[0][0]); >+ result[0][1] = ddy_fine(x[0][1]); >+ result[0][2] = ddy_fine(x[0][2]); >+ result[0][3] = ddy_fine(x[0][3]); >+ result[1][0] = ddy_fine(x[1][0]); >+ result[1][1] = ddy_fine(x[1][1]); >+ result[1][2] = ddy_fine(x[1][2]); >+ result[1][3] = ddy_fine(x[1][3]); >+ return result; >+} >+half3x2 ddy_fine(half3x2 x) { >+ half3x2 result; >+ result[0][0] = ddy_fine(x[0][0]); >+ result[0][1] = ddy_fine(x[0][1]); >+ result[1][0] = ddy_fine(x[1][0]); >+ result[1][1] = ddy_fine(x[1][1]); >+ result[2][0] = ddy_fine(x[2][0]); >+ result[2][1] = ddy_fine(x[2][1]); >+ return result; >+} >+half3x3 ddy_fine(half3x3 x) { >+ half3x3 result; >+ result[0][0] = ddy_fine(x[0][0]); >+ result[0][1] = ddy_fine(x[0][1]); >+ result[0][2] = ddy_fine(x[0][2]); >+ result[1][0] = ddy_fine(x[1][0]); >+ result[1][1] = ddy_fine(x[1][1]); >+ result[1][2] = ddy_fine(x[1][2]); >+ result[2][0] = ddy_fine(x[2][0]); >+ result[2][1] = ddy_fine(x[2][1]); >+ result[2][2] = ddy_fine(x[2][2]); >+ return result; >+} >+half3x4 ddy_fine(half3x4 x) { >+ half3x4 result; >+ result[0][0] = ddy_fine(x[0][0]); >+ result[0][1] = ddy_fine(x[0][1]); >+ result[0][2] = ddy_fine(x[0][2]); >+ result[0][3] = ddy_fine(x[0][3]); >+ result[1][0] = ddy_fine(x[1][0]); >+ result[1][1] = ddy_fine(x[1][1]); >+ result[1][2] = ddy_fine(x[1][2]); >+ result[1][3] = ddy_fine(x[1][3]); >+ result[2][0] = ddy_fine(x[2][0]); >+ result[2][1] = ddy_fine(x[2][1]); >+ result[2][2] = ddy_fine(x[2][2]); >+ result[2][3] = ddy_fine(x[2][3]); >+ return result; >+} >+half4x2 ddy_fine(half4x2 x) { >+ half4x2 result; >+ result[0][0] = ddy_fine(x[0][0]); >+ result[0][1] = ddy_fine(x[0][1]); >+ result[1][0] = ddy_fine(x[1][0]); >+ result[1][1] = ddy_fine(x[1][1]); >+ result[2][0] = ddy_fine(x[2][0]); >+ result[2][1] = ddy_fine(x[2][1]); >+ result[3][0] = ddy_fine(x[3][0]); >+ result[3][1] = ddy_fine(x[3][1]); >+ return result; >+} >+half4x3 ddy_fine(half4x3 x) { >+ half4x3 result; >+ result[0][0] = ddy_fine(x[0][0]); >+ result[0][1] = ddy_fine(x[0][1]); >+ result[0][2] = ddy_fine(x[0][2]); >+ result[1][0] = ddy_fine(x[1][0]); >+ result[1][1] = ddy_fine(x[1][1]); >+ result[1][2] = ddy_fine(x[1][2]); >+ result[2][0] = ddy_fine(x[2][0]); >+ result[2][1] = ddy_fine(x[2][1]); >+ result[2][2] = ddy_fine(x[2][2]); >+ result[3][0] = ddy_fine(x[3][0]); >+ result[3][1] = ddy_fine(x[3][1]); >+ result[3][2] = ddy_fine(x[3][2]); >+ return result; >+} >+half4x4 ddy_fine(half4x4 x) { >+ half4x4 result; >+ result[0][0] = ddy_fine(x[0][0]); >+ result[0][1] = ddy_fine(x[0][1]); >+ result[0][2] = ddy_fine(x[0][2]); >+ result[0][3] = ddy_fine(x[0][3]); >+ result[1][0] = ddy_fine(x[1][0]); >+ result[1][1] = ddy_fine(x[1][1]); >+ result[1][2] = ddy_fine(x[1][2]); >+ result[1][3] = ddy_fine(x[1][3]); >+ result[2][0] = ddy_fine(x[2][0]); >+ result[2][1] = ddy_fine(x[2][1]); >+ result[2][2] = ddy_fine(x[2][2]); >+ result[2][3] = ddy_fine(x[2][3]); >+ result[3][0] = ddy_fine(x[3][0]); >+ result[3][1] = ddy_fine(x[3][1]); >+ result[3][2] = ddy_fine(x[3][2]); >+ result[3][3] = ddy_fine(x[3][3]); >+ return result; >+} >+half2 fwidth(half2 x) { >+ half2 result; >+ result[0] = fwidth(x[0]); >+ result[1] = fwidth(x[1]); >+ return result; >+} >+half3 fwidth(half3 x) { >+ half3 result; >+ result[0] = fwidth(x[0]); >+ result[1] = fwidth(x[1]); >+ result[2] = fwidth(x[2]); >+ return result; >+} >+half4 fwidth(half4 x) { >+ half4 result; >+ result[0] = fwidth(x[0]); >+ result[1] = fwidth(x[1]); >+ result[2] = fwidth(x[2]); >+ result[3] = fwidth(x[3]); >+ return result; >+} >+half2x2 fwidth(half2x2 x) { >+ half2x2 result; >+ result[0][0] = fwidth(x[0][0]); >+ result[0][1] = fwidth(x[0][1]); >+ result[1][0] = fwidth(x[1][0]); >+ result[1][1] = fwidth(x[1][1]); >+ return result; >+} >+half2x3 fwidth(half2x3 x) { >+ half2x3 result; >+ result[0][0] = fwidth(x[0][0]); >+ result[0][1] = fwidth(x[0][1]); >+ result[0][2] = fwidth(x[0][2]); >+ result[1][0] = fwidth(x[1][0]); >+ result[1][1] = fwidth(x[1][1]); >+ result[1][2] = fwidth(x[1][2]); >+ return result; >+} >+half2x4 fwidth(half2x4 x) { >+ half2x4 result; >+ result[0][0] = fwidth(x[0][0]); >+ result[0][1] = fwidth(x[0][1]); >+ result[0][2] = fwidth(x[0][2]); >+ result[0][3] = fwidth(x[0][3]); >+ result[1][0] = fwidth(x[1][0]); >+ result[1][1] = fwidth(x[1][1]); >+ result[1][2] = fwidth(x[1][2]); >+ result[1][3] = fwidth(x[1][3]); >+ return result; >+} >+half3x2 fwidth(half3x2 x) { >+ half3x2 result; >+ result[0][0] = fwidth(x[0][0]); >+ result[0][1] = fwidth(x[0][1]); >+ result[1][0] = fwidth(x[1][0]); >+ result[1][1] = fwidth(x[1][1]); >+ result[2][0] = fwidth(x[2][0]); >+ result[2][1] = fwidth(x[2][1]); >+ return result; >+} >+half3x3 fwidth(half3x3 x) { >+ half3x3 result; >+ result[0][0] = fwidth(x[0][0]); >+ result[0][1] = fwidth(x[0][1]); >+ result[0][2] = fwidth(x[0][2]); >+ result[1][0] = fwidth(x[1][0]); >+ result[1][1] = fwidth(x[1][1]); >+ result[1][2] = fwidth(x[1][2]); >+ result[2][0] = fwidth(x[2][0]); >+ result[2][1] = fwidth(x[2][1]); >+ result[2][2] = fwidth(x[2][2]); >+ return result; >+} >+half3x4 fwidth(half3x4 x) { >+ half3x4 result; >+ result[0][0] = fwidth(x[0][0]); >+ result[0][1] = fwidth(x[0][1]); >+ result[0][2] = fwidth(x[0][2]); >+ result[0][3] = fwidth(x[0][3]); >+ result[1][0] = fwidth(x[1][0]); >+ result[1][1] = fwidth(x[1][1]); >+ result[1][2] = fwidth(x[1][2]); >+ result[1][3] = fwidth(x[1][3]); >+ result[2][0] = fwidth(x[2][0]); >+ result[2][1] = fwidth(x[2][1]); >+ result[2][2] = fwidth(x[2][2]); >+ result[2][3] = fwidth(x[2][3]); >+ return result; >+} >+half4x2 fwidth(half4x2 x) { >+ half4x2 result; >+ result[0][0] = fwidth(x[0][0]); >+ result[0][1] = fwidth(x[0][1]); >+ result[1][0] = fwidth(x[1][0]); >+ result[1][1] = fwidth(x[1][1]); >+ result[2][0] = fwidth(x[2][0]); >+ result[2][1] = fwidth(x[2][1]); >+ result[3][0] = fwidth(x[3][0]); >+ result[3][1] = fwidth(x[3][1]); >+ return result; >+} >+half4x3 fwidth(half4x3 x) { >+ half4x3 result; >+ result[0][0] = fwidth(x[0][0]); >+ result[0][1] = fwidth(x[0][1]); >+ result[0][2] = fwidth(x[0][2]); >+ result[1][0] = fwidth(x[1][0]); >+ result[1][1] = fwidth(x[1][1]); >+ result[1][2] = fwidth(x[1][2]); >+ result[2][0] = fwidth(x[2][0]); >+ result[2][1] = fwidth(x[2][1]); >+ result[2][2] = fwidth(x[2][2]); >+ result[3][0] = fwidth(x[3][0]); >+ result[3][1] = fwidth(x[3][1]); >+ result[3][2] = fwidth(x[3][2]); >+ return result; >+} >+half4x4 fwidth(half4x4 x) { >+ half4x4 result; >+ result[0][0] = fwidth(x[0][0]); >+ result[0][1] = fwidth(x[0][1]); >+ result[0][2] = fwidth(x[0][2]); >+ result[0][3] = fwidth(x[0][3]); >+ result[1][0] = fwidth(x[1][0]); >+ result[1][1] = fwidth(x[1][1]); >+ result[1][2] = fwidth(x[1][2]); >+ result[1][3] = fwidth(x[1][3]); >+ result[2][0] = fwidth(x[2][0]); >+ result[2][1] = fwidth(x[2][1]); >+ result[2][2] = fwidth(x[2][2]); >+ result[2][3] = fwidth(x[2][3]); >+ result[3][0] = fwidth(x[3][0]); >+ result[3][1] = fwidth(x[3][1]); >+ result[3][2] = fwidth(x[3][2]); >+ result[3][3] = fwidth(x[3][3]); >+ return result; >+} >+ >+float sqrt(float x) { >+ return pow(x, 0.5); >+} >+float log2(float x) { >+ return log(x) / log(float(2)); >+} >+float log10(float x) { >+ return log(x) / log(float(10)); >+} >+float frac(float x) { >+ return x - floor(x); >+} >+float exp2(float x) { >+ return exp(x * log(float(2))); >+} >+float degrees(float x) { >+ return x * 180 / 3.14159; >+} >+float radians(float x) { >+ return x * 3.14159 / 180; >+} >+float rcp(float x) { >+ return 1 / x; >+} >+float rsqrt(float x) { >+ return 1 / sqrt(x); >+} >+float saturate(float x) { >+ return clamp(x, 0, 1); >+} >+float ddx_coarse(float x) { >+ return ddx(x); >+} >+float ddx_fine(float x) { >+ return ddx(x); >+} >+float ddy_coarse(float x) { >+ return ddy(x); >+} >+float ddy_fine(float x) { >+ return ddy(x); >+} >+float fwidth(float x) { >+ return abs(ddx(x)) + abs(ddy(x)); >+} >+float2 cos(float2 x) { >+ float2 result; >+ result[0] = cos(x[0]); >+ result[1] = cos(x[1]); >+ return result; >+} >+float3 cos(float3 x) { >+ float3 result; >+ result[0] = cos(x[0]); >+ result[1] = cos(x[1]); >+ result[2] = cos(x[2]); >+ return result; >+} >+float4 cos(float4 x) { >+ float4 result; >+ result[0] = cos(x[0]); >+ result[1] = cos(x[1]); >+ result[2] = cos(x[2]); >+ result[3] = cos(x[3]); >+ return result; >+} >+float2x2 cos(float2x2 x) { >+ float2x2 result; >+ result[0][0] = cos(x[0][0]); >+ result[0][1] = cos(x[0][1]); >+ result[1][0] = cos(x[1][0]); >+ result[1][1] = cos(x[1][1]); >+ return result; >+} >+float2x3 cos(float2x3 x) { >+ float2x3 result; >+ result[0][0] = cos(x[0][0]); >+ result[0][1] = cos(x[0][1]); >+ result[0][2] = cos(x[0][2]); >+ result[1][0] = cos(x[1][0]); >+ result[1][1] = cos(x[1][1]); >+ result[1][2] = cos(x[1][2]); >+ return result; >+} >+float2x4 cos(float2x4 x) { >+ float2x4 result; >+ result[0][0] = cos(x[0][0]); >+ result[0][1] = cos(x[0][1]); >+ result[0][2] = cos(x[0][2]); >+ result[0][3] = cos(x[0][3]); >+ result[1][0] = cos(x[1][0]); >+ result[1][1] = cos(x[1][1]); >+ result[1][2] = cos(x[1][2]); >+ result[1][3] = cos(x[1][3]); >+ return result; >+} >+float3x2 cos(float3x2 x) { >+ float3x2 result; >+ result[0][0] = cos(x[0][0]); >+ result[0][1] = cos(x[0][1]); >+ result[1][0] = cos(x[1][0]); >+ result[1][1] = cos(x[1][1]); >+ result[2][0] = cos(x[2][0]); >+ result[2][1] = cos(x[2][1]); >+ return result; >+} >+float3x3 cos(float3x3 x) { >+ float3x3 result; >+ result[0][0] = cos(x[0][0]); >+ result[0][1] = cos(x[0][1]); >+ result[0][2] = cos(x[0][2]); >+ result[1][0] = cos(x[1][0]); >+ result[1][1] = cos(x[1][1]); >+ result[1][2] = cos(x[1][2]); >+ result[2][0] = cos(x[2][0]); >+ result[2][1] = cos(x[2][1]); >+ result[2][2] = cos(x[2][2]); >+ return result; >+} >+float3x4 cos(float3x4 x) { >+ float3x4 result; >+ result[0][0] = cos(x[0][0]); >+ result[0][1] = cos(x[0][1]); >+ result[0][2] = cos(x[0][2]); >+ result[0][3] = cos(x[0][3]); >+ result[1][0] = cos(x[1][0]); >+ result[1][1] = cos(x[1][1]); >+ result[1][2] = cos(x[1][2]); >+ result[1][3] = cos(x[1][3]); >+ result[2][0] = cos(x[2][0]); >+ result[2][1] = cos(x[2][1]); >+ result[2][2] = cos(x[2][2]); >+ result[2][3] = cos(x[2][3]); >+ return result; >+} >+float4x2 cos(float4x2 x) { >+ float4x2 result; >+ result[0][0] = cos(x[0][0]); >+ result[0][1] = cos(x[0][1]); >+ result[1][0] = cos(x[1][0]); >+ result[1][1] = cos(x[1][1]); >+ result[2][0] = cos(x[2][0]); >+ result[2][1] = cos(x[2][1]); >+ result[3][0] = cos(x[3][0]); >+ result[3][1] = cos(x[3][1]); >+ return result; >+} >+float4x3 cos(float4x3 x) { >+ float4x3 result; >+ result[0][0] = cos(x[0][0]); >+ result[0][1] = cos(x[0][1]); >+ result[0][2] = cos(x[0][2]); >+ result[1][0] = cos(x[1][0]); >+ result[1][1] = cos(x[1][1]); >+ result[1][2] = cos(x[1][2]); >+ result[2][0] = cos(x[2][0]); >+ result[2][1] = cos(x[2][1]); >+ result[2][2] = cos(x[2][2]); >+ result[3][0] = cos(x[3][0]); >+ result[3][1] = cos(x[3][1]); >+ result[3][2] = cos(x[3][2]); >+ return result; >+} >+float4x4 cos(float4x4 x) { >+ float4x4 result; >+ result[0][0] = cos(x[0][0]); >+ result[0][1] = cos(x[0][1]); >+ result[0][2] = cos(x[0][2]); >+ result[0][3] = cos(x[0][3]); >+ result[1][0] = cos(x[1][0]); >+ result[1][1] = cos(x[1][1]); >+ result[1][2] = cos(x[1][2]); >+ result[1][3] = cos(x[1][3]); >+ result[2][0] = cos(x[2][0]); >+ result[2][1] = cos(x[2][1]); >+ result[2][2] = cos(x[2][2]); >+ result[2][3] = cos(x[2][3]); >+ result[3][0] = cos(x[3][0]); >+ result[3][1] = cos(x[3][1]); >+ result[3][2] = cos(x[3][2]); >+ result[3][3] = cos(x[3][3]); >+ return result; >+} >+float2 sin(float2 x) { >+ float2 result; >+ result[0] = sin(x[0]); >+ result[1] = sin(x[1]); >+ return result; >+} >+float3 sin(float3 x) { >+ float3 result; >+ result[0] = sin(x[0]); >+ result[1] = sin(x[1]); >+ result[2] = sin(x[2]); >+ return result; >+} >+float4 sin(float4 x) { >+ float4 result; >+ result[0] = sin(x[0]); >+ result[1] = sin(x[1]); >+ result[2] = sin(x[2]); >+ result[3] = sin(x[3]); >+ return result; >+} >+float2x2 sin(float2x2 x) { >+ float2x2 result; >+ result[0][0] = sin(x[0][0]); >+ result[0][1] = sin(x[0][1]); >+ result[1][0] = sin(x[1][0]); >+ result[1][1] = sin(x[1][1]); >+ return result; >+} >+float2x3 sin(float2x3 x) { >+ float2x3 result; >+ result[0][0] = sin(x[0][0]); >+ result[0][1] = sin(x[0][1]); >+ result[0][2] = sin(x[0][2]); >+ result[1][0] = sin(x[1][0]); >+ result[1][1] = sin(x[1][1]); >+ result[1][2] = sin(x[1][2]); >+ return result; >+} >+float2x4 sin(float2x4 x) { >+ float2x4 result; >+ result[0][0] = sin(x[0][0]); >+ result[0][1] = sin(x[0][1]); >+ result[0][2] = sin(x[0][2]); >+ result[0][3] = sin(x[0][3]); >+ result[1][0] = sin(x[1][0]); >+ result[1][1] = sin(x[1][1]); >+ result[1][2] = sin(x[1][2]); >+ result[1][3] = sin(x[1][3]); >+ return result; >+} >+float3x2 sin(float3x2 x) { >+ float3x2 result; >+ result[0][0] = sin(x[0][0]); >+ result[0][1] = sin(x[0][1]); >+ result[1][0] = sin(x[1][0]); >+ result[1][1] = sin(x[1][1]); >+ result[2][0] = sin(x[2][0]); >+ result[2][1] = sin(x[2][1]); >+ return result; >+} >+float3x3 sin(float3x3 x) { >+ float3x3 result; >+ result[0][0] = sin(x[0][0]); >+ result[0][1] = sin(x[0][1]); >+ result[0][2] = sin(x[0][2]); >+ result[1][0] = sin(x[1][0]); >+ result[1][1] = sin(x[1][1]); >+ result[1][2] = sin(x[1][2]); >+ result[2][0] = sin(x[2][0]); >+ result[2][1] = sin(x[2][1]); >+ result[2][2] = sin(x[2][2]); >+ return result; >+} >+float3x4 sin(float3x4 x) { >+ float3x4 result; >+ result[0][0] = sin(x[0][0]); >+ result[0][1] = sin(x[0][1]); >+ result[0][2] = sin(x[0][2]); >+ result[0][3] = sin(x[0][3]); >+ result[1][0] = sin(x[1][0]); >+ result[1][1] = sin(x[1][1]); >+ result[1][2] = sin(x[1][2]); >+ result[1][3] = sin(x[1][3]); >+ result[2][0] = sin(x[2][0]); >+ result[2][1] = sin(x[2][1]); >+ result[2][2] = sin(x[2][2]); >+ result[2][3] = sin(x[2][3]); >+ return result; >+} >+float4x2 sin(float4x2 x) { >+ float4x2 result; >+ result[0][0] = sin(x[0][0]); >+ result[0][1] = sin(x[0][1]); >+ result[1][0] = sin(x[1][0]); >+ result[1][1] = sin(x[1][1]); >+ result[2][0] = sin(x[2][0]); >+ result[2][1] = sin(x[2][1]); >+ result[3][0] = sin(x[3][0]); >+ result[3][1] = sin(x[3][1]); >+ return result; >+} >+float4x3 sin(float4x3 x) { >+ float4x3 result; >+ result[0][0] = sin(x[0][0]); >+ result[0][1] = sin(x[0][1]); >+ result[0][2] = sin(x[0][2]); >+ result[1][0] = sin(x[1][0]); >+ result[1][1] = sin(x[1][1]); >+ result[1][2] = sin(x[1][2]); >+ result[2][0] = sin(x[2][0]); >+ result[2][1] = sin(x[2][1]); >+ result[2][2] = sin(x[2][2]); >+ result[3][0] = sin(x[3][0]); >+ result[3][1] = sin(x[3][1]); >+ result[3][2] = sin(x[3][2]); >+ return result; >+} >+float4x4 sin(float4x4 x) { >+ float4x4 result; >+ result[0][0] = sin(x[0][0]); >+ result[0][1] = sin(x[0][1]); >+ result[0][2] = sin(x[0][2]); >+ result[0][3] = sin(x[0][3]); >+ result[1][0] = sin(x[1][0]); >+ result[1][1] = sin(x[1][1]); >+ result[1][2] = sin(x[1][2]); >+ result[1][3] = sin(x[1][3]); >+ result[2][0] = sin(x[2][0]); >+ result[2][1] = sin(x[2][1]); >+ result[2][2] = sin(x[2][2]); >+ result[2][3] = sin(x[2][3]); >+ result[3][0] = sin(x[3][0]); >+ result[3][1] = sin(x[3][1]); >+ result[3][2] = sin(x[3][2]); >+ result[3][3] = sin(x[3][3]); >+ return result; >+} >+float2 tan(float2 x) { >+ float2 result; >+ result[0] = tan(x[0]); >+ result[1] = tan(x[1]); >+ return result; >+} >+float3 tan(float3 x) { >+ float3 result; >+ result[0] = tan(x[0]); >+ result[1] = tan(x[1]); >+ result[2] = tan(x[2]); >+ return result; >+} >+float4 tan(float4 x) { >+ float4 result; >+ result[0] = tan(x[0]); >+ result[1] = tan(x[1]); >+ result[2] = tan(x[2]); >+ result[3] = tan(x[3]); >+ return result; >+} >+float2x2 tan(float2x2 x) { >+ float2x2 result; >+ result[0][0] = tan(x[0][0]); >+ result[0][1] = tan(x[0][1]); >+ result[1][0] = tan(x[1][0]); >+ result[1][1] = tan(x[1][1]); >+ return result; >+} >+float2x3 tan(float2x3 x) { >+ float2x3 result; >+ result[0][0] = tan(x[0][0]); >+ result[0][1] = tan(x[0][1]); >+ result[0][2] = tan(x[0][2]); >+ result[1][0] = tan(x[1][0]); >+ result[1][1] = tan(x[1][1]); >+ result[1][2] = tan(x[1][2]); >+ return result; >+} >+float2x4 tan(float2x4 x) { >+ float2x4 result; >+ result[0][0] = tan(x[0][0]); >+ result[0][1] = tan(x[0][1]); >+ result[0][2] = tan(x[0][2]); >+ result[0][3] = tan(x[0][3]); >+ result[1][0] = tan(x[1][0]); >+ result[1][1] = tan(x[1][1]); >+ result[1][2] = tan(x[1][2]); >+ result[1][3] = tan(x[1][3]); >+ return result; >+} >+float3x2 tan(float3x2 x) { >+ float3x2 result; >+ result[0][0] = tan(x[0][0]); >+ result[0][1] = tan(x[0][1]); >+ result[1][0] = tan(x[1][0]); >+ result[1][1] = tan(x[1][1]); >+ result[2][0] = tan(x[2][0]); >+ result[2][1] = tan(x[2][1]); >+ return result; >+} >+float3x3 tan(float3x3 x) { >+ float3x3 result; >+ result[0][0] = tan(x[0][0]); >+ result[0][1] = tan(x[0][1]); >+ result[0][2] = tan(x[0][2]); >+ result[1][0] = tan(x[1][0]); >+ result[1][1] = tan(x[1][1]); >+ result[1][2] = tan(x[1][2]); >+ result[2][0] = tan(x[2][0]); >+ result[2][1] = tan(x[2][1]); >+ result[2][2] = tan(x[2][2]); >+ return result; >+} >+float3x4 tan(float3x4 x) { >+ float3x4 result; >+ result[0][0] = tan(x[0][0]); >+ result[0][1] = tan(x[0][1]); >+ result[0][2] = tan(x[0][2]); >+ result[0][3] = tan(x[0][3]); >+ result[1][0] = tan(x[1][0]); >+ result[1][1] = tan(x[1][1]); >+ result[1][2] = tan(x[1][2]); >+ result[1][3] = tan(x[1][3]); >+ result[2][0] = tan(x[2][0]); >+ result[2][1] = tan(x[2][1]); >+ result[2][2] = tan(x[2][2]); >+ result[2][3] = tan(x[2][3]); >+ return result; >+} >+float4x2 tan(float4x2 x) { >+ float4x2 result; >+ result[0][0] = tan(x[0][0]); >+ result[0][1] = tan(x[0][1]); >+ result[1][0] = tan(x[1][0]); >+ result[1][1] = tan(x[1][1]); >+ result[2][0] = tan(x[2][0]); >+ result[2][1] = tan(x[2][1]); >+ result[3][0] = tan(x[3][0]); >+ result[3][1] = tan(x[3][1]); >+ return result; >+} >+float4x3 tan(float4x3 x) { >+ float4x3 result; >+ result[0][0] = tan(x[0][0]); >+ result[0][1] = tan(x[0][1]); >+ result[0][2] = tan(x[0][2]); >+ result[1][0] = tan(x[1][0]); >+ result[1][1] = tan(x[1][1]); >+ result[1][2] = tan(x[1][2]); >+ result[2][0] = tan(x[2][0]); >+ result[2][1] = tan(x[2][1]); >+ result[2][2] = tan(x[2][2]); >+ result[3][0] = tan(x[3][0]); >+ result[3][1] = tan(x[3][1]); >+ result[3][2] = tan(x[3][2]); >+ return result; >+} >+float4x4 tan(float4x4 x) { >+ float4x4 result; >+ result[0][0] = tan(x[0][0]); >+ result[0][1] = tan(x[0][1]); >+ result[0][2] = tan(x[0][2]); >+ result[0][3] = tan(x[0][3]); >+ result[1][0] = tan(x[1][0]); >+ result[1][1] = tan(x[1][1]); >+ result[1][2] = tan(x[1][2]); >+ result[1][3] = tan(x[1][3]); >+ result[2][0] = tan(x[2][0]); >+ result[2][1] = tan(x[2][1]); >+ result[2][2] = tan(x[2][2]); >+ result[2][3] = tan(x[2][3]); >+ result[3][0] = tan(x[3][0]); >+ result[3][1] = tan(x[3][1]); >+ result[3][2] = tan(x[3][2]); >+ result[3][3] = tan(x[3][3]); >+ return result; >+} >+float2 acos(float2 x) { >+ float2 result; >+ result[0] = acos(x[0]); >+ result[1] = acos(x[1]); >+ return result; >+} >+float3 acos(float3 x) { >+ float3 result; >+ result[0] = acos(x[0]); >+ result[1] = acos(x[1]); >+ result[2] = acos(x[2]); >+ return result; >+} >+float4 acos(float4 x) { >+ float4 result; >+ result[0] = acos(x[0]); >+ result[1] = acos(x[1]); >+ result[2] = acos(x[2]); >+ result[3] = acos(x[3]); >+ return result; >+} >+float2x2 acos(float2x2 x) { >+ float2x2 result; >+ result[0][0] = acos(x[0][0]); >+ result[0][1] = acos(x[0][1]); >+ result[1][0] = acos(x[1][0]); >+ result[1][1] = acos(x[1][1]); >+ return result; >+} >+float2x3 acos(float2x3 x) { >+ float2x3 result; >+ result[0][0] = acos(x[0][0]); >+ result[0][1] = acos(x[0][1]); >+ result[0][2] = acos(x[0][2]); >+ result[1][0] = acos(x[1][0]); >+ result[1][1] = acos(x[1][1]); >+ result[1][2] = acos(x[1][2]); >+ return result; >+} >+float2x4 acos(float2x4 x) { >+ float2x4 result; >+ result[0][0] = acos(x[0][0]); >+ result[0][1] = acos(x[0][1]); >+ result[0][2] = acos(x[0][2]); >+ result[0][3] = acos(x[0][3]); >+ result[1][0] = acos(x[1][0]); >+ result[1][1] = acos(x[1][1]); >+ result[1][2] = acos(x[1][2]); >+ result[1][3] = acos(x[1][3]); >+ return result; >+} >+float3x2 acos(float3x2 x) { >+ float3x2 result; >+ result[0][0] = acos(x[0][0]); >+ result[0][1] = acos(x[0][1]); >+ result[1][0] = acos(x[1][0]); >+ result[1][1] = acos(x[1][1]); >+ result[2][0] = acos(x[2][0]); >+ result[2][1] = acos(x[2][1]); >+ return result; >+} >+float3x3 acos(float3x3 x) { >+ float3x3 result; >+ result[0][0] = acos(x[0][0]); >+ result[0][1] = acos(x[0][1]); >+ result[0][2] = acos(x[0][2]); >+ result[1][0] = acos(x[1][0]); >+ result[1][1] = acos(x[1][1]); >+ result[1][2] = acos(x[1][2]); >+ result[2][0] = acos(x[2][0]); >+ result[2][1] = acos(x[2][1]); >+ result[2][2] = acos(x[2][2]); >+ return result; >+} >+float3x4 acos(float3x4 x) { >+ float3x4 result; >+ result[0][0] = acos(x[0][0]); >+ result[0][1] = acos(x[0][1]); >+ result[0][2] = acos(x[0][2]); >+ result[0][3] = acos(x[0][3]); >+ result[1][0] = acos(x[1][0]); >+ result[1][1] = acos(x[1][1]); >+ result[1][2] = acos(x[1][2]); >+ result[1][3] = acos(x[1][3]); >+ result[2][0] = acos(x[2][0]); >+ result[2][1] = acos(x[2][1]); >+ result[2][2] = acos(x[2][2]); >+ result[2][3] = acos(x[2][3]); >+ return result; >+} >+float4x2 acos(float4x2 x) { >+ float4x2 result; >+ result[0][0] = acos(x[0][0]); >+ result[0][1] = acos(x[0][1]); >+ result[1][0] = acos(x[1][0]); >+ result[1][1] = acos(x[1][1]); >+ result[2][0] = acos(x[2][0]); >+ result[2][1] = acos(x[2][1]); >+ result[3][0] = acos(x[3][0]); >+ result[3][1] = acos(x[3][1]); >+ return result; >+} >+float4x3 acos(float4x3 x) { >+ float4x3 result; >+ result[0][0] = acos(x[0][0]); >+ result[0][1] = acos(x[0][1]); >+ result[0][2] = acos(x[0][2]); >+ result[1][0] = acos(x[1][0]); >+ result[1][1] = acos(x[1][1]); >+ result[1][2] = acos(x[1][2]); >+ result[2][0] = acos(x[2][0]); >+ result[2][1] = acos(x[2][1]); >+ result[2][2] = acos(x[2][2]); >+ result[3][0] = acos(x[3][0]); >+ result[3][1] = acos(x[3][1]); >+ result[3][2] = acos(x[3][2]); >+ return result; >+} >+float4x4 acos(float4x4 x) { >+ float4x4 result; >+ result[0][0] = acos(x[0][0]); >+ result[0][1] = acos(x[0][1]); >+ result[0][2] = acos(x[0][2]); >+ result[0][3] = acos(x[0][3]); >+ result[1][0] = acos(x[1][0]); >+ result[1][1] = acos(x[1][1]); >+ result[1][2] = acos(x[1][2]); >+ result[1][3] = acos(x[1][3]); >+ result[2][0] = acos(x[2][0]); >+ result[2][1] = acos(x[2][1]); >+ result[2][2] = acos(x[2][2]); >+ result[2][3] = acos(x[2][3]); >+ result[3][0] = acos(x[3][0]); >+ result[3][1] = acos(x[3][1]); >+ result[3][2] = acos(x[3][2]); >+ result[3][3] = acos(x[3][3]); >+ return result; >+} >+float2 asin(float2 x) { >+ float2 result; >+ result[0] = asin(x[0]); >+ result[1] = asin(x[1]); >+ return result; >+} >+float3 asin(float3 x) { >+ float3 result; >+ result[0] = asin(x[0]); >+ result[1] = asin(x[1]); >+ result[2] = asin(x[2]); >+ return result; >+} >+float4 asin(float4 x) { >+ float4 result; >+ result[0] = asin(x[0]); >+ result[1] = asin(x[1]); >+ result[2] = asin(x[2]); >+ result[3] = asin(x[3]); >+ return result; >+} >+float2x2 asin(float2x2 x) { >+ float2x2 result; >+ result[0][0] = asin(x[0][0]); >+ result[0][1] = asin(x[0][1]); >+ result[1][0] = asin(x[1][0]); >+ result[1][1] = asin(x[1][1]); >+ return result; >+} >+float2x3 asin(float2x3 x) { >+ float2x3 result; >+ result[0][0] = asin(x[0][0]); >+ result[0][1] = asin(x[0][1]); >+ result[0][2] = asin(x[0][2]); >+ result[1][0] = asin(x[1][0]); >+ result[1][1] = asin(x[1][1]); >+ result[1][2] = asin(x[1][2]); >+ return result; >+} >+float2x4 asin(float2x4 x) { >+ float2x4 result; >+ result[0][0] = asin(x[0][0]); >+ result[0][1] = asin(x[0][1]); >+ result[0][2] = asin(x[0][2]); >+ result[0][3] = asin(x[0][3]); >+ result[1][0] = asin(x[1][0]); >+ result[1][1] = asin(x[1][1]); >+ result[1][2] = asin(x[1][2]); >+ result[1][3] = asin(x[1][3]); >+ return result; >+} >+float3x2 asin(float3x2 x) { >+ float3x2 result; >+ result[0][0] = asin(x[0][0]); >+ result[0][1] = asin(x[0][1]); >+ result[1][0] = asin(x[1][0]); >+ result[1][1] = asin(x[1][1]); >+ result[2][0] = asin(x[2][0]); >+ result[2][1] = asin(x[2][1]); >+ return result; >+} >+float3x3 asin(float3x3 x) { >+ float3x3 result; >+ result[0][0] = asin(x[0][0]); >+ result[0][1] = asin(x[0][1]); >+ result[0][2] = asin(x[0][2]); >+ result[1][0] = asin(x[1][0]); >+ result[1][1] = asin(x[1][1]); >+ result[1][2] = asin(x[1][2]); >+ result[2][0] = asin(x[2][0]); >+ result[2][1] = asin(x[2][1]); >+ result[2][2] = asin(x[2][2]); >+ return result; >+} >+float3x4 asin(float3x4 x) { >+ float3x4 result; >+ result[0][0] = asin(x[0][0]); >+ result[0][1] = asin(x[0][1]); >+ result[0][2] = asin(x[0][2]); >+ result[0][3] = asin(x[0][3]); >+ result[1][0] = asin(x[1][0]); >+ result[1][1] = asin(x[1][1]); >+ result[1][2] = asin(x[1][2]); >+ result[1][3] = asin(x[1][3]); >+ result[2][0] = asin(x[2][0]); >+ result[2][1] = asin(x[2][1]); >+ result[2][2] = asin(x[2][2]); >+ result[2][3] = asin(x[2][3]); >+ return result; >+} >+float4x2 asin(float4x2 x) { >+ float4x2 result; >+ result[0][0] = asin(x[0][0]); >+ result[0][1] = asin(x[0][1]); >+ result[1][0] = asin(x[1][0]); >+ result[1][1] = asin(x[1][1]); >+ result[2][0] = asin(x[2][0]); >+ result[2][1] = asin(x[2][1]); >+ result[3][0] = asin(x[3][0]); >+ result[3][1] = asin(x[3][1]); >+ return result; >+} >+float4x3 asin(float4x3 x) { >+ float4x3 result; >+ result[0][0] = asin(x[0][0]); >+ result[0][1] = asin(x[0][1]); >+ result[0][2] = asin(x[0][2]); >+ result[1][0] = asin(x[1][0]); >+ result[1][1] = asin(x[1][1]); >+ result[1][2] = asin(x[1][2]); >+ result[2][0] = asin(x[2][0]); >+ result[2][1] = asin(x[2][1]); >+ result[2][2] = asin(x[2][2]); >+ result[3][0] = asin(x[3][0]); >+ result[3][1] = asin(x[3][1]); >+ result[3][2] = asin(x[3][2]); >+ return result; >+} >+float4x4 asin(float4x4 x) { >+ float4x4 result; >+ result[0][0] = asin(x[0][0]); >+ result[0][1] = asin(x[0][1]); >+ result[0][2] = asin(x[0][2]); >+ result[0][3] = asin(x[0][3]); >+ result[1][0] = asin(x[1][0]); >+ result[1][1] = asin(x[1][1]); >+ result[1][2] = asin(x[1][2]); >+ result[1][3] = asin(x[1][3]); >+ result[2][0] = asin(x[2][0]); >+ result[2][1] = asin(x[2][1]); >+ result[2][2] = asin(x[2][2]); >+ result[2][3] = asin(x[2][3]); >+ result[3][0] = asin(x[3][0]); >+ result[3][1] = asin(x[3][1]); >+ result[3][2] = asin(x[3][2]); >+ result[3][3] = asin(x[3][3]); >+ return result; >+} >+float2 atan(float2 x) { >+ float2 result; >+ result[0] = atan(x[0]); >+ result[1] = atan(x[1]); >+ return result; >+} >+float3 atan(float3 x) { >+ float3 result; >+ result[0] = atan(x[0]); >+ result[1] = atan(x[1]); >+ result[2] = atan(x[2]); >+ return result; >+} >+float4 atan(float4 x) { >+ float4 result; >+ result[0] = atan(x[0]); >+ result[1] = atan(x[1]); >+ result[2] = atan(x[2]); >+ result[3] = atan(x[3]); >+ return result; >+} >+float2x2 atan(float2x2 x) { >+ float2x2 result; >+ result[0][0] = atan(x[0][0]); >+ result[0][1] = atan(x[0][1]); >+ result[1][0] = atan(x[1][0]); >+ result[1][1] = atan(x[1][1]); >+ return result; >+} >+float2x3 atan(float2x3 x) { >+ float2x3 result; >+ result[0][0] = atan(x[0][0]); >+ result[0][1] = atan(x[0][1]); >+ result[0][2] = atan(x[0][2]); >+ result[1][0] = atan(x[1][0]); >+ result[1][1] = atan(x[1][1]); >+ result[1][2] = atan(x[1][2]); >+ return result; >+} >+float2x4 atan(float2x4 x) { >+ float2x4 result; >+ result[0][0] = atan(x[0][0]); >+ result[0][1] = atan(x[0][1]); >+ result[0][2] = atan(x[0][2]); >+ result[0][3] = atan(x[0][3]); >+ result[1][0] = atan(x[1][0]); >+ result[1][1] = atan(x[1][1]); >+ result[1][2] = atan(x[1][2]); >+ result[1][3] = atan(x[1][3]); >+ return result; >+} >+float3x2 atan(float3x2 x) { >+ float3x2 result; >+ result[0][0] = atan(x[0][0]); >+ result[0][1] = atan(x[0][1]); >+ result[1][0] = atan(x[1][0]); >+ result[1][1] = atan(x[1][1]); >+ result[2][0] = atan(x[2][0]); >+ result[2][1] = atan(x[2][1]); >+ return result; >+} >+float3x3 atan(float3x3 x) { >+ float3x3 result; >+ result[0][0] = atan(x[0][0]); >+ result[0][1] = atan(x[0][1]); >+ result[0][2] = atan(x[0][2]); >+ result[1][0] = atan(x[1][0]); >+ result[1][1] = atan(x[1][1]); >+ result[1][2] = atan(x[1][2]); >+ result[2][0] = atan(x[2][0]); >+ result[2][1] = atan(x[2][1]); >+ result[2][2] = atan(x[2][2]); >+ return result; >+} >+float3x4 atan(float3x4 x) { >+ float3x4 result; >+ result[0][0] = atan(x[0][0]); >+ result[0][1] = atan(x[0][1]); >+ result[0][2] = atan(x[0][2]); >+ result[0][3] = atan(x[0][3]); >+ result[1][0] = atan(x[1][0]); >+ result[1][1] = atan(x[1][1]); >+ result[1][2] = atan(x[1][2]); >+ result[1][3] = atan(x[1][3]); >+ result[2][0] = atan(x[2][0]); >+ result[2][1] = atan(x[2][1]); >+ result[2][2] = atan(x[2][2]); >+ result[2][3] = atan(x[2][3]); >+ return result; >+} >+float4x2 atan(float4x2 x) { >+ float4x2 result; >+ result[0][0] = atan(x[0][0]); >+ result[0][1] = atan(x[0][1]); >+ result[1][0] = atan(x[1][0]); >+ result[1][1] = atan(x[1][1]); >+ result[2][0] = atan(x[2][0]); >+ result[2][1] = atan(x[2][1]); >+ result[3][0] = atan(x[3][0]); >+ result[3][1] = atan(x[3][1]); >+ return result; >+} >+float4x3 atan(float4x3 x) { >+ float4x3 result; >+ result[0][0] = atan(x[0][0]); >+ result[0][1] = atan(x[0][1]); >+ result[0][2] = atan(x[0][2]); >+ result[1][0] = atan(x[1][0]); >+ result[1][1] = atan(x[1][1]); >+ result[1][2] = atan(x[1][2]); >+ result[2][0] = atan(x[2][0]); >+ result[2][1] = atan(x[2][1]); >+ result[2][2] = atan(x[2][2]); >+ result[3][0] = atan(x[3][0]); >+ result[3][1] = atan(x[3][1]); >+ result[3][2] = atan(x[3][2]); >+ return result; >+} >+float4x4 atan(float4x4 x) { >+ float4x4 result; >+ result[0][0] = atan(x[0][0]); >+ result[0][1] = atan(x[0][1]); >+ result[0][2] = atan(x[0][2]); >+ result[0][3] = atan(x[0][3]); >+ result[1][0] = atan(x[1][0]); >+ result[1][1] = atan(x[1][1]); >+ result[1][2] = atan(x[1][2]); >+ result[1][3] = atan(x[1][3]); >+ result[2][0] = atan(x[2][0]); >+ result[2][1] = atan(x[2][1]); >+ result[2][2] = atan(x[2][2]); >+ result[2][3] = atan(x[2][3]); >+ result[3][0] = atan(x[3][0]); >+ result[3][1] = atan(x[3][1]); >+ result[3][2] = atan(x[3][2]); >+ result[3][3] = atan(x[3][3]); >+ return result; >+} >+float2 cosh(float2 x) { >+ float2 result; >+ result[0] = cosh(x[0]); >+ result[1] = cosh(x[1]); >+ return result; >+} >+float3 cosh(float3 x) { >+ float3 result; >+ result[0] = cosh(x[0]); >+ result[1] = cosh(x[1]); >+ result[2] = cosh(x[2]); >+ return result; >+} >+float4 cosh(float4 x) { >+ float4 result; >+ result[0] = cosh(x[0]); >+ result[1] = cosh(x[1]); >+ result[2] = cosh(x[2]); >+ result[3] = cosh(x[3]); >+ return result; >+} >+float2x2 cosh(float2x2 x) { >+ float2x2 result; >+ result[0][0] = cosh(x[0][0]); >+ result[0][1] = cosh(x[0][1]); >+ result[1][0] = cosh(x[1][0]); >+ result[1][1] = cosh(x[1][1]); >+ return result; >+} >+float2x3 cosh(float2x3 x) { >+ float2x3 result; >+ result[0][0] = cosh(x[0][0]); >+ result[0][1] = cosh(x[0][1]); >+ result[0][2] = cosh(x[0][2]); >+ result[1][0] = cosh(x[1][0]); >+ result[1][1] = cosh(x[1][1]); >+ result[1][2] = cosh(x[1][2]); >+ return result; >+} >+float2x4 cosh(float2x4 x) { >+ float2x4 result; >+ result[0][0] = cosh(x[0][0]); >+ result[0][1] = cosh(x[0][1]); >+ result[0][2] = cosh(x[0][2]); >+ result[0][3] = cosh(x[0][3]); >+ result[1][0] = cosh(x[1][0]); >+ result[1][1] = cosh(x[1][1]); >+ result[1][2] = cosh(x[1][2]); >+ result[1][3] = cosh(x[1][3]); >+ return result; >+} >+float3x2 cosh(float3x2 x) { >+ float3x2 result; >+ result[0][0] = cosh(x[0][0]); >+ result[0][1] = cosh(x[0][1]); >+ result[1][0] = cosh(x[1][0]); >+ result[1][1] = cosh(x[1][1]); >+ result[2][0] = cosh(x[2][0]); >+ result[2][1] = cosh(x[2][1]); >+ return result; >+} >+float3x3 cosh(float3x3 x) { >+ float3x3 result; >+ result[0][0] = cosh(x[0][0]); >+ result[0][1] = cosh(x[0][1]); >+ result[0][2] = cosh(x[0][2]); >+ result[1][0] = cosh(x[1][0]); >+ result[1][1] = cosh(x[1][1]); >+ result[1][2] = cosh(x[1][2]); >+ result[2][0] = cosh(x[2][0]); >+ result[2][1] = cosh(x[2][1]); >+ result[2][2] = cosh(x[2][2]); >+ return result; >+} >+float3x4 cosh(float3x4 x) { >+ float3x4 result; >+ result[0][0] = cosh(x[0][0]); >+ result[0][1] = cosh(x[0][1]); >+ result[0][2] = cosh(x[0][2]); >+ result[0][3] = cosh(x[0][3]); >+ result[1][0] = cosh(x[1][0]); >+ result[1][1] = cosh(x[1][1]); >+ result[1][2] = cosh(x[1][2]); >+ result[1][3] = cosh(x[1][3]); >+ result[2][0] = cosh(x[2][0]); >+ result[2][1] = cosh(x[2][1]); >+ result[2][2] = cosh(x[2][2]); >+ result[2][3] = cosh(x[2][3]); >+ return result; >+} >+float4x2 cosh(float4x2 x) { >+ float4x2 result; >+ result[0][0] = cosh(x[0][0]); >+ result[0][1] = cosh(x[0][1]); >+ result[1][0] = cosh(x[1][0]); >+ result[1][1] = cosh(x[1][1]); >+ result[2][0] = cosh(x[2][0]); >+ result[2][1] = cosh(x[2][1]); >+ result[3][0] = cosh(x[3][0]); >+ result[3][1] = cosh(x[3][1]); >+ return result; >+} >+float4x3 cosh(float4x3 x) { >+ float4x3 result; >+ result[0][0] = cosh(x[0][0]); >+ result[0][1] = cosh(x[0][1]); >+ result[0][2] = cosh(x[0][2]); >+ result[1][0] = cosh(x[1][0]); >+ result[1][1] = cosh(x[1][1]); >+ result[1][2] = cosh(x[1][2]); >+ result[2][0] = cosh(x[2][0]); >+ result[2][1] = cosh(x[2][1]); >+ result[2][2] = cosh(x[2][2]); >+ result[3][0] = cosh(x[3][0]); >+ result[3][1] = cosh(x[3][1]); >+ result[3][2] = cosh(x[3][2]); >+ return result; >+} >+float4x4 cosh(float4x4 x) { >+ float4x4 result; >+ result[0][0] = cosh(x[0][0]); >+ result[0][1] = cosh(x[0][1]); >+ result[0][2] = cosh(x[0][2]); >+ result[0][3] = cosh(x[0][3]); >+ result[1][0] = cosh(x[1][0]); >+ result[1][1] = cosh(x[1][1]); >+ result[1][2] = cosh(x[1][2]); >+ result[1][3] = cosh(x[1][3]); >+ result[2][0] = cosh(x[2][0]); >+ result[2][1] = cosh(x[2][1]); >+ result[2][2] = cosh(x[2][2]); >+ result[2][3] = cosh(x[2][3]); >+ result[3][0] = cosh(x[3][0]); >+ result[3][1] = cosh(x[3][1]); >+ result[3][2] = cosh(x[3][2]); >+ result[3][3] = cosh(x[3][3]); >+ return result; >+} >+float2 sinh(float2 x) { >+ float2 result; >+ result[0] = sinh(x[0]); >+ result[1] = sinh(x[1]); >+ return result; >+} >+float3 sinh(float3 x) { >+ float3 result; >+ result[0] = sinh(x[0]); >+ result[1] = sinh(x[1]); >+ result[2] = sinh(x[2]); >+ return result; >+} >+float4 sinh(float4 x) { >+ float4 result; >+ result[0] = sinh(x[0]); >+ result[1] = sinh(x[1]); >+ result[2] = sinh(x[2]); >+ result[3] = sinh(x[3]); >+ return result; >+} >+float2x2 sinh(float2x2 x) { >+ float2x2 result; >+ result[0][0] = sinh(x[0][0]); >+ result[0][1] = sinh(x[0][1]); >+ result[1][0] = sinh(x[1][0]); >+ result[1][1] = sinh(x[1][1]); >+ return result; >+} >+float2x3 sinh(float2x3 x) { >+ float2x3 result; >+ result[0][0] = sinh(x[0][0]); >+ result[0][1] = sinh(x[0][1]); >+ result[0][2] = sinh(x[0][2]); >+ result[1][0] = sinh(x[1][0]); >+ result[1][1] = sinh(x[1][1]); >+ result[1][2] = sinh(x[1][2]); >+ return result; >+} >+float2x4 sinh(float2x4 x) { >+ float2x4 result; >+ result[0][0] = sinh(x[0][0]); >+ result[0][1] = sinh(x[0][1]); >+ result[0][2] = sinh(x[0][2]); >+ result[0][3] = sinh(x[0][3]); >+ result[1][0] = sinh(x[1][0]); >+ result[1][1] = sinh(x[1][1]); >+ result[1][2] = sinh(x[1][2]); >+ result[1][3] = sinh(x[1][3]); >+ return result; >+} >+float3x2 sinh(float3x2 x) { >+ float3x2 result; >+ result[0][0] = sinh(x[0][0]); >+ result[0][1] = sinh(x[0][1]); >+ result[1][0] = sinh(x[1][0]); >+ result[1][1] = sinh(x[1][1]); >+ result[2][0] = sinh(x[2][0]); >+ result[2][1] = sinh(x[2][1]); >+ return result; >+} >+float3x3 sinh(float3x3 x) { >+ float3x3 result; >+ result[0][0] = sinh(x[0][0]); >+ result[0][1] = sinh(x[0][1]); >+ result[0][2] = sinh(x[0][2]); >+ result[1][0] = sinh(x[1][0]); >+ result[1][1] = sinh(x[1][1]); >+ result[1][2] = sinh(x[1][2]); >+ result[2][0] = sinh(x[2][0]); >+ result[2][1] = sinh(x[2][1]); >+ result[2][2] = sinh(x[2][2]); >+ return result; >+} >+float3x4 sinh(float3x4 x) { >+ float3x4 result; >+ result[0][0] = sinh(x[0][0]); >+ result[0][1] = sinh(x[0][1]); >+ result[0][2] = sinh(x[0][2]); >+ result[0][3] = sinh(x[0][3]); >+ result[1][0] = sinh(x[1][0]); >+ result[1][1] = sinh(x[1][1]); >+ result[1][2] = sinh(x[1][2]); >+ result[1][3] = sinh(x[1][3]); >+ result[2][0] = sinh(x[2][0]); >+ result[2][1] = sinh(x[2][1]); >+ result[2][2] = sinh(x[2][2]); >+ result[2][3] = sinh(x[2][3]); >+ return result; >+} >+float4x2 sinh(float4x2 x) { >+ float4x2 result; >+ result[0][0] = sinh(x[0][0]); >+ result[0][1] = sinh(x[0][1]); >+ result[1][0] = sinh(x[1][0]); >+ result[1][1] = sinh(x[1][1]); >+ result[2][0] = sinh(x[2][0]); >+ result[2][1] = sinh(x[2][1]); >+ result[3][0] = sinh(x[3][0]); >+ result[3][1] = sinh(x[3][1]); >+ return result; >+} >+float4x3 sinh(float4x3 x) { >+ float4x3 result; >+ result[0][0] = sinh(x[0][0]); >+ result[0][1] = sinh(x[0][1]); >+ result[0][2] = sinh(x[0][2]); >+ result[1][0] = sinh(x[1][0]); >+ result[1][1] = sinh(x[1][1]); >+ result[1][2] = sinh(x[1][2]); >+ result[2][0] = sinh(x[2][0]); >+ result[2][1] = sinh(x[2][1]); >+ result[2][2] = sinh(x[2][2]); >+ result[3][0] = sinh(x[3][0]); >+ result[3][1] = sinh(x[3][1]); >+ result[3][2] = sinh(x[3][2]); >+ return result; >+} >+float4x4 sinh(float4x4 x) { >+ float4x4 result; >+ result[0][0] = sinh(x[0][0]); >+ result[0][1] = sinh(x[0][1]); >+ result[0][2] = sinh(x[0][2]); >+ result[0][3] = sinh(x[0][3]); >+ result[1][0] = sinh(x[1][0]); >+ result[1][1] = sinh(x[1][1]); >+ result[1][2] = sinh(x[1][2]); >+ result[1][3] = sinh(x[1][3]); >+ result[2][0] = sinh(x[2][0]); >+ result[2][1] = sinh(x[2][1]); >+ result[2][2] = sinh(x[2][2]); >+ result[2][3] = sinh(x[2][3]); >+ result[3][0] = sinh(x[3][0]); >+ result[3][1] = sinh(x[3][1]); >+ result[3][2] = sinh(x[3][2]); >+ result[3][3] = sinh(x[3][3]); >+ return result; >+} >+float2 tanh(float2 x) { >+ float2 result; >+ result[0] = tanh(x[0]); >+ result[1] = tanh(x[1]); >+ return result; >+} >+float3 tanh(float3 x) { >+ float3 result; >+ result[0] = tanh(x[0]); >+ result[1] = tanh(x[1]); >+ result[2] = tanh(x[2]); >+ return result; >+} >+float4 tanh(float4 x) { >+ float4 result; >+ result[0] = tanh(x[0]); >+ result[1] = tanh(x[1]); >+ result[2] = tanh(x[2]); >+ result[3] = tanh(x[3]); >+ return result; >+} >+float2x2 tanh(float2x2 x) { >+ float2x2 result; >+ result[0][0] = tanh(x[0][0]); >+ result[0][1] = tanh(x[0][1]); >+ result[1][0] = tanh(x[1][0]); >+ result[1][1] = tanh(x[1][1]); >+ return result; >+} >+float2x3 tanh(float2x3 x) { >+ float2x3 result; >+ result[0][0] = tanh(x[0][0]); >+ result[0][1] = tanh(x[0][1]); >+ result[0][2] = tanh(x[0][2]); >+ result[1][0] = tanh(x[1][0]); >+ result[1][1] = tanh(x[1][1]); >+ result[1][2] = tanh(x[1][2]); >+ return result; >+} >+float2x4 tanh(float2x4 x) { >+ float2x4 result; >+ result[0][0] = tanh(x[0][0]); >+ result[0][1] = tanh(x[0][1]); >+ result[0][2] = tanh(x[0][2]); >+ result[0][3] = tanh(x[0][3]); >+ result[1][0] = tanh(x[1][0]); >+ result[1][1] = tanh(x[1][1]); >+ result[1][2] = tanh(x[1][2]); >+ result[1][3] = tanh(x[1][3]); >+ return result; >+} >+float3x2 tanh(float3x2 x) { >+ float3x2 result; >+ result[0][0] = tanh(x[0][0]); >+ result[0][1] = tanh(x[0][1]); >+ result[1][0] = tanh(x[1][0]); >+ result[1][1] = tanh(x[1][1]); >+ result[2][0] = tanh(x[2][0]); >+ result[2][1] = tanh(x[2][1]); >+ return result; >+} >+float3x3 tanh(float3x3 x) { >+ float3x3 result; >+ result[0][0] = tanh(x[0][0]); >+ result[0][1] = tanh(x[0][1]); >+ result[0][2] = tanh(x[0][2]); >+ result[1][0] = tanh(x[1][0]); >+ result[1][1] = tanh(x[1][1]); >+ result[1][2] = tanh(x[1][2]); >+ result[2][0] = tanh(x[2][0]); >+ result[2][1] = tanh(x[2][1]); >+ result[2][2] = tanh(x[2][2]); >+ return result; >+} >+float3x4 tanh(float3x4 x) { >+ float3x4 result; >+ result[0][0] = tanh(x[0][0]); >+ result[0][1] = tanh(x[0][1]); >+ result[0][2] = tanh(x[0][2]); >+ result[0][3] = tanh(x[0][3]); >+ result[1][0] = tanh(x[1][0]); >+ result[1][1] = tanh(x[1][1]); >+ result[1][2] = tanh(x[1][2]); >+ result[1][3] = tanh(x[1][3]); >+ result[2][0] = tanh(x[2][0]); >+ result[2][1] = tanh(x[2][1]); >+ result[2][2] = tanh(x[2][2]); >+ result[2][3] = tanh(x[2][3]); >+ return result; >+} >+float4x2 tanh(float4x2 x) { >+ float4x2 result; >+ result[0][0] = tanh(x[0][0]); >+ result[0][1] = tanh(x[0][1]); >+ result[1][0] = tanh(x[1][0]); >+ result[1][1] = tanh(x[1][1]); >+ result[2][0] = tanh(x[2][0]); >+ result[2][1] = tanh(x[2][1]); >+ result[3][0] = tanh(x[3][0]); >+ result[3][1] = tanh(x[3][1]); >+ return result; >+} >+float4x3 tanh(float4x3 x) { >+ float4x3 result; >+ result[0][0] = tanh(x[0][0]); >+ result[0][1] = tanh(x[0][1]); >+ result[0][2] = tanh(x[0][2]); >+ result[1][0] = tanh(x[1][0]); >+ result[1][1] = tanh(x[1][1]); >+ result[1][2] = tanh(x[1][2]); >+ result[2][0] = tanh(x[2][0]); >+ result[2][1] = tanh(x[2][1]); >+ result[2][2] = tanh(x[2][2]); >+ result[3][0] = tanh(x[3][0]); >+ result[3][1] = tanh(x[3][1]); >+ result[3][2] = tanh(x[3][2]); >+ return result; >+} >+float4x4 tanh(float4x4 x) { >+ float4x4 result; >+ result[0][0] = tanh(x[0][0]); >+ result[0][1] = tanh(x[0][1]); >+ result[0][2] = tanh(x[0][2]); >+ result[0][3] = tanh(x[0][3]); >+ result[1][0] = tanh(x[1][0]); >+ result[1][1] = tanh(x[1][1]); >+ result[1][2] = tanh(x[1][2]); >+ result[1][3] = tanh(x[1][3]); >+ result[2][0] = tanh(x[2][0]); >+ result[2][1] = tanh(x[2][1]); >+ result[2][2] = tanh(x[2][2]); >+ result[2][3] = tanh(x[2][3]); >+ result[3][0] = tanh(x[3][0]); >+ result[3][1] = tanh(x[3][1]); >+ result[3][2] = tanh(x[3][2]); >+ result[3][3] = tanh(x[3][3]); >+ return result; >+} >+float2 ceil(float2 x) { >+ float2 result; >+ result[0] = ceil(x[0]); >+ result[1] = ceil(x[1]); >+ return result; >+} >+float3 ceil(float3 x) { >+ float3 result; >+ result[0] = ceil(x[0]); >+ result[1] = ceil(x[1]); >+ result[2] = ceil(x[2]); >+ return result; >+} >+float4 ceil(float4 x) { >+ float4 result; >+ result[0] = ceil(x[0]); >+ result[1] = ceil(x[1]); >+ result[2] = ceil(x[2]); >+ result[3] = ceil(x[3]); >+ return result; >+} >+float2x2 ceil(float2x2 x) { >+ float2x2 result; >+ result[0][0] = ceil(x[0][0]); >+ result[0][1] = ceil(x[0][1]); >+ result[1][0] = ceil(x[1][0]); >+ result[1][1] = ceil(x[1][1]); >+ return result; >+} >+float2x3 ceil(float2x3 x) { >+ float2x3 result; >+ result[0][0] = ceil(x[0][0]); >+ result[0][1] = ceil(x[0][1]); >+ result[0][2] = ceil(x[0][2]); >+ result[1][0] = ceil(x[1][0]); >+ result[1][1] = ceil(x[1][1]); >+ result[1][2] = ceil(x[1][2]); >+ return result; >+} >+float2x4 ceil(float2x4 x) { >+ float2x4 result; >+ result[0][0] = ceil(x[0][0]); >+ result[0][1] = ceil(x[0][1]); >+ result[0][2] = ceil(x[0][2]); >+ result[0][3] = ceil(x[0][3]); >+ result[1][0] = ceil(x[1][0]); >+ result[1][1] = ceil(x[1][1]); >+ result[1][2] = ceil(x[1][2]); >+ result[1][3] = ceil(x[1][3]); >+ return result; >+} >+float3x2 ceil(float3x2 x) { >+ float3x2 result; >+ result[0][0] = ceil(x[0][0]); >+ result[0][1] = ceil(x[0][1]); >+ result[1][0] = ceil(x[1][0]); >+ result[1][1] = ceil(x[1][1]); >+ result[2][0] = ceil(x[2][0]); >+ result[2][1] = ceil(x[2][1]); >+ return result; >+} >+float3x3 ceil(float3x3 x) { >+ float3x3 result; >+ result[0][0] = ceil(x[0][0]); >+ result[0][1] = ceil(x[0][1]); >+ result[0][2] = ceil(x[0][2]); >+ result[1][0] = ceil(x[1][0]); >+ result[1][1] = ceil(x[1][1]); >+ result[1][2] = ceil(x[1][2]); >+ result[2][0] = ceil(x[2][0]); >+ result[2][1] = ceil(x[2][1]); >+ result[2][2] = ceil(x[2][2]); >+ return result; >+} >+float3x4 ceil(float3x4 x) { >+ float3x4 result; >+ result[0][0] = ceil(x[0][0]); >+ result[0][1] = ceil(x[0][1]); >+ result[0][2] = ceil(x[0][2]); >+ result[0][3] = ceil(x[0][3]); >+ result[1][0] = ceil(x[1][0]); >+ result[1][1] = ceil(x[1][1]); >+ result[1][2] = ceil(x[1][2]); >+ result[1][3] = ceil(x[1][3]); >+ result[2][0] = ceil(x[2][0]); >+ result[2][1] = ceil(x[2][1]); >+ result[2][2] = ceil(x[2][2]); >+ result[2][3] = ceil(x[2][3]); >+ return result; >+} >+float4x2 ceil(float4x2 x) { >+ float4x2 result; >+ result[0][0] = ceil(x[0][0]); >+ result[0][1] = ceil(x[0][1]); >+ result[1][0] = ceil(x[1][0]); >+ result[1][1] = ceil(x[1][1]); >+ result[2][0] = ceil(x[2][0]); >+ result[2][1] = ceil(x[2][1]); >+ result[3][0] = ceil(x[3][0]); >+ result[3][1] = ceil(x[3][1]); >+ return result; >+} >+float4x3 ceil(float4x3 x) { >+ float4x3 result; >+ result[0][0] = ceil(x[0][0]); >+ result[0][1] = ceil(x[0][1]); >+ result[0][2] = ceil(x[0][2]); >+ result[1][0] = ceil(x[1][0]); >+ result[1][1] = ceil(x[1][1]); >+ result[1][2] = ceil(x[1][2]); >+ result[2][0] = ceil(x[2][0]); >+ result[2][1] = ceil(x[2][1]); >+ result[2][2] = ceil(x[2][2]); >+ result[3][0] = ceil(x[3][0]); >+ result[3][1] = ceil(x[3][1]); >+ result[3][2] = ceil(x[3][2]); >+ return result; >+} >+float4x4 ceil(float4x4 x) { >+ float4x4 result; >+ result[0][0] = ceil(x[0][0]); >+ result[0][1] = ceil(x[0][1]); >+ result[0][2] = ceil(x[0][2]); >+ result[0][3] = ceil(x[0][3]); >+ result[1][0] = ceil(x[1][0]); >+ result[1][1] = ceil(x[1][1]); >+ result[1][2] = ceil(x[1][2]); >+ result[1][3] = ceil(x[1][3]); >+ result[2][0] = ceil(x[2][0]); >+ result[2][1] = ceil(x[2][1]); >+ result[2][2] = ceil(x[2][2]); >+ result[2][3] = ceil(x[2][3]); >+ result[3][0] = ceil(x[3][0]); >+ result[3][1] = ceil(x[3][1]); >+ result[3][2] = ceil(x[3][2]); >+ result[3][3] = ceil(x[3][3]); >+ return result; >+} >+float2 exp(float2 x) { >+ float2 result; >+ result[0] = exp(x[0]); >+ result[1] = exp(x[1]); >+ return result; >+} >+float3 exp(float3 x) { >+ float3 result; >+ result[0] = exp(x[0]); >+ result[1] = exp(x[1]); >+ result[2] = exp(x[2]); >+ return result; >+} >+float4 exp(float4 x) { >+ float4 result; >+ result[0] = exp(x[0]); >+ result[1] = exp(x[1]); >+ result[2] = exp(x[2]); >+ result[3] = exp(x[3]); >+ return result; >+} >+float2x2 exp(float2x2 x) { >+ float2x2 result; >+ result[0][0] = exp(x[0][0]); >+ result[0][1] = exp(x[0][1]); >+ result[1][0] = exp(x[1][0]); >+ result[1][1] = exp(x[1][1]); >+ return result; >+} >+float2x3 exp(float2x3 x) { >+ float2x3 result; >+ result[0][0] = exp(x[0][0]); >+ result[0][1] = exp(x[0][1]); >+ result[0][2] = exp(x[0][2]); >+ result[1][0] = exp(x[1][0]); >+ result[1][1] = exp(x[1][1]); >+ result[1][2] = exp(x[1][2]); >+ return result; >+} >+float2x4 exp(float2x4 x) { >+ float2x4 result; >+ result[0][0] = exp(x[0][0]); >+ result[0][1] = exp(x[0][1]); >+ result[0][2] = exp(x[0][2]); >+ result[0][3] = exp(x[0][3]); >+ result[1][0] = exp(x[1][0]); >+ result[1][1] = exp(x[1][1]); >+ result[1][2] = exp(x[1][2]); >+ result[1][3] = exp(x[1][3]); >+ return result; >+} >+float3x2 exp(float3x2 x) { >+ float3x2 result; >+ result[0][0] = exp(x[0][0]); >+ result[0][1] = exp(x[0][1]); >+ result[1][0] = exp(x[1][0]); >+ result[1][1] = exp(x[1][1]); >+ result[2][0] = exp(x[2][0]); >+ result[2][1] = exp(x[2][1]); >+ return result; >+} >+float3x3 exp(float3x3 x) { >+ float3x3 result; >+ result[0][0] = exp(x[0][0]); >+ result[0][1] = exp(x[0][1]); >+ result[0][2] = exp(x[0][2]); >+ result[1][0] = exp(x[1][0]); >+ result[1][1] = exp(x[1][1]); >+ result[1][2] = exp(x[1][2]); >+ result[2][0] = exp(x[2][0]); >+ result[2][1] = exp(x[2][1]); >+ result[2][2] = exp(x[2][2]); >+ return result; >+} >+float3x4 exp(float3x4 x) { >+ float3x4 result; >+ result[0][0] = exp(x[0][0]); >+ result[0][1] = exp(x[0][1]); >+ result[0][2] = exp(x[0][2]); >+ result[0][3] = exp(x[0][3]); >+ result[1][0] = exp(x[1][0]); >+ result[1][1] = exp(x[1][1]); >+ result[1][2] = exp(x[1][2]); >+ result[1][3] = exp(x[1][3]); >+ result[2][0] = exp(x[2][0]); >+ result[2][1] = exp(x[2][1]); >+ result[2][2] = exp(x[2][2]); >+ result[2][3] = exp(x[2][3]); >+ return result; >+} >+float4x2 exp(float4x2 x) { >+ float4x2 result; >+ result[0][0] = exp(x[0][0]); >+ result[0][1] = exp(x[0][1]); >+ result[1][0] = exp(x[1][0]); >+ result[1][1] = exp(x[1][1]); >+ result[2][0] = exp(x[2][0]); >+ result[2][1] = exp(x[2][1]); >+ result[3][0] = exp(x[3][0]); >+ result[3][1] = exp(x[3][1]); >+ return result; >+} >+float4x3 exp(float4x3 x) { >+ float4x3 result; >+ result[0][0] = exp(x[0][0]); >+ result[0][1] = exp(x[0][1]); >+ result[0][2] = exp(x[0][2]); >+ result[1][0] = exp(x[1][0]); >+ result[1][1] = exp(x[1][1]); >+ result[1][2] = exp(x[1][2]); >+ result[2][0] = exp(x[2][0]); >+ result[2][1] = exp(x[2][1]); >+ result[2][2] = exp(x[2][2]); >+ result[3][0] = exp(x[3][0]); >+ result[3][1] = exp(x[3][1]); >+ result[3][2] = exp(x[3][2]); >+ return result; >+} >+float4x4 exp(float4x4 x) { >+ float4x4 result; >+ result[0][0] = exp(x[0][0]); >+ result[0][1] = exp(x[0][1]); >+ result[0][2] = exp(x[0][2]); >+ result[0][3] = exp(x[0][3]); >+ result[1][0] = exp(x[1][0]); >+ result[1][1] = exp(x[1][1]); >+ result[1][2] = exp(x[1][2]); >+ result[1][3] = exp(x[1][3]); >+ result[2][0] = exp(x[2][0]); >+ result[2][1] = exp(x[2][1]); >+ result[2][2] = exp(x[2][2]); >+ result[2][3] = exp(x[2][3]); >+ result[3][0] = exp(x[3][0]); >+ result[3][1] = exp(x[3][1]); >+ result[3][2] = exp(x[3][2]); >+ result[3][3] = exp(x[3][3]); >+ return result; >+} >+float2 floor(float2 x) { >+ float2 result; >+ result[0] = floor(x[0]); >+ result[1] = floor(x[1]); >+ return result; >+} >+float3 floor(float3 x) { >+ float3 result; >+ result[0] = floor(x[0]); >+ result[1] = floor(x[1]); >+ result[2] = floor(x[2]); >+ return result; >+} >+float4 floor(float4 x) { >+ float4 result; >+ result[0] = floor(x[0]); >+ result[1] = floor(x[1]); >+ result[2] = floor(x[2]); >+ result[3] = floor(x[3]); >+ return result; >+} >+float2x2 floor(float2x2 x) { >+ float2x2 result; >+ result[0][0] = floor(x[0][0]); >+ result[0][1] = floor(x[0][1]); >+ result[1][0] = floor(x[1][0]); >+ result[1][1] = floor(x[1][1]); >+ return result; >+} >+float2x3 floor(float2x3 x) { >+ float2x3 result; >+ result[0][0] = floor(x[0][0]); >+ result[0][1] = floor(x[0][1]); >+ result[0][2] = floor(x[0][2]); >+ result[1][0] = floor(x[1][0]); >+ result[1][1] = floor(x[1][1]); >+ result[1][2] = floor(x[1][2]); >+ return result; >+} >+float2x4 floor(float2x4 x) { >+ float2x4 result; >+ result[0][0] = floor(x[0][0]); >+ result[0][1] = floor(x[0][1]); >+ result[0][2] = floor(x[0][2]); >+ result[0][3] = floor(x[0][3]); >+ result[1][0] = floor(x[1][0]); >+ result[1][1] = floor(x[1][1]); >+ result[1][2] = floor(x[1][2]); >+ result[1][3] = floor(x[1][3]); >+ return result; >+} >+float3x2 floor(float3x2 x) { >+ float3x2 result; >+ result[0][0] = floor(x[0][0]); >+ result[0][1] = floor(x[0][1]); >+ result[1][0] = floor(x[1][0]); >+ result[1][1] = floor(x[1][1]); >+ result[2][0] = floor(x[2][0]); >+ result[2][1] = floor(x[2][1]); >+ return result; >+} >+float3x3 floor(float3x3 x) { >+ float3x3 result; >+ result[0][0] = floor(x[0][0]); >+ result[0][1] = floor(x[0][1]); >+ result[0][2] = floor(x[0][2]); >+ result[1][0] = floor(x[1][0]); >+ result[1][1] = floor(x[1][1]); >+ result[1][2] = floor(x[1][2]); >+ result[2][0] = floor(x[2][0]); >+ result[2][1] = floor(x[2][1]); >+ result[2][2] = floor(x[2][2]); >+ return result; >+} >+float3x4 floor(float3x4 x) { >+ float3x4 result; >+ result[0][0] = floor(x[0][0]); >+ result[0][1] = floor(x[0][1]); >+ result[0][2] = floor(x[0][2]); >+ result[0][3] = floor(x[0][3]); >+ result[1][0] = floor(x[1][0]); >+ result[1][1] = floor(x[1][1]); >+ result[1][2] = floor(x[1][2]); >+ result[1][3] = floor(x[1][3]); >+ result[2][0] = floor(x[2][0]); >+ result[2][1] = floor(x[2][1]); >+ result[2][2] = floor(x[2][2]); >+ result[2][3] = floor(x[2][3]); >+ return result; >+} >+float4x2 floor(float4x2 x) { >+ float4x2 result; >+ result[0][0] = floor(x[0][0]); >+ result[0][1] = floor(x[0][1]); >+ result[1][0] = floor(x[1][0]); >+ result[1][1] = floor(x[1][1]); >+ result[2][0] = floor(x[2][0]); >+ result[2][1] = floor(x[2][1]); >+ result[3][0] = floor(x[3][0]); >+ result[3][1] = floor(x[3][1]); >+ return result; >+} >+float4x3 floor(float4x3 x) { >+ float4x3 result; >+ result[0][0] = floor(x[0][0]); >+ result[0][1] = floor(x[0][1]); >+ result[0][2] = floor(x[0][2]); >+ result[1][0] = floor(x[1][0]); >+ result[1][1] = floor(x[1][1]); >+ result[1][2] = floor(x[1][2]); >+ result[2][0] = floor(x[2][0]); >+ result[2][1] = floor(x[2][1]); >+ result[2][2] = floor(x[2][2]); >+ result[3][0] = floor(x[3][0]); >+ result[3][1] = floor(x[3][1]); >+ result[3][2] = floor(x[3][2]); >+ return result; >+} >+float4x4 floor(float4x4 x) { >+ float4x4 result; >+ result[0][0] = floor(x[0][0]); >+ result[0][1] = floor(x[0][1]); >+ result[0][2] = floor(x[0][2]); >+ result[0][3] = floor(x[0][3]); >+ result[1][0] = floor(x[1][0]); >+ result[1][1] = floor(x[1][1]); >+ result[1][2] = floor(x[1][2]); >+ result[1][3] = floor(x[1][3]); >+ result[2][0] = floor(x[2][0]); >+ result[2][1] = floor(x[2][1]); >+ result[2][2] = floor(x[2][2]); >+ result[2][3] = floor(x[2][3]); >+ result[3][0] = floor(x[3][0]); >+ result[3][1] = floor(x[3][1]); >+ result[3][2] = floor(x[3][2]); >+ result[3][3] = floor(x[3][3]); >+ return result; >+} >+float2 log(float2 x) { >+ float2 result; >+ result[0] = log(x[0]); >+ result[1] = log(x[1]); >+ return result; >+} >+float3 log(float3 x) { >+ float3 result; >+ result[0] = log(x[0]); >+ result[1] = log(x[1]); >+ result[2] = log(x[2]); >+ return result; >+} >+float4 log(float4 x) { >+ float4 result; >+ result[0] = log(x[0]); >+ result[1] = log(x[1]); >+ result[2] = log(x[2]); >+ result[3] = log(x[3]); >+ return result; >+} >+float2x2 log(float2x2 x) { >+ float2x2 result; >+ result[0][0] = log(x[0][0]); >+ result[0][1] = log(x[0][1]); >+ result[1][0] = log(x[1][0]); >+ result[1][1] = log(x[1][1]); >+ return result; >+} >+float2x3 log(float2x3 x) { >+ float2x3 result; >+ result[0][0] = log(x[0][0]); >+ result[0][1] = log(x[0][1]); >+ result[0][2] = log(x[0][2]); >+ result[1][0] = log(x[1][0]); >+ result[1][1] = log(x[1][1]); >+ result[1][2] = log(x[1][2]); >+ return result; >+} >+float2x4 log(float2x4 x) { >+ float2x4 result; >+ result[0][0] = log(x[0][0]); >+ result[0][1] = log(x[0][1]); >+ result[0][2] = log(x[0][2]); >+ result[0][3] = log(x[0][3]); >+ result[1][0] = log(x[1][0]); >+ result[1][1] = log(x[1][1]); >+ result[1][2] = log(x[1][2]); >+ result[1][3] = log(x[1][3]); >+ return result; >+} >+float3x2 log(float3x2 x) { >+ float3x2 result; >+ result[0][0] = log(x[0][0]); >+ result[0][1] = log(x[0][1]); >+ result[1][0] = log(x[1][0]); >+ result[1][1] = log(x[1][1]); >+ result[2][0] = log(x[2][0]); >+ result[2][1] = log(x[2][1]); >+ return result; >+} >+float3x3 log(float3x3 x) { >+ float3x3 result; >+ result[0][0] = log(x[0][0]); >+ result[0][1] = log(x[0][1]); >+ result[0][2] = log(x[0][2]); >+ result[1][0] = log(x[1][0]); >+ result[1][1] = log(x[1][1]); >+ result[1][2] = log(x[1][2]); >+ result[2][0] = log(x[2][0]); >+ result[2][1] = log(x[2][1]); >+ result[2][2] = log(x[2][2]); >+ return result; >+} >+float3x4 log(float3x4 x) { >+ float3x4 result; >+ result[0][0] = log(x[0][0]); >+ result[0][1] = log(x[0][1]); >+ result[0][2] = log(x[0][2]); >+ result[0][3] = log(x[0][3]); >+ result[1][0] = log(x[1][0]); >+ result[1][1] = log(x[1][1]); >+ result[1][2] = log(x[1][2]); >+ result[1][3] = log(x[1][3]); >+ result[2][0] = log(x[2][0]); >+ result[2][1] = log(x[2][1]); >+ result[2][2] = log(x[2][2]); >+ result[2][3] = log(x[2][3]); >+ return result; >+} >+float4x2 log(float4x2 x) { >+ float4x2 result; >+ result[0][0] = log(x[0][0]); >+ result[0][1] = log(x[0][1]); >+ result[1][0] = log(x[1][0]); >+ result[1][1] = log(x[1][1]); >+ result[2][0] = log(x[2][0]); >+ result[2][1] = log(x[2][1]); >+ result[3][0] = log(x[3][0]); >+ result[3][1] = log(x[3][1]); >+ return result; >+} >+float4x3 log(float4x3 x) { >+ float4x3 result; >+ result[0][0] = log(x[0][0]); >+ result[0][1] = log(x[0][1]); >+ result[0][2] = log(x[0][2]); >+ result[1][0] = log(x[1][0]); >+ result[1][1] = log(x[1][1]); >+ result[1][2] = log(x[1][2]); >+ result[2][0] = log(x[2][0]); >+ result[2][1] = log(x[2][1]); >+ result[2][2] = log(x[2][2]); >+ result[3][0] = log(x[3][0]); >+ result[3][1] = log(x[3][1]); >+ result[3][2] = log(x[3][2]); >+ return result; >+} >+float4x4 log(float4x4 x) { >+ float4x4 result; >+ result[0][0] = log(x[0][0]); >+ result[0][1] = log(x[0][1]); >+ result[0][2] = log(x[0][2]); >+ result[0][3] = log(x[0][3]); >+ result[1][0] = log(x[1][0]); >+ result[1][1] = log(x[1][1]); >+ result[1][2] = log(x[1][2]); >+ result[1][3] = log(x[1][3]); >+ result[2][0] = log(x[2][0]); >+ result[2][1] = log(x[2][1]); >+ result[2][2] = log(x[2][2]); >+ result[2][3] = log(x[2][3]); >+ result[3][0] = log(x[3][0]); >+ result[3][1] = log(x[3][1]); >+ result[3][2] = log(x[3][2]); >+ result[3][3] = log(x[3][3]); >+ return result; >+} >+float2 round(float2 x) { >+ float2 result; >+ result[0] = round(x[0]); >+ result[1] = round(x[1]); >+ return result; >+} >+float3 round(float3 x) { >+ float3 result; >+ result[0] = round(x[0]); >+ result[1] = round(x[1]); >+ result[2] = round(x[2]); >+ return result; >+} >+float4 round(float4 x) { >+ float4 result; >+ result[0] = round(x[0]); >+ result[1] = round(x[1]); >+ result[2] = round(x[2]); >+ result[3] = round(x[3]); >+ return result; >+} >+float2x2 round(float2x2 x) { >+ float2x2 result; >+ result[0][0] = round(x[0][0]); >+ result[0][1] = round(x[0][1]); >+ result[1][0] = round(x[1][0]); >+ result[1][1] = round(x[1][1]); >+ return result; >+} >+float2x3 round(float2x3 x) { >+ float2x3 result; >+ result[0][0] = round(x[0][0]); >+ result[0][1] = round(x[0][1]); >+ result[0][2] = round(x[0][2]); >+ result[1][0] = round(x[1][0]); >+ result[1][1] = round(x[1][1]); >+ result[1][2] = round(x[1][2]); >+ return result; >+} >+float2x4 round(float2x4 x) { >+ float2x4 result; >+ result[0][0] = round(x[0][0]); >+ result[0][1] = round(x[0][1]); >+ result[0][2] = round(x[0][2]); >+ result[0][3] = round(x[0][3]); >+ result[1][0] = round(x[1][0]); >+ result[1][1] = round(x[1][1]); >+ result[1][2] = round(x[1][2]); >+ result[1][3] = round(x[1][3]); >+ return result; >+} >+float3x2 round(float3x2 x) { >+ float3x2 result; >+ result[0][0] = round(x[0][0]); >+ result[0][1] = round(x[0][1]); >+ result[1][0] = round(x[1][0]); >+ result[1][1] = round(x[1][1]); >+ result[2][0] = round(x[2][0]); >+ result[2][1] = round(x[2][1]); >+ return result; >+} >+float3x3 round(float3x3 x) { >+ float3x3 result; >+ result[0][0] = round(x[0][0]); >+ result[0][1] = round(x[0][1]); >+ result[0][2] = round(x[0][2]); >+ result[1][0] = round(x[1][0]); >+ result[1][1] = round(x[1][1]); >+ result[1][2] = round(x[1][2]); >+ result[2][0] = round(x[2][0]); >+ result[2][1] = round(x[2][1]); >+ result[2][2] = round(x[2][2]); >+ return result; >+} >+float3x4 round(float3x4 x) { >+ float3x4 result; >+ result[0][0] = round(x[0][0]); >+ result[0][1] = round(x[0][1]); >+ result[0][2] = round(x[0][2]); >+ result[0][3] = round(x[0][3]); >+ result[1][0] = round(x[1][0]); >+ result[1][1] = round(x[1][1]); >+ result[1][2] = round(x[1][2]); >+ result[1][3] = round(x[1][3]); >+ result[2][0] = round(x[2][0]); >+ result[2][1] = round(x[2][1]); >+ result[2][2] = round(x[2][2]); >+ result[2][3] = round(x[2][3]); >+ return result; >+} >+float4x2 round(float4x2 x) { >+ float4x2 result; >+ result[0][0] = round(x[0][0]); >+ result[0][1] = round(x[0][1]); >+ result[1][0] = round(x[1][0]); >+ result[1][1] = round(x[1][1]); >+ result[2][0] = round(x[2][0]); >+ result[2][1] = round(x[2][1]); >+ result[3][0] = round(x[3][0]); >+ result[3][1] = round(x[3][1]); >+ return result; >+} >+float4x3 round(float4x3 x) { >+ float4x3 result; >+ result[0][0] = round(x[0][0]); >+ result[0][1] = round(x[0][1]); >+ result[0][2] = round(x[0][2]); >+ result[1][0] = round(x[1][0]); >+ result[1][1] = round(x[1][1]); >+ result[1][2] = round(x[1][2]); >+ result[2][0] = round(x[2][0]); >+ result[2][1] = round(x[2][1]); >+ result[2][2] = round(x[2][2]); >+ result[3][0] = round(x[3][0]); >+ result[3][1] = round(x[3][1]); >+ result[3][2] = round(x[3][2]); >+ return result; >+} >+float4x4 round(float4x4 x) { >+ float4x4 result; >+ result[0][0] = round(x[0][0]); >+ result[0][1] = round(x[0][1]); >+ result[0][2] = round(x[0][2]); >+ result[0][3] = round(x[0][3]); >+ result[1][0] = round(x[1][0]); >+ result[1][1] = round(x[1][1]); >+ result[1][2] = round(x[1][2]); >+ result[1][3] = round(x[1][3]); >+ result[2][0] = round(x[2][0]); >+ result[2][1] = round(x[2][1]); >+ result[2][2] = round(x[2][2]); >+ result[2][3] = round(x[2][3]); >+ result[3][0] = round(x[3][0]); >+ result[3][1] = round(x[3][1]); >+ result[3][2] = round(x[3][2]); >+ result[3][3] = round(x[3][3]); >+ return result; >+} >+float2 trunc(float2 x) { >+ float2 result; >+ result[0] = trunc(x[0]); >+ result[1] = trunc(x[1]); >+ return result; >+} >+float3 trunc(float3 x) { >+ float3 result; >+ result[0] = trunc(x[0]); >+ result[1] = trunc(x[1]); >+ result[2] = trunc(x[2]); >+ return result; >+} >+float4 trunc(float4 x) { >+ float4 result; >+ result[0] = trunc(x[0]); >+ result[1] = trunc(x[1]); >+ result[2] = trunc(x[2]); >+ result[3] = trunc(x[3]); >+ return result; >+} >+float2x2 trunc(float2x2 x) { >+ float2x2 result; >+ result[0][0] = trunc(x[0][0]); >+ result[0][1] = trunc(x[0][1]); >+ result[1][0] = trunc(x[1][0]); >+ result[1][1] = trunc(x[1][1]); >+ return result; >+} >+float2x3 trunc(float2x3 x) { >+ float2x3 result; >+ result[0][0] = trunc(x[0][0]); >+ result[0][1] = trunc(x[0][1]); >+ result[0][2] = trunc(x[0][2]); >+ result[1][0] = trunc(x[1][0]); >+ result[1][1] = trunc(x[1][1]); >+ result[1][2] = trunc(x[1][2]); >+ return result; >+} >+float2x4 trunc(float2x4 x) { >+ float2x4 result; >+ result[0][0] = trunc(x[0][0]); >+ result[0][1] = trunc(x[0][1]); >+ result[0][2] = trunc(x[0][2]); >+ result[0][3] = trunc(x[0][3]); >+ result[1][0] = trunc(x[1][0]); >+ result[1][1] = trunc(x[1][1]); >+ result[1][2] = trunc(x[1][2]); >+ result[1][3] = trunc(x[1][3]); >+ return result; >+} >+float3x2 trunc(float3x2 x) { >+ float3x2 result; >+ result[0][0] = trunc(x[0][0]); >+ result[0][1] = trunc(x[0][1]); >+ result[1][0] = trunc(x[1][0]); >+ result[1][1] = trunc(x[1][1]); >+ result[2][0] = trunc(x[2][0]); >+ result[2][1] = trunc(x[2][1]); >+ return result; >+} >+float3x3 trunc(float3x3 x) { >+ float3x3 result; >+ result[0][0] = trunc(x[0][0]); >+ result[0][1] = trunc(x[0][1]); >+ result[0][2] = trunc(x[0][2]); >+ result[1][0] = trunc(x[1][0]); >+ result[1][1] = trunc(x[1][1]); >+ result[1][2] = trunc(x[1][2]); >+ result[2][0] = trunc(x[2][0]); >+ result[2][1] = trunc(x[2][1]); >+ result[2][2] = trunc(x[2][2]); >+ return result; >+} >+float3x4 trunc(float3x4 x) { >+ float3x4 result; >+ result[0][0] = trunc(x[0][0]); >+ result[0][1] = trunc(x[0][1]); >+ result[0][2] = trunc(x[0][2]); >+ result[0][3] = trunc(x[0][3]); >+ result[1][0] = trunc(x[1][0]); >+ result[1][1] = trunc(x[1][1]); >+ result[1][2] = trunc(x[1][2]); >+ result[1][3] = trunc(x[1][3]); >+ result[2][0] = trunc(x[2][0]); >+ result[2][1] = trunc(x[2][1]); >+ result[2][2] = trunc(x[2][2]); >+ result[2][3] = trunc(x[2][3]); >+ return result; >+} >+float4x2 trunc(float4x2 x) { >+ float4x2 result; >+ result[0][0] = trunc(x[0][0]); >+ result[0][1] = trunc(x[0][1]); >+ result[1][0] = trunc(x[1][0]); >+ result[1][1] = trunc(x[1][1]); >+ result[2][0] = trunc(x[2][0]); >+ result[2][1] = trunc(x[2][1]); >+ result[3][0] = trunc(x[3][0]); >+ result[3][1] = trunc(x[3][1]); >+ return result; >+} >+float4x3 trunc(float4x3 x) { >+ float4x3 result; >+ result[0][0] = trunc(x[0][0]); >+ result[0][1] = trunc(x[0][1]); >+ result[0][2] = trunc(x[0][2]); >+ result[1][0] = trunc(x[1][0]); >+ result[1][1] = trunc(x[1][1]); >+ result[1][2] = trunc(x[1][2]); >+ result[2][0] = trunc(x[2][0]); >+ result[2][1] = trunc(x[2][1]); >+ result[2][2] = trunc(x[2][2]); >+ result[3][0] = trunc(x[3][0]); >+ result[3][1] = trunc(x[3][1]); >+ result[3][2] = trunc(x[3][2]); >+ return result; >+} >+float4x4 trunc(float4x4 x) { >+ float4x4 result; >+ result[0][0] = trunc(x[0][0]); >+ result[0][1] = trunc(x[0][1]); >+ result[0][2] = trunc(x[0][2]); >+ result[0][3] = trunc(x[0][3]); >+ result[1][0] = trunc(x[1][0]); >+ result[1][1] = trunc(x[1][1]); >+ result[1][2] = trunc(x[1][2]); >+ result[1][3] = trunc(x[1][3]); >+ result[2][0] = trunc(x[2][0]); >+ result[2][1] = trunc(x[2][1]); >+ result[2][2] = trunc(x[2][2]); >+ result[2][3] = trunc(x[2][3]); >+ result[3][0] = trunc(x[3][0]); >+ result[3][1] = trunc(x[3][1]); >+ result[3][2] = trunc(x[3][2]); >+ result[3][3] = trunc(x[3][3]); >+ return result; >+} >+float2 ddx(float2 x) { >+ float2 result; >+ result[0] = ddx(x[0]); >+ result[1] = ddx(x[1]); >+ return result; >+} >+float3 ddx(float3 x) { >+ float3 result; >+ result[0] = ddx(x[0]); >+ result[1] = ddx(x[1]); >+ result[2] = ddx(x[2]); >+ return result; >+} >+float4 ddx(float4 x) { >+ float4 result; >+ result[0] = ddx(x[0]); >+ result[1] = ddx(x[1]); >+ result[2] = ddx(x[2]); >+ result[3] = ddx(x[3]); >+ return result; >+} >+float2x2 ddx(float2x2 x) { >+ float2x2 result; >+ result[0][0] = ddx(x[0][0]); >+ result[0][1] = ddx(x[0][1]); >+ result[1][0] = ddx(x[1][0]); >+ result[1][1] = ddx(x[1][1]); >+ return result; >+} >+float2x3 ddx(float2x3 x) { >+ float2x3 result; >+ result[0][0] = ddx(x[0][0]); >+ result[0][1] = ddx(x[0][1]); >+ result[0][2] = ddx(x[0][2]); >+ result[1][0] = ddx(x[1][0]); >+ result[1][1] = ddx(x[1][1]); >+ result[1][2] = ddx(x[1][2]); >+ return result; >+} >+float2x4 ddx(float2x4 x) { >+ float2x4 result; >+ result[0][0] = ddx(x[0][0]); >+ result[0][1] = ddx(x[0][1]); >+ result[0][2] = ddx(x[0][2]); >+ result[0][3] = ddx(x[0][3]); >+ result[1][0] = ddx(x[1][0]); >+ result[1][1] = ddx(x[1][1]); >+ result[1][2] = ddx(x[1][2]); >+ result[1][3] = ddx(x[1][3]); >+ return result; >+} >+float3x2 ddx(float3x2 x) { >+ float3x2 result; >+ result[0][0] = ddx(x[0][0]); >+ result[0][1] = ddx(x[0][1]); >+ result[1][0] = ddx(x[1][0]); >+ result[1][1] = ddx(x[1][1]); >+ result[2][0] = ddx(x[2][0]); >+ result[2][1] = ddx(x[2][1]); >+ return result; >+} >+float3x3 ddx(float3x3 x) { >+ float3x3 result; >+ result[0][0] = ddx(x[0][0]); >+ result[0][1] = ddx(x[0][1]); >+ result[0][2] = ddx(x[0][2]); >+ result[1][0] = ddx(x[1][0]); >+ result[1][1] = ddx(x[1][1]); >+ result[1][2] = ddx(x[1][2]); >+ result[2][0] = ddx(x[2][0]); >+ result[2][1] = ddx(x[2][1]); >+ result[2][2] = ddx(x[2][2]); >+ return result; >+} >+float3x4 ddx(float3x4 x) { >+ float3x4 result; >+ result[0][0] = ddx(x[0][0]); >+ result[0][1] = ddx(x[0][1]); >+ result[0][2] = ddx(x[0][2]); >+ result[0][3] = ddx(x[0][3]); >+ result[1][0] = ddx(x[1][0]); >+ result[1][1] = ddx(x[1][1]); >+ result[1][2] = ddx(x[1][2]); >+ result[1][3] = ddx(x[1][3]); >+ result[2][0] = ddx(x[2][0]); >+ result[2][1] = ddx(x[2][1]); >+ result[2][2] = ddx(x[2][2]); >+ result[2][3] = ddx(x[2][3]); >+ return result; >+} >+float4x2 ddx(float4x2 x) { >+ float4x2 result; >+ result[0][0] = ddx(x[0][0]); >+ result[0][1] = ddx(x[0][1]); >+ result[1][0] = ddx(x[1][0]); >+ result[1][1] = ddx(x[1][1]); >+ result[2][0] = ddx(x[2][0]); >+ result[2][1] = ddx(x[2][1]); >+ result[3][0] = ddx(x[3][0]); >+ result[3][1] = ddx(x[3][1]); >+ return result; >+} >+float4x3 ddx(float4x3 x) { >+ float4x3 result; >+ result[0][0] = ddx(x[0][0]); >+ result[0][1] = ddx(x[0][1]); >+ result[0][2] = ddx(x[0][2]); >+ result[1][0] = ddx(x[1][0]); >+ result[1][1] = ddx(x[1][1]); >+ result[1][2] = ddx(x[1][2]); >+ result[2][0] = ddx(x[2][0]); >+ result[2][1] = ddx(x[2][1]); >+ result[2][2] = ddx(x[2][2]); >+ result[3][0] = ddx(x[3][0]); >+ result[3][1] = ddx(x[3][1]); >+ result[3][2] = ddx(x[3][2]); >+ return result; >+} >+float4x4 ddx(float4x4 x) { >+ float4x4 result; >+ result[0][0] = ddx(x[0][0]); >+ result[0][1] = ddx(x[0][1]); >+ result[0][2] = ddx(x[0][2]); >+ result[0][3] = ddx(x[0][3]); >+ result[1][0] = ddx(x[1][0]); >+ result[1][1] = ddx(x[1][1]); >+ result[1][2] = ddx(x[1][2]); >+ result[1][3] = ddx(x[1][3]); >+ result[2][0] = ddx(x[2][0]); >+ result[2][1] = ddx(x[2][1]); >+ result[2][2] = ddx(x[2][2]); >+ result[2][3] = ddx(x[2][3]); >+ result[3][0] = ddx(x[3][0]); >+ result[3][1] = ddx(x[3][1]); >+ result[3][2] = ddx(x[3][2]); >+ result[3][3] = ddx(x[3][3]); >+ return result; >+} >+float2 ddy(float2 x) { >+ float2 result; >+ result[0] = ddy(x[0]); >+ result[1] = ddy(x[1]); >+ return result; >+} >+float3 ddy(float3 x) { >+ float3 result; >+ result[0] = ddy(x[0]); >+ result[1] = ddy(x[1]); >+ result[2] = ddy(x[2]); >+ return result; >+} >+float4 ddy(float4 x) { >+ float4 result; >+ result[0] = ddy(x[0]); >+ result[1] = ddy(x[1]); >+ result[2] = ddy(x[2]); >+ result[3] = ddy(x[3]); >+ return result; >+} >+float2x2 ddy(float2x2 x) { >+ float2x2 result; >+ result[0][0] = ddy(x[0][0]); >+ result[0][1] = ddy(x[0][1]); >+ result[1][0] = ddy(x[1][0]); >+ result[1][1] = ddy(x[1][1]); >+ return result; >+} >+float2x3 ddy(float2x3 x) { >+ float2x3 result; >+ result[0][0] = ddy(x[0][0]); >+ result[0][1] = ddy(x[0][1]); >+ result[0][2] = ddy(x[0][2]); >+ result[1][0] = ddy(x[1][0]); >+ result[1][1] = ddy(x[1][1]); >+ result[1][2] = ddy(x[1][2]); >+ return result; >+} >+float2x4 ddy(float2x4 x) { >+ float2x4 result; >+ result[0][0] = ddy(x[0][0]); >+ result[0][1] = ddy(x[0][1]); >+ result[0][2] = ddy(x[0][2]); >+ result[0][3] = ddy(x[0][3]); >+ result[1][0] = ddy(x[1][0]); >+ result[1][1] = ddy(x[1][1]); >+ result[1][2] = ddy(x[1][2]); >+ result[1][3] = ddy(x[1][3]); >+ return result; >+} >+float3x2 ddy(float3x2 x) { >+ float3x2 result; >+ result[0][0] = ddy(x[0][0]); >+ result[0][1] = ddy(x[0][1]); >+ result[1][0] = ddy(x[1][0]); >+ result[1][1] = ddy(x[1][1]); >+ result[2][0] = ddy(x[2][0]); >+ result[2][1] = ddy(x[2][1]); >+ return result; >+} >+float3x3 ddy(float3x3 x) { >+ float3x3 result; >+ result[0][0] = ddy(x[0][0]); >+ result[0][1] = ddy(x[0][1]); >+ result[0][2] = ddy(x[0][2]); >+ result[1][0] = ddy(x[1][0]); >+ result[1][1] = ddy(x[1][1]); >+ result[1][2] = ddy(x[1][2]); >+ result[2][0] = ddy(x[2][0]); >+ result[2][1] = ddy(x[2][1]); >+ result[2][2] = ddy(x[2][2]); >+ return result; >+} >+float3x4 ddy(float3x4 x) { >+ float3x4 result; >+ result[0][0] = ddy(x[0][0]); >+ result[0][1] = ddy(x[0][1]); >+ result[0][2] = ddy(x[0][2]); >+ result[0][3] = ddy(x[0][3]); >+ result[1][0] = ddy(x[1][0]); >+ result[1][1] = ddy(x[1][1]); >+ result[1][2] = ddy(x[1][2]); >+ result[1][3] = ddy(x[1][3]); >+ result[2][0] = ddy(x[2][0]); >+ result[2][1] = ddy(x[2][1]); >+ result[2][2] = ddy(x[2][2]); >+ result[2][3] = ddy(x[2][3]); >+ return result; >+} >+float4x2 ddy(float4x2 x) { >+ float4x2 result; >+ result[0][0] = ddy(x[0][0]); >+ result[0][1] = ddy(x[0][1]); >+ result[1][0] = ddy(x[1][0]); >+ result[1][1] = ddy(x[1][1]); >+ result[2][0] = ddy(x[2][0]); >+ result[2][1] = ddy(x[2][1]); >+ result[3][0] = ddy(x[3][0]); >+ result[3][1] = ddy(x[3][1]); >+ return result; >+} >+float4x3 ddy(float4x3 x) { >+ float4x3 result; >+ result[0][0] = ddy(x[0][0]); >+ result[0][1] = ddy(x[0][1]); >+ result[0][2] = ddy(x[0][2]); >+ result[1][0] = ddy(x[1][0]); >+ result[1][1] = ddy(x[1][1]); >+ result[1][2] = ddy(x[1][2]); >+ result[2][0] = ddy(x[2][0]); >+ result[2][1] = ddy(x[2][1]); >+ result[2][2] = ddy(x[2][2]); >+ result[3][0] = ddy(x[3][0]); >+ result[3][1] = ddy(x[3][1]); >+ result[3][2] = ddy(x[3][2]); >+ return result; >+} >+float4x4 ddy(float4x4 x) { >+ float4x4 result; >+ result[0][0] = ddy(x[0][0]); >+ result[0][1] = ddy(x[0][1]); >+ result[0][2] = ddy(x[0][2]); >+ result[0][3] = ddy(x[0][3]); >+ result[1][0] = ddy(x[1][0]); >+ result[1][1] = ddy(x[1][1]); >+ result[1][2] = ddy(x[1][2]); >+ result[1][3] = ddy(x[1][3]); >+ result[2][0] = ddy(x[2][0]); >+ result[2][1] = ddy(x[2][1]); >+ result[2][2] = ddy(x[2][2]); >+ result[2][3] = ddy(x[2][3]); >+ result[3][0] = ddy(x[3][0]); >+ result[3][1] = ddy(x[3][1]); >+ result[3][2] = ddy(x[3][2]); >+ result[3][3] = ddy(x[3][3]); >+ return result; >+} >+float2 sqrt(float2 x) { >+ float2 result; >+ result[0] = sqrt(x[0]); >+ result[1] = sqrt(x[1]); >+ return result; >+} >+float3 sqrt(float3 x) { >+ float3 result; >+ result[0] = sqrt(x[0]); >+ result[1] = sqrt(x[1]); >+ result[2] = sqrt(x[2]); >+ return result; >+} >+float4 sqrt(float4 x) { >+ float4 result; >+ result[0] = sqrt(x[0]); >+ result[1] = sqrt(x[1]); >+ result[2] = sqrt(x[2]); >+ result[3] = sqrt(x[3]); >+ return result; >+} >+float2x2 sqrt(float2x2 x) { >+ float2x2 result; >+ result[0][0] = sqrt(x[0][0]); >+ result[0][1] = sqrt(x[0][1]); >+ result[1][0] = sqrt(x[1][0]); >+ result[1][1] = sqrt(x[1][1]); >+ return result; >+} >+float2x3 sqrt(float2x3 x) { >+ float2x3 result; >+ result[0][0] = sqrt(x[0][0]); >+ result[0][1] = sqrt(x[0][1]); >+ result[0][2] = sqrt(x[0][2]); >+ result[1][0] = sqrt(x[1][0]); >+ result[1][1] = sqrt(x[1][1]); >+ result[1][2] = sqrt(x[1][2]); >+ return result; >+} >+float2x4 sqrt(float2x4 x) { >+ float2x4 result; >+ result[0][0] = sqrt(x[0][0]); >+ result[0][1] = sqrt(x[0][1]); >+ result[0][2] = sqrt(x[0][2]); >+ result[0][3] = sqrt(x[0][3]); >+ result[1][0] = sqrt(x[1][0]); >+ result[1][1] = sqrt(x[1][1]); >+ result[1][2] = sqrt(x[1][2]); >+ result[1][3] = sqrt(x[1][3]); >+ return result; >+} >+float3x2 sqrt(float3x2 x) { >+ float3x2 result; >+ result[0][0] = sqrt(x[0][0]); >+ result[0][1] = sqrt(x[0][1]); >+ result[1][0] = sqrt(x[1][0]); >+ result[1][1] = sqrt(x[1][1]); >+ result[2][0] = sqrt(x[2][0]); >+ result[2][1] = sqrt(x[2][1]); >+ return result; >+} >+float3x3 sqrt(float3x3 x) { >+ float3x3 result; >+ result[0][0] = sqrt(x[0][0]); >+ result[0][1] = sqrt(x[0][1]); >+ result[0][2] = sqrt(x[0][2]); >+ result[1][0] = sqrt(x[1][0]); >+ result[1][1] = sqrt(x[1][1]); >+ result[1][2] = sqrt(x[1][2]); >+ result[2][0] = sqrt(x[2][0]); >+ result[2][1] = sqrt(x[2][1]); >+ result[2][2] = sqrt(x[2][2]); >+ return result; >+} >+float3x4 sqrt(float3x4 x) { >+ float3x4 result; >+ result[0][0] = sqrt(x[0][0]); >+ result[0][1] = sqrt(x[0][1]); >+ result[0][2] = sqrt(x[0][2]); >+ result[0][3] = sqrt(x[0][3]); >+ result[1][0] = sqrt(x[1][0]); >+ result[1][1] = sqrt(x[1][1]); >+ result[1][2] = sqrt(x[1][2]); >+ result[1][3] = sqrt(x[1][3]); >+ result[2][0] = sqrt(x[2][0]); >+ result[2][1] = sqrt(x[2][1]); >+ result[2][2] = sqrt(x[2][2]); >+ result[2][3] = sqrt(x[2][3]); >+ return result; >+} >+float4x2 sqrt(float4x2 x) { >+ float4x2 result; >+ result[0][0] = sqrt(x[0][0]); >+ result[0][1] = sqrt(x[0][1]); >+ result[1][0] = sqrt(x[1][0]); >+ result[1][1] = sqrt(x[1][1]); >+ result[2][0] = sqrt(x[2][0]); >+ result[2][1] = sqrt(x[2][1]); >+ result[3][0] = sqrt(x[3][0]); >+ result[3][1] = sqrt(x[3][1]); >+ return result; >+} >+float4x3 sqrt(float4x3 x) { >+ float4x3 result; >+ result[0][0] = sqrt(x[0][0]); >+ result[0][1] = sqrt(x[0][1]); >+ result[0][2] = sqrt(x[0][2]); >+ result[1][0] = sqrt(x[1][0]); >+ result[1][1] = sqrt(x[1][1]); >+ result[1][2] = sqrt(x[1][2]); >+ result[2][0] = sqrt(x[2][0]); >+ result[2][1] = sqrt(x[2][1]); >+ result[2][2] = sqrt(x[2][2]); >+ result[3][0] = sqrt(x[3][0]); >+ result[3][1] = sqrt(x[3][1]); >+ result[3][2] = sqrt(x[3][2]); >+ return result; >+} >+float4x4 sqrt(float4x4 x) { >+ float4x4 result; >+ result[0][0] = sqrt(x[0][0]); >+ result[0][1] = sqrt(x[0][1]); >+ result[0][2] = sqrt(x[0][2]); >+ result[0][3] = sqrt(x[0][3]); >+ result[1][0] = sqrt(x[1][0]); >+ result[1][1] = sqrt(x[1][1]); >+ result[1][2] = sqrt(x[1][2]); >+ result[1][3] = sqrt(x[1][3]); >+ result[2][0] = sqrt(x[2][0]); >+ result[2][1] = sqrt(x[2][1]); >+ result[2][2] = sqrt(x[2][2]); >+ result[2][3] = sqrt(x[2][3]); >+ result[3][0] = sqrt(x[3][0]); >+ result[3][1] = sqrt(x[3][1]); >+ result[3][2] = sqrt(x[3][2]); >+ result[3][3] = sqrt(x[3][3]); >+ return result; >+} >+float2 log2(float2 x) { >+ float2 result; >+ result[0] = log2(x[0]); >+ result[1] = log2(x[1]); >+ return result; >+} >+float3 log2(float3 x) { >+ float3 result; >+ result[0] = log2(x[0]); >+ result[1] = log2(x[1]); >+ result[2] = log2(x[2]); >+ return result; >+} >+float4 log2(float4 x) { >+ float4 result; >+ result[0] = log2(x[0]); >+ result[1] = log2(x[1]); >+ result[2] = log2(x[2]); >+ result[3] = log2(x[3]); >+ return result; >+} >+float2x2 log2(float2x2 x) { >+ float2x2 result; >+ result[0][0] = log2(x[0][0]); >+ result[0][1] = log2(x[0][1]); >+ result[1][0] = log2(x[1][0]); >+ result[1][1] = log2(x[1][1]); >+ return result; >+} >+float2x3 log2(float2x3 x) { >+ float2x3 result; >+ result[0][0] = log2(x[0][0]); >+ result[0][1] = log2(x[0][1]); >+ result[0][2] = log2(x[0][2]); >+ result[1][0] = log2(x[1][0]); >+ result[1][1] = log2(x[1][1]); >+ result[1][2] = log2(x[1][2]); >+ return result; >+} >+float2x4 log2(float2x4 x) { >+ float2x4 result; >+ result[0][0] = log2(x[0][0]); >+ result[0][1] = log2(x[0][1]); >+ result[0][2] = log2(x[0][2]); >+ result[0][3] = log2(x[0][3]); >+ result[1][0] = log2(x[1][0]); >+ result[1][1] = log2(x[1][1]); >+ result[1][2] = log2(x[1][2]); >+ result[1][3] = log2(x[1][3]); >+ return result; >+} >+float3x2 log2(float3x2 x) { >+ float3x2 result; >+ result[0][0] = log2(x[0][0]); >+ result[0][1] = log2(x[0][1]); >+ result[1][0] = log2(x[1][0]); >+ result[1][1] = log2(x[1][1]); >+ result[2][0] = log2(x[2][0]); >+ result[2][1] = log2(x[2][1]); >+ return result; >+} >+float3x3 log2(float3x3 x) { >+ float3x3 result; >+ result[0][0] = log2(x[0][0]); >+ result[0][1] = log2(x[0][1]); >+ result[0][2] = log2(x[0][2]); >+ result[1][0] = log2(x[1][0]); >+ result[1][1] = log2(x[1][1]); >+ result[1][2] = log2(x[1][2]); >+ result[2][0] = log2(x[2][0]); >+ result[2][1] = log2(x[2][1]); >+ result[2][2] = log2(x[2][2]); >+ return result; >+} >+float3x4 log2(float3x4 x) { >+ float3x4 result; >+ result[0][0] = log2(x[0][0]); >+ result[0][1] = log2(x[0][1]); >+ result[0][2] = log2(x[0][2]); >+ result[0][3] = log2(x[0][3]); >+ result[1][0] = log2(x[1][0]); >+ result[1][1] = log2(x[1][1]); >+ result[1][2] = log2(x[1][2]); >+ result[1][3] = log2(x[1][3]); >+ result[2][0] = log2(x[2][0]); >+ result[2][1] = log2(x[2][1]); >+ result[2][2] = log2(x[2][2]); >+ result[2][3] = log2(x[2][3]); >+ return result; >+} >+float4x2 log2(float4x2 x) { >+ float4x2 result; >+ result[0][0] = log2(x[0][0]); >+ result[0][1] = log2(x[0][1]); >+ result[1][0] = log2(x[1][0]); >+ result[1][1] = log2(x[1][1]); >+ result[2][0] = log2(x[2][0]); >+ result[2][1] = log2(x[2][1]); >+ result[3][0] = log2(x[3][0]); >+ result[3][1] = log2(x[3][1]); >+ return result; >+} >+float4x3 log2(float4x3 x) { >+ float4x3 result; >+ result[0][0] = log2(x[0][0]); >+ result[0][1] = log2(x[0][1]); >+ result[0][2] = log2(x[0][2]); >+ result[1][0] = log2(x[1][0]); >+ result[1][1] = log2(x[1][1]); >+ result[1][2] = log2(x[1][2]); >+ result[2][0] = log2(x[2][0]); >+ result[2][1] = log2(x[2][1]); >+ result[2][2] = log2(x[2][2]); >+ result[3][0] = log2(x[3][0]); >+ result[3][1] = log2(x[3][1]); >+ result[3][2] = log2(x[3][2]); >+ return result; >+} >+float4x4 log2(float4x4 x) { >+ float4x4 result; >+ result[0][0] = log2(x[0][0]); >+ result[0][1] = log2(x[0][1]); >+ result[0][2] = log2(x[0][2]); >+ result[0][3] = log2(x[0][3]); >+ result[1][0] = log2(x[1][0]); >+ result[1][1] = log2(x[1][1]); >+ result[1][2] = log2(x[1][2]); >+ result[1][3] = log2(x[1][3]); >+ result[2][0] = log2(x[2][0]); >+ result[2][1] = log2(x[2][1]); >+ result[2][2] = log2(x[2][2]); >+ result[2][3] = log2(x[2][3]); >+ result[3][0] = log2(x[3][0]); >+ result[3][1] = log2(x[3][1]); >+ result[3][2] = log2(x[3][2]); >+ result[3][3] = log2(x[3][3]); >+ return result; >+} >+float2 log10(float2 x) { >+ float2 result; >+ result[0] = log10(x[0]); >+ result[1] = log10(x[1]); >+ return result; >+} >+float3 log10(float3 x) { >+ float3 result; >+ result[0] = log10(x[0]); >+ result[1] = log10(x[1]); >+ result[2] = log10(x[2]); >+ return result; >+} >+float4 log10(float4 x) { >+ float4 result; >+ result[0] = log10(x[0]); >+ result[1] = log10(x[1]); >+ result[2] = log10(x[2]); >+ result[3] = log10(x[3]); >+ return result; >+} >+float2x2 log10(float2x2 x) { >+ float2x2 result; >+ result[0][0] = log10(x[0][0]); >+ result[0][1] = log10(x[0][1]); >+ result[1][0] = log10(x[1][0]); >+ result[1][1] = log10(x[1][1]); >+ return result; >+} >+float2x3 log10(float2x3 x) { >+ float2x3 result; >+ result[0][0] = log10(x[0][0]); >+ result[0][1] = log10(x[0][1]); >+ result[0][2] = log10(x[0][2]); >+ result[1][0] = log10(x[1][0]); >+ result[1][1] = log10(x[1][1]); >+ result[1][2] = log10(x[1][2]); >+ return result; >+} >+float2x4 log10(float2x4 x) { >+ float2x4 result; >+ result[0][0] = log10(x[0][0]); >+ result[0][1] = log10(x[0][1]); >+ result[0][2] = log10(x[0][2]); >+ result[0][3] = log10(x[0][3]); >+ result[1][0] = log10(x[1][0]); >+ result[1][1] = log10(x[1][1]); >+ result[1][2] = log10(x[1][2]); >+ result[1][3] = log10(x[1][3]); >+ return result; >+} >+float3x2 log10(float3x2 x) { >+ float3x2 result; >+ result[0][0] = log10(x[0][0]); >+ result[0][1] = log10(x[0][1]); >+ result[1][0] = log10(x[1][0]); >+ result[1][1] = log10(x[1][1]); >+ result[2][0] = log10(x[2][0]); >+ result[2][1] = log10(x[2][1]); >+ return result; >+} >+float3x3 log10(float3x3 x) { >+ float3x3 result; >+ result[0][0] = log10(x[0][0]); >+ result[0][1] = log10(x[0][1]); >+ result[0][2] = log10(x[0][2]); >+ result[1][0] = log10(x[1][0]); >+ result[1][1] = log10(x[1][1]); >+ result[1][2] = log10(x[1][2]); >+ result[2][0] = log10(x[2][0]); >+ result[2][1] = log10(x[2][1]); >+ result[2][2] = log10(x[2][2]); >+ return result; >+} >+float3x4 log10(float3x4 x) { >+ float3x4 result; >+ result[0][0] = log10(x[0][0]); >+ result[0][1] = log10(x[0][1]); >+ result[0][2] = log10(x[0][2]); >+ result[0][3] = log10(x[0][3]); >+ result[1][0] = log10(x[1][0]); >+ result[1][1] = log10(x[1][1]); >+ result[1][2] = log10(x[1][2]); >+ result[1][3] = log10(x[1][3]); >+ result[2][0] = log10(x[2][0]); >+ result[2][1] = log10(x[2][1]); >+ result[2][2] = log10(x[2][2]); >+ result[2][3] = log10(x[2][3]); >+ return result; >+} >+float4x2 log10(float4x2 x) { >+ float4x2 result; >+ result[0][0] = log10(x[0][0]); >+ result[0][1] = log10(x[0][1]); >+ result[1][0] = log10(x[1][0]); >+ result[1][1] = log10(x[1][1]); >+ result[2][0] = log10(x[2][0]); >+ result[2][1] = log10(x[2][1]); >+ result[3][0] = log10(x[3][0]); >+ result[3][1] = log10(x[3][1]); >+ return result; >+} >+float4x3 log10(float4x3 x) { >+ float4x3 result; >+ result[0][0] = log10(x[0][0]); >+ result[0][1] = log10(x[0][1]); >+ result[0][2] = log10(x[0][2]); >+ result[1][0] = log10(x[1][0]); >+ result[1][1] = log10(x[1][1]); >+ result[1][2] = log10(x[1][2]); >+ result[2][0] = log10(x[2][0]); >+ result[2][1] = log10(x[2][1]); >+ result[2][2] = log10(x[2][2]); >+ result[3][0] = log10(x[3][0]); >+ result[3][1] = log10(x[3][1]); >+ result[3][2] = log10(x[3][2]); >+ return result; >+} >+float4x4 log10(float4x4 x) { >+ float4x4 result; >+ result[0][0] = log10(x[0][0]); >+ result[0][1] = log10(x[0][1]); >+ result[0][2] = log10(x[0][2]); >+ result[0][3] = log10(x[0][3]); >+ result[1][0] = log10(x[1][0]); >+ result[1][1] = log10(x[1][1]); >+ result[1][2] = log10(x[1][2]); >+ result[1][3] = log10(x[1][3]); >+ result[2][0] = log10(x[2][0]); >+ result[2][1] = log10(x[2][1]); >+ result[2][2] = log10(x[2][2]); >+ result[2][3] = log10(x[2][3]); >+ result[3][0] = log10(x[3][0]); >+ result[3][1] = log10(x[3][1]); >+ result[3][2] = log10(x[3][2]); >+ result[3][3] = log10(x[3][3]); >+ return result; >+} >+float2 frac(float2 x) { >+ float2 result; >+ result[0] = frac(x[0]); >+ result[1] = frac(x[1]); >+ return result; >+} >+float3 frac(float3 x) { >+ float3 result; >+ result[0] = frac(x[0]); >+ result[1] = frac(x[1]); >+ result[2] = frac(x[2]); >+ return result; >+} >+float4 frac(float4 x) { >+ float4 result; >+ result[0] = frac(x[0]); >+ result[1] = frac(x[1]); >+ result[2] = frac(x[2]); >+ result[3] = frac(x[3]); >+ return result; >+} >+float2x2 frac(float2x2 x) { >+ float2x2 result; >+ result[0][0] = frac(x[0][0]); >+ result[0][1] = frac(x[0][1]); >+ result[1][0] = frac(x[1][0]); >+ result[1][1] = frac(x[1][1]); >+ return result; >+} >+float2x3 frac(float2x3 x) { >+ float2x3 result; >+ result[0][0] = frac(x[0][0]); >+ result[0][1] = frac(x[0][1]); >+ result[0][2] = frac(x[0][2]); >+ result[1][0] = frac(x[1][0]); >+ result[1][1] = frac(x[1][1]); >+ result[1][2] = frac(x[1][2]); >+ return result; >+} >+float2x4 frac(float2x4 x) { >+ float2x4 result; >+ result[0][0] = frac(x[0][0]); >+ result[0][1] = frac(x[0][1]); >+ result[0][2] = frac(x[0][2]); >+ result[0][3] = frac(x[0][3]); >+ result[1][0] = frac(x[1][0]); >+ result[1][1] = frac(x[1][1]); >+ result[1][2] = frac(x[1][2]); >+ result[1][3] = frac(x[1][3]); >+ return result; >+} >+float3x2 frac(float3x2 x) { >+ float3x2 result; >+ result[0][0] = frac(x[0][0]); >+ result[0][1] = frac(x[0][1]); >+ result[1][0] = frac(x[1][0]); >+ result[1][1] = frac(x[1][1]); >+ result[2][0] = frac(x[2][0]); >+ result[2][1] = frac(x[2][1]); >+ return result; >+} >+float3x3 frac(float3x3 x) { >+ float3x3 result; >+ result[0][0] = frac(x[0][0]); >+ result[0][1] = frac(x[0][1]); >+ result[0][2] = frac(x[0][2]); >+ result[1][0] = frac(x[1][0]); >+ result[1][1] = frac(x[1][1]); >+ result[1][2] = frac(x[1][2]); >+ result[2][0] = frac(x[2][0]); >+ result[2][1] = frac(x[2][1]); >+ result[2][2] = frac(x[2][2]); >+ return result; >+} >+float3x4 frac(float3x4 x) { >+ float3x4 result; >+ result[0][0] = frac(x[0][0]); >+ result[0][1] = frac(x[0][1]); >+ result[0][2] = frac(x[0][2]); >+ result[0][3] = frac(x[0][3]); >+ result[1][0] = frac(x[1][0]); >+ result[1][1] = frac(x[1][1]); >+ result[1][2] = frac(x[1][2]); >+ result[1][3] = frac(x[1][3]); >+ result[2][0] = frac(x[2][0]); >+ result[2][1] = frac(x[2][1]); >+ result[2][2] = frac(x[2][2]); >+ result[2][3] = frac(x[2][3]); >+ return result; >+} >+float4x2 frac(float4x2 x) { >+ float4x2 result; >+ result[0][0] = frac(x[0][0]); >+ result[0][1] = frac(x[0][1]); >+ result[1][0] = frac(x[1][0]); >+ result[1][1] = frac(x[1][1]); >+ result[2][0] = frac(x[2][0]); >+ result[2][1] = frac(x[2][1]); >+ result[3][0] = frac(x[3][0]); >+ result[3][1] = frac(x[3][1]); >+ return result; >+} >+float4x3 frac(float4x3 x) { >+ float4x3 result; >+ result[0][0] = frac(x[0][0]); >+ result[0][1] = frac(x[0][1]); >+ result[0][2] = frac(x[0][2]); >+ result[1][0] = frac(x[1][0]); >+ result[1][1] = frac(x[1][1]); >+ result[1][2] = frac(x[1][2]); >+ result[2][0] = frac(x[2][0]); >+ result[2][1] = frac(x[2][1]); >+ result[2][2] = frac(x[2][2]); >+ result[3][0] = frac(x[3][0]); >+ result[3][1] = frac(x[3][1]); >+ result[3][2] = frac(x[3][2]); >+ return result; >+} >+float4x4 frac(float4x4 x) { >+ float4x4 result; >+ result[0][0] = frac(x[0][0]); >+ result[0][1] = frac(x[0][1]); >+ result[0][2] = frac(x[0][2]); >+ result[0][3] = frac(x[0][3]); >+ result[1][0] = frac(x[1][0]); >+ result[1][1] = frac(x[1][1]); >+ result[1][2] = frac(x[1][2]); >+ result[1][3] = frac(x[1][3]); >+ result[2][0] = frac(x[2][0]); >+ result[2][1] = frac(x[2][1]); >+ result[2][2] = frac(x[2][2]); >+ result[2][3] = frac(x[2][3]); >+ result[3][0] = frac(x[3][0]); >+ result[3][1] = frac(x[3][1]); >+ result[3][2] = frac(x[3][2]); >+ result[3][3] = frac(x[3][3]); >+ return result; >+} >+float2 exp2(float2 x) { >+ float2 result; >+ result[0] = exp2(x[0]); >+ result[1] = exp2(x[1]); >+ return result; >+} >+float3 exp2(float3 x) { >+ float3 result; >+ result[0] = exp2(x[0]); >+ result[1] = exp2(x[1]); >+ result[2] = exp2(x[2]); >+ return result; >+} >+float4 exp2(float4 x) { >+ float4 result; >+ result[0] = exp2(x[0]); >+ result[1] = exp2(x[1]); >+ result[2] = exp2(x[2]); >+ result[3] = exp2(x[3]); >+ return result; >+} >+float2x2 exp2(float2x2 x) { >+ float2x2 result; >+ result[0][0] = exp2(x[0][0]); >+ result[0][1] = exp2(x[0][1]); >+ result[1][0] = exp2(x[1][0]); >+ result[1][1] = exp2(x[1][1]); >+ return result; >+} >+float2x3 exp2(float2x3 x) { >+ float2x3 result; >+ result[0][0] = exp2(x[0][0]); >+ result[0][1] = exp2(x[0][1]); >+ result[0][2] = exp2(x[0][2]); >+ result[1][0] = exp2(x[1][0]); >+ result[1][1] = exp2(x[1][1]); >+ result[1][2] = exp2(x[1][2]); >+ return result; >+} >+float2x4 exp2(float2x4 x) { >+ float2x4 result; >+ result[0][0] = exp2(x[0][0]); >+ result[0][1] = exp2(x[0][1]); >+ result[0][2] = exp2(x[0][2]); >+ result[0][3] = exp2(x[0][3]); >+ result[1][0] = exp2(x[1][0]); >+ result[1][1] = exp2(x[1][1]); >+ result[1][2] = exp2(x[1][2]); >+ result[1][3] = exp2(x[1][3]); >+ return result; >+} >+float3x2 exp2(float3x2 x) { >+ float3x2 result; >+ result[0][0] = exp2(x[0][0]); >+ result[0][1] = exp2(x[0][1]); >+ result[1][0] = exp2(x[1][0]); >+ result[1][1] = exp2(x[1][1]); >+ result[2][0] = exp2(x[2][0]); >+ result[2][1] = exp2(x[2][1]); >+ return result; >+} >+float3x3 exp2(float3x3 x) { >+ float3x3 result; >+ result[0][0] = exp2(x[0][0]); >+ result[0][1] = exp2(x[0][1]); >+ result[0][2] = exp2(x[0][2]); >+ result[1][0] = exp2(x[1][0]); >+ result[1][1] = exp2(x[1][1]); >+ result[1][2] = exp2(x[1][2]); >+ result[2][0] = exp2(x[2][0]); >+ result[2][1] = exp2(x[2][1]); >+ result[2][2] = exp2(x[2][2]); >+ return result; >+} >+float3x4 exp2(float3x4 x) { >+ float3x4 result; >+ result[0][0] = exp2(x[0][0]); >+ result[0][1] = exp2(x[0][1]); >+ result[0][2] = exp2(x[0][2]); >+ result[0][3] = exp2(x[0][3]); >+ result[1][0] = exp2(x[1][0]); >+ result[1][1] = exp2(x[1][1]); >+ result[1][2] = exp2(x[1][2]); >+ result[1][3] = exp2(x[1][3]); >+ result[2][0] = exp2(x[2][0]); >+ result[2][1] = exp2(x[2][1]); >+ result[2][2] = exp2(x[2][2]); >+ result[2][3] = exp2(x[2][3]); >+ return result; >+} >+float4x2 exp2(float4x2 x) { >+ float4x2 result; >+ result[0][0] = exp2(x[0][0]); >+ result[0][1] = exp2(x[0][1]); >+ result[1][0] = exp2(x[1][0]); >+ result[1][1] = exp2(x[1][1]); >+ result[2][0] = exp2(x[2][0]); >+ result[2][1] = exp2(x[2][1]); >+ result[3][0] = exp2(x[3][0]); >+ result[3][1] = exp2(x[3][1]); >+ return result; >+} >+float4x3 exp2(float4x3 x) { >+ float4x3 result; >+ result[0][0] = exp2(x[0][0]); >+ result[0][1] = exp2(x[0][1]); >+ result[0][2] = exp2(x[0][2]); >+ result[1][0] = exp2(x[1][0]); >+ result[1][1] = exp2(x[1][1]); >+ result[1][2] = exp2(x[1][2]); >+ result[2][0] = exp2(x[2][0]); >+ result[2][1] = exp2(x[2][1]); >+ result[2][2] = exp2(x[2][2]); >+ result[3][0] = exp2(x[3][0]); >+ result[3][1] = exp2(x[3][1]); >+ result[3][2] = exp2(x[3][2]); >+ return result; >+} >+float4x4 exp2(float4x4 x) { >+ float4x4 result; >+ result[0][0] = exp2(x[0][0]); >+ result[0][1] = exp2(x[0][1]); >+ result[0][2] = exp2(x[0][2]); >+ result[0][3] = exp2(x[0][3]); >+ result[1][0] = exp2(x[1][0]); >+ result[1][1] = exp2(x[1][1]); >+ result[1][2] = exp2(x[1][2]); >+ result[1][3] = exp2(x[1][3]); >+ result[2][0] = exp2(x[2][0]); >+ result[2][1] = exp2(x[2][1]); >+ result[2][2] = exp2(x[2][2]); >+ result[2][3] = exp2(x[2][3]); >+ result[3][0] = exp2(x[3][0]); >+ result[3][1] = exp2(x[3][1]); >+ result[3][2] = exp2(x[3][2]); >+ result[3][3] = exp2(x[3][3]); >+ return result; >+} >+float2 degrees(float2 x) { >+ float2 result; >+ result[0] = degrees(x[0]); >+ result[1] = degrees(x[1]); >+ return result; >+} >+float3 degrees(float3 x) { >+ float3 result; >+ result[0] = degrees(x[0]); >+ result[1] = degrees(x[1]); >+ result[2] = degrees(x[2]); >+ return result; >+} >+float4 degrees(float4 x) { >+ float4 result; >+ result[0] = degrees(x[0]); >+ result[1] = degrees(x[1]); >+ result[2] = degrees(x[2]); >+ result[3] = degrees(x[3]); >+ return result; >+} >+float2x2 degrees(float2x2 x) { >+ float2x2 result; >+ result[0][0] = degrees(x[0][0]); >+ result[0][1] = degrees(x[0][1]); >+ result[1][0] = degrees(x[1][0]); >+ result[1][1] = degrees(x[1][1]); >+ return result; >+} >+float2x3 degrees(float2x3 x) { >+ float2x3 result; >+ result[0][0] = degrees(x[0][0]); >+ result[0][1] = degrees(x[0][1]); >+ result[0][2] = degrees(x[0][2]); >+ result[1][0] = degrees(x[1][0]); >+ result[1][1] = degrees(x[1][1]); >+ result[1][2] = degrees(x[1][2]); >+ return result; >+} >+float2x4 degrees(float2x4 x) { >+ float2x4 result; >+ result[0][0] = degrees(x[0][0]); >+ result[0][1] = degrees(x[0][1]); >+ result[0][2] = degrees(x[0][2]); >+ result[0][3] = degrees(x[0][3]); >+ result[1][0] = degrees(x[1][0]); >+ result[1][1] = degrees(x[1][1]); >+ result[1][2] = degrees(x[1][2]); >+ result[1][3] = degrees(x[1][3]); >+ return result; >+} >+float3x2 degrees(float3x2 x) { >+ float3x2 result; >+ result[0][0] = degrees(x[0][0]); >+ result[0][1] = degrees(x[0][1]); >+ result[1][0] = degrees(x[1][0]); >+ result[1][1] = degrees(x[1][1]); >+ result[2][0] = degrees(x[2][0]); >+ result[2][1] = degrees(x[2][1]); >+ return result; >+} >+float3x3 degrees(float3x3 x) { >+ float3x3 result; >+ result[0][0] = degrees(x[0][0]); >+ result[0][1] = degrees(x[0][1]); >+ result[0][2] = degrees(x[0][2]); >+ result[1][0] = degrees(x[1][0]); >+ result[1][1] = degrees(x[1][1]); >+ result[1][2] = degrees(x[1][2]); >+ result[2][0] = degrees(x[2][0]); >+ result[2][1] = degrees(x[2][1]); >+ result[2][2] = degrees(x[2][2]); >+ return result; >+} >+float3x4 degrees(float3x4 x) { >+ float3x4 result; >+ result[0][0] = degrees(x[0][0]); >+ result[0][1] = degrees(x[0][1]); >+ result[0][2] = degrees(x[0][2]); >+ result[0][3] = degrees(x[0][3]); >+ result[1][0] = degrees(x[1][0]); >+ result[1][1] = degrees(x[1][1]); >+ result[1][2] = degrees(x[1][2]); >+ result[1][3] = degrees(x[1][3]); >+ result[2][0] = degrees(x[2][0]); >+ result[2][1] = degrees(x[2][1]); >+ result[2][2] = degrees(x[2][2]); >+ result[2][3] = degrees(x[2][3]); >+ return result; >+} >+float4x2 degrees(float4x2 x) { >+ float4x2 result; >+ result[0][0] = degrees(x[0][0]); >+ result[0][1] = degrees(x[0][1]); >+ result[1][0] = degrees(x[1][0]); >+ result[1][1] = degrees(x[1][1]); >+ result[2][0] = degrees(x[2][0]); >+ result[2][1] = degrees(x[2][1]); >+ result[3][0] = degrees(x[3][0]); >+ result[3][1] = degrees(x[3][1]); >+ return result; >+} >+float4x3 degrees(float4x3 x) { >+ float4x3 result; >+ result[0][0] = degrees(x[0][0]); >+ result[0][1] = degrees(x[0][1]); >+ result[0][2] = degrees(x[0][2]); >+ result[1][0] = degrees(x[1][0]); >+ result[1][1] = degrees(x[1][1]); >+ result[1][2] = degrees(x[1][2]); >+ result[2][0] = degrees(x[2][0]); >+ result[2][1] = degrees(x[2][1]); >+ result[2][2] = degrees(x[2][2]); >+ result[3][0] = degrees(x[3][0]); >+ result[3][1] = degrees(x[3][1]); >+ result[3][2] = degrees(x[3][2]); >+ return result; >+} >+float4x4 degrees(float4x4 x) { >+ float4x4 result; >+ result[0][0] = degrees(x[0][0]); >+ result[0][1] = degrees(x[0][1]); >+ result[0][2] = degrees(x[0][2]); >+ result[0][3] = degrees(x[0][3]); >+ result[1][0] = degrees(x[1][0]); >+ result[1][1] = degrees(x[1][1]); >+ result[1][2] = degrees(x[1][2]); >+ result[1][3] = degrees(x[1][3]); >+ result[2][0] = degrees(x[2][0]); >+ result[2][1] = degrees(x[2][1]); >+ result[2][2] = degrees(x[2][2]); >+ result[2][3] = degrees(x[2][3]); >+ result[3][0] = degrees(x[3][0]); >+ result[3][1] = degrees(x[3][1]); >+ result[3][2] = degrees(x[3][2]); >+ result[3][3] = degrees(x[3][3]); >+ return result; >+} >+float2 radians(float2 x) { >+ float2 result; >+ result[0] = radians(x[0]); >+ result[1] = radians(x[1]); >+ return result; >+} >+float3 radians(float3 x) { >+ float3 result; >+ result[0] = radians(x[0]); >+ result[1] = radians(x[1]); >+ result[2] = radians(x[2]); >+ return result; >+} >+float4 radians(float4 x) { >+ float4 result; >+ result[0] = radians(x[0]); >+ result[1] = radians(x[1]); >+ result[2] = radians(x[2]); >+ result[3] = radians(x[3]); >+ return result; >+} >+float2x2 radians(float2x2 x) { >+ float2x2 result; >+ result[0][0] = radians(x[0][0]); >+ result[0][1] = radians(x[0][1]); >+ result[1][0] = radians(x[1][0]); >+ result[1][1] = radians(x[1][1]); >+ return result; >+} >+float2x3 radians(float2x3 x) { >+ float2x3 result; >+ result[0][0] = radians(x[0][0]); >+ result[0][1] = radians(x[0][1]); >+ result[0][2] = radians(x[0][2]); >+ result[1][0] = radians(x[1][0]); >+ result[1][1] = radians(x[1][1]); >+ result[1][2] = radians(x[1][2]); >+ return result; >+} >+float2x4 radians(float2x4 x) { >+ float2x4 result; >+ result[0][0] = radians(x[0][0]); >+ result[0][1] = radians(x[0][1]); >+ result[0][2] = radians(x[0][2]); >+ result[0][3] = radians(x[0][3]); >+ result[1][0] = radians(x[1][0]); >+ result[1][1] = radians(x[1][1]); >+ result[1][2] = radians(x[1][2]); >+ result[1][3] = radians(x[1][3]); >+ return result; >+} >+float3x2 radians(float3x2 x) { >+ float3x2 result; >+ result[0][0] = radians(x[0][0]); >+ result[0][1] = radians(x[0][1]); >+ result[1][0] = radians(x[1][0]); >+ result[1][1] = radians(x[1][1]); >+ result[2][0] = radians(x[2][0]); >+ result[2][1] = radians(x[2][1]); >+ return result; >+} >+float3x3 radians(float3x3 x) { >+ float3x3 result; >+ result[0][0] = radians(x[0][0]); >+ result[0][1] = radians(x[0][1]); >+ result[0][2] = radians(x[0][2]); >+ result[1][0] = radians(x[1][0]); >+ result[1][1] = radians(x[1][1]); >+ result[1][2] = radians(x[1][2]); >+ result[2][0] = radians(x[2][0]); >+ result[2][1] = radians(x[2][1]); >+ result[2][2] = radians(x[2][2]); >+ return result; >+} >+float3x4 radians(float3x4 x) { >+ float3x4 result; >+ result[0][0] = radians(x[0][0]); >+ result[0][1] = radians(x[0][1]); >+ result[0][2] = radians(x[0][2]); >+ result[0][3] = radians(x[0][3]); >+ result[1][0] = radians(x[1][0]); >+ result[1][1] = radians(x[1][1]); >+ result[1][2] = radians(x[1][2]); >+ result[1][3] = radians(x[1][3]); >+ result[2][0] = radians(x[2][0]); >+ result[2][1] = radians(x[2][1]); >+ result[2][2] = radians(x[2][2]); >+ result[2][3] = radians(x[2][3]); >+ return result; >+} >+float4x2 radians(float4x2 x) { >+ float4x2 result; >+ result[0][0] = radians(x[0][0]); >+ result[0][1] = radians(x[0][1]); >+ result[1][0] = radians(x[1][0]); >+ result[1][1] = radians(x[1][1]); >+ result[2][0] = radians(x[2][0]); >+ result[2][1] = radians(x[2][1]); >+ result[3][0] = radians(x[3][0]); >+ result[3][1] = radians(x[3][1]); >+ return result; >+} >+float4x3 radians(float4x3 x) { >+ float4x3 result; >+ result[0][0] = radians(x[0][0]); >+ result[0][1] = radians(x[0][1]); >+ result[0][2] = radians(x[0][2]); >+ result[1][0] = radians(x[1][0]); >+ result[1][1] = radians(x[1][1]); >+ result[1][2] = radians(x[1][2]); >+ result[2][0] = radians(x[2][0]); >+ result[2][1] = radians(x[2][1]); >+ result[2][2] = radians(x[2][2]); >+ result[3][0] = radians(x[3][0]); >+ result[3][1] = radians(x[3][1]); >+ result[3][2] = radians(x[3][2]); >+ return result; >+} >+float4x4 radians(float4x4 x) { >+ float4x4 result; >+ result[0][0] = radians(x[0][0]); >+ result[0][1] = radians(x[0][1]); >+ result[0][2] = radians(x[0][2]); >+ result[0][3] = radians(x[0][3]); >+ result[1][0] = radians(x[1][0]); >+ result[1][1] = radians(x[1][1]); >+ result[1][2] = radians(x[1][2]); >+ result[1][3] = radians(x[1][3]); >+ result[2][0] = radians(x[2][0]); >+ result[2][1] = radians(x[2][1]); >+ result[2][2] = radians(x[2][2]); >+ result[2][3] = radians(x[2][3]); >+ result[3][0] = radians(x[3][0]); >+ result[3][1] = radians(x[3][1]); >+ result[3][2] = radians(x[3][2]); >+ result[3][3] = radians(x[3][3]); >+ return result; >+} >+float2 rcp(float2 x) { >+ float2 result; >+ result[0] = rcp(x[0]); >+ result[1] = rcp(x[1]); >+ return result; >+} >+float3 rcp(float3 x) { >+ float3 result; >+ result[0] = rcp(x[0]); >+ result[1] = rcp(x[1]); >+ result[2] = rcp(x[2]); >+ return result; >+} >+float4 rcp(float4 x) { >+ float4 result; >+ result[0] = rcp(x[0]); >+ result[1] = rcp(x[1]); >+ result[2] = rcp(x[2]); >+ result[3] = rcp(x[3]); >+ return result; >+} >+float2x2 rcp(float2x2 x) { >+ float2x2 result; >+ result[0][0] = rcp(x[0][0]); >+ result[0][1] = rcp(x[0][1]); >+ result[1][0] = rcp(x[1][0]); >+ result[1][1] = rcp(x[1][1]); >+ return result; >+} >+float2x3 rcp(float2x3 x) { >+ float2x3 result; >+ result[0][0] = rcp(x[0][0]); >+ result[0][1] = rcp(x[0][1]); >+ result[0][2] = rcp(x[0][2]); >+ result[1][0] = rcp(x[1][0]); >+ result[1][1] = rcp(x[1][1]); >+ result[1][2] = rcp(x[1][2]); >+ return result; >+} >+float2x4 rcp(float2x4 x) { >+ float2x4 result; >+ result[0][0] = rcp(x[0][0]); >+ result[0][1] = rcp(x[0][1]); >+ result[0][2] = rcp(x[0][2]); >+ result[0][3] = rcp(x[0][3]); >+ result[1][0] = rcp(x[1][0]); >+ result[1][1] = rcp(x[1][1]); >+ result[1][2] = rcp(x[1][2]); >+ result[1][3] = rcp(x[1][3]); >+ return result; >+} >+float3x2 rcp(float3x2 x) { >+ float3x2 result; >+ result[0][0] = rcp(x[0][0]); >+ result[0][1] = rcp(x[0][1]); >+ result[1][0] = rcp(x[1][0]); >+ result[1][1] = rcp(x[1][1]); >+ result[2][0] = rcp(x[2][0]); >+ result[2][1] = rcp(x[2][1]); >+ return result; >+} >+float3x3 rcp(float3x3 x) { >+ float3x3 result; >+ result[0][0] = rcp(x[0][0]); >+ result[0][1] = rcp(x[0][1]); >+ result[0][2] = rcp(x[0][2]); >+ result[1][0] = rcp(x[1][0]); >+ result[1][1] = rcp(x[1][1]); >+ result[1][2] = rcp(x[1][2]); >+ result[2][0] = rcp(x[2][0]); >+ result[2][1] = rcp(x[2][1]); >+ result[2][2] = rcp(x[2][2]); >+ return result; >+} >+float3x4 rcp(float3x4 x) { >+ float3x4 result; >+ result[0][0] = rcp(x[0][0]); >+ result[0][1] = rcp(x[0][1]); >+ result[0][2] = rcp(x[0][2]); >+ result[0][3] = rcp(x[0][3]); >+ result[1][0] = rcp(x[1][0]); >+ result[1][1] = rcp(x[1][1]); >+ result[1][2] = rcp(x[1][2]); >+ result[1][3] = rcp(x[1][3]); >+ result[2][0] = rcp(x[2][0]); >+ result[2][1] = rcp(x[2][1]); >+ result[2][2] = rcp(x[2][2]); >+ result[2][3] = rcp(x[2][3]); >+ return result; >+} >+float4x2 rcp(float4x2 x) { >+ float4x2 result; >+ result[0][0] = rcp(x[0][0]); >+ result[0][1] = rcp(x[0][1]); >+ result[1][0] = rcp(x[1][0]); >+ result[1][1] = rcp(x[1][1]); >+ result[2][0] = rcp(x[2][0]); >+ result[2][1] = rcp(x[2][1]); >+ result[3][0] = rcp(x[3][0]); >+ result[3][1] = rcp(x[3][1]); >+ return result; >+} >+float4x3 rcp(float4x3 x) { >+ float4x3 result; >+ result[0][0] = rcp(x[0][0]); >+ result[0][1] = rcp(x[0][1]); >+ result[0][2] = rcp(x[0][2]); >+ result[1][0] = rcp(x[1][0]); >+ result[1][1] = rcp(x[1][1]); >+ result[1][2] = rcp(x[1][2]); >+ result[2][0] = rcp(x[2][0]); >+ result[2][1] = rcp(x[2][1]); >+ result[2][2] = rcp(x[2][2]); >+ result[3][0] = rcp(x[3][0]); >+ result[3][1] = rcp(x[3][1]); >+ result[3][2] = rcp(x[3][2]); >+ return result; >+} >+float4x4 rcp(float4x4 x) { >+ float4x4 result; >+ result[0][0] = rcp(x[0][0]); >+ result[0][1] = rcp(x[0][1]); >+ result[0][2] = rcp(x[0][2]); >+ result[0][3] = rcp(x[0][3]); >+ result[1][0] = rcp(x[1][0]); >+ result[1][1] = rcp(x[1][1]); >+ result[1][2] = rcp(x[1][2]); >+ result[1][3] = rcp(x[1][3]); >+ result[2][0] = rcp(x[2][0]); >+ result[2][1] = rcp(x[2][1]); >+ result[2][2] = rcp(x[2][2]); >+ result[2][3] = rcp(x[2][3]); >+ result[3][0] = rcp(x[3][0]); >+ result[3][1] = rcp(x[3][1]); >+ result[3][2] = rcp(x[3][2]); >+ result[3][3] = rcp(x[3][3]); >+ return result; >+} >+float2 rsqrt(float2 x) { >+ float2 result; >+ result[0] = rsqrt(x[0]); >+ result[1] = rsqrt(x[1]); >+ return result; >+} >+float3 rsqrt(float3 x) { >+ float3 result; >+ result[0] = rsqrt(x[0]); >+ result[1] = rsqrt(x[1]); >+ result[2] = rsqrt(x[2]); >+ return result; >+} >+float4 rsqrt(float4 x) { >+ float4 result; >+ result[0] = rsqrt(x[0]); >+ result[1] = rsqrt(x[1]); >+ result[2] = rsqrt(x[2]); >+ result[3] = rsqrt(x[3]); >+ return result; >+} >+float2x2 rsqrt(float2x2 x) { >+ float2x2 result; >+ result[0][0] = rsqrt(x[0][0]); >+ result[0][1] = rsqrt(x[0][1]); >+ result[1][0] = rsqrt(x[1][0]); >+ result[1][1] = rsqrt(x[1][1]); >+ return result; >+} >+float2x3 rsqrt(float2x3 x) { >+ float2x3 result; >+ result[0][0] = rsqrt(x[0][0]); >+ result[0][1] = rsqrt(x[0][1]); >+ result[0][2] = rsqrt(x[0][2]); >+ result[1][0] = rsqrt(x[1][0]); >+ result[1][1] = rsqrt(x[1][1]); >+ result[1][2] = rsqrt(x[1][2]); >+ return result; >+} >+float2x4 rsqrt(float2x4 x) { >+ float2x4 result; >+ result[0][0] = rsqrt(x[0][0]); >+ result[0][1] = rsqrt(x[0][1]); >+ result[0][2] = rsqrt(x[0][2]); >+ result[0][3] = rsqrt(x[0][3]); >+ result[1][0] = rsqrt(x[1][0]); >+ result[1][1] = rsqrt(x[1][1]); >+ result[1][2] = rsqrt(x[1][2]); >+ result[1][3] = rsqrt(x[1][3]); >+ return result; >+} >+float3x2 rsqrt(float3x2 x) { >+ float3x2 result; >+ result[0][0] = rsqrt(x[0][0]); >+ result[0][1] = rsqrt(x[0][1]); >+ result[1][0] = rsqrt(x[1][0]); >+ result[1][1] = rsqrt(x[1][1]); >+ result[2][0] = rsqrt(x[2][0]); >+ result[2][1] = rsqrt(x[2][1]); >+ return result; >+} >+float3x3 rsqrt(float3x3 x) { >+ float3x3 result; >+ result[0][0] = rsqrt(x[0][0]); >+ result[0][1] = rsqrt(x[0][1]); >+ result[0][2] = rsqrt(x[0][2]); >+ result[1][0] = rsqrt(x[1][0]); >+ result[1][1] = rsqrt(x[1][1]); >+ result[1][2] = rsqrt(x[1][2]); >+ result[2][0] = rsqrt(x[2][0]); >+ result[2][1] = rsqrt(x[2][1]); >+ result[2][2] = rsqrt(x[2][2]); >+ return result; >+} >+float3x4 rsqrt(float3x4 x) { >+ float3x4 result; >+ result[0][0] = rsqrt(x[0][0]); >+ result[0][1] = rsqrt(x[0][1]); >+ result[0][2] = rsqrt(x[0][2]); >+ result[0][3] = rsqrt(x[0][3]); >+ result[1][0] = rsqrt(x[1][0]); >+ result[1][1] = rsqrt(x[1][1]); >+ result[1][2] = rsqrt(x[1][2]); >+ result[1][3] = rsqrt(x[1][3]); >+ result[2][0] = rsqrt(x[2][0]); >+ result[2][1] = rsqrt(x[2][1]); >+ result[2][2] = rsqrt(x[2][2]); >+ result[2][3] = rsqrt(x[2][3]); >+ return result; >+} >+float4x2 rsqrt(float4x2 x) { >+ float4x2 result; >+ result[0][0] = rsqrt(x[0][0]); >+ result[0][1] = rsqrt(x[0][1]); >+ result[1][0] = rsqrt(x[1][0]); >+ result[1][1] = rsqrt(x[1][1]); >+ result[2][0] = rsqrt(x[2][0]); >+ result[2][1] = rsqrt(x[2][1]); >+ result[3][0] = rsqrt(x[3][0]); >+ result[3][1] = rsqrt(x[3][1]); >+ return result; >+} >+float4x3 rsqrt(float4x3 x) { >+ float4x3 result; >+ result[0][0] = rsqrt(x[0][0]); >+ result[0][1] = rsqrt(x[0][1]); >+ result[0][2] = rsqrt(x[0][2]); >+ result[1][0] = rsqrt(x[1][0]); >+ result[1][1] = rsqrt(x[1][1]); >+ result[1][2] = rsqrt(x[1][2]); >+ result[2][0] = rsqrt(x[2][0]); >+ result[2][1] = rsqrt(x[2][1]); >+ result[2][2] = rsqrt(x[2][2]); >+ result[3][0] = rsqrt(x[3][0]); >+ result[3][1] = rsqrt(x[3][1]); >+ result[3][2] = rsqrt(x[3][2]); >+ return result; >+} >+float4x4 rsqrt(float4x4 x) { >+ float4x4 result; >+ result[0][0] = rsqrt(x[0][0]); >+ result[0][1] = rsqrt(x[0][1]); >+ result[0][2] = rsqrt(x[0][2]); >+ result[0][3] = rsqrt(x[0][3]); >+ result[1][0] = rsqrt(x[1][0]); >+ result[1][1] = rsqrt(x[1][1]); >+ result[1][2] = rsqrt(x[1][2]); >+ result[1][3] = rsqrt(x[1][3]); >+ result[2][0] = rsqrt(x[2][0]); >+ result[2][1] = rsqrt(x[2][1]); >+ result[2][2] = rsqrt(x[2][2]); >+ result[2][3] = rsqrt(x[2][3]); >+ result[3][0] = rsqrt(x[3][0]); >+ result[3][1] = rsqrt(x[3][1]); >+ result[3][2] = rsqrt(x[3][2]); >+ result[3][3] = rsqrt(x[3][3]); >+ return result; >+} >+float2 saturate(float2 x) { >+ float2 result; >+ result[0] = saturate(x[0]); >+ result[1] = saturate(x[1]); >+ return result; >+} >+float3 saturate(float3 x) { >+ float3 result; >+ result[0] = saturate(x[0]); >+ result[1] = saturate(x[1]); >+ result[2] = saturate(x[2]); >+ return result; >+} >+float4 saturate(float4 x) { >+ float4 result; >+ result[0] = saturate(x[0]); >+ result[1] = saturate(x[1]); >+ result[2] = saturate(x[2]); >+ result[3] = saturate(x[3]); >+ return result; >+} >+float2x2 saturate(float2x2 x) { >+ float2x2 result; >+ result[0][0] = saturate(x[0][0]); >+ result[0][1] = saturate(x[0][1]); >+ result[1][0] = saturate(x[1][0]); >+ result[1][1] = saturate(x[1][1]); >+ return result; >+} >+float2x3 saturate(float2x3 x) { >+ float2x3 result; >+ result[0][0] = saturate(x[0][0]); >+ result[0][1] = saturate(x[0][1]); >+ result[0][2] = saturate(x[0][2]); >+ result[1][0] = saturate(x[1][0]); >+ result[1][1] = saturate(x[1][1]); >+ result[1][2] = saturate(x[1][2]); >+ return result; >+} >+float2x4 saturate(float2x4 x) { >+ float2x4 result; >+ result[0][0] = saturate(x[0][0]); >+ result[0][1] = saturate(x[0][1]); >+ result[0][2] = saturate(x[0][2]); >+ result[0][3] = saturate(x[0][3]); >+ result[1][0] = saturate(x[1][0]); >+ result[1][1] = saturate(x[1][1]); >+ result[1][2] = saturate(x[1][2]); >+ result[1][3] = saturate(x[1][3]); >+ return result; >+} >+float3x2 saturate(float3x2 x) { >+ float3x2 result; >+ result[0][0] = saturate(x[0][0]); >+ result[0][1] = saturate(x[0][1]); >+ result[1][0] = saturate(x[1][0]); >+ result[1][1] = saturate(x[1][1]); >+ result[2][0] = saturate(x[2][0]); >+ result[2][1] = saturate(x[2][1]); >+ return result; >+} >+float3x3 saturate(float3x3 x) { >+ float3x3 result; >+ result[0][0] = saturate(x[0][0]); >+ result[0][1] = saturate(x[0][1]); >+ result[0][2] = saturate(x[0][2]); >+ result[1][0] = saturate(x[1][0]); >+ result[1][1] = saturate(x[1][1]); >+ result[1][2] = saturate(x[1][2]); >+ result[2][0] = saturate(x[2][0]); >+ result[2][1] = saturate(x[2][1]); >+ result[2][2] = saturate(x[2][2]); >+ return result; >+} >+float3x4 saturate(float3x4 x) { >+ float3x4 result; >+ result[0][0] = saturate(x[0][0]); >+ result[0][1] = saturate(x[0][1]); >+ result[0][2] = saturate(x[0][2]); >+ result[0][3] = saturate(x[0][3]); >+ result[1][0] = saturate(x[1][0]); >+ result[1][1] = saturate(x[1][1]); >+ result[1][2] = saturate(x[1][2]); >+ result[1][3] = saturate(x[1][3]); >+ result[2][0] = saturate(x[2][0]); >+ result[2][1] = saturate(x[2][1]); >+ result[2][2] = saturate(x[2][2]); >+ result[2][3] = saturate(x[2][3]); >+ return result; >+} >+float4x2 saturate(float4x2 x) { >+ float4x2 result; >+ result[0][0] = saturate(x[0][0]); >+ result[0][1] = saturate(x[0][1]); >+ result[1][0] = saturate(x[1][0]); >+ result[1][1] = saturate(x[1][1]); >+ result[2][0] = saturate(x[2][0]); >+ result[2][1] = saturate(x[2][1]); >+ result[3][0] = saturate(x[3][0]); >+ result[3][1] = saturate(x[3][1]); >+ return result; >+} >+float4x3 saturate(float4x3 x) { >+ float4x3 result; >+ result[0][0] = saturate(x[0][0]); >+ result[0][1] = saturate(x[0][1]); >+ result[0][2] = saturate(x[0][2]); >+ result[1][0] = saturate(x[1][0]); >+ result[1][1] = saturate(x[1][1]); >+ result[1][2] = saturate(x[1][2]); >+ result[2][0] = saturate(x[2][0]); >+ result[2][1] = saturate(x[2][1]); >+ result[2][2] = saturate(x[2][2]); >+ result[3][0] = saturate(x[3][0]); >+ result[3][1] = saturate(x[3][1]); >+ result[3][2] = saturate(x[3][2]); >+ return result; >+} >+float4x4 saturate(float4x4 x) { >+ float4x4 result; >+ result[0][0] = saturate(x[0][0]); >+ result[0][1] = saturate(x[0][1]); >+ result[0][2] = saturate(x[0][2]); >+ result[0][3] = saturate(x[0][3]); >+ result[1][0] = saturate(x[1][0]); >+ result[1][1] = saturate(x[1][1]); >+ result[1][2] = saturate(x[1][2]); >+ result[1][3] = saturate(x[1][3]); >+ result[2][0] = saturate(x[2][0]); >+ result[2][1] = saturate(x[2][1]); >+ result[2][2] = saturate(x[2][2]); >+ result[2][3] = saturate(x[2][3]); >+ result[3][0] = saturate(x[3][0]); >+ result[3][1] = saturate(x[3][1]); >+ result[3][2] = saturate(x[3][2]); >+ result[3][3] = saturate(x[3][3]); >+ return result; >+} >+float2 ddx_coarse(float2 x) { >+ float2 result; >+ result[0] = ddx_coarse(x[0]); >+ result[1] = ddx_coarse(x[1]); >+ return result; >+} >+float3 ddx_coarse(float3 x) { >+ float3 result; >+ result[0] = ddx_coarse(x[0]); >+ result[1] = ddx_coarse(x[1]); >+ result[2] = ddx_coarse(x[2]); >+ return result; >+} >+float4 ddx_coarse(float4 x) { >+ float4 result; >+ result[0] = ddx_coarse(x[0]); >+ result[1] = ddx_coarse(x[1]); >+ result[2] = ddx_coarse(x[2]); >+ result[3] = ddx_coarse(x[3]); >+ return result; >+} >+float2x2 ddx_coarse(float2x2 x) { >+ float2x2 result; >+ result[0][0] = ddx_coarse(x[0][0]); >+ result[0][1] = ddx_coarse(x[0][1]); >+ result[1][0] = ddx_coarse(x[1][0]); >+ result[1][1] = ddx_coarse(x[1][1]); >+ return result; >+} >+float2x3 ddx_coarse(float2x3 x) { >+ float2x3 result; >+ result[0][0] = ddx_coarse(x[0][0]); >+ result[0][1] = ddx_coarse(x[0][1]); >+ result[0][2] = ddx_coarse(x[0][2]); >+ result[1][0] = ddx_coarse(x[1][0]); >+ result[1][1] = ddx_coarse(x[1][1]); >+ result[1][2] = ddx_coarse(x[1][2]); >+ return result; >+} >+float2x4 ddx_coarse(float2x4 x) { >+ float2x4 result; >+ result[0][0] = ddx_coarse(x[0][0]); >+ result[0][1] = ddx_coarse(x[0][1]); >+ result[0][2] = ddx_coarse(x[0][2]); >+ result[0][3] = ddx_coarse(x[0][3]); >+ result[1][0] = ddx_coarse(x[1][0]); >+ result[1][1] = ddx_coarse(x[1][1]); >+ result[1][2] = ddx_coarse(x[1][2]); >+ result[1][3] = ddx_coarse(x[1][3]); >+ return result; >+} >+float3x2 ddx_coarse(float3x2 x) { >+ float3x2 result; >+ result[0][0] = ddx_coarse(x[0][0]); >+ result[0][1] = ddx_coarse(x[0][1]); >+ result[1][0] = ddx_coarse(x[1][0]); >+ result[1][1] = ddx_coarse(x[1][1]); >+ result[2][0] = ddx_coarse(x[2][0]); >+ result[2][1] = ddx_coarse(x[2][1]); >+ return result; >+} >+float3x3 ddx_coarse(float3x3 x) { >+ float3x3 result; >+ result[0][0] = ddx_coarse(x[0][0]); >+ result[0][1] = ddx_coarse(x[0][1]); >+ result[0][2] = ddx_coarse(x[0][2]); >+ result[1][0] = ddx_coarse(x[1][0]); >+ result[1][1] = ddx_coarse(x[1][1]); >+ result[1][2] = ddx_coarse(x[1][2]); >+ result[2][0] = ddx_coarse(x[2][0]); >+ result[2][1] = ddx_coarse(x[2][1]); >+ result[2][2] = ddx_coarse(x[2][2]); >+ return result; >+} >+float3x4 ddx_coarse(float3x4 x) { >+ float3x4 result; >+ result[0][0] = ddx_coarse(x[0][0]); >+ result[0][1] = ddx_coarse(x[0][1]); >+ result[0][2] = ddx_coarse(x[0][2]); >+ result[0][3] = ddx_coarse(x[0][3]); >+ result[1][0] = ddx_coarse(x[1][0]); >+ result[1][1] = ddx_coarse(x[1][1]); >+ result[1][2] = ddx_coarse(x[1][2]); >+ result[1][3] = ddx_coarse(x[1][3]); >+ result[2][0] = ddx_coarse(x[2][0]); >+ result[2][1] = ddx_coarse(x[2][1]); >+ result[2][2] = ddx_coarse(x[2][2]); >+ result[2][3] = ddx_coarse(x[2][3]); >+ return result; >+} >+float4x2 ddx_coarse(float4x2 x) { >+ float4x2 result; >+ result[0][0] = ddx_coarse(x[0][0]); >+ result[0][1] = ddx_coarse(x[0][1]); >+ result[1][0] = ddx_coarse(x[1][0]); >+ result[1][1] = ddx_coarse(x[1][1]); >+ result[2][0] = ddx_coarse(x[2][0]); >+ result[2][1] = ddx_coarse(x[2][1]); >+ result[3][0] = ddx_coarse(x[3][0]); >+ result[3][1] = ddx_coarse(x[3][1]); >+ return result; >+} >+float4x3 ddx_coarse(float4x3 x) { >+ float4x3 result; >+ result[0][0] = ddx_coarse(x[0][0]); >+ result[0][1] = ddx_coarse(x[0][1]); >+ result[0][2] = ddx_coarse(x[0][2]); >+ result[1][0] = ddx_coarse(x[1][0]); >+ result[1][1] = ddx_coarse(x[1][1]); >+ result[1][2] = ddx_coarse(x[1][2]); >+ result[2][0] = ddx_coarse(x[2][0]); >+ result[2][1] = ddx_coarse(x[2][1]); >+ result[2][2] = ddx_coarse(x[2][2]); >+ result[3][0] = ddx_coarse(x[3][0]); >+ result[3][1] = ddx_coarse(x[3][1]); >+ result[3][2] = ddx_coarse(x[3][2]); >+ return result; >+} >+float4x4 ddx_coarse(float4x4 x) { >+ float4x4 result; >+ result[0][0] = ddx_coarse(x[0][0]); >+ result[0][1] = ddx_coarse(x[0][1]); >+ result[0][2] = ddx_coarse(x[0][2]); >+ result[0][3] = ddx_coarse(x[0][3]); >+ result[1][0] = ddx_coarse(x[1][0]); >+ result[1][1] = ddx_coarse(x[1][1]); >+ result[1][2] = ddx_coarse(x[1][2]); >+ result[1][3] = ddx_coarse(x[1][3]); >+ result[2][0] = ddx_coarse(x[2][0]); >+ result[2][1] = ddx_coarse(x[2][1]); >+ result[2][2] = ddx_coarse(x[2][2]); >+ result[2][3] = ddx_coarse(x[2][3]); >+ result[3][0] = ddx_coarse(x[3][0]); >+ result[3][1] = ddx_coarse(x[3][1]); >+ result[3][2] = ddx_coarse(x[3][2]); >+ result[3][3] = ddx_coarse(x[3][3]); >+ return result; >+} >+float2 ddx_fine(float2 x) { >+ float2 result; >+ result[0] = ddx_fine(x[0]); >+ result[1] = ddx_fine(x[1]); >+ return result; >+} >+float3 ddx_fine(float3 x) { >+ float3 result; >+ result[0] = ddx_fine(x[0]); >+ result[1] = ddx_fine(x[1]); >+ result[2] = ddx_fine(x[2]); >+ return result; >+} >+float4 ddx_fine(float4 x) { >+ float4 result; >+ result[0] = ddx_fine(x[0]); >+ result[1] = ddx_fine(x[1]); >+ result[2] = ddx_fine(x[2]); >+ result[3] = ddx_fine(x[3]); >+ return result; >+} >+float2x2 ddx_fine(float2x2 x) { >+ float2x2 result; >+ result[0][0] = ddx_fine(x[0][0]); >+ result[0][1] = ddx_fine(x[0][1]); >+ result[1][0] = ddx_fine(x[1][0]); >+ result[1][1] = ddx_fine(x[1][1]); >+ return result; >+} >+float2x3 ddx_fine(float2x3 x) { >+ float2x3 result; >+ result[0][0] = ddx_fine(x[0][0]); >+ result[0][1] = ddx_fine(x[0][1]); >+ result[0][2] = ddx_fine(x[0][2]); >+ result[1][0] = ddx_fine(x[1][0]); >+ result[1][1] = ddx_fine(x[1][1]); >+ result[1][2] = ddx_fine(x[1][2]); >+ return result; >+} >+float2x4 ddx_fine(float2x4 x) { >+ float2x4 result; >+ result[0][0] = ddx_fine(x[0][0]); >+ result[0][1] = ddx_fine(x[0][1]); >+ result[0][2] = ddx_fine(x[0][2]); >+ result[0][3] = ddx_fine(x[0][3]); >+ result[1][0] = ddx_fine(x[1][0]); >+ result[1][1] = ddx_fine(x[1][1]); >+ result[1][2] = ddx_fine(x[1][2]); >+ result[1][3] = ddx_fine(x[1][3]); >+ return result; >+} >+float3x2 ddx_fine(float3x2 x) { >+ float3x2 result; >+ result[0][0] = ddx_fine(x[0][0]); >+ result[0][1] = ddx_fine(x[0][1]); >+ result[1][0] = ddx_fine(x[1][0]); >+ result[1][1] = ddx_fine(x[1][1]); >+ result[2][0] = ddx_fine(x[2][0]); >+ result[2][1] = ddx_fine(x[2][1]); >+ return result; >+} >+float3x3 ddx_fine(float3x3 x) { >+ float3x3 result; >+ result[0][0] = ddx_fine(x[0][0]); >+ result[0][1] = ddx_fine(x[0][1]); >+ result[0][2] = ddx_fine(x[0][2]); >+ result[1][0] = ddx_fine(x[1][0]); >+ result[1][1] = ddx_fine(x[1][1]); >+ result[1][2] = ddx_fine(x[1][2]); >+ result[2][0] = ddx_fine(x[2][0]); >+ result[2][1] = ddx_fine(x[2][1]); >+ result[2][2] = ddx_fine(x[2][2]); >+ return result; >+} >+float3x4 ddx_fine(float3x4 x) { >+ float3x4 result; >+ result[0][0] = ddx_fine(x[0][0]); >+ result[0][1] = ddx_fine(x[0][1]); >+ result[0][2] = ddx_fine(x[0][2]); >+ result[0][3] = ddx_fine(x[0][3]); >+ result[1][0] = ddx_fine(x[1][0]); >+ result[1][1] = ddx_fine(x[1][1]); >+ result[1][2] = ddx_fine(x[1][2]); >+ result[1][3] = ddx_fine(x[1][3]); >+ result[2][0] = ddx_fine(x[2][0]); >+ result[2][1] = ddx_fine(x[2][1]); >+ result[2][2] = ddx_fine(x[2][2]); >+ result[2][3] = ddx_fine(x[2][3]); >+ return result; >+} >+float4x2 ddx_fine(float4x2 x) { >+ float4x2 result; >+ result[0][0] = ddx_fine(x[0][0]); >+ result[0][1] = ddx_fine(x[0][1]); >+ result[1][0] = ddx_fine(x[1][0]); >+ result[1][1] = ddx_fine(x[1][1]); >+ result[2][0] = ddx_fine(x[2][0]); >+ result[2][1] = ddx_fine(x[2][1]); >+ result[3][0] = ddx_fine(x[3][0]); >+ result[3][1] = ddx_fine(x[3][1]); >+ return result; >+} >+float4x3 ddx_fine(float4x3 x) { >+ float4x3 result; >+ result[0][0] = ddx_fine(x[0][0]); >+ result[0][1] = ddx_fine(x[0][1]); >+ result[0][2] = ddx_fine(x[0][2]); >+ result[1][0] = ddx_fine(x[1][0]); >+ result[1][1] = ddx_fine(x[1][1]); >+ result[1][2] = ddx_fine(x[1][2]); >+ result[2][0] = ddx_fine(x[2][0]); >+ result[2][1] = ddx_fine(x[2][1]); >+ result[2][2] = ddx_fine(x[2][2]); >+ result[3][0] = ddx_fine(x[3][0]); >+ result[3][1] = ddx_fine(x[3][1]); >+ result[3][2] = ddx_fine(x[3][2]); >+ return result; >+} >+float4x4 ddx_fine(float4x4 x) { >+ float4x4 result; >+ result[0][0] = ddx_fine(x[0][0]); >+ result[0][1] = ddx_fine(x[0][1]); >+ result[0][2] = ddx_fine(x[0][2]); >+ result[0][3] = ddx_fine(x[0][3]); >+ result[1][0] = ddx_fine(x[1][0]); >+ result[1][1] = ddx_fine(x[1][1]); >+ result[1][2] = ddx_fine(x[1][2]); >+ result[1][3] = ddx_fine(x[1][3]); >+ result[2][0] = ddx_fine(x[2][0]); >+ result[2][1] = ddx_fine(x[2][1]); >+ result[2][2] = ddx_fine(x[2][2]); >+ result[2][3] = ddx_fine(x[2][3]); >+ result[3][0] = ddx_fine(x[3][0]); >+ result[3][1] = ddx_fine(x[3][1]); >+ result[3][2] = ddx_fine(x[3][2]); >+ result[3][3] = ddx_fine(x[3][3]); >+ return result; >+} >+float2 ddy_coarse(float2 x) { >+ float2 result; >+ result[0] = ddy_coarse(x[0]); >+ result[1] = ddy_coarse(x[1]); >+ return result; >+} >+float3 ddy_coarse(float3 x) { >+ float3 result; >+ result[0] = ddy_coarse(x[0]); >+ result[1] = ddy_coarse(x[1]); >+ result[2] = ddy_coarse(x[2]); >+ return result; >+} >+float4 ddy_coarse(float4 x) { >+ float4 result; >+ result[0] = ddy_coarse(x[0]); >+ result[1] = ddy_coarse(x[1]); >+ result[2] = ddy_coarse(x[2]); >+ result[3] = ddy_coarse(x[3]); >+ return result; >+} >+float2x2 ddy_coarse(float2x2 x) { >+ float2x2 result; >+ result[0][0] = ddy_coarse(x[0][0]); >+ result[0][1] = ddy_coarse(x[0][1]); >+ result[1][0] = ddy_coarse(x[1][0]); >+ result[1][1] = ddy_coarse(x[1][1]); >+ return result; >+} >+float2x3 ddy_coarse(float2x3 x) { >+ float2x3 result; >+ result[0][0] = ddy_coarse(x[0][0]); >+ result[0][1] = ddy_coarse(x[0][1]); >+ result[0][2] = ddy_coarse(x[0][2]); >+ result[1][0] = ddy_coarse(x[1][0]); >+ result[1][1] = ddy_coarse(x[1][1]); >+ result[1][2] = ddy_coarse(x[1][2]); >+ return result; >+} >+float2x4 ddy_coarse(float2x4 x) { >+ float2x4 result; >+ result[0][0] = ddy_coarse(x[0][0]); >+ result[0][1] = ddy_coarse(x[0][1]); >+ result[0][2] = ddy_coarse(x[0][2]); >+ result[0][3] = ddy_coarse(x[0][3]); >+ result[1][0] = ddy_coarse(x[1][0]); >+ result[1][1] = ddy_coarse(x[1][1]); >+ result[1][2] = ddy_coarse(x[1][2]); >+ result[1][3] = ddy_coarse(x[1][3]); >+ return result; >+} >+float3x2 ddy_coarse(float3x2 x) { >+ float3x2 result; >+ result[0][0] = ddy_coarse(x[0][0]); >+ result[0][1] = ddy_coarse(x[0][1]); >+ result[1][0] = ddy_coarse(x[1][0]); >+ result[1][1] = ddy_coarse(x[1][1]); >+ result[2][0] = ddy_coarse(x[2][0]); >+ result[2][1] = ddy_coarse(x[2][1]); >+ return result; >+} >+float3x3 ddy_coarse(float3x3 x) { >+ float3x3 result; >+ result[0][0] = ddy_coarse(x[0][0]); >+ result[0][1] = ddy_coarse(x[0][1]); >+ result[0][2] = ddy_coarse(x[0][2]); >+ result[1][0] = ddy_coarse(x[1][0]); >+ result[1][1] = ddy_coarse(x[1][1]); >+ result[1][2] = ddy_coarse(x[1][2]); >+ result[2][0] = ddy_coarse(x[2][0]); >+ result[2][1] = ddy_coarse(x[2][1]); >+ result[2][2] = ddy_coarse(x[2][2]); >+ return result; >+} >+float3x4 ddy_coarse(float3x4 x) { >+ float3x4 result; >+ result[0][0] = ddy_coarse(x[0][0]); >+ result[0][1] = ddy_coarse(x[0][1]); >+ result[0][2] = ddy_coarse(x[0][2]); >+ result[0][3] = ddy_coarse(x[0][3]); >+ result[1][0] = ddy_coarse(x[1][0]); >+ result[1][1] = ddy_coarse(x[1][1]); >+ result[1][2] = ddy_coarse(x[1][2]); >+ result[1][3] = ddy_coarse(x[1][3]); >+ result[2][0] = ddy_coarse(x[2][0]); >+ result[2][1] = ddy_coarse(x[2][1]); >+ result[2][2] = ddy_coarse(x[2][2]); >+ result[2][3] = ddy_coarse(x[2][3]); >+ return result; >+} >+float4x2 ddy_coarse(float4x2 x) { >+ float4x2 result; >+ result[0][0] = ddy_coarse(x[0][0]); >+ result[0][1] = ddy_coarse(x[0][1]); >+ result[1][0] = ddy_coarse(x[1][0]); >+ result[1][1] = ddy_coarse(x[1][1]); >+ result[2][0] = ddy_coarse(x[2][0]); >+ result[2][1] = ddy_coarse(x[2][1]); >+ result[3][0] = ddy_coarse(x[3][0]); >+ result[3][1] = ddy_coarse(x[3][1]); >+ return result; >+} >+float4x3 ddy_coarse(float4x3 x) { >+ float4x3 result; >+ result[0][0] = ddy_coarse(x[0][0]); >+ result[0][1] = ddy_coarse(x[0][1]); >+ result[0][2] = ddy_coarse(x[0][2]); >+ result[1][0] = ddy_coarse(x[1][0]); >+ result[1][1] = ddy_coarse(x[1][1]); >+ result[1][2] = ddy_coarse(x[1][2]); >+ result[2][0] = ddy_coarse(x[2][0]); >+ result[2][1] = ddy_coarse(x[2][1]); >+ result[2][2] = ddy_coarse(x[2][2]); >+ result[3][0] = ddy_coarse(x[3][0]); >+ result[3][1] = ddy_coarse(x[3][1]); >+ result[3][2] = ddy_coarse(x[3][2]); >+ return result; >+} >+float4x4 ddy_coarse(float4x4 x) { >+ float4x4 result; >+ result[0][0] = ddy_coarse(x[0][0]); >+ result[0][1] = ddy_coarse(x[0][1]); >+ result[0][2] = ddy_coarse(x[0][2]); >+ result[0][3] = ddy_coarse(x[0][3]); >+ result[1][0] = ddy_coarse(x[1][0]); >+ result[1][1] = ddy_coarse(x[1][1]); >+ result[1][2] = ddy_coarse(x[1][2]); >+ result[1][3] = ddy_coarse(x[1][3]); >+ result[2][0] = ddy_coarse(x[2][0]); >+ result[2][1] = ddy_coarse(x[2][1]); >+ result[2][2] = ddy_coarse(x[2][2]); >+ result[2][3] = ddy_coarse(x[2][3]); >+ result[3][0] = ddy_coarse(x[3][0]); >+ result[3][1] = ddy_coarse(x[3][1]); >+ result[3][2] = ddy_coarse(x[3][2]); >+ result[3][3] = ddy_coarse(x[3][3]); >+ return result; >+} >+float2 ddy_fine(float2 x) { >+ float2 result; >+ result[0] = ddy_fine(x[0]); >+ result[1] = ddy_fine(x[1]); >+ return result; >+} >+float3 ddy_fine(float3 x) { >+ float3 result; >+ result[0] = ddy_fine(x[0]); >+ result[1] = ddy_fine(x[1]); >+ result[2] = ddy_fine(x[2]); >+ return result; >+} >+float4 ddy_fine(float4 x) { >+ float4 result; >+ result[0] = ddy_fine(x[0]); >+ result[1] = ddy_fine(x[1]); >+ result[2] = ddy_fine(x[2]); >+ result[3] = ddy_fine(x[3]); >+ return result; >+} >+float2x2 ddy_fine(float2x2 x) { >+ float2x2 result; >+ result[0][0] = ddy_fine(x[0][0]); >+ result[0][1] = ddy_fine(x[0][1]); >+ result[1][0] = ddy_fine(x[1][0]); >+ result[1][1] = ddy_fine(x[1][1]); >+ return result; >+} >+float2x3 ddy_fine(float2x3 x) { >+ float2x3 result; >+ result[0][0] = ddy_fine(x[0][0]); >+ result[0][1] = ddy_fine(x[0][1]); >+ result[0][2] = ddy_fine(x[0][2]); >+ result[1][0] = ddy_fine(x[1][0]); >+ result[1][1] = ddy_fine(x[1][1]); >+ result[1][2] = ddy_fine(x[1][2]); >+ return result; >+} >+float2x4 ddy_fine(float2x4 x) { >+ float2x4 result; >+ result[0][0] = ddy_fine(x[0][0]); >+ result[0][1] = ddy_fine(x[0][1]); >+ result[0][2] = ddy_fine(x[0][2]); >+ result[0][3] = ddy_fine(x[0][3]); >+ result[1][0] = ddy_fine(x[1][0]); >+ result[1][1] = ddy_fine(x[1][1]); >+ result[1][2] = ddy_fine(x[1][2]); >+ result[1][3] = ddy_fine(x[1][3]); >+ return result; >+} >+float3x2 ddy_fine(float3x2 x) { >+ float3x2 result; >+ result[0][0] = ddy_fine(x[0][0]); >+ result[0][1] = ddy_fine(x[0][1]); >+ result[1][0] = ddy_fine(x[1][0]); >+ result[1][1] = ddy_fine(x[1][1]); >+ result[2][0] = ddy_fine(x[2][0]); >+ result[2][1] = ddy_fine(x[2][1]); >+ return result; >+} >+float3x3 ddy_fine(float3x3 x) { >+ float3x3 result; >+ result[0][0] = ddy_fine(x[0][0]); >+ result[0][1] = ddy_fine(x[0][1]); >+ result[0][2] = ddy_fine(x[0][2]); >+ result[1][0] = ddy_fine(x[1][0]); >+ result[1][1] = ddy_fine(x[1][1]); >+ result[1][2] = ddy_fine(x[1][2]); >+ result[2][0] = ddy_fine(x[2][0]); >+ result[2][1] = ddy_fine(x[2][1]); >+ result[2][2] = ddy_fine(x[2][2]); >+ return result; >+} >+float3x4 ddy_fine(float3x4 x) { >+ float3x4 result; >+ result[0][0] = ddy_fine(x[0][0]); >+ result[0][1] = ddy_fine(x[0][1]); >+ result[0][2] = ddy_fine(x[0][2]); >+ result[0][3] = ddy_fine(x[0][3]); >+ result[1][0] = ddy_fine(x[1][0]); >+ result[1][1] = ddy_fine(x[1][1]); >+ result[1][2] = ddy_fine(x[1][2]); >+ result[1][3] = ddy_fine(x[1][3]); >+ result[2][0] = ddy_fine(x[2][0]); >+ result[2][1] = ddy_fine(x[2][1]); >+ result[2][2] = ddy_fine(x[2][2]); >+ result[2][3] = ddy_fine(x[2][3]); >+ return result; >+} >+float4x2 ddy_fine(float4x2 x) { >+ float4x2 result; >+ result[0][0] = ddy_fine(x[0][0]); >+ result[0][1] = ddy_fine(x[0][1]); >+ result[1][0] = ddy_fine(x[1][0]); >+ result[1][1] = ddy_fine(x[1][1]); >+ result[2][0] = ddy_fine(x[2][0]); >+ result[2][1] = ddy_fine(x[2][1]); >+ result[3][0] = ddy_fine(x[3][0]); >+ result[3][1] = ddy_fine(x[3][1]); >+ return result; >+} >+float4x3 ddy_fine(float4x3 x) { >+ float4x3 result; >+ result[0][0] = ddy_fine(x[0][0]); >+ result[0][1] = ddy_fine(x[0][1]); >+ result[0][2] = ddy_fine(x[0][2]); >+ result[1][0] = ddy_fine(x[1][0]); >+ result[1][1] = ddy_fine(x[1][1]); >+ result[1][2] = ddy_fine(x[1][2]); >+ result[2][0] = ddy_fine(x[2][0]); >+ result[2][1] = ddy_fine(x[2][1]); >+ result[2][2] = ddy_fine(x[2][2]); >+ result[3][0] = ddy_fine(x[3][0]); >+ result[3][1] = ddy_fine(x[3][1]); >+ result[3][2] = ddy_fine(x[3][2]); >+ return result; >+} >+float4x4 ddy_fine(float4x4 x) { >+ float4x4 result; >+ result[0][0] = ddy_fine(x[0][0]); >+ result[0][1] = ddy_fine(x[0][1]); >+ result[0][2] = ddy_fine(x[0][2]); >+ result[0][3] = ddy_fine(x[0][3]); >+ result[1][0] = ddy_fine(x[1][0]); >+ result[1][1] = ddy_fine(x[1][1]); >+ result[1][2] = ddy_fine(x[1][2]); >+ result[1][3] = ddy_fine(x[1][3]); >+ result[2][0] = ddy_fine(x[2][0]); >+ result[2][1] = ddy_fine(x[2][1]); >+ result[2][2] = ddy_fine(x[2][2]); >+ result[2][3] = ddy_fine(x[2][3]); >+ result[3][0] = ddy_fine(x[3][0]); >+ result[3][1] = ddy_fine(x[3][1]); >+ result[3][2] = ddy_fine(x[3][2]); >+ result[3][3] = ddy_fine(x[3][3]); >+ return result; >+} >+float2 fwidth(float2 x) { >+ float2 result; >+ result[0] = fwidth(x[0]); >+ result[1] = fwidth(x[1]); >+ return result; >+} >+float3 fwidth(float3 x) { >+ float3 result; >+ result[0] = fwidth(x[0]); >+ result[1] = fwidth(x[1]); >+ result[2] = fwidth(x[2]); >+ return result; >+} >+float4 fwidth(float4 x) { >+ float4 result; >+ result[0] = fwidth(x[0]); >+ result[1] = fwidth(x[1]); >+ result[2] = fwidth(x[2]); >+ result[3] = fwidth(x[3]); >+ return result; >+} >+float2x2 fwidth(float2x2 x) { >+ float2x2 result; >+ result[0][0] = fwidth(x[0][0]); >+ result[0][1] = fwidth(x[0][1]); >+ result[1][0] = fwidth(x[1][0]); >+ result[1][1] = fwidth(x[1][1]); >+ return result; >+} >+float2x3 fwidth(float2x3 x) { >+ float2x3 result; >+ result[0][0] = fwidth(x[0][0]); >+ result[0][1] = fwidth(x[0][1]); >+ result[0][2] = fwidth(x[0][2]); >+ result[1][0] = fwidth(x[1][0]); >+ result[1][1] = fwidth(x[1][1]); >+ result[1][2] = fwidth(x[1][2]); >+ return result; >+} >+float2x4 fwidth(float2x4 x) { >+ float2x4 result; >+ result[0][0] = fwidth(x[0][0]); >+ result[0][1] = fwidth(x[0][1]); >+ result[0][2] = fwidth(x[0][2]); >+ result[0][3] = fwidth(x[0][3]); >+ result[1][0] = fwidth(x[1][0]); >+ result[1][1] = fwidth(x[1][1]); >+ result[1][2] = fwidth(x[1][2]); >+ result[1][3] = fwidth(x[1][3]); >+ return result; >+} >+float3x2 fwidth(float3x2 x) { >+ float3x2 result; >+ result[0][0] = fwidth(x[0][0]); >+ result[0][1] = fwidth(x[0][1]); >+ result[1][0] = fwidth(x[1][0]); >+ result[1][1] = fwidth(x[1][1]); >+ result[2][0] = fwidth(x[2][0]); >+ result[2][1] = fwidth(x[2][1]); >+ return result; >+} >+float3x3 fwidth(float3x3 x) { >+ float3x3 result; >+ result[0][0] = fwidth(x[0][0]); >+ result[0][1] = fwidth(x[0][1]); >+ result[0][2] = fwidth(x[0][2]); >+ result[1][0] = fwidth(x[1][0]); >+ result[1][1] = fwidth(x[1][1]); >+ result[1][2] = fwidth(x[1][2]); >+ result[2][0] = fwidth(x[2][0]); >+ result[2][1] = fwidth(x[2][1]); >+ result[2][2] = fwidth(x[2][2]); >+ return result; >+} >+float3x4 fwidth(float3x4 x) { >+ float3x4 result; >+ result[0][0] = fwidth(x[0][0]); >+ result[0][1] = fwidth(x[0][1]); >+ result[0][2] = fwidth(x[0][2]); >+ result[0][3] = fwidth(x[0][3]); >+ result[1][0] = fwidth(x[1][0]); >+ result[1][1] = fwidth(x[1][1]); >+ result[1][2] = fwidth(x[1][2]); >+ result[1][3] = fwidth(x[1][3]); >+ result[2][0] = fwidth(x[2][0]); >+ result[2][1] = fwidth(x[2][1]); >+ result[2][2] = fwidth(x[2][2]); >+ result[2][3] = fwidth(x[2][3]); >+ return result; >+} >+float4x2 fwidth(float4x2 x) { >+ float4x2 result; >+ result[0][0] = fwidth(x[0][0]); >+ result[0][1] = fwidth(x[0][1]); >+ result[1][0] = fwidth(x[1][0]); >+ result[1][1] = fwidth(x[1][1]); >+ result[2][0] = fwidth(x[2][0]); >+ result[2][1] = fwidth(x[2][1]); >+ result[3][0] = fwidth(x[3][0]); >+ result[3][1] = fwidth(x[3][1]); >+ return result; >+} >+float4x3 fwidth(float4x3 x) { >+ float4x3 result; >+ result[0][0] = fwidth(x[0][0]); >+ result[0][1] = fwidth(x[0][1]); >+ result[0][2] = fwidth(x[0][2]); >+ result[1][0] = fwidth(x[1][0]); >+ result[1][1] = fwidth(x[1][1]); >+ result[1][2] = fwidth(x[1][2]); >+ result[2][0] = fwidth(x[2][0]); >+ result[2][1] = fwidth(x[2][1]); >+ result[2][2] = fwidth(x[2][2]); >+ result[3][0] = fwidth(x[3][0]); >+ result[3][1] = fwidth(x[3][1]); >+ result[3][2] = fwidth(x[3][2]); >+ return result; >+} >+float4x4 fwidth(float4x4 x) { >+ float4x4 result; >+ result[0][0] = fwidth(x[0][0]); >+ result[0][1] = fwidth(x[0][1]); >+ result[0][2] = fwidth(x[0][2]); >+ result[0][3] = fwidth(x[0][3]); >+ result[1][0] = fwidth(x[1][0]); >+ result[1][1] = fwidth(x[1][1]); >+ result[1][2] = fwidth(x[1][2]); >+ result[1][3] = fwidth(x[1][3]); >+ result[2][0] = fwidth(x[2][0]); >+ result[2][1] = fwidth(x[2][1]); >+ result[2][2] = fwidth(x[2][2]); >+ result[2][3] = fwidth(x[2][3]); >+ result[3][0] = fwidth(x[3][0]); >+ result[3][1] = fwidth(x[3][1]); >+ result[3][2] = fwidth(x[3][2]); >+ result[3][3] = fwidth(x[3][3]); >+ return result; >+} >+ >+native float pow(float, float); >+half pow(half x, half y) { >+ return half(pow(float(x), float(y))); >+} >+half step(half y, half x) { >+ return x >= y ? 1 : 0; >+} >+half ldexp(half x, half e) { >+ return x * pow(2, e); >+} >+half fmod(half x, half y) { >+ uint whole = uint(x / y); >+ half multiple = half(whole) * y; >+ return x - multiple; >+} >+half2 pow(half2 x, half2 y) { >+ half2 result; >+ result[0] = pow(x[0], y[0]); >+ result[1] = pow(x[1], y[1]); >+ return result; >+} >+half3 pow(half3 x, half3 y) { >+ half3 result; >+ result[0] = pow(x[0], y[0]); >+ result[1] = pow(x[1], y[1]); >+ result[2] = pow(x[2], y[2]); >+ return result; >+} >+half4 pow(half4 x, half4 y) { >+ half4 result; >+ result[0] = pow(x[0], y[0]); >+ result[1] = pow(x[1], y[1]); >+ result[2] = pow(x[2], y[2]); >+ result[3] = pow(x[3], y[3]); >+ return result; >+} >+half2x2 pow(half2x2 x, half2x2 y) { >+ half2x2 result; >+ result[0][0] = pow(x[0][0], y[0][0]); >+ result[0][1] = pow(x[0][1], y[0][1]); >+ result[1][0] = pow(x[1][0], y[1][0]); >+ result[1][1] = pow(x[1][1], y[1][1]); >+ return result; >+} >+half2x3 pow(half2x3 x, half2x3 y) { >+ half2x3 result; >+ result[0][0] = pow(x[0][0], y[0][0]); >+ result[0][1] = pow(x[0][1], y[0][1]); >+ result[0][2] = pow(x[0][2], y[0][2]); >+ result[1][0] = pow(x[1][0], y[1][0]); >+ result[1][1] = pow(x[1][1], y[1][1]); >+ result[1][2] = pow(x[1][2], y[1][2]); >+ return result; >+} >+half2x4 pow(half2x4 x, half2x4 y) { >+ half2x4 result; >+ result[0][0] = pow(x[0][0], y[0][0]); >+ result[0][1] = pow(x[0][1], y[0][1]); >+ result[0][2] = pow(x[0][2], y[0][2]); >+ result[0][3] = pow(x[0][3], y[0][3]); >+ result[1][0] = pow(x[1][0], y[1][0]); >+ result[1][1] = pow(x[1][1], y[1][1]); >+ result[1][2] = pow(x[1][2], y[1][2]); >+ result[1][3] = pow(x[1][3], y[1][3]); >+ return result; >+} >+half3x2 pow(half3x2 x, half3x2 y) { >+ half3x2 result; >+ result[0][0] = pow(x[0][0], y[0][0]); >+ result[0][1] = pow(x[0][1], y[0][1]); >+ result[1][0] = pow(x[1][0], y[1][0]); >+ result[1][1] = pow(x[1][1], y[1][1]); >+ result[2][0] = pow(x[2][0], y[2][0]); >+ result[2][1] = pow(x[2][1], y[2][1]); >+ return result; >+} >+half3x3 pow(half3x3 x, half3x3 y) { >+ half3x3 result; >+ result[0][0] = pow(x[0][0], y[0][0]); >+ result[0][1] = pow(x[0][1], y[0][1]); >+ result[0][2] = pow(x[0][2], y[0][2]); >+ result[1][0] = pow(x[1][0], y[1][0]); >+ result[1][1] = pow(x[1][1], y[1][1]); >+ result[1][2] = pow(x[1][2], y[1][2]); >+ result[2][0] = pow(x[2][0], y[2][0]); >+ result[2][1] = pow(x[2][1], y[2][1]); >+ result[2][2] = pow(x[2][2], y[2][2]); >+ return result; >+} >+half3x4 pow(half3x4 x, half3x4 y) { >+ half3x4 result; >+ result[0][0] = pow(x[0][0], y[0][0]); >+ result[0][1] = pow(x[0][1], y[0][1]); >+ result[0][2] = pow(x[0][2], y[0][2]); >+ result[0][3] = pow(x[0][3], y[0][3]); >+ result[1][0] = pow(x[1][0], y[1][0]); >+ result[1][1] = pow(x[1][1], y[1][1]); >+ result[1][2] = pow(x[1][2], y[1][2]); >+ result[1][3] = pow(x[1][3], y[1][3]); >+ result[2][0] = pow(x[2][0], y[2][0]); >+ result[2][1] = pow(x[2][1], y[2][1]); >+ result[2][2] = pow(x[2][2], y[2][2]); >+ result[2][3] = pow(x[2][3], y[2][3]); >+ return result; >+} >+half4x2 pow(half4x2 x, half4x2 y) { >+ half4x2 result; >+ result[0][0] = pow(x[0][0], y[0][0]); >+ result[0][1] = pow(x[0][1], y[0][1]); >+ result[1][0] = pow(x[1][0], y[1][0]); >+ result[1][1] = pow(x[1][1], y[1][1]); >+ result[2][0] = pow(x[2][0], y[2][0]); >+ result[2][1] = pow(x[2][1], y[2][1]); >+ result[3][0] = pow(x[3][0], y[3][0]); >+ result[3][1] = pow(x[3][1], y[3][1]); >+ return result; >+} >+half4x3 pow(half4x3 x, half4x3 y) { >+ half4x3 result; >+ result[0][0] = pow(x[0][0], y[0][0]); >+ result[0][1] = pow(x[0][1], y[0][1]); >+ result[0][2] = pow(x[0][2], y[0][2]); >+ result[1][0] = pow(x[1][0], y[1][0]); >+ result[1][1] = pow(x[1][1], y[1][1]); >+ result[1][2] = pow(x[1][2], y[1][2]); >+ result[2][0] = pow(x[2][0], y[2][0]); >+ result[2][1] = pow(x[2][1], y[2][1]); >+ result[2][2] = pow(x[2][2], y[2][2]); >+ result[3][0] = pow(x[3][0], y[3][0]); >+ result[3][1] = pow(x[3][1], y[3][1]); >+ result[3][2] = pow(x[3][2], y[3][2]); >+ return result; >+} >+half4x4 pow(half4x4 x, half4x4 y) { >+ half4x4 result; >+ result[0][0] = pow(x[0][0], y[0][0]); >+ result[0][1] = pow(x[0][1], y[0][1]); >+ result[0][2] = pow(x[0][2], y[0][2]); >+ result[0][3] = pow(x[0][3], y[0][3]); >+ result[1][0] = pow(x[1][0], y[1][0]); >+ result[1][1] = pow(x[1][1], y[1][1]); >+ result[1][2] = pow(x[1][2], y[1][2]); >+ result[1][3] = pow(x[1][3], y[1][3]); >+ result[2][0] = pow(x[2][0], y[2][0]); >+ result[2][1] = pow(x[2][1], y[2][1]); >+ result[2][2] = pow(x[2][2], y[2][2]); >+ result[2][3] = pow(x[2][3], y[2][3]); >+ result[3][0] = pow(x[3][0], y[3][0]); >+ result[3][1] = pow(x[3][1], y[3][1]); >+ result[3][2] = pow(x[3][2], y[3][2]); >+ result[3][3] = pow(x[3][3], y[3][3]); >+ return result; >+} >+half2 step(half2 x, half2 y) { >+ half2 result; >+ result[0] = step(x[0], y[0]); >+ result[1] = step(x[1], y[1]); >+ return result; >+} >+half3 step(half3 x, half3 y) { >+ half3 result; >+ result[0] = step(x[0], y[0]); >+ result[1] = step(x[1], y[1]); >+ result[2] = step(x[2], y[2]); >+ return result; >+} >+half4 step(half4 x, half4 y) { >+ half4 result; >+ result[0] = step(x[0], y[0]); >+ result[1] = step(x[1], y[1]); >+ result[2] = step(x[2], y[2]); >+ result[3] = step(x[3], y[3]); >+ return result; >+} >+half2x2 step(half2x2 x, half2x2 y) { >+ half2x2 result; >+ result[0][0] = step(x[0][0], y[0][0]); >+ result[0][1] = step(x[0][1], y[0][1]); >+ result[1][0] = step(x[1][0], y[1][0]); >+ result[1][1] = step(x[1][1], y[1][1]); >+ return result; >+} >+half2x3 step(half2x3 x, half2x3 y) { >+ half2x3 result; >+ result[0][0] = step(x[0][0], y[0][0]); >+ result[0][1] = step(x[0][1], y[0][1]); >+ result[0][2] = step(x[0][2], y[0][2]); >+ result[1][0] = step(x[1][0], y[1][0]); >+ result[1][1] = step(x[1][1], y[1][1]); >+ result[1][2] = step(x[1][2], y[1][2]); >+ return result; >+} >+half2x4 step(half2x4 x, half2x4 y) { >+ half2x4 result; >+ result[0][0] = step(x[0][0], y[0][0]); >+ result[0][1] = step(x[0][1], y[0][1]); >+ result[0][2] = step(x[0][2], y[0][2]); >+ result[0][3] = step(x[0][3], y[0][3]); >+ result[1][0] = step(x[1][0], y[1][0]); >+ result[1][1] = step(x[1][1], y[1][1]); >+ result[1][2] = step(x[1][2], y[1][2]); >+ result[1][3] = step(x[1][3], y[1][3]); >+ return result; >+} >+half3x2 step(half3x2 x, half3x2 y) { >+ half3x2 result; >+ result[0][0] = step(x[0][0], y[0][0]); >+ result[0][1] = step(x[0][1], y[0][1]); >+ result[1][0] = step(x[1][0], y[1][0]); >+ result[1][1] = step(x[1][1], y[1][1]); >+ result[2][0] = step(x[2][0], y[2][0]); >+ result[2][1] = step(x[2][1], y[2][1]); >+ return result; >+} >+half3x3 step(half3x3 x, half3x3 y) { >+ half3x3 result; >+ result[0][0] = step(x[0][0], y[0][0]); >+ result[0][1] = step(x[0][1], y[0][1]); >+ result[0][2] = step(x[0][2], y[0][2]); >+ result[1][0] = step(x[1][0], y[1][0]); >+ result[1][1] = step(x[1][1], y[1][1]); >+ result[1][2] = step(x[1][2], y[1][2]); >+ result[2][0] = step(x[2][0], y[2][0]); >+ result[2][1] = step(x[2][1], y[2][1]); >+ result[2][2] = step(x[2][2], y[2][2]); >+ return result; >+} >+half3x4 step(half3x4 x, half3x4 y) { >+ half3x4 result; >+ result[0][0] = step(x[0][0], y[0][0]); >+ result[0][1] = step(x[0][1], y[0][1]); >+ result[0][2] = step(x[0][2], y[0][2]); >+ result[0][3] = step(x[0][3], y[0][3]); >+ result[1][0] = step(x[1][0], y[1][0]); >+ result[1][1] = step(x[1][1], y[1][1]); >+ result[1][2] = step(x[1][2], y[1][2]); >+ result[1][3] = step(x[1][3], y[1][3]); >+ result[2][0] = step(x[2][0], y[2][0]); >+ result[2][1] = step(x[2][1], y[2][1]); >+ result[2][2] = step(x[2][2], y[2][2]); >+ result[2][3] = step(x[2][3], y[2][3]); >+ return result; >+} >+half4x2 step(half4x2 x, half4x2 y) { >+ half4x2 result; >+ result[0][0] = step(x[0][0], y[0][0]); >+ result[0][1] = step(x[0][1], y[0][1]); >+ result[1][0] = step(x[1][0], y[1][0]); >+ result[1][1] = step(x[1][1], y[1][1]); >+ result[2][0] = step(x[2][0], y[2][0]); >+ result[2][1] = step(x[2][1], y[2][1]); >+ result[3][0] = step(x[3][0], y[3][0]); >+ result[3][1] = step(x[3][1], y[3][1]); >+ return result; >+} >+half4x3 step(half4x3 x, half4x3 y) { >+ half4x3 result; >+ result[0][0] = step(x[0][0], y[0][0]); >+ result[0][1] = step(x[0][1], y[0][1]); >+ result[0][2] = step(x[0][2], y[0][2]); >+ result[1][0] = step(x[1][0], y[1][0]); >+ result[1][1] = step(x[1][1], y[1][1]); >+ result[1][2] = step(x[1][2], y[1][2]); >+ result[2][0] = step(x[2][0], y[2][0]); >+ result[2][1] = step(x[2][1], y[2][1]); >+ result[2][2] = step(x[2][2], y[2][2]); >+ result[3][0] = step(x[3][0], y[3][0]); >+ result[3][1] = step(x[3][1], y[3][1]); >+ result[3][2] = step(x[3][2], y[3][2]); >+ return result; >+} >+half4x4 step(half4x4 x, half4x4 y) { >+ half4x4 result; >+ result[0][0] = step(x[0][0], y[0][0]); >+ result[0][1] = step(x[0][1], y[0][1]); >+ result[0][2] = step(x[0][2], y[0][2]); >+ result[0][3] = step(x[0][3], y[0][3]); >+ result[1][0] = step(x[1][0], y[1][0]); >+ result[1][1] = step(x[1][1], y[1][1]); >+ result[1][2] = step(x[1][2], y[1][2]); >+ result[1][3] = step(x[1][3], y[1][3]); >+ result[2][0] = step(x[2][0], y[2][0]); >+ result[2][1] = step(x[2][1], y[2][1]); >+ result[2][2] = step(x[2][2], y[2][2]); >+ result[2][3] = step(x[2][3], y[2][3]); >+ result[3][0] = step(x[3][0], y[3][0]); >+ result[3][1] = step(x[3][1], y[3][1]); >+ result[3][2] = step(x[3][2], y[3][2]); >+ result[3][3] = step(x[3][3], y[3][3]); >+ return result; >+} >+half2 ldexp(half2 x, half2 y) { >+ half2 result; >+ result[0] = ldexp(x[0], y[0]); >+ result[1] = ldexp(x[1], y[1]); >+ return result; >+} >+half3 ldexp(half3 x, half3 y) { >+ half3 result; >+ result[0] = ldexp(x[0], y[0]); >+ result[1] = ldexp(x[1], y[1]); >+ result[2] = ldexp(x[2], y[2]); >+ return result; >+} >+half4 ldexp(half4 x, half4 y) { >+ half4 result; >+ result[0] = ldexp(x[0], y[0]); >+ result[1] = ldexp(x[1], y[1]); >+ result[2] = ldexp(x[2], y[2]); >+ result[3] = ldexp(x[3], y[3]); >+ return result; >+} >+half2x2 ldexp(half2x2 x, half2x2 y) { >+ half2x2 result; >+ result[0][0] = ldexp(x[0][0], y[0][0]); >+ result[0][1] = ldexp(x[0][1], y[0][1]); >+ result[1][0] = ldexp(x[1][0], y[1][0]); >+ result[1][1] = ldexp(x[1][1], y[1][1]); >+ return result; >+} >+half2x3 ldexp(half2x3 x, half2x3 y) { >+ half2x3 result; >+ result[0][0] = ldexp(x[0][0], y[0][0]); >+ result[0][1] = ldexp(x[0][1], y[0][1]); >+ result[0][2] = ldexp(x[0][2], y[0][2]); >+ result[1][0] = ldexp(x[1][0], y[1][0]); >+ result[1][1] = ldexp(x[1][1], y[1][1]); >+ result[1][2] = ldexp(x[1][2], y[1][2]); >+ return result; >+} >+half2x4 ldexp(half2x4 x, half2x4 y) { >+ half2x4 result; >+ result[0][0] = ldexp(x[0][0], y[0][0]); >+ result[0][1] = ldexp(x[0][1], y[0][1]); >+ result[0][2] = ldexp(x[0][2], y[0][2]); >+ result[0][3] = ldexp(x[0][3], y[0][3]); >+ result[1][0] = ldexp(x[1][0], y[1][0]); >+ result[1][1] = ldexp(x[1][1], y[1][1]); >+ result[1][2] = ldexp(x[1][2], y[1][2]); >+ result[1][3] = ldexp(x[1][3], y[1][3]); >+ return result; >+} >+half3x2 ldexp(half3x2 x, half3x2 y) { >+ half3x2 result; >+ result[0][0] = ldexp(x[0][0], y[0][0]); >+ result[0][1] = ldexp(x[0][1], y[0][1]); >+ result[1][0] = ldexp(x[1][0], y[1][0]); >+ result[1][1] = ldexp(x[1][1], y[1][1]); >+ result[2][0] = ldexp(x[2][0], y[2][0]); >+ result[2][1] = ldexp(x[2][1], y[2][1]); >+ return result; >+} >+half3x3 ldexp(half3x3 x, half3x3 y) { >+ half3x3 result; >+ result[0][0] = ldexp(x[0][0], y[0][0]); >+ result[0][1] = ldexp(x[0][1], y[0][1]); >+ result[0][2] = ldexp(x[0][2], y[0][2]); >+ result[1][0] = ldexp(x[1][0], y[1][0]); >+ result[1][1] = ldexp(x[1][1], y[1][1]); >+ result[1][2] = ldexp(x[1][2], y[1][2]); >+ result[2][0] = ldexp(x[2][0], y[2][0]); >+ result[2][1] = ldexp(x[2][1], y[2][1]); >+ result[2][2] = ldexp(x[2][2], y[2][2]); >+ return result; >+} >+half3x4 ldexp(half3x4 x, half3x4 y) { >+ half3x4 result; >+ result[0][0] = ldexp(x[0][0], y[0][0]); >+ result[0][1] = ldexp(x[0][1], y[0][1]); >+ result[0][2] = ldexp(x[0][2], y[0][2]); >+ result[0][3] = ldexp(x[0][3], y[0][3]); >+ result[1][0] = ldexp(x[1][0], y[1][0]); >+ result[1][1] = ldexp(x[1][1], y[1][1]); >+ result[1][2] = ldexp(x[1][2], y[1][2]); >+ result[1][3] = ldexp(x[1][3], y[1][3]); >+ result[2][0] = ldexp(x[2][0], y[2][0]); >+ result[2][1] = ldexp(x[2][1], y[2][1]); >+ result[2][2] = ldexp(x[2][2], y[2][2]); >+ result[2][3] = ldexp(x[2][3], y[2][3]); >+ return result; >+} >+half4x2 ldexp(half4x2 x, half4x2 y) { >+ half4x2 result; >+ result[0][0] = ldexp(x[0][0], y[0][0]); >+ result[0][1] = ldexp(x[0][1], y[0][1]); >+ result[1][0] = ldexp(x[1][0], y[1][0]); >+ result[1][1] = ldexp(x[1][1], y[1][1]); >+ result[2][0] = ldexp(x[2][0], y[2][0]); >+ result[2][1] = ldexp(x[2][1], y[2][1]); >+ result[3][0] = ldexp(x[3][0], y[3][0]); >+ result[3][1] = ldexp(x[3][1], y[3][1]); >+ return result; >+} >+half4x3 ldexp(half4x3 x, half4x3 y) { >+ half4x3 result; >+ result[0][0] = ldexp(x[0][0], y[0][0]); >+ result[0][1] = ldexp(x[0][1], y[0][1]); >+ result[0][2] = ldexp(x[0][2], y[0][2]); >+ result[1][0] = ldexp(x[1][0], y[1][0]); >+ result[1][1] = ldexp(x[1][1], y[1][1]); >+ result[1][2] = ldexp(x[1][2], y[1][2]); >+ result[2][0] = ldexp(x[2][0], y[2][0]); >+ result[2][1] = ldexp(x[2][1], y[2][1]); >+ result[2][2] = ldexp(x[2][2], y[2][2]); >+ result[3][0] = ldexp(x[3][0], y[3][0]); >+ result[3][1] = ldexp(x[3][1], y[3][1]); >+ result[3][2] = ldexp(x[3][2], y[3][2]); >+ return result; >+} >+half4x4 ldexp(half4x4 x, half4x4 y) { >+ half4x4 result; >+ result[0][0] = ldexp(x[0][0], y[0][0]); >+ result[0][1] = ldexp(x[0][1], y[0][1]); >+ result[0][2] = ldexp(x[0][2], y[0][2]); >+ result[0][3] = ldexp(x[0][3], y[0][3]); >+ result[1][0] = ldexp(x[1][0], y[1][0]); >+ result[1][1] = ldexp(x[1][1], y[1][1]); >+ result[1][2] = ldexp(x[1][2], y[1][2]); >+ result[1][3] = ldexp(x[1][3], y[1][3]); >+ result[2][0] = ldexp(x[2][0], y[2][0]); >+ result[2][1] = ldexp(x[2][1], y[2][1]); >+ result[2][2] = ldexp(x[2][2], y[2][2]); >+ result[2][3] = ldexp(x[2][3], y[2][3]); >+ result[3][0] = ldexp(x[3][0], y[3][0]); >+ result[3][1] = ldexp(x[3][1], y[3][1]); >+ result[3][2] = ldexp(x[3][2], y[3][2]); >+ result[3][3] = ldexp(x[3][3], y[3][3]); >+ return result; >+} >+half2 fmod(half2 x, half2 y) { >+ half2 result; >+ result[0] = fmod(x[0], y[0]); >+ result[1] = fmod(x[1], y[1]); >+ return result; >+} >+half3 fmod(half3 x, half3 y) { >+ half3 result; >+ result[0] = fmod(x[0], y[0]); >+ result[1] = fmod(x[1], y[1]); >+ result[2] = fmod(x[2], y[2]); >+ return result; >+} >+half4 fmod(half4 x, half4 y) { >+ half4 result; >+ result[0] = fmod(x[0], y[0]); >+ result[1] = fmod(x[1], y[1]); >+ result[2] = fmod(x[2], y[2]); >+ result[3] = fmod(x[3], y[3]); >+ return result; >+} >+half2x2 fmod(half2x2 x, half2x2 y) { >+ half2x2 result; >+ result[0][0] = fmod(x[0][0], y[0][0]); >+ result[0][1] = fmod(x[0][1], y[0][1]); >+ result[1][0] = fmod(x[1][0], y[1][0]); >+ result[1][1] = fmod(x[1][1], y[1][1]); >+ return result; >+} >+half2x3 fmod(half2x3 x, half2x3 y) { >+ half2x3 result; >+ result[0][0] = fmod(x[0][0], y[0][0]); >+ result[0][1] = fmod(x[0][1], y[0][1]); >+ result[0][2] = fmod(x[0][2], y[0][2]); >+ result[1][0] = fmod(x[1][0], y[1][0]); >+ result[1][1] = fmod(x[1][1], y[1][1]); >+ result[1][2] = fmod(x[1][2], y[1][2]); >+ return result; >+} >+half2x4 fmod(half2x4 x, half2x4 y) { >+ half2x4 result; >+ result[0][0] = fmod(x[0][0], y[0][0]); >+ result[0][1] = fmod(x[0][1], y[0][1]); >+ result[0][2] = fmod(x[0][2], y[0][2]); >+ result[0][3] = fmod(x[0][3], y[0][3]); >+ result[1][0] = fmod(x[1][0], y[1][0]); >+ result[1][1] = fmod(x[1][1], y[1][1]); >+ result[1][2] = fmod(x[1][2], y[1][2]); >+ result[1][3] = fmod(x[1][3], y[1][3]); >+ return result; >+} >+half3x2 fmod(half3x2 x, half3x2 y) { >+ half3x2 result; >+ result[0][0] = fmod(x[0][0], y[0][0]); >+ result[0][1] = fmod(x[0][1], y[0][1]); >+ result[1][0] = fmod(x[1][0], y[1][0]); >+ result[1][1] = fmod(x[1][1], y[1][1]); >+ result[2][0] = fmod(x[2][0], y[2][0]); >+ result[2][1] = fmod(x[2][1], y[2][1]); >+ return result; >+} >+half3x3 fmod(half3x3 x, half3x3 y) { >+ half3x3 result; >+ result[0][0] = fmod(x[0][0], y[0][0]); >+ result[0][1] = fmod(x[0][1], y[0][1]); >+ result[0][2] = fmod(x[0][2], y[0][2]); >+ result[1][0] = fmod(x[1][0], y[1][0]); >+ result[1][1] = fmod(x[1][1], y[1][1]); >+ result[1][2] = fmod(x[1][2], y[1][2]); >+ result[2][0] = fmod(x[2][0], y[2][0]); >+ result[2][1] = fmod(x[2][1], y[2][1]); >+ result[2][2] = fmod(x[2][2], y[2][2]); >+ return result; >+} >+half3x4 fmod(half3x4 x, half3x4 y) { >+ half3x4 result; >+ result[0][0] = fmod(x[0][0], y[0][0]); >+ result[0][1] = fmod(x[0][1], y[0][1]); >+ result[0][2] = fmod(x[0][2], y[0][2]); >+ result[0][3] = fmod(x[0][3], y[0][3]); >+ result[1][0] = fmod(x[1][0], y[1][0]); >+ result[1][1] = fmod(x[1][1], y[1][1]); >+ result[1][2] = fmod(x[1][2], y[1][2]); >+ result[1][3] = fmod(x[1][3], y[1][3]); >+ result[2][0] = fmod(x[2][0], y[2][0]); >+ result[2][1] = fmod(x[2][1], y[2][1]); >+ result[2][2] = fmod(x[2][2], y[2][2]); >+ result[2][3] = fmod(x[2][3], y[2][3]); >+ return result; >+} >+half4x2 fmod(half4x2 x, half4x2 y) { >+ half4x2 result; >+ result[0][0] = fmod(x[0][0], y[0][0]); >+ result[0][1] = fmod(x[0][1], y[0][1]); >+ result[1][0] = fmod(x[1][0], y[1][0]); >+ result[1][1] = fmod(x[1][1], y[1][1]); >+ result[2][0] = fmod(x[2][0], y[2][0]); >+ result[2][1] = fmod(x[2][1], y[2][1]); >+ result[3][0] = fmod(x[3][0], y[3][0]); >+ result[3][1] = fmod(x[3][1], y[3][1]); >+ return result; >+} >+half4x3 fmod(half4x3 x, half4x3 y) { >+ half4x3 result; >+ result[0][0] = fmod(x[0][0], y[0][0]); >+ result[0][1] = fmod(x[0][1], y[0][1]); >+ result[0][2] = fmod(x[0][2], y[0][2]); >+ result[1][0] = fmod(x[1][0], y[1][0]); >+ result[1][1] = fmod(x[1][1], y[1][1]); >+ result[1][2] = fmod(x[1][2], y[1][2]); >+ result[2][0] = fmod(x[2][0], y[2][0]); >+ result[2][1] = fmod(x[2][1], y[2][1]); >+ result[2][2] = fmod(x[2][2], y[2][2]); >+ result[3][0] = fmod(x[3][0], y[3][0]); >+ result[3][1] = fmod(x[3][1], y[3][1]); >+ result[3][2] = fmod(x[3][2], y[3][2]); >+ return result; >+} >+half4x4 fmod(half4x4 x, half4x4 y) { >+ half4x4 result; >+ result[0][0] = fmod(x[0][0], y[0][0]); >+ result[0][1] = fmod(x[0][1], y[0][1]); >+ result[0][2] = fmod(x[0][2], y[0][2]); >+ result[0][3] = fmod(x[0][3], y[0][3]); >+ result[1][0] = fmod(x[1][0], y[1][0]); >+ result[1][1] = fmod(x[1][1], y[1][1]); >+ result[1][2] = fmod(x[1][2], y[1][2]); >+ result[1][3] = fmod(x[1][3], y[1][3]); >+ result[2][0] = fmod(x[2][0], y[2][0]); >+ result[2][1] = fmod(x[2][1], y[2][1]); >+ result[2][2] = fmod(x[2][2], y[2][2]); >+ result[2][3] = fmod(x[2][3], y[2][3]); >+ result[3][0] = fmod(x[3][0], y[3][0]); >+ result[3][1] = fmod(x[3][1], y[3][1]); >+ result[3][2] = fmod(x[3][2], y[3][2]); >+ result[3][3] = fmod(x[3][3], y[3][3]); >+ return result; >+} >+ >+float step(float y, float x) { >+ return x >= y ? 1 : 0; >+} >+float ldexp(float x, float e) { >+ return x * pow(2, e); >+} >+float fmod(float x, float y) { >+ uint whole = uint(x / y); >+ float multiple = float(whole) * y; >+ return x - multiple; >+} >+float2 pow(float2 x, float2 y) { >+ float2 result; >+ result[0] = pow(x[0], y[0]); >+ result[1] = pow(x[1], y[1]); >+ return result; >+} >+float3 pow(float3 x, float3 y) { >+ float3 result; >+ result[0] = pow(x[0], y[0]); >+ result[1] = pow(x[1], y[1]); >+ result[2] = pow(x[2], y[2]); >+ return result; >+} >+float4 pow(float4 x, float4 y) { >+ float4 result; >+ result[0] = pow(x[0], y[0]); >+ result[1] = pow(x[1], y[1]); >+ result[2] = pow(x[2], y[2]); >+ result[3] = pow(x[3], y[3]); >+ return result; >+} >+float2x2 pow(float2x2 x, float2x2 y) { >+ float2x2 result; >+ result[0][0] = pow(x[0][0], y[0][0]); >+ result[0][1] = pow(x[0][1], y[0][1]); >+ result[1][0] = pow(x[1][0], y[1][0]); >+ result[1][1] = pow(x[1][1], y[1][1]); >+ return result; >+} >+float2x3 pow(float2x3 x, float2x3 y) { >+ float2x3 result; >+ result[0][0] = pow(x[0][0], y[0][0]); >+ result[0][1] = pow(x[0][1], y[0][1]); >+ result[0][2] = pow(x[0][2], y[0][2]); >+ result[1][0] = pow(x[1][0], y[1][0]); >+ result[1][1] = pow(x[1][1], y[1][1]); >+ result[1][2] = pow(x[1][2], y[1][2]); >+ return result; >+} >+float2x4 pow(float2x4 x, float2x4 y) { >+ float2x4 result; >+ result[0][0] = pow(x[0][0], y[0][0]); >+ result[0][1] = pow(x[0][1], y[0][1]); >+ result[0][2] = pow(x[0][2], y[0][2]); >+ result[0][3] = pow(x[0][3], y[0][3]); >+ result[1][0] = pow(x[1][0], y[1][0]); >+ result[1][1] = pow(x[1][1], y[1][1]); >+ result[1][2] = pow(x[1][2], y[1][2]); >+ result[1][3] = pow(x[1][3], y[1][3]); >+ return result; >+} >+float3x2 pow(float3x2 x, float3x2 y) { >+ float3x2 result; >+ result[0][0] = pow(x[0][0], y[0][0]); >+ result[0][1] = pow(x[0][1], y[0][1]); >+ result[1][0] = pow(x[1][0], y[1][0]); >+ result[1][1] = pow(x[1][1], y[1][1]); >+ result[2][0] = pow(x[2][0], y[2][0]); >+ result[2][1] = pow(x[2][1], y[2][1]); >+ return result; >+} >+float3x3 pow(float3x3 x, float3x3 y) { >+ float3x3 result; >+ result[0][0] = pow(x[0][0], y[0][0]); >+ result[0][1] = pow(x[0][1], y[0][1]); >+ result[0][2] = pow(x[0][2], y[0][2]); >+ result[1][0] = pow(x[1][0], y[1][0]); >+ result[1][1] = pow(x[1][1], y[1][1]); >+ result[1][2] = pow(x[1][2], y[1][2]); >+ result[2][0] = pow(x[2][0], y[2][0]); >+ result[2][1] = pow(x[2][1], y[2][1]); >+ result[2][2] = pow(x[2][2], y[2][2]); >+ return result; >+} >+float3x4 pow(float3x4 x, float3x4 y) { >+ float3x4 result; >+ result[0][0] = pow(x[0][0], y[0][0]); >+ result[0][1] = pow(x[0][1], y[0][1]); >+ result[0][2] = pow(x[0][2], y[0][2]); >+ result[0][3] = pow(x[0][3], y[0][3]); >+ result[1][0] = pow(x[1][0], y[1][0]); >+ result[1][1] = pow(x[1][1], y[1][1]); >+ result[1][2] = pow(x[1][2], y[1][2]); >+ result[1][3] = pow(x[1][3], y[1][3]); >+ result[2][0] = pow(x[2][0], y[2][0]); >+ result[2][1] = pow(x[2][1], y[2][1]); >+ result[2][2] = pow(x[2][2], y[2][2]); >+ result[2][3] = pow(x[2][3], y[2][3]); >+ return result; >+} >+float4x2 pow(float4x2 x, float4x2 y) { >+ float4x2 result; >+ result[0][0] = pow(x[0][0], y[0][0]); >+ result[0][1] = pow(x[0][1], y[0][1]); >+ result[1][0] = pow(x[1][0], y[1][0]); >+ result[1][1] = pow(x[1][1], y[1][1]); >+ result[2][0] = pow(x[2][0], y[2][0]); >+ result[2][1] = pow(x[2][1], y[2][1]); >+ result[3][0] = pow(x[3][0], y[3][0]); >+ result[3][1] = pow(x[3][1], y[3][1]); >+ return result; >+} >+float4x3 pow(float4x3 x, float4x3 y) { >+ float4x3 result; >+ result[0][0] = pow(x[0][0], y[0][0]); >+ result[0][1] = pow(x[0][1], y[0][1]); >+ result[0][2] = pow(x[0][2], y[0][2]); >+ result[1][0] = pow(x[1][0], y[1][0]); >+ result[1][1] = pow(x[1][1], y[1][1]); >+ result[1][2] = pow(x[1][2], y[1][2]); >+ result[2][0] = pow(x[2][0], y[2][0]); >+ result[2][1] = pow(x[2][1], y[2][1]); >+ result[2][2] = pow(x[2][2], y[2][2]); >+ result[3][0] = pow(x[3][0], y[3][0]); >+ result[3][1] = pow(x[3][1], y[3][1]); >+ result[3][2] = pow(x[3][2], y[3][2]); >+ return result; >+} >+float4x4 pow(float4x4 x, float4x4 y) { >+ float4x4 result; >+ result[0][0] = pow(x[0][0], y[0][0]); >+ result[0][1] = pow(x[0][1], y[0][1]); >+ result[0][2] = pow(x[0][2], y[0][2]); >+ result[0][3] = pow(x[0][3], y[0][3]); >+ result[1][0] = pow(x[1][0], y[1][0]); >+ result[1][1] = pow(x[1][1], y[1][1]); >+ result[1][2] = pow(x[1][2], y[1][2]); >+ result[1][3] = pow(x[1][3], y[1][3]); >+ result[2][0] = pow(x[2][0], y[2][0]); >+ result[2][1] = pow(x[2][1], y[2][1]); >+ result[2][2] = pow(x[2][2], y[2][2]); >+ result[2][3] = pow(x[2][3], y[2][3]); >+ result[3][0] = pow(x[3][0], y[3][0]); >+ result[3][1] = pow(x[3][1], y[3][1]); >+ result[3][2] = pow(x[3][2], y[3][2]); >+ result[3][3] = pow(x[3][3], y[3][3]); >+ return result; >+} >+float2 step(float2 x, float2 y) { >+ float2 result; >+ result[0] = step(x[0], y[0]); >+ result[1] = step(x[1], y[1]); >+ return result; >+} >+float3 step(float3 x, float3 y) { >+ float3 result; >+ result[0] = step(x[0], y[0]); >+ result[1] = step(x[1], y[1]); >+ result[2] = step(x[2], y[2]); >+ return result; >+} >+float4 step(float4 x, float4 y) { >+ float4 result; >+ result[0] = step(x[0], y[0]); >+ result[1] = step(x[1], y[1]); >+ result[2] = step(x[2], y[2]); >+ result[3] = step(x[3], y[3]); >+ return result; >+} >+float2x2 step(float2x2 x, float2x2 y) { >+ float2x2 result; >+ result[0][0] = step(x[0][0], y[0][0]); >+ result[0][1] = step(x[0][1], y[0][1]); >+ result[1][0] = step(x[1][0], y[1][0]); >+ result[1][1] = step(x[1][1], y[1][1]); >+ return result; >+} >+float2x3 step(float2x3 x, float2x3 y) { >+ float2x3 result; >+ result[0][0] = step(x[0][0], y[0][0]); >+ result[0][1] = step(x[0][1], y[0][1]); >+ result[0][2] = step(x[0][2], y[0][2]); >+ result[1][0] = step(x[1][0], y[1][0]); >+ result[1][1] = step(x[1][1], y[1][1]); >+ result[1][2] = step(x[1][2], y[1][2]); >+ return result; >+} >+float2x4 step(float2x4 x, float2x4 y) { >+ float2x4 result; >+ result[0][0] = step(x[0][0], y[0][0]); >+ result[0][1] = step(x[0][1], y[0][1]); >+ result[0][2] = step(x[0][2], y[0][2]); >+ result[0][3] = step(x[0][3], y[0][3]); >+ result[1][0] = step(x[1][0], y[1][0]); >+ result[1][1] = step(x[1][1], y[1][1]); >+ result[1][2] = step(x[1][2], y[1][2]); >+ result[1][3] = step(x[1][3], y[1][3]); >+ return result; >+} >+float3x2 step(float3x2 x, float3x2 y) { >+ float3x2 result; >+ result[0][0] = step(x[0][0], y[0][0]); >+ result[0][1] = step(x[0][1], y[0][1]); >+ result[1][0] = step(x[1][0], y[1][0]); >+ result[1][1] = step(x[1][1], y[1][1]); >+ result[2][0] = step(x[2][0], y[2][0]); >+ result[2][1] = step(x[2][1], y[2][1]); >+ return result; >+} >+float3x3 step(float3x3 x, float3x3 y) { >+ float3x3 result; >+ result[0][0] = step(x[0][0], y[0][0]); >+ result[0][1] = step(x[0][1], y[0][1]); >+ result[0][2] = step(x[0][2], y[0][2]); >+ result[1][0] = step(x[1][0], y[1][0]); >+ result[1][1] = step(x[1][1], y[1][1]); >+ result[1][2] = step(x[1][2], y[1][2]); >+ result[2][0] = step(x[2][0], y[2][0]); >+ result[2][1] = step(x[2][1], y[2][1]); >+ result[2][2] = step(x[2][2], y[2][2]); >+ return result; >+} >+float3x4 step(float3x4 x, float3x4 y) { >+ float3x4 result; >+ result[0][0] = step(x[0][0], y[0][0]); >+ result[0][1] = step(x[0][1], y[0][1]); >+ result[0][2] = step(x[0][2], y[0][2]); >+ result[0][3] = step(x[0][3], y[0][3]); >+ result[1][0] = step(x[1][0], y[1][0]); >+ result[1][1] = step(x[1][1], y[1][1]); >+ result[1][2] = step(x[1][2], y[1][2]); >+ result[1][3] = step(x[1][3], y[1][3]); >+ result[2][0] = step(x[2][0], y[2][0]); >+ result[2][1] = step(x[2][1], y[2][1]); >+ result[2][2] = step(x[2][2], y[2][2]); >+ result[2][3] = step(x[2][3], y[2][3]); >+ return result; >+} >+float4x2 step(float4x2 x, float4x2 y) { >+ float4x2 result; >+ result[0][0] = step(x[0][0], y[0][0]); >+ result[0][1] = step(x[0][1], y[0][1]); >+ result[1][0] = step(x[1][0], y[1][0]); >+ result[1][1] = step(x[1][1], y[1][1]); >+ result[2][0] = step(x[2][0], y[2][0]); >+ result[2][1] = step(x[2][1], y[2][1]); >+ result[3][0] = step(x[3][0], y[3][0]); >+ result[3][1] = step(x[3][1], y[3][1]); >+ return result; >+} >+float4x3 step(float4x3 x, float4x3 y) { >+ float4x3 result; >+ result[0][0] = step(x[0][0], y[0][0]); >+ result[0][1] = step(x[0][1], y[0][1]); >+ result[0][2] = step(x[0][2], y[0][2]); >+ result[1][0] = step(x[1][0], y[1][0]); >+ result[1][1] = step(x[1][1], y[1][1]); >+ result[1][2] = step(x[1][2], y[1][2]); >+ result[2][0] = step(x[2][0], y[2][0]); >+ result[2][1] = step(x[2][1], y[2][1]); >+ result[2][2] = step(x[2][2], y[2][2]); >+ result[3][0] = step(x[3][0], y[3][0]); >+ result[3][1] = step(x[3][1], y[3][1]); >+ result[3][2] = step(x[3][2], y[3][2]); >+ return result; >+} >+float4x4 step(float4x4 x, float4x4 y) { >+ float4x4 result; >+ result[0][0] = step(x[0][0], y[0][0]); >+ result[0][1] = step(x[0][1], y[0][1]); >+ result[0][2] = step(x[0][2], y[0][2]); >+ result[0][3] = step(x[0][3], y[0][3]); >+ result[1][0] = step(x[1][0], y[1][0]); >+ result[1][1] = step(x[1][1], y[1][1]); >+ result[1][2] = step(x[1][2], y[1][2]); >+ result[1][3] = step(x[1][3], y[1][3]); >+ result[2][0] = step(x[2][0], y[2][0]); >+ result[2][1] = step(x[2][1], y[2][1]); >+ result[2][2] = step(x[2][2], y[2][2]); >+ result[2][3] = step(x[2][3], y[2][3]); >+ result[3][0] = step(x[3][0], y[3][0]); >+ result[3][1] = step(x[3][1], y[3][1]); >+ result[3][2] = step(x[3][2], y[3][2]); >+ result[3][3] = step(x[3][3], y[3][3]); >+ return result; >+} >+float2 ldexp(float2 x, float2 y) { >+ float2 result; >+ result[0] = ldexp(x[0], y[0]); >+ result[1] = ldexp(x[1], y[1]); >+ return result; >+} >+float3 ldexp(float3 x, float3 y) { >+ float3 result; >+ result[0] = ldexp(x[0], y[0]); >+ result[1] = ldexp(x[1], y[1]); >+ result[2] = ldexp(x[2], y[2]); >+ return result; >+} >+float4 ldexp(float4 x, float4 y) { >+ float4 result; >+ result[0] = ldexp(x[0], y[0]); >+ result[1] = ldexp(x[1], y[1]); >+ result[2] = ldexp(x[2], y[2]); >+ result[3] = ldexp(x[3], y[3]); >+ return result; >+} >+float2x2 ldexp(float2x2 x, float2x2 y) { >+ float2x2 result; >+ result[0][0] = ldexp(x[0][0], y[0][0]); >+ result[0][1] = ldexp(x[0][1], y[0][1]); >+ result[1][0] = ldexp(x[1][0], y[1][0]); >+ result[1][1] = ldexp(x[1][1], y[1][1]); >+ return result; >+} >+float2x3 ldexp(float2x3 x, float2x3 y) { >+ float2x3 result; >+ result[0][0] = ldexp(x[0][0], y[0][0]); >+ result[0][1] = ldexp(x[0][1], y[0][1]); >+ result[0][2] = ldexp(x[0][2], y[0][2]); >+ result[1][0] = ldexp(x[1][0], y[1][0]); >+ result[1][1] = ldexp(x[1][1], y[1][1]); >+ result[1][2] = ldexp(x[1][2], y[1][2]); >+ return result; >+} >+float2x4 ldexp(float2x4 x, float2x4 y) { >+ float2x4 result; >+ result[0][0] = ldexp(x[0][0], y[0][0]); >+ result[0][1] = ldexp(x[0][1], y[0][1]); >+ result[0][2] = ldexp(x[0][2], y[0][2]); >+ result[0][3] = ldexp(x[0][3], y[0][3]); >+ result[1][0] = ldexp(x[1][0], y[1][0]); >+ result[1][1] = ldexp(x[1][1], y[1][1]); >+ result[1][2] = ldexp(x[1][2], y[1][2]); >+ result[1][3] = ldexp(x[1][3], y[1][3]); >+ return result; >+} >+float3x2 ldexp(float3x2 x, float3x2 y) { >+ float3x2 result; >+ result[0][0] = ldexp(x[0][0], y[0][0]); >+ result[0][1] = ldexp(x[0][1], y[0][1]); >+ result[1][0] = ldexp(x[1][0], y[1][0]); >+ result[1][1] = ldexp(x[1][1], y[1][1]); >+ result[2][0] = ldexp(x[2][0], y[2][0]); >+ result[2][1] = ldexp(x[2][1], y[2][1]); >+ return result; >+} >+float3x3 ldexp(float3x3 x, float3x3 y) { >+ float3x3 result; >+ result[0][0] = ldexp(x[0][0], y[0][0]); >+ result[0][1] = ldexp(x[0][1], y[0][1]); >+ result[0][2] = ldexp(x[0][2], y[0][2]); >+ result[1][0] = ldexp(x[1][0], y[1][0]); >+ result[1][1] = ldexp(x[1][1], y[1][1]); >+ result[1][2] = ldexp(x[1][2], y[1][2]); >+ result[2][0] = ldexp(x[2][0], y[2][0]); >+ result[2][1] = ldexp(x[2][1], y[2][1]); >+ result[2][2] = ldexp(x[2][2], y[2][2]); >+ return result; >+} >+float3x4 ldexp(float3x4 x, float3x4 y) { >+ float3x4 result; >+ result[0][0] = ldexp(x[0][0], y[0][0]); >+ result[0][1] = ldexp(x[0][1], y[0][1]); >+ result[0][2] = ldexp(x[0][2], y[0][2]); >+ result[0][3] = ldexp(x[0][3], y[0][3]); >+ result[1][0] = ldexp(x[1][0], y[1][0]); >+ result[1][1] = ldexp(x[1][1], y[1][1]); >+ result[1][2] = ldexp(x[1][2], y[1][2]); >+ result[1][3] = ldexp(x[1][3], y[1][3]); >+ result[2][0] = ldexp(x[2][0], y[2][0]); >+ result[2][1] = ldexp(x[2][1], y[2][1]); >+ result[2][2] = ldexp(x[2][2], y[2][2]); >+ result[2][3] = ldexp(x[2][3], y[2][3]); >+ return result; >+} >+float4x2 ldexp(float4x2 x, float4x2 y) { >+ float4x2 result; >+ result[0][0] = ldexp(x[0][0], y[0][0]); >+ result[0][1] = ldexp(x[0][1], y[0][1]); >+ result[1][0] = ldexp(x[1][0], y[1][0]); >+ result[1][1] = ldexp(x[1][1], y[1][1]); >+ result[2][0] = ldexp(x[2][0], y[2][0]); >+ result[2][1] = ldexp(x[2][1], y[2][1]); >+ result[3][0] = ldexp(x[3][0], y[3][0]); >+ result[3][1] = ldexp(x[3][1], y[3][1]); >+ return result; >+} >+float4x3 ldexp(float4x3 x, float4x3 y) { >+ float4x3 result; >+ result[0][0] = ldexp(x[0][0], y[0][0]); >+ result[0][1] = ldexp(x[0][1], y[0][1]); >+ result[0][2] = ldexp(x[0][2], y[0][2]); >+ result[1][0] = ldexp(x[1][0], y[1][0]); >+ result[1][1] = ldexp(x[1][1], y[1][1]); >+ result[1][2] = ldexp(x[1][2], y[1][2]); >+ result[2][0] = ldexp(x[2][0], y[2][0]); >+ result[2][1] = ldexp(x[2][1], y[2][1]); >+ result[2][2] = ldexp(x[2][2], y[2][2]); >+ result[3][0] = ldexp(x[3][0], y[3][0]); >+ result[3][1] = ldexp(x[3][1], y[3][1]); >+ result[3][2] = ldexp(x[3][2], y[3][2]); >+ return result; >+} >+float4x4 ldexp(float4x4 x, float4x4 y) { >+ float4x4 result; >+ result[0][0] = ldexp(x[0][0], y[0][0]); >+ result[0][1] = ldexp(x[0][1], y[0][1]); >+ result[0][2] = ldexp(x[0][2], y[0][2]); >+ result[0][3] = ldexp(x[0][3], y[0][3]); >+ result[1][0] = ldexp(x[1][0], y[1][0]); >+ result[1][1] = ldexp(x[1][1], y[1][1]); >+ result[1][2] = ldexp(x[1][2], y[1][2]); >+ result[1][3] = ldexp(x[1][3], y[1][3]); >+ result[2][0] = ldexp(x[2][0], y[2][0]); >+ result[2][1] = ldexp(x[2][1], y[2][1]); >+ result[2][2] = ldexp(x[2][2], y[2][2]); >+ result[2][3] = ldexp(x[2][3], y[2][3]); >+ result[3][0] = ldexp(x[3][0], y[3][0]); >+ result[3][1] = ldexp(x[3][1], y[3][1]); >+ result[3][2] = ldexp(x[3][2], y[3][2]); >+ result[3][3] = ldexp(x[3][3], y[3][3]); >+ return result; >+} >+float2 fmod(float2 x, float2 y) { >+ float2 result; >+ result[0] = fmod(x[0], y[0]); >+ result[1] = fmod(x[1], y[1]); >+ return result; >+} >+float3 fmod(float3 x, float3 y) { >+ float3 result; >+ result[0] = fmod(x[0], y[0]); >+ result[1] = fmod(x[1], y[1]); >+ result[2] = fmod(x[2], y[2]); >+ return result; >+} >+float4 fmod(float4 x, float4 y) { >+ float4 result; >+ result[0] = fmod(x[0], y[0]); >+ result[1] = fmod(x[1], y[1]); >+ result[2] = fmod(x[2], y[2]); >+ result[3] = fmod(x[3], y[3]); >+ return result; >+} >+float2x2 fmod(float2x2 x, float2x2 y) { >+ float2x2 result; >+ result[0][0] = fmod(x[0][0], y[0][0]); >+ result[0][1] = fmod(x[0][1], y[0][1]); >+ result[1][0] = fmod(x[1][0], y[1][0]); >+ result[1][1] = fmod(x[1][1], y[1][1]); >+ return result; >+} >+float2x3 fmod(float2x3 x, float2x3 y) { >+ float2x3 result; >+ result[0][0] = fmod(x[0][0], y[0][0]); >+ result[0][1] = fmod(x[0][1], y[0][1]); >+ result[0][2] = fmod(x[0][2], y[0][2]); >+ result[1][0] = fmod(x[1][0], y[1][0]); >+ result[1][1] = fmod(x[1][1], y[1][1]); >+ result[1][2] = fmod(x[1][2], y[1][2]); >+ return result; >+} >+float2x4 fmod(float2x4 x, float2x4 y) { >+ float2x4 result; >+ result[0][0] = fmod(x[0][0], y[0][0]); >+ result[0][1] = fmod(x[0][1], y[0][1]); >+ result[0][2] = fmod(x[0][2], y[0][2]); >+ result[0][3] = fmod(x[0][3], y[0][3]); >+ result[1][0] = fmod(x[1][0], y[1][0]); >+ result[1][1] = fmod(x[1][1], y[1][1]); >+ result[1][2] = fmod(x[1][2], y[1][2]); >+ result[1][3] = fmod(x[1][3], y[1][3]); >+ return result; >+} >+float3x2 fmod(float3x2 x, float3x2 y) { >+ float3x2 result; >+ result[0][0] = fmod(x[0][0], y[0][0]); >+ result[0][1] = fmod(x[0][1], y[0][1]); >+ result[1][0] = fmod(x[1][0], y[1][0]); >+ result[1][1] = fmod(x[1][1], y[1][1]); >+ result[2][0] = fmod(x[2][0], y[2][0]); >+ result[2][1] = fmod(x[2][1], y[2][1]); >+ return result; >+} >+float3x3 fmod(float3x3 x, float3x3 y) { >+ float3x3 result; >+ result[0][0] = fmod(x[0][0], y[0][0]); >+ result[0][1] = fmod(x[0][1], y[0][1]); >+ result[0][2] = fmod(x[0][2], y[0][2]); >+ result[1][0] = fmod(x[1][0], y[1][0]); >+ result[1][1] = fmod(x[1][1], y[1][1]); >+ result[1][2] = fmod(x[1][2], y[1][2]); >+ result[2][0] = fmod(x[2][0], y[2][0]); >+ result[2][1] = fmod(x[2][1], y[2][1]); >+ result[2][2] = fmod(x[2][2], y[2][2]); >+ return result; >+} >+float3x4 fmod(float3x4 x, float3x4 y) { >+ float3x4 result; >+ result[0][0] = fmod(x[0][0], y[0][0]); >+ result[0][1] = fmod(x[0][1], y[0][1]); >+ result[0][2] = fmod(x[0][2], y[0][2]); >+ result[0][3] = fmod(x[0][3], y[0][3]); >+ result[1][0] = fmod(x[1][0], y[1][0]); >+ result[1][1] = fmod(x[1][1], y[1][1]); >+ result[1][2] = fmod(x[1][2], y[1][2]); >+ result[1][3] = fmod(x[1][3], y[1][3]); >+ result[2][0] = fmod(x[2][0], y[2][0]); >+ result[2][1] = fmod(x[2][1], y[2][1]); >+ result[2][2] = fmod(x[2][2], y[2][2]); >+ result[2][3] = fmod(x[2][3], y[2][3]); >+ return result; >+} >+float4x2 fmod(float4x2 x, float4x2 y) { >+ float4x2 result; >+ result[0][0] = fmod(x[0][0], y[0][0]); >+ result[0][1] = fmod(x[0][1], y[0][1]); >+ result[1][0] = fmod(x[1][0], y[1][0]); >+ result[1][1] = fmod(x[1][1], y[1][1]); >+ result[2][0] = fmod(x[2][0], y[2][0]); >+ result[2][1] = fmod(x[2][1], y[2][1]); >+ result[3][0] = fmod(x[3][0], y[3][0]); >+ result[3][1] = fmod(x[3][1], y[3][1]); >+ return result; >+} >+float4x3 fmod(float4x3 x, float4x3 y) { >+ float4x3 result; >+ result[0][0] = fmod(x[0][0], y[0][0]); >+ result[0][1] = fmod(x[0][1], y[0][1]); >+ result[0][2] = fmod(x[0][2], y[0][2]); >+ result[1][0] = fmod(x[1][0], y[1][0]); >+ result[1][1] = fmod(x[1][1], y[1][1]); >+ result[1][2] = fmod(x[1][2], y[1][2]); >+ result[2][0] = fmod(x[2][0], y[2][0]); >+ result[2][1] = fmod(x[2][1], y[2][1]); >+ result[2][2] = fmod(x[2][2], y[2][2]); >+ result[3][0] = fmod(x[3][0], y[3][0]); >+ result[3][1] = fmod(x[3][1], y[3][1]); >+ result[3][2] = fmod(x[3][2], y[3][2]); >+ return result; >+} >+float4x4 fmod(float4x4 x, float4x4 y) { >+ float4x4 result; >+ result[0][0] = fmod(x[0][0], y[0][0]); >+ result[0][1] = fmod(x[0][1], y[0][1]); >+ result[0][2] = fmod(x[0][2], y[0][2]); >+ result[0][3] = fmod(x[0][3], y[0][3]); >+ result[1][0] = fmod(x[1][0], y[1][0]); >+ result[1][1] = fmod(x[1][1], y[1][1]); >+ result[1][2] = fmod(x[1][2], y[1][2]); >+ result[1][3] = fmod(x[1][3], y[1][3]); >+ result[2][0] = fmod(x[2][0], y[2][0]); >+ result[2][1] = fmod(x[2][1], y[2][1]); >+ result[2][2] = fmod(x[2][2], y[2][2]); >+ result[2][3] = fmod(x[2][3], y[2][3]); >+ result[3][0] = fmod(x[3][0], y[3][0]); >+ result[3][1] = fmod(x[3][1], y[3][1]); >+ result[3][2] = fmod(x[3][2], y[3][2]); >+ result[3][3] = fmod(x[3][3], y[3][3]); >+ return result; >+} >+ >+half smoothstep(half edge0, half edge1, half x) { >+ half t = clamp((x - edge0) / (edge1 - edge0), 0, 1); >+ return t * t * (3 - 2 * t); >+} >+half lerp(half x, half y, half s) { >+ return x * (1 - s) + y * s; >+} >+half fma(half x, half y, half z) { >+ return x * y + z; >+} >+half mad(half x, half y, half z) { >+ return x * y + z; >+} >+half2 smoothstep(half2 x, half2 y, half2 z) { >+ half2 result; >+ result[0] = smoothstep(x[0], y[0], z[0]); >+ result[1] = smoothstep(x[1], y[1], z[1]); >+ return result; >+} >+half3 smoothstep(half3 x, half3 y, half3 z) { >+ half3 result; >+ result[0] = smoothstep(x[0], y[0], z[0]); >+ result[1] = smoothstep(x[1], y[1], z[1]); >+ result[2] = smoothstep(x[2], y[2], z[2]); >+ return result; >+} >+half4 smoothstep(half4 x, half4 y, half4 z) { >+ half4 result; >+ result[0] = smoothstep(x[0], y[0], z[0]); >+ result[1] = smoothstep(x[1], y[1], z[1]); >+ result[2] = smoothstep(x[2], y[2], z[2]); >+ result[3] = smoothstep(x[3], y[3], z[3]); >+ return result; >+} >+half2x2 smoothstep(half2x2 x, half2x2 y, half2x2 z) { >+ half2x2 result; >+ result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]); >+ return result; >+} >+half2x3 smoothstep(half2x3 x, half2x3 y, half2x3 z) { >+ half2x3 result; >+ result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = smoothstep(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = smoothstep(x[1][2], y[1][2], z[1][2]); >+ return result; >+} >+half2x4 smoothstep(half2x4 x, half2x4 y, half2x4 z) { >+ half2x4 result; >+ result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = smoothstep(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = smoothstep(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = smoothstep(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = smoothstep(x[1][3], y[1][3], z[1][3]); >+ return result; >+} >+half3x2 smoothstep(half3x2 x, half3x2 y, half3x2 z) { >+ half3x2 result; >+ result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]); >+ result[2][0] = smoothstep(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = smoothstep(x[2][1], y[2][1], z[2][1]); >+ return result; >+} >+half3x3 smoothstep(half3x3 x, half3x3 y, half3x3 z) { >+ half3x3 result; >+ result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = smoothstep(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = smoothstep(x[1][2], y[1][2], z[1][2]); >+ result[2][0] = smoothstep(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = smoothstep(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = smoothstep(x[2][2], y[2][2], z[2][2]); >+ return result; >+} >+half3x4 smoothstep(half3x4 x, half3x4 y, half3x4 z) { >+ half3x4 result; >+ result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = smoothstep(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = smoothstep(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = smoothstep(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = smoothstep(x[1][3], y[1][3], z[1][3]); >+ result[2][0] = smoothstep(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = smoothstep(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = smoothstep(x[2][2], y[2][2], z[2][2]); >+ result[2][3] = smoothstep(x[2][3], y[2][3], z[2][3]); >+ return result; >+} >+half4x2 smoothstep(half4x2 x, half4x2 y, half4x2 z) { >+ half4x2 result; >+ result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]); >+ result[2][0] = smoothstep(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = smoothstep(x[2][1], y[2][1], z[2][1]); >+ result[3][0] = smoothstep(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = smoothstep(x[3][1], y[3][1], z[3][1]); >+ return result; >+} >+half4x3 smoothstep(half4x3 x, half4x3 y, half4x3 z) { >+ half4x3 result; >+ result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = smoothstep(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = smoothstep(x[1][2], y[1][2], z[1][2]); >+ result[2][0] = smoothstep(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = smoothstep(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = smoothstep(x[2][2], y[2][2], z[2][2]); >+ result[3][0] = smoothstep(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = smoothstep(x[3][1], y[3][1], z[3][1]); >+ result[3][2] = smoothstep(x[3][2], y[3][2], z[3][2]); >+ return result; >+} >+half4x4 smoothstep(half4x4 x, half4x4 y, half4x4 z) { >+ half4x4 result; >+ result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = smoothstep(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = smoothstep(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = smoothstep(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = smoothstep(x[1][3], y[1][3], z[1][3]); >+ result[2][0] = smoothstep(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = smoothstep(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = smoothstep(x[2][2], y[2][2], z[2][2]); >+ result[2][3] = smoothstep(x[2][3], y[2][3], z[2][3]); >+ result[3][0] = smoothstep(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = smoothstep(x[3][1], y[3][1], z[3][1]); >+ result[3][2] = smoothstep(x[3][2], y[3][2], z[3][2]); >+ result[3][3] = smoothstep(x[3][3], y[3][3], z[3][3]); >+ return result; >+} >+half2 lerp(half2 x, half2 y, half2 z) { >+ half2 result; >+ result[0] = lerp(x[0], y[0], z[0]); >+ result[1] = lerp(x[1], y[1], z[1]); >+ return result; >+} >+half3 lerp(half3 x, half3 y, half3 z) { >+ half3 result; >+ result[0] = lerp(x[0], y[0], z[0]); >+ result[1] = lerp(x[1], y[1], z[1]); >+ result[2] = lerp(x[2], y[2], z[2]); >+ return result; >+} >+half4 lerp(half4 x, half4 y, half4 z) { >+ half4 result; >+ result[0] = lerp(x[0], y[0], z[0]); >+ result[1] = lerp(x[1], y[1], z[1]); >+ result[2] = lerp(x[2], y[2], z[2]); >+ result[3] = lerp(x[3], y[3], z[3]); >+ return result; >+} >+half2x2 lerp(half2x2 x, half2x2 y, half2x2 z) { >+ half2x2 result; >+ result[0][0] = lerp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = lerp(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = lerp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = lerp(x[1][1], y[1][1], z[1][1]); >+ return result; >+} >+half2x3 lerp(half2x3 x, half2x3 y, half2x3 z) { >+ half2x3 result; >+ result[0][0] = lerp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = lerp(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = lerp(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = lerp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = lerp(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = lerp(x[1][2], y[1][2], z[1][2]); >+ return result; >+} >+half2x4 lerp(half2x4 x, half2x4 y, half2x4 z) { >+ half2x4 result; >+ result[0][0] = lerp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = lerp(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = lerp(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = lerp(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = lerp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = lerp(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = lerp(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = lerp(x[1][3], y[1][3], z[1][3]); >+ return result; >+} >+half3x2 lerp(half3x2 x, half3x2 y, half3x2 z) { >+ half3x2 result; >+ result[0][0] = lerp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = lerp(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = lerp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = lerp(x[1][1], y[1][1], z[1][1]); >+ result[2][0] = lerp(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = lerp(x[2][1], y[2][1], z[2][1]); >+ return result; >+} >+half3x3 lerp(half3x3 x, half3x3 y, half3x3 z) { >+ half3x3 result; >+ result[0][0] = lerp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = lerp(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = lerp(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = lerp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = lerp(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = lerp(x[1][2], y[1][2], z[1][2]); >+ result[2][0] = lerp(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = lerp(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = lerp(x[2][2], y[2][2], z[2][2]); >+ return result; >+} >+half3x4 lerp(half3x4 x, half3x4 y, half3x4 z) { >+ half3x4 result; >+ result[0][0] = lerp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = lerp(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = lerp(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = lerp(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = lerp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = lerp(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = lerp(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = lerp(x[1][3], y[1][3], z[1][3]); >+ result[2][0] = lerp(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = lerp(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = lerp(x[2][2], y[2][2], z[2][2]); >+ result[2][3] = lerp(x[2][3], y[2][3], z[2][3]); >+ return result; >+} >+half4x2 lerp(half4x2 x, half4x2 y, half4x2 z) { >+ half4x2 result; >+ result[0][0] = lerp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = lerp(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = lerp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = lerp(x[1][1], y[1][1], z[1][1]); >+ result[2][0] = lerp(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = lerp(x[2][1], y[2][1], z[2][1]); >+ result[3][0] = lerp(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = lerp(x[3][1], y[3][1], z[3][1]); >+ return result; >+} >+half4x3 lerp(half4x3 x, half4x3 y, half4x3 z) { >+ half4x3 result; >+ result[0][0] = lerp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = lerp(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = lerp(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = lerp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = lerp(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = lerp(x[1][2], y[1][2], z[1][2]); >+ result[2][0] = lerp(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = lerp(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = lerp(x[2][2], y[2][2], z[2][2]); >+ result[3][0] = lerp(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = lerp(x[3][1], y[3][1], z[3][1]); >+ result[3][2] = lerp(x[3][2], y[3][2], z[3][2]); >+ return result; >+} >+half4x4 lerp(half4x4 x, half4x4 y, half4x4 z) { >+ half4x4 result; >+ result[0][0] = lerp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = lerp(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = lerp(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = lerp(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = lerp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = lerp(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = lerp(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = lerp(x[1][3], y[1][3], z[1][3]); >+ result[2][0] = lerp(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = lerp(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = lerp(x[2][2], y[2][2], z[2][2]); >+ result[2][3] = lerp(x[2][3], y[2][3], z[2][3]); >+ result[3][0] = lerp(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = lerp(x[3][1], y[3][1], z[3][1]); >+ result[3][2] = lerp(x[3][2], y[3][2], z[3][2]); >+ result[3][3] = lerp(x[3][3], y[3][3], z[3][3]); >+ return result; >+} >+half2 fma(half2 x, half2 y, half2 z) { >+ half2 result; >+ result[0] = fma(x[0], y[0], z[0]); >+ result[1] = fma(x[1], y[1], z[1]); >+ return result; >+} >+half3 fma(half3 x, half3 y, half3 z) { >+ half3 result; >+ result[0] = fma(x[0], y[0], z[0]); >+ result[1] = fma(x[1], y[1], z[1]); >+ result[2] = fma(x[2], y[2], z[2]); >+ return result; >+} >+half4 fma(half4 x, half4 y, half4 z) { >+ half4 result; >+ result[0] = fma(x[0], y[0], z[0]); >+ result[1] = fma(x[1], y[1], z[1]); >+ result[2] = fma(x[2], y[2], z[2]); >+ result[3] = fma(x[3], y[3], z[3]); >+ return result; >+} >+half2x2 fma(half2x2 x, half2x2 y, half2x2 z) { >+ half2x2 result; >+ result[0][0] = fma(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = fma(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = fma(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = fma(x[1][1], y[1][1], z[1][1]); >+ return result; >+} >+half2x3 fma(half2x3 x, half2x3 y, half2x3 z) { >+ half2x3 result; >+ result[0][0] = fma(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = fma(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = fma(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = fma(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = fma(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = fma(x[1][2], y[1][2], z[1][2]); >+ return result; >+} >+half2x4 fma(half2x4 x, half2x4 y, half2x4 z) { >+ half2x4 result; >+ result[0][0] = fma(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = fma(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = fma(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = fma(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = fma(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = fma(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = fma(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = fma(x[1][3], y[1][3], z[1][3]); >+ return result; >+} >+half3x2 fma(half3x2 x, half3x2 y, half3x2 z) { >+ half3x2 result; >+ result[0][0] = fma(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = fma(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = fma(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = fma(x[1][1], y[1][1], z[1][1]); >+ result[2][0] = fma(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = fma(x[2][1], y[2][1], z[2][1]); >+ return result; >+} >+half3x3 fma(half3x3 x, half3x3 y, half3x3 z) { >+ half3x3 result; >+ result[0][0] = fma(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = fma(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = fma(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = fma(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = fma(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = fma(x[1][2], y[1][2], z[1][2]); >+ result[2][0] = fma(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = fma(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = fma(x[2][2], y[2][2], z[2][2]); >+ return result; >+} >+half3x4 fma(half3x4 x, half3x4 y, half3x4 z) { >+ half3x4 result; >+ result[0][0] = fma(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = fma(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = fma(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = fma(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = fma(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = fma(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = fma(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = fma(x[1][3], y[1][3], z[1][3]); >+ result[2][0] = fma(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = fma(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = fma(x[2][2], y[2][2], z[2][2]); >+ result[2][3] = fma(x[2][3], y[2][3], z[2][3]); >+ return result; >+} >+half4x2 fma(half4x2 x, half4x2 y, half4x2 z) { >+ half4x2 result; >+ result[0][0] = fma(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = fma(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = fma(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = fma(x[1][1], y[1][1], z[1][1]); >+ result[2][0] = fma(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = fma(x[2][1], y[2][1], z[2][1]); >+ result[3][0] = fma(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = fma(x[3][1], y[3][1], z[3][1]); >+ return result; >+} >+half4x3 fma(half4x3 x, half4x3 y, half4x3 z) { >+ half4x3 result; >+ result[0][0] = fma(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = fma(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = fma(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = fma(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = fma(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = fma(x[1][2], y[1][2], z[1][2]); >+ result[2][0] = fma(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = fma(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = fma(x[2][2], y[2][2], z[2][2]); >+ result[3][0] = fma(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = fma(x[3][1], y[3][1], z[3][1]); >+ result[3][2] = fma(x[3][2], y[3][2], z[3][2]); >+ return result; >+} >+half4x4 fma(half4x4 x, half4x4 y, half4x4 z) { >+ half4x4 result; >+ result[0][0] = fma(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = fma(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = fma(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = fma(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = fma(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = fma(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = fma(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = fma(x[1][3], y[1][3], z[1][3]); >+ result[2][0] = fma(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = fma(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = fma(x[2][2], y[2][2], z[2][2]); >+ result[2][3] = fma(x[2][3], y[2][3], z[2][3]); >+ result[3][0] = fma(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = fma(x[3][1], y[3][1], z[3][1]); >+ result[3][2] = fma(x[3][2], y[3][2], z[3][2]); >+ result[3][3] = fma(x[3][3], y[3][3], z[3][3]); >+ return result; >+} >+half2 mad(half2 x, half2 y, half2 z) { >+ half2 result; >+ result[0] = mad(x[0], y[0], z[0]); >+ result[1] = mad(x[1], y[1], z[1]); >+ return result; >+} >+half3 mad(half3 x, half3 y, half3 z) { >+ half3 result; >+ result[0] = mad(x[0], y[0], z[0]); >+ result[1] = mad(x[1], y[1], z[1]); >+ result[2] = mad(x[2], y[2], z[2]); >+ return result; >+} >+half4 mad(half4 x, half4 y, half4 z) { >+ half4 result; >+ result[0] = mad(x[0], y[0], z[0]); >+ result[1] = mad(x[1], y[1], z[1]); >+ result[2] = mad(x[2], y[2], z[2]); >+ result[3] = mad(x[3], y[3], z[3]); >+ return result; >+} >+half2x2 mad(half2x2 x, half2x2 y, half2x2 z) { >+ half2x2 result; >+ result[0][0] = mad(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = mad(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = mad(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = mad(x[1][1], y[1][1], z[1][1]); >+ return result; >+} >+half2x3 mad(half2x3 x, half2x3 y, half2x3 z) { >+ half2x3 result; >+ result[0][0] = mad(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = mad(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = mad(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = mad(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = mad(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = mad(x[1][2], y[1][2], z[1][2]); >+ return result; >+} >+half2x4 mad(half2x4 x, half2x4 y, half2x4 z) { >+ half2x4 result; >+ result[0][0] = mad(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = mad(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = mad(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = mad(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = mad(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = mad(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = mad(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = mad(x[1][3], y[1][3], z[1][3]); >+ return result; >+} >+half3x2 mad(half3x2 x, half3x2 y, half3x2 z) { >+ half3x2 result; >+ result[0][0] = mad(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = mad(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = mad(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = mad(x[1][1], y[1][1], z[1][1]); >+ result[2][0] = mad(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = mad(x[2][1], y[2][1], z[2][1]); >+ return result; >+} >+half3x3 mad(half3x3 x, half3x3 y, half3x3 z) { >+ half3x3 result; >+ result[0][0] = mad(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = mad(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = mad(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = mad(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = mad(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = mad(x[1][2], y[1][2], z[1][2]); >+ result[2][0] = mad(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = mad(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = mad(x[2][2], y[2][2], z[2][2]); >+ return result; >+} >+half3x4 mad(half3x4 x, half3x4 y, half3x4 z) { >+ half3x4 result; >+ result[0][0] = mad(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = mad(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = mad(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = mad(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = mad(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = mad(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = mad(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = mad(x[1][3], y[1][3], z[1][3]); >+ result[2][0] = mad(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = mad(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = mad(x[2][2], y[2][2], z[2][2]); >+ result[2][3] = mad(x[2][3], y[2][3], z[2][3]); >+ return result; >+} >+half4x2 mad(half4x2 x, half4x2 y, half4x2 z) { >+ half4x2 result; >+ result[0][0] = mad(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = mad(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = mad(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = mad(x[1][1], y[1][1], z[1][1]); >+ result[2][0] = mad(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = mad(x[2][1], y[2][1], z[2][1]); >+ result[3][0] = mad(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = mad(x[3][1], y[3][1], z[3][1]); >+ return result; >+} >+half4x3 mad(half4x3 x, half4x3 y, half4x3 z) { >+ half4x3 result; >+ result[0][0] = mad(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = mad(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = mad(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = mad(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = mad(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = mad(x[1][2], y[1][2], z[1][2]); >+ result[2][0] = mad(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = mad(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = mad(x[2][2], y[2][2], z[2][2]); >+ result[3][0] = mad(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = mad(x[3][1], y[3][1], z[3][1]); >+ result[3][2] = mad(x[3][2], y[3][2], z[3][2]); >+ return result; >+} >+half4x4 mad(half4x4 x, half4x4 y, half4x4 z) { >+ half4x4 result; >+ result[0][0] = mad(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = mad(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = mad(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = mad(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = mad(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = mad(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = mad(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = mad(x[1][3], y[1][3], z[1][3]); >+ result[2][0] = mad(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = mad(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = mad(x[2][2], y[2][2], z[2][2]); >+ result[2][3] = mad(x[2][3], y[2][3], z[2][3]); >+ result[3][0] = mad(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = mad(x[3][1], y[3][1], z[3][1]); >+ result[3][2] = mad(x[3][2], y[3][2], z[3][2]); >+ result[3][3] = mad(x[3][3], y[3][3], z[3][3]); >+ return result; >+} >+ >+float smoothstep(float edge0, float edge1, float x) { >+ float t = clamp((x - edge0) / (edge1 - edge0), 0, 1); >+ return t * t * (3 - 2 * t); >+} >+float lerp(float x, float y, float s) { >+ return x * (1 - s) + y * s; >+} >+float fma(float x, float y, float z) { >+ return x * y + z; >+} >+float mad(float x, float y, float z) { >+ return x * y + z; >+} >+float2 smoothstep(float2 x, float2 y, float2 z) { >+ float2 result; >+ result[0] = smoothstep(x[0], y[0], z[0]); >+ result[1] = smoothstep(x[1], y[1], z[1]); >+ return result; >+} >+float3 smoothstep(float3 x, float3 y, float3 z) { >+ float3 result; >+ result[0] = smoothstep(x[0], y[0], z[0]); >+ result[1] = smoothstep(x[1], y[1], z[1]); >+ result[2] = smoothstep(x[2], y[2], z[2]); >+ return result; >+} >+float4 smoothstep(float4 x, float4 y, float4 z) { >+ float4 result; >+ result[0] = smoothstep(x[0], y[0], z[0]); >+ result[1] = smoothstep(x[1], y[1], z[1]); >+ result[2] = smoothstep(x[2], y[2], z[2]); >+ result[3] = smoothstep(x[3], y[3], z[3]); >+ return result; >+} >+float2x2 smoothstep(float2x2 x, float2x2 y, float2x2 z) { >+ float2x2 result; >+ result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]); >+ return result; >+} >+float2x3 smoothstep(float2x3 x, float2x3 y, float2x3 z) { >+ float2x3 result; >+ result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = smoothstep(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = smoothstep(x[1][2], y[1][2], z[1][2]); >+ return result; >+} >+float2x4 smoothstep(float2x4 x, float2x4 y, float2x4 z) { >+ float2x4 result; >+ result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = smoothstep(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = smoothstep(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = smoothstep(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = smoothstep(x[1][3], y[1][3], z[1][3]); >+ return result; >+} >+float3x2 smoothstep(float3x2 x, float3x2 y, float3x2 z) { >+ float3x2 result; >+ result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]); >+ result[2][0] = smoothstep(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = smoothstep(x[2][1], y[2][1], z[2][1]); >+ return result; >+} >+float3x3 smoothstep(float3x3 x, float3x3 y, float3x3 z) { >+ float3x3 result; >+ result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = smoothstep(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = smoothstep(x[1][2], y[1][2], z[1][2]); >+ result[2][0] = smoothstep(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = smoothstep(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = smoothstep(x[2][2], y[2][2], z[2][2]); >+ return result; >+} >+float3x4 smoothstep(float3x4 x, float3x4 y, float3x4 z) { >+ float3x4 result; >+ result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = smoothstep(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = smoothstep(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = smoothstep(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = smoothstep(x[1][3], y[1][3], z[1][3]); >+ result[2][0] = smoothstep(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = smoothstep(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = smoothstep(x[2][2], y[2][2], z[2][2]); >+ result[2][3] = smoothstep(x[2][3], y[2][3], z[2][3]); >+ return result; >+} >+float4x2 smoothstep(float4x2 x, float4x2 y, float4x2 z) { >+ float4x2 result; >+ result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]); >+ result[2][0] = smoothstep(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = smoothstep(x[2][1], y[2][1], z[2][1]); >+ result[3][0] = smoothstep(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = smoothstep(x[3][1], y[3][1], z[3][1]); >+ return result; >+} >+float4x3 smoothstep(float4x3 x, float4x3 y, float4x3 z) { >+ float4x3 result; >+ result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = smoothstep(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = smoothstep(x[1][2], y[1][2], z[1][2]); >+ result[2][0] = smoothstep(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = smoothstep(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = smoothstep(x[2][2], y[2][2], z[2][2]); >+ result[3][0] = smoothstep(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = smoothstep(x[3][1], y[3][1], z[3][1]); >+ result[3][2] = smoothstep(x[3][2], y[3][2], z[3][2]); >+ return result; >+} >+float4x4 smoothstep(float4x4 x, float4x4 y, float4x4 z) { >+ float4x4 result; >+ result[0][0] = smoothstep(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = smoothstep(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = smoothstep(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = smoothstep(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = smoothstep(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = smoothstep(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = smoothstep(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = smoothstep(x[1][3], y[1][3], z[1][3]); >+ result[2][0] = smoothstep(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = smoothstep(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = smoothstep(x[2][2], y[2][2], z[2][2]); >+ result[2][3] = smoothstep(x[2][3], y[2][3], z[2][3]); >+ result[3][0] = smoothstep(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = smoothstep(x[3][1], y[3][1], z[3][1]); >+ result[3][2] = smoothstep(x[3][2], y[3][2], z[3][2]); >+ result[3][3] = smoothstep(x[3][3], y[3][3], z[3][3]); >+ return result; >+} >+float2 lerp(float2 x, float2 y, float2 z) { >+ float2 result; >+ result[0] = lerp(x[0], y[0], z[0]); >+ result[1] = lerp(x[1], y[1], z[1]); >+ return result; >+} >+float3 lerp(float3 x, float3 y, float3 z) { >+ float3 result; >+ result[0] = lerp(x[0], y[0], z[0]); >+ result[1] = lerp(x[1], y[1], z[1]); >+ result[2] = lerp(x[2], y[2], z[2]); >+ return result; >+} >+float4 lerp(float4 x, float4 y, float4 z) { >+ float4 result; >+ result[0] = lerp(x[0], y[0], z[0]); >+ result[1] = lerp(x[1], y[1], z[1]); >+ result[2] = lerp(x[2], y[2], z[2]); >+ result[3] = lerp(x[3], y[3], z[3]); >+ return result; >+} >+float2x2 lerp(float2x2 x, float2x2 y, float2x2 z) { >+ float2x2 result; >+ result[0][0] = lerp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = lerp(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = lerp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = lerp(x[1][1], y[1][1], z[1][1]); >+ return result; >+} >+float2x3 lerp(float2x3 x, float2x3 y, float2x3 z) { >+ float2x3 result; >+ result[0][0] = lerp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = lerp(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = lerp(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = lerp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = lerp(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = lerp(x[1][2], y[1][2], z[1][2]); >+ return result; >+} >+float2x4 lerp(float2x4 x, float2x4 y, float2x4 z) { >+ float2x4 result; >+ result[0][0] = lerp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = lerp(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = lerp(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = lerp(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = lerp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = lerp(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = lerp(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = lerp(x[1][3], y[1][3], z[1][3]); >+ return result; >+} >+float3x2 lerp(float3x2 x, float3x2 y, float3x2 z) { >+ float3x2 result; >+ result[0][0] = lerp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = lerp(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = lerp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = lerp(x[1][1], y[1][1], z[1][1]); >+ result[2][0] = lerp(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = lerp(x[2][1], y[2][1], z[2][1]); >+ return result; >+} >+float3x3 lerp(float3x3 x, float3x3 y, float3x3 z) { >+ float3x3 result; >+ result[0][0] = lerp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = lerp(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = lerp(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = lerp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = lerp(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = lerp(x[1][2], y[1][2], z[1][2]); >+ result[2][0] = lerp(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = lerp(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = lerp(x[2][2], y[2][2], z[2][2]); >+ return result; >+} >+float3x4 lerp(float3x4 x, float3x4 y, float3x4 z) { >+ float3x4 result; >+ result[0][0] = lerp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = lerp(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = lerp(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = lerp(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = lerp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = lerp(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = lerp(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = lerp(x[1][3], y[1][3], z[1][3]); >+ result[2][0] = lerp(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = lerp(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = lerp(x[2][2], y[2][2], z[2][2]); >+ result[2][3] = lerp(x[2][3], y[2][3], z[2][3]); >+ return result; >+} >+float4x2 lerp(float4x2 x, float4x2 y, float4x2 z) { >+ float4x2 result; >+ result[0][0] = lerp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = lerp(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = lerp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = lerp(x[1][1], y[1][1], z[1][1]); >+ result[2][0] = lerp(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = lerp(x[2][1], y[2][1], z[2][1]); >+ result[3][0] = lerp(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = lerp(x[3][1], y[3][1], z[3][1]); >+ return result; >+} >+float4x3 lerp(float4x3 x, float4x3 y, float4x3 z) { >+ float4x3 result; >+ result[0][0] = lerp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = lerp(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = lerp(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = lerp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = lerp(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = lerp(x[1][2], y[1][2], z[1][2]); >+ result[2][0] = lerp(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = lerp(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = lerp(x[2][2], y[2][2], z[2][2]); >+ result[3][0] = lerp(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = lerp(x[3][1], y[3][1], z[3][1]); >+ result[3][2] = lerp(x[3][2], y[3][2], z[3][2]); >+ return result; >+} >+float4x4 lerp(float4x4 x, float4x4 y, float4x4 z) { >+ float4x4 result; >+ result[0][0] = lerp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = lerp(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = lerp(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = lerp(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = lerp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = lerp(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = lerp(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = lerp(x[1][3], y[1][3], z[1][3]); >+ result[2][0] = lerp(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = lerp(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = lerp(x[2][2], y[2][2], z[2][2]); >+ result[2][3] = lerp(x[2][3], y[2][3], z[2][3]); >+ result[3][0] = lerp(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = lerp(x[3][1], y[3][1], z[3][1]); >+ result[3][2] = lerp(x[3][2], y[3][2], z[3][2]); >+ result[3][3] = lerp(x[3][3], y[3][3], z[3][3]); >+ return result; >+} >+float2 fma(float2 x, float2 y, float2 z) { >+ float2 result; >+ result[0] = fma(x[0], y[0], z[0]); >+ result[1] = fma(x[1], y[1], z[1]); >+ return result; >+} >+float3 fma(float3 x, float3 y, float3 z) { >+ float3 result; >+ result[0] = fma(x[0], y[0], z[0]); >+ result[1] = fma(x[1], y[1], z[1]); >+ result[2] = fma(x[2], y[2], z[2]); >+ return result; >+} >+float4 fma(float4 x, float4 y, float4 z) { >+ float4 result; >+ result[0] = fma(x[0], y[0], z[0]); >+ result[1] = fma(x[1], y[1], z[1]); >+ result[2] = fma(x[2], y[2], z[2]); >+ result[3] = fma(x[3], y[3], z[3]); >+ return result; >+} >+float2x2 fma(float2x2 x, float2x2 y, float2x2 z) { >+ float2x2 result; >+ result[0][0] = fma(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = fma(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = fma(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = fma(x[1][1], y[1][1], z[1][1]); >+ return result; >+} >+float2x3 fma(float2x3 x, float2x3 y, float2x3 z) { >+ float2x3 result; >+ result[0][0] = fma(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = fma(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = fma(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = fma(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = fma(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = fma(x[1][2], y[1][2], z[1][2]); >+ return result; >+} >+float2x4 fma(float2x4 x, float2x4 y, float2x4 z) { >+ float2x4 result; >+ result[0][0] = fma(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = fma(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = fma(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = fma(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = fma(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = fma(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = fma(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = fma(x[1][3], y[1][3], z[1][3]); >+ return result; >+} >+float3x2 fma(float3x2 x, float3x2 y, float3x2 z) { >+ float3x2 result; >+ result[0][0] = fma(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = fma(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = fma(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = fma(x[1][1], y[1][1], z[1][1]); >+ result[2][0] = fma(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = fma(x[2][1], y[2][1], z[2][1]); >+ return result; >+} >+float3x3 fma(float3x3 x, float3x3 y, float3x3 z) { >+ float3x3 result; >+ result[0][0] = fma(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = fma(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = fma(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = fma(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = fma(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = fma(x[1][2], y[1][2], z[1][2]); >+ result[2][0] = fma(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = fma(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = fma(x[2][2], y[2][2], z[2][2]); >+ return result; >+} >+float3x4 fma(float3x4 x, float3x4 y, float3x4 z) { >+ float3x4 result; >+ result[0][0] = fma(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = fma(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = fma(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = fma(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = fma(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = fma(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = fma(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = fma(x[1][3], y[1][3], z[1][3]); >+ result[2][0] = fma(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = fma(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = fma(x[2][2], y[2][2], z[2][2]); >+ result[2][3] = fma(x[2][3], y[2][3], z[2][3]); >+ return result; >+} >+float4x2 fma(float4x2 x, float4x2 y, float4x2 z) { >+ float4x2 result; >+ result[0][0] = fma(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = fma(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = fma(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = fma(x[1][1], y[1][1], z[1][1]); >+ result[2][0] = fma(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = fma(x[2][1], y[2][1], z[2][1]); >+ result[3][0] = fma(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = fma(x[3][1], y[3][1], z[3][1]); >+ return result; >+} >+float4x3 fma(float4x3 x, float4x3 y, float4x3 z) { >+ float4x3 result; >+ result[0][0] = fma(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = fma(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = fma(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = fma(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = fma(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = fma(x[1][2], y[1][2], z[1][2]); >+ result[2][0] = fma(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = fma(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = fma(x[2][2], y[2][2], z[2][2]); >+ result[3][0] = fma(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = fma(x[3][1], y[3][1], z[3][1]); >+ result[3][2] = fma(x[3][2], y[3][2], z[3][2]); >+ return result; >+} >+float4x4 fma(float4x4 x, float4x4 y, float4x4 z) { >+ float4x4 result; >+ result[0][0] = fma(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = fma(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = fma(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = fma(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = fma(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = fma(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = fma(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = fma(x[1][3], y[1][3], z[1][3]); >+ result[2][0] = fma(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = fma(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = fma(x[2][2], y[2][2], z[2][2]); >+ result[2][3] = fma(x[2][3], y[2][3], z[2][3]); >+ result[3][0] = fma(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = fma(x[3][1], y[3][1], z[3][1]); >+ result[3][2] = fma(x[3][2], y[3][2], z[3][2]); >+ result[3][3] = fma(x[3][3], y[3][3], z[3][3]); >+ return result; >+} >+float2 mad(float2 x, float2 y, float2 z) { >+ float2 result; >+ result[0] = mad(x[0], y[0], z[0]); >+ result[1] = mad(x[1], y[1], z[1]); >+ return result; >+} >+float3 mad(float3 x, float3 y, float3 z) { >+ float3 result; >+ result[0] = mad(x[0], y[0], z[0]); >+ result[1] = mad(x[1], y[1], z[1]); >+ result[2] = mad(x[2], y[2], z[2]); >+ return result; >+} >+float4 mad(float4 x, float4 y, float4 z) { >+ float4 result; >+ result[0] = mad(x[0], y[0], z[0]); >+ result[1] = mad(x[1], y[1], z[1]); >+ result[2] = mad(x[2], y[2], z[2]); >+ result[3] = mad(x[3], y[3], z[3]); >+ return result; >+} >+float2x2 mad(float2x2 x, float2x2 y, float2x2 z) { >+ float2x2 result; >+ result[0][0] = mad(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = mad(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = mad(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = mad(x[1][1], y[1][1], z[1][1]); >+ return result; >+} >+float2x3 mad(float2x3 x, float2x3 y, float2x3 z) { >+ float2x3 result; >+ result[0][0] = mad(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = mad(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = mad(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = mad(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = mad(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = mad(x[1][2], y[1][2], z[1][2]); >+ return result; >+} >+float2x4 mad(float2x4 x, float2x4 y, float2x4 z) { >+ float2x4 result; >+ result[0][0] = mad(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = mad(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = mad(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = mad(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = mad(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = mad(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = mad(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = mad(x[1][3], y[1][3], z[1][3]); >+ return result; >+} >+float3x2 mad(float3x2 x, float3x2 y, float3x2 z) { >+ float3x2 result; >+ result[0][0] = mad(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = mad(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = mad(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = mad(x[1][1], y[1][1], z[1][1]); >+ result[2][0] = mad(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = mad(x[2][1], y[2][1], z[2][1]); >+ return result; >+} >+float3x3 mad(float3x3 x, float3x3 y, float3x3 z) { >+ float3x3 result; >+ result[0][0] = mad(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = mad(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = mad(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = mad(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = mad(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = mad(x[1][2], y[1][2], z[1][2]); >+ result[2][0] = mad(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = mad(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = mad(x[2][2], y[2][2], z[2][2]); >+ return result; >+} >+float3x4 mad(float3x4 x, float3x4 y, float3x4 z) { >+ float3x4 result; >+ result[0][0] = mad(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = mad(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = mad(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = mad(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = mad(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = mad(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = mad(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = mad(x[1][3], y[1][3], z[1][3]); >+ result[2][0] = mad(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = mad(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = mad(x[2][2], y[2][2], z[2][2]); >+ result[2][3] = mad(x[2][3], y[2][3], z[2][3]); >+ return result; >+} >+float4x2 mad(float4x2 x, float4x2 y, float4x2 z) { >+ float4x2 result; >+ result[0][0] = mad(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = mad(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = mad(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = mad(x[1][1], y[1][1], z[1][1]); >+ result[2][0] = mad(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = mad(x[2][1], y[2][1], z[2][1]); >+ result[3][0] = mad(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = mad(x[3][1], y[3][1], z[3][1]); >+ return result; >+} >+float4x3 mad(float4x3 x, float4x3 y, float4x3 z) { >+ float4x3 result; >+ result[0][0] = mad(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = mad(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = mad(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = mad(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = mad(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = mad(x[1][2], y[1][2], z[1][2]); >+ result[2][0] = mad(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = mad(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = mad(x[2][2], y[2][2], z[2][2]); >+ result[3][0] = mad(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = mad(x[3][1], y[3][1], z[3][1]); >+ result[3][2] = mad(x[3][2], y[3][2], z[3][2]); >+ return result; >+} >+float4x4 mad(float4x4 x, float4x4 y, float4x4 z) { >+ float4x4 result; >+ result[0][0] = mad(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = mad(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = mad(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = mad(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = mad(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = mad(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = mad(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = mad(x[1][3], y[1][3], z[1][3]); >+ result[2][0] = mad(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = mad(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = mad(x[2][2], y[2][2], z[2][2]); >+ result[2][3] = mad(x[2][3], y[2][3], z[2][3]); >+ result[3][0] = mad(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = mad(x[3][1], y[3][1], z[3][1]); >+ result[3][2] = mad(x[3][2], y[3][2], z[3][2]); >+ result[3][3] = mad(x[3][3], y[3][3], z[3][3]); >+ return result; >+} >+ >+native bool isnormal(half); >+native bool isnormal(float); >+bool2 isnormal(half2 x) { >+ bool2 result; >+ result[0] = isnormal(x[0]); >+ result[1] = isnormal(x[1]); >+ return result; >+} >+bool3 isnormal(half3 x) { >+ bool3 result; >+ result[0] = isnormal(x[0]); >+ result[1] = isnormal(x[1]); >+ result[2] = isnormal(x[2]); >+ return result; >+} >+bool4 isnormal(half4 x) { >+ bool4 result; >+ result[0] = isnormal(x[0]); >+ result[1] = isnormal(x[1]); >+ result[2] = isnormal(x[2]); >+ result[3] = isnormal(x[3]); >+ return result; >+} >+ >+bool2 isnormal(float2 x) { >+ bool2 result; >+ result[0] = isnormal(x[0]); >+ result[1] = isnormal(x[1]); >+ return result; >+} >+bool3 isnormal(float3 x) { >+ bool3 result; >+ result[0] = isnormal(x[0]); >+ result[1] = isnormal(x[1]); >+ result[2] = isnormal(x[2]); >+ return result; >+} >+bool4 isnormal(float4 x) { >+ bool4 result; >+ result[0] = isnormal(x[0]); >+ result[1] = isnormal(x[1]); >+ result[2] = isnormal(x[2]); >+ result[3] = isnormal(x[3]); >+ return result; >+} >+ >+native bool isfinite(float); >+bool isfinite(half x) { >+ return isfinite(float(x)); >+} >+native bool isinf(float); >+bool isinf(half x) { >+ return isinf(float(x)); >+} >+native bool isnan(float); >+bool isnan(half x) { >+ return isnan(float(x)); >+} >+bool2 isfinite(half2 x) { >+ bool2 result; >+ result[0] = isfinite(x[0]); >+ result[1] = isfinite(x[1]); >+ return result; >+} >+bool3 isfinite(half3 x) { >+ bool3 result; >+ result[0] = isfinite(x[0]); >+ result[1] = isfinite(x[1]); >+ result[2] = isfinite(x[2]); >+ return result; >+} >+bool4 isfinite(half4 x) { >+ bool4 result; >+ result[0] = isfinite(x[0]); >+ result[1] = isfinite(x[1]); >+ result[2] = isfinite(x[2]); >+ result[3] = isfinite(x[3]); >+ return result; >+} >+bool2 isinf(half2 x) { >+ bool2 result; >+ result[0] = isinf(x[0]); >+ result[1] = isinf(x[1]); >+ return result; >+} >+bool3 isinf(half3 x) { >+ bool3 result; >+ result[0] = isinf(x[0]); >+ result[1] = isinf(x[1]); >+ result[2] = isinf(x[2]); >+ return result; >+} >+bool4 isinf(half4 x) { >+ bool4 result; >+ result[0] = isinf(x[0]); >+ result[1] = isinf(x[1]); >+ result[2] = isinf(x[2]); >+ result[3] = isinf(x[3]); >+ return result; >+} >+bool2 isnan(half2 x) { >+ bool2 result; >+ result[0] = isnan(x[0]); >+ result[1] = isnan(x[1]); >+ return result; >+} >+bool3 isnan(half3 x) { >+ bool3 result; >+ result[0] = isnan(x[0]); >+ result[1] = isnan(x[1]); >+ result[2] = isnan(x[2]); >+ return result; >+} >+bool4 isnan(half4 x) { >+ bool4 result; >+ result[0] = isnan(x[0]); >+ result[1] = isnan(x[1]); >+ result[2] = isnan(x[2]); >+ result[3] = isnan(x[3]); >+ return result; >+} >+ >+bool2 isfinite(float2 x) { >+ bool2 result; >+ result[0] = isfinite(x[0]); >+ result[1] = isfinite(x[1]); >+ return result; >+} >+bool3 isfinite(float3 x) { >+ bool3 result; >+ result[0] = isfinite(x[0]); >+ result[1] = isfinite(x[1]); >+ result[2] = isfinite(x[2]); >+ return result; >+} >+bool4 isfinite(float4 x) { >+ bool4 result; >+ result[0] = isfinite(x[0]); >+ result[1] = isfinite(x[1]); >+ result[2] = isfinite(x[2]); >+ result[3] = isfinite(x[3]); >+ return result; >+} >+bool2 isinf(float2 x) { >+ bool2 result; >+ result[0] = isinf(x[0]); >+ result[1] = isinf(x[1]); >+ return result; >+} >+bool3 isinf(float3 x) { >+ bool3 result; >+ result[0] = isinf(x[0]); >+ result[1] = isinf(x[1]); >+ result[2] = isinf(x[2]); >+ return result; >+} >+bool4 isinf(float4 x) { >+ bool4 result; >+ result[0] = isinf(x[0]); >+ result[1] = isinf(x[1]); >+ result[2] = isinf(x[2]); >+ result[3] = isinf(x[3]); >+ return result; >+} >+bool2 isnan(float2 x) { >+ bool2 result; >+ result[0] = isnan(x[0]); >+ result[1] = isnan(x[1]); >+ return result; >+} >+bool3 isnan(float3 x) { >+ bool3 result; >+ result[0] = isnan(x[0]); >+ result[1] = isnan(x[1]); >+ result[2] = isnan(x[2]); >+ return result; >+} >+bool4 isnan(float4 x) { >+ bool4 result; >+ result[0] = isnan(x[0]); >+ result[1] = isnan(x[1]); >+ result[2] = isnan(x[2]); >+ result[3] = isnan(x[3]); >+ return result; >+} >+ >+bool isordered(half x, half y) { >+ return (x == x) && (y == y); >+} >+bool isunordered(half x, half y) { >+ return isnan(x) || isnan(y); >+} >+bool2 isordered(half2 x, half2 y) { >+ bool2 result; >+ result[0] = isordered(x[0], y[0]); >+ result[1] = isordered(x[1], y[1]); >+ return result; >+} >+bool3 isordered(half3 x, half3 y) { >+ bool3 result; >+ result[0] = isordered(x[0], y[0]); >+ result[1] = isordered(x[1], y[1]); >+ result[2] = isordered(x[2], y[2]); >+ return result; >+} >+bool4 isordered(half4 x, half4 y) { >+ bool4 result; >+ result[0] = isordered(x[0], y[0]); >+ result[1] = isordered(x[1], y[1]); >+ result[2] = isordered(x[2], y[2]); >+ result[3] = isordered(x[3], y[3]); >+ return result; >+} >+bool2 isunordered(half2 x, half2 y) { >+ bool2 result; >+ result[0] = isunordered(x[0], y[0]); >+ result[1] = isunordered(x[1], y[1]); >+ return result; >+} >+bool3 isunordered(half3 x, half3 y) { >+ bool3 result; >+ result[0] = isunordered(x[0], y[0]); >+ result[1] = isunordered(x[1], y[1]); >+ result[2] = isunordered(x[2], y[2]); >+ return result; >+} >+bool4 isunordered(half4 x, half4 y) { >+ bool4 result; >+ result[0] = isunordered(x[0], y[0]); >+ result[1] = isunordered(x[1], y[1]); >+ result[2] = isunordered(x[2], y[2]); >+ result[3] = isunordered(x[3], y[3]); >+ return result; >+} >+ >+bool isordered(float x, float y) { >+ return (x == x) && (y == y); >+} >+bool isunordered(float x, float y) { >+ return isnan(x) || isnan(y); >+} >+bool2 isordered(float2 x, float2 y) { >+ bool2 result; >+ result[0] = isordered(x[0], y[0]); >+ result[1] = isordered(x[1], y[1]); >+ return result; >+} >+bool3 isordered(float3 x, float3 y) { >+ bool3 result; >+ result[0] = isordered(x[0], y[0]); >+ result[1] = isordered(x[1], y[1]); >+ result[2] = isordered(x[2], y[2]); >+ return result; >+} >+bool4 isordered(float4 x, float4 y) { >+ bool4 result; >+ result[0] = isordered(x[0], y[0]); >+ result[1] = isordered(x[1], y[1]); >+ result[2] = isordered(x[2], y[2]); >+ result[3] = isordered(x[3], y[3]); >+ return result; >+} >+bool2 isunordered(float2 x, float2 y) { >+ bool2 result; >+ result[0] = isunordered(x[0], y[0]); >+ result[1] = isunordered(x[1], y[1]); >+ return result; >+} >+bool3 isunordered(float3 x, float3 y) { >+ bool3 result; >+ result[0] = isunordered(x[0], y[0]); >+ result[1] = isunordered(x[1], y[1]); >+ result[2] = isunordered(x[2], y[2]); >+ return result; >+} >+bool4 isunordered(float4 x, float4 y) { >+ bool4 result; >+ result[0] = isunordered(x[0], y[0]); >+ result[1] = isunordered(x[1], y[1]); >+ result[2] = isunordered(x[2], y[2]); >+ result[3] = isunordered(x[3], y[3]); >+ return result; >+} >+ >+native float atan2(float, float); >+half atan2(half x, half y) { >+ return half(atan2(float(x), float(y))); >+} >+half2 atan2(half2 x, half2 y) { >+ half2 result; >+ result[0] = atan2(x[0], y[0]); >+ result[1] = atan2(x[1], y[1]); >+ return result; >+} >+half3 atan2(half3 x, half3 y) { >+ half3 result; >+ result[0] = atan2(x[0], y[0]); >+ result[1] = atan2(x[1], y[1]); >+ result[2] = atan2(x[2], y[2]); >+ return result; >+} >+half4 atan2(half4 x, half4 y) { >+ half4 result; >+ result[0] = atan2(x[0], y[0]); >+ result[1] = atan2(x[1], y[1]); >+ result[2] = atan2(x[2], y[2]); >+ result[3] = atan2(x[3], y[3]); >+ return result; >+} >+half2x2 atan2(half2x2 x, half2x2 y) { >+ half2x2 result; >+ result[0][0] = atan2(x[0][0], y[0][0]); >+ result[0][1] = atan2(x[0][1], y[0][1]); >+ result[1][0] = atan2(x[1][0], y[1][0]); >+ result[1][1] = atan2(x[1][1], y[1][1]); >+ return result; >+} >+half2x3 atan2(half2x3 x, half2x3 y) { >+ half2x3 result; >+ result[0][0] = atan2(x[0][0], y[0][0]); >+ result[0][1] = atan2(x[0][1], y[0][1]); >+ result[0][2] = atan2(x[0][2], y[0][2]); >+ result[1][0] = atan2(x[1][0], y[1][0]); >+ result[1][1] = atan2(x[1][1], y[1][1]); >+ result[1][2] = atan2(x[1][2], y[1][2]); >+ return result; >+} >+half2x4 atan2(half2x4 x, half2x4 y) { >+ half2x4 result; >+ result[0][0] = atan2(x[0][0], y[0][0]); >+ result[0][1] = atan2(x[0][1], y[0][1]); >+ result[0][2] = atan2(x[0][2], y[0][2]); >+ result[0][3] = atan2(x[0][3], y[0][3]); >+ result[1][0] = atan2(x[1][0], y[1][0]); >+ result[1][1] = atan2(x[1][1], y[1][1]); >+ result[1][2] = atan2(x[1][2], y[1][2]); >+ result[1][3] = atan2(x[1][3], y[1][3]); >+ return result; >+} >+half3x2 atan2(half3x2 x, half3x2 y) { >+ half3x2 result; >+ result[0][0] = atan2(x[0][0], y[0][0]); >+ result[0][1] = atan2(x[0][1], y[0][1]); >+ result[1][0] = atan2(x[1][0], y[1][0]); >+ result[1][1] = atan2(x[1][1], y[1][1]); >+ result[2][0] = atan2(x[2][0], y[2][0]); >+ result[2][1] = atan2(x[2][1], y[2][1]); >+ return result; >+} >+half3x3 atan2(half3x3 x, half3x3 y) { >+ half3x3 result; >+ result[0][0] = atan2(x[0][0], y[0][0]); >+ result[0][1] = atan2(x[0][1], y[0][1]); >+ result[0][2] = atan2(x[0][2], y[0][2]); >+ result[1][0] = atan2(x[1][0], y[1][0]); >+ result[1][1] = atan2(x[1][1], y[1][1]); >+ result[1][2] = atan2(x[1][2], y[1][2]); >+ result[2][0] = atan2(x[2][0], y[2][0]); >+ result[2][1] = atan2(x[2][1], y[2][1]); >+ result[2][2] = atan2(x[2][2], y[2][2]); >+ return result; >+} >+half3x4 atan2(half3x4 x, half3x4 y) { >+ half3x4 result; >+ result[0][0] = atan2(x[0][0], y[0][0]); >+ result[0][1] = atan2(x[0][1], y[0][1]); >+ result[0][2] = atan2(x[0][2], y[0][2]); >+ result[0][3] = atan2(x[0][3], y[0][3]); >+ result[1][0] = atan2(x[1][0], y[1][0]); >+ result[1][1] = atan2(x[1][1], y[1][1]); >+ result[1][2] = atan2(x[1][2], y[1][2]); >+ result[1][3] = atan2(x[1][3], y[1][3]); >+ result[2][0] = atan2(x[2][0], y[2][0]); >+ result[2][1] = atan2(x[2][1], y[2][1]); >+ result[2][2] = atan2(x[2][2], y[2][2]); >+ result[2][3] = atan2(x[2][3], y[2][3]); >+ return result; >+} >+half4x2 atan2(half4x2 x, half4x2 y) { >+ half4x2 result; >+ result[0][0] = atan2(x[0][0], y[0][0]); >+ result[0][1] = atan2(x[0][1], y[0][1]); >+ result[1][0] = atan2(x[1][0], y[1][0]); >+ result[1][1] = atan2(x[1][1], y[1][1]); >+ result[2][0] = atan2(x[2][0], y[2][0]); >+ result[2][1] = atan2(x[2][1], y[2][1]); >+ result[3][0] = atan2(x[3][0], y[3][0]); >+ result[3][1] = atan2(x[3][1], y[3][1]); >+ return result; >+} >+half4x3 atan2(half4x3 x, half4x3 y) { >+ half4x3 result; >+ result[0][0] = atan2(x[0][0], y[0][0]); >+ result[0][1] = atan2(x[0][1], y[0][1]); >+ result[0][2] = atan2(x[0][2], y[0][2]); >+ result[1][0] = atan2(x[1][0], y[1][0]); >+ result[1][1] = atan2(x[1][1], y[1][1]); >+ result[1][2] = atan2(x[1][2], y[1][2]); >+ result[2][0] = atan2(x[2][0], y[2][0]); >+ result[2][1] = atan2(x[2][1], y[2][1]); >+ result[2][2] = atan2(x[2][2], y[2][2]); >+ result[3][0] = atan2(x[3][0], y[3][0]); >+ result[3][1] = atan2(x[3][1], y[3][1]); >+ result[3][2] = atan2(x[3][2], y[3][2]); >+ return result; >+} >+half4x4 atan2(half4x4 x, half4x4 y) { >+ half4x4 result; >+ result[0][0] = atan2(x[0][0], y[0][0]); >+ result[0][1] = atan2(x[0][1], y[0][1]); >+ result[0][2] = atan2(x[0][2], y[0][2]); >+ result[0][3] = atan2(x[0][3], y[0][3]); >+ result[1][0] = atan2(x[1][0], y[1][0]); >+ result[1][1] = atan2(x[1][1], y[1][1]); >+ result[1][2] = atan2(x[1][2], y[1][2]); >+ result[1][3] = atan2(x[1][3], y[1][3]); >+ result[2][0] = atan2(x[2][0], y[2][0]); >+ result[2][1] = atan2(x[2][1], y[2][1]); >+ result[2][2] = atan2(x[2][2], y[2][2]); >+ result[2][3] = atan2(x[2][3], y[2][3]); >+ result[3][0] = atan2(x[3][0], y[3][0]); >+ result[3][1] = atan2(x[3][1], y[3][1]); >+ result[3][2] = atan2(x[3][2], y[3][2]); >+ result[3][3] = atan2(x[3][3], y[3][3]); >+ return result; >+} >+float2 atan2(float2 x, float2 y) { >+ float2 result; >+ result[0] = atan2(x[0], y[0]); >+ result[1] = atan2(x[1], y[1]); >+ return result; >+} >+float3 atan2(float3 x, float3 y) { >+ float3 result; >+ result[0] = atan2(x[0], y[0]); >+ result[1] = atan2(x[1], y[1]); >+ result[2] = atan2(x[2], y[2]); >+ return result; >+} >+float4 atan2(float4 x, float4 y) { >+ float4 result; >+ result[0] = atan2(x[0], y[0]); >+ result[1] = atan2(x[1], y[1]); >+ result[2] = atan2(x[2], y[2]); >+ result[3] = atan2(x[3], y[3]); >+ return result; >+} >+float2x2 atan2(float2x2 x, float2x2 y) { >+ float2x2 result; >+ result[0][0] = atan2(x[0][0], y[0][0]); >+ result[0][1] = atan2(x[0][1], y[0][1]); >+ result[1][0] = atan2(x[1][0], y[1][0]); >+ result[1][1] = atan2(x[1][1], y[1][1]); >+ return result; >+} >+float2x3 atan2(float2x3 x, float2x3 y) { >+ float2x3 result; >+ result[0][0] = atan2(x[0][0], y[0][0]); >+ result[0][1] = atan2(x[0][1], y[0][1]); >+ result[0][2] = atan2(x[0][2], y[0][2]); >+ result[1][0] = atan2(x[1][0], y[1][0]); >+ result[1][1] = atan2(x[1][1], y[1][1]); >+ result[1][2] = atan2(x[1][2], y[1][2]); >+ return result; >+} >+float2x4 atan2(float2x4 x, float2x4 y) { >+ float2x4 result; >+ result[0][0] = atan2(x[0][0], y[0][0]); >+ result[0][1] = atan2(x[0][1], y[0][1]); >+ result[0][2] = atan2(x[0][2], y[0][2]); >+ result[0][3] = atan2(x[0][3], y[0][3]); >+ result[1][0] = atan2(x[1][0], y[1][0]); >+ result[1][1] = atan2(x[1][1], y[1][1]); >+ result[1][2] = atan2(x[1][2], y[1][2]); >+ result[1][3] = atan2(x[1][3], y[1][3]); >+ return result; >+} >+float3x2 atan2(float3x2 x, float3x2 y) { >+ float3x2 result; >+ result[0][0] = atan2(x[0][0], y[0][0]); >+ result[0][1] = atan2(x[0][1], y[0][1]); >+ result[1][0] = atan2(x[1][0], y[1][0]); >+ result[1][1] = atan2(x[1][1], y[1][1]); >+ result[2][0] = atan2(x[2][0], y[2][0]); >+ result[2][1] = atan2(x[2][1], y[2][1]); >+ return result; >+} >+float3x3 atan2(float3x3 x, float3x3 y) { >+ float3x3 result; >+ result[0][0] = atan2(x[0][0], y[0][0]); >+ result[0][1] = atan2(x[0][1], y[0][1]); >+ result[0][2] = atan2(x[0][2], y[0][2]); >+ result[1][0] = atan2(x[1][0], y[1][0]); >+ result[1][1] = atan2(x[1][1], y[1][1]); >+ result[1][2] = atan2(x[1][2], y[1][2]); >+ result[2][0] = atan2(x[2][0], y[2][0]); >+ result[2][1] = atan2(x[2][1], y[2][1]); >+ result[2][2] = atan2(x[2][2], y[2][2]); >+ return result; >+} >+float3x4 atan2(float3x4 x, float3x4 y) { >+ float3x4 result; >+ result[0][0] = atan2(x[0][0], y[0][0]); >+ result[0][1] = atan2(x[0][1], y[0][1]); >+ result[0][2] = atan2(x[0][2], y[0][2]); >+ result[0][3] = atan2(x[0][3], y[0][3]); >+ result[1][0] = atan2(x[1][0], y[1][0]); >+ result[1][1] = atan2(x[1][1], y[1][1]); >+ result[1][2] = atan2(x[1][2], y[1][2]); >+ result[1][3] = atan2(x[1][3], y[1][3]); >+ result[2][0] = atan2(x[2][0], y[2][0]); >+ result[2][1] = atan2(x[2][1], y[2][1]); >+ result[2][2] = atan2(x[2][2], y[2][2]); >+ result[2][3] = atan2(x[2][3], y[2][3]); >+ return result; >+} >+float4x2 atan2(float4x2 x, float4x2 y) { >+ float4x2 result; >+ result[0][0] = atan2(x[0][0], y[0][0]); >+ result[0][1] = atan2(x[0][1], y[0][1]); >+ result[1][0] = atan2(x[1][0], y[1][0]); >+ result[1][1] = atan2(x[1][1], y[1][1]); >+ result[2][0] = atan2(x[2][0], y[2][0]); >+ result[2][1] = atan2(x[2][1], y[2][1]); >+ result[3][0] = atan2(x[3][0], y[3][0]); >+ result[3][1] = atan2(x[3][1], y[3][1]); >+ return result; >+} >+float4x3 atan2(float4x3 x, float4x3 y) { >+ float4x3 result; >+ result[0][0] = atan2(x[0][0], y[0][0]); >+ result[0][1] = atan2(x[0][1], y[0][1]); >+ result[0][2] = atan2(x[0][2], y[0][2]); >+ result[1][0] = atan2(x[1][0], y[1][0]); >+ result[1][1] = atan2(x[1][1], y[1][1]); >+ result[1][2] = atan2(x[1][2], y[1][2]); >+ result[2][0] = atan2(x[2][0], y[2][0]); >+ result[2][1] = atan2(x[2][1], y[2][1]); >+ result[2][2] = atan2(x[2][2], y[2][2]); >+ result[3][0] = atan2(x[3][0], y[3][0]); >+ result[3][1] = atan2(x[3][1], y[3][1]); >+ result[3][2] = atan2(x[3][2], y[3][2]); >+ return result; >+} >+float4x4 atan2(float4x4 x, float4x4 y) { >+ float4x4 result; >+ result[0][0] = atan2(x[0][0], y[0][0]); >+ result[0][1] = atan2(x[0][1], y[0][1]); >+ result[0][2] = atan2(x[0][2], y[0][2]); >+ result[0][3] = atan2(x[0][3], y[0][3]); >+ result[1][0] = atan2(x[1][0], y[1][0]); >+ result[1][1] = atan2(x[1][1], y[1][1]); >+ result[1][2] = atan2(x[1][2], y[1][2]); >+ result[1][3] = atan2(x[1][3], y[1][3]); >+ result[2][0] = atan2(x[2][0], y[2][0]); >+ result[2][1] = atan2(x[2][1], y[2][1]); >+ result[2][2] = atan2(x[2][2], y[2][2]); >+ result[2][3] = atan2(x[2][3], y[2][3]); >+ result[3][0] = atan2(x[3][0], y[3][0]); >+ result[3][1] = atan2(x[3][1], y[3][1]); >+ result[3][2] = atan2(x[3][2], y[3][2]); >+ result[3][3] = atan2(x[3][3], y[3][3]); >+ return result; >+} >+void sincos(half x, thread half* y, thread half* z) { >+ if (y != null) >+ *y = sin(x); >+ if (z != null) >+ *z = cos(x); >+} >+void sincos(half2 x, thread half2* y, thread half2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+} >+void sincos(half3 x, thread half3* y, thread half3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+} >+void sincos(half4 x, thread half4* y, thread half4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+ sincos(x[3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3] = sinResult; >+ if (z != null) >+ (*z)[3] = cosResult; >+} >+void sincos(half2x2 x, thread half2x2* y, thread half2x2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+} >+void sincos(half2x3 x, thread half2x3* y, thread half2x3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+} >+void sincos(half2x4 x, thread half2x4* y, thread half2x4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+} >+void sincos(half3x2 x, thread half3x2* y, thread half3x2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+} >+void sincos(half3x3 x, thread half3x3* y, thread half3x3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+} >+void sincos(half3x4 x, thread half3x4* y, thread half3x4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+} >+void sincos(half4x2 x, thread half4x2* y, thread half4x2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+} >+void sincos(half4x3 x, thread half4x3* y, thread half4x3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+} >+void sincos(half4x4 x, thread half4x4* y, thread half4x4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+ sincos(x[3][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][3] = sinResult; >+ if (z != null) >+ (*z)[3][3] = cosResult; >+} >+void sincos(float x, thread float* y, thread float* z) { >+ if (y != null) >+ *y = sin(x); >+ if (z != null) >+ *z = cos(x); >+} >+void sincos(float2 x, thread float2* y, thread float2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+} >+void sincos(float3 x, thread float3* y, thread float3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+} >+void sincos(float4 x, thread float4* y, thread float4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+ sincos(x[3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3] = sinResult; >+ if (z != null) >+ (*z)[3] = cosResult; >+} >+void sincos(float2x2 x, thread float2x2* y, thread float2x2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+} >+void sincos(float2x3 x, thread float2x3* y, thread float2x3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+} >+void sincos(float2x4 x, thread float2x4* y, thread float2x4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+} >+void sincos(float3x2 x, thread float3x2* y, thread float3x2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+} >+void sincos(float3x3 x, thread float3x3* y, thread float3x3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+} >+void sincos(float3x4 x, thread float3x4* y, thread float3x4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+} >+void sincos(float4x2 x, thread float4x2* y, thread float4x2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+} >+void sincos(float4x3 x, thread float4x3* y, thread float4x3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+} >+void sincos(float4x4 x, thread float4x4* y, thread float4x4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+ sincos(x[3][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][3] = sinResult; >+ if (z != null) >+ (*z)[3][3] = cosResult; >+} >+void sincos(half x, thread half* y, device half* z) { >+ if (y != null) >+ *y = sin(x); >+ if (z != null) >+ *z = cos(x); >+} >+void sincos(half2 x, thread half2* y, device half2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+} >+void sincos(half3 x, thread half3* y, device half3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+} >+void sincos(half4 x, thread half4* y, device half4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+ sincos(x[3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3] = sinResult; >+ if (z != null) >+ (*z)[3] = cosResult; >+} >+void sincos(half2x2 x, thread half2x2* y, device half2x2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+} >+void sincos(half2x3 x, thread half2x3* y, device half2x3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+} >+void sincos(half2x4 x, thread half2x4* y, device half2x4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+} >+void sincos(half3x2 x, thread half3x2* y, device half3x2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+} >+void sincos(half3x3 x, thread half3x3* y, device half3x3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+} >+void sincos(half3x4 x, thread half3x4* y, device half3x4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+} >+void sincos(half4x2 x, thread half4x2* y, device half4x2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+} >+void sincos(half4x3 x, thread half4x3* y, device half4x3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+} >+void sincos(half4x4 x, thread half4x4* y, device half4x4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+ sincos(x[3][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][3] = sinResult; >+ if (z != null) >+ (*z)[3][3] = cosResult; >+} >+void sincos(float x, thread float* y, device float* z) { >+ if (y != null) >+ *y = sin(x); >+ if (z != null) >+ *z = cos(x); >+} >+void sincos(float2 x, thread float2* y, device float2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+} >+void sincos(float3 x, thread float3* y, device float3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+} >+void sincos(float4 x, thread float4* y, device float4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+ sincos(x[3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3] = sinResult; >+ if (z != null) >+ (*z)[3] = cosResult; >+} >+void sincos(float2x2 x, thread float2x2* y, device float2x2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+} >+void sincos(float2x3 x, thread float2x3* y, device float2x3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+} >+void sincos(float2x4 x, thread float2x4* y, device float2x4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+} >+void sincos(float3x2 x, thread float3x2* y, device float3x2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+} >+void sincos(float3x3 x, thread float3x3* y, device float3x3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+} >+void sincos(float3x4 x, thread float3x4* y, device float3x4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+} >+void sincos(float4x2 x, thread float4x2* y, device float4x2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+} >+void sincos(float4x3 x, thread float4x3* y, device float4x3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+} >+void sincos(float4x4 x, thread float4x4* y, device float4x4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+ sincos(x[3][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][3] = sinResult; >+ if (z != null) >+ (*z)[3][3] = cosResult; >+} >+void sincos(half x, thread half* y, threadgroup half* z) { >+ if (y != null) >+ *y = sin(x); >+ if (z != null) >+ *z = cos(x); >+} >+void sincos(half2 x, thread half2* y, threadgroup half2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+} >+void sincos(half3 x, thread half3* y, threadgroup half3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+} >+void sincos(half4 x, thread half4* y, threadgroup half4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+ sincos(x[3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3] = sinResult; >+ if (z != null) >+ (*z)[3] = cosResult; >+} >+void sincos(half2x2 x, thread half2x2* y, threadgroup half2x2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+} >+void sincos(half2x3 x, thread half2x3* y, threadgroup half2x3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+} >+void sincos(half2x4 x, thread half2x4* y, threadgroup half2x4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+} >+void sincos(half3x2 x, thread half3x2* y, threadgroup half3x2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+} >+void sincos(half3x3 x, thread half3x3* y, threadgroup half3x3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+} >+void sincos(half3x4 x, thread half3x4* y, threadgroup half3x4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+} >+void sincos(half4x2 x, thread half4x2* y, threadgroup half4x2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+} >+void sincos(half4x3 x, thread half4x3* y, threadgroup half4x3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+} >+void sincos(half4x4 x, thread half4x4* y, threadgroup half4x4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+ sincos(x[3][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][3] = sinResult; >+ if (z != null) >+ (*z)[3][3] = cosResult; >+} >+void sincos(float x, thread float* y, threadgroup float* z) { >+ if (y != null) >+ *y = sin(x); >+ if (z != null) >+ *z = cos(x); >+} >+void sincos(float2 x, thread float2* y, threadgroup float2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+} >+void sincos(float3 x, thread float3* y, threadgroup float3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+} >+void sincos(float4 x, thread float4* y, threadgroup float4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+ sincos(x[3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3] = sinResult; >+ if (z != null) >+ (*z)[3] = cosResult; >+} >+void sincos(float2x2 x, thread float2x2* y, threadgroup float2x2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+} >+void sincos(float2x3 x, thread float2x3* y, threadgroup float2x3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+} >+void sincos(float2x4 x, thread float2x4* y, threadgroup float2x4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+} >+void sincos(float3x2 x, thread float3x2* y, threadgroup float3x2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+} >+void sincos(float3x3 x, thread float3x3* y, threadgroup float3x3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+} >+void sincos(float3x4 x, thread float3x4* y, threadgroup float3x4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+} >+void sincos(float4x2 x, thread float4x2* y, threadgroup float4x2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+} >+void sincos(float4x3 x, thread float4x3* y, threadgroup float4x3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+} >+void sincos(float4x4 x, thread float4x4* y, threadgroup float4x4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+ sincos(x[3][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][3] = sinResult; >+ if (z != null) >+ (*z)[3][3] = cosResult; >+} >+void sincos(half x, device half* y, thread half* z) { >+ if (y != null) >+ *y = sin(x); >+ if (z != null) >+ *z = cos(x); >+} >+void sincos(half2 x, device half2* y, thread half2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+} >+void sincos(half3 x, device half3* y, thread half3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+} >+void sincos(half4 x, device half4* y, thread half4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+ sincos(x[3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3] = sinResult; >+ if (z != null) >+ (*z)[3] = cosResult; >+} >+void sincos(half2x2 x, device half2x2* y, thread half2x2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+} >+void sincos(half2x3 x, device half2x3* y, thread half2x3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+} >+void sincos(half2x4 x, device half2x4* y, thread half2x4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+} >+void sincos(half3x2 x, device half3x2* y, thread half3x2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+} >+void sincos(half3x3 x, device half3x3* y, thread half3x3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+} >+void sincos(half3x4 x, device half3x4* y, thread half3x4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+} >+void sincos(half4x2 x, device half4x2* y, thread half4x2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+} >+void sincos(half4x3 x, device half4x3* y, thread half4x3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+} >+void sincos(half4x4 x, device half4x4* y, thread half4x4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+ sincos(x[3][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][3] = sinResult; >+ if (z != null) >+ (*z)[3][3] = cosResult; >+} >+void sincos(float x, device float* y, thread float* z) { >+ if (y != null) >+ *y = sin(x); >+ if (z != null) >+ *z = cos(x); >+} >+void sincos(float2 x, device float2* y, thread float2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+} >+void sincos(float3 x, device float3* y, thread float3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+} >+void sincos(float4 x, device float4* y, thread float4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+ sincos(x[3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3] = sinResult; >+ if (z != null) >+ (*z)[3] = cosResult; >+} >+void sincos(float2x2 x, device float2x2* y, thread float2x2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+} >+void sincos(float2x3 x, device float2x3* y, thread float2x3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+} >+void sincos(float2x4 x, device float2x4* y, thread float2x4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+} >+void sincos(float3x2 x, device float3x2* y, thread float3x2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+} >+void sincos(float3x3 x, device float3x3* y, thread float3x3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+} >+void sincos(float3x4 x, device float3x4* y, thread float3x4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+} >+void sincos(float4x2 x, device float4x2* y, thread float4x2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+} >+void sincos(float4x3 x, device float4x3* y, thread float4x3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+} >+void sincos(float4x4 x, device float4x4* y, thread float4x4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+ sincos(x[3][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][3] = sinResult; >+ if (z != null) >+ (*z)[3][3] = cosResult; >+} >+void sincos(half x, device half* y, device half* z) { >+ if (y != null) >+ *y = sin(x); >+ if (z != null) >+ *z = cos(x); >+} >+void sincos(half2 x, device half2* y, device half2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+} >+void sincos(half3 x, device half3* y, device half3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+} >+void sincos(half4 x, device half4* y, device half4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+ sincos(x[3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3] = sinResult; >+ if (z != null) >+ (*z)[3] = cosResult; >+} >+void sincos(half2x2 x, device half2x2* y, device half2x2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+} >+void sincos(half2x3 x, device half2x3* y, device half2x3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+} >+void sincos(half2x4 x, device half2x4* y, device half2x4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+} >+void sincos(half3x2 x, device half3x2* y, device half3x2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+} >+void sincos(half3x3 x, device half3x3* y, device half3x3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+} >+void sincos(half3x4 x, device half3x4* y, device half3x4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+} >+void sincos(half4x2 x, device half4x2* y, device half4x2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+} >+void sincos(half4x3 x, device half4x3* y, device half4x3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+} >+void sincos(half4x4 x, device half4x4* y, device half4x4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+ sincos(x[3][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][3] = sinResult; >+ if (z != null) >+ (*z)[3][3] = cosResult; >+} >+void sincos(float x, device float* y, device float* z) { >+ if (y != null) >+ *y = sin(x); >+ if (z != null) >+ *z = cos(x); >+} >+void sincos(float2 x, device float2* y, device float2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+} >+void sincos(float3 x, device float3* y, device float3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+} >+void sincos(float4 x, device float4* y, device float4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+ sincos(x[3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3] = sinResult; >+ if (z != null) >+ (*z)[3] = cosResult; >+} >+void sincos(float2x2 x, device float2x2* y, device float2x2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+} >+void sincos(float2x3 x, device float2x3* y, device float2x3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+} >+void sincos(float2x4 x, device float2x4* y, device float2x4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+} >+void sincos(float3x2 x, device float3x2* y, device float3x2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+} >+void sincos(float3x3 x, device float3x3* y, device float3x3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+} >+void sincos(float3x4 x, device float3x4* y, device float3x4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+} >+void sincos(float4x2 x, device float4x2* y, device float4x2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+} >+void sincos(float4x3 x, device float4x3* y, device float4x3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+} >+void sincos(float4x4 x, device float4x4* y, device float4x4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+ sincos(x[3][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][3] = sinResult; >+ if (z != null) >+ (*z)[3][3] = cosResult; >+} >+void sincos(half x, device half* y, threadgroup half* z) { >+ if (y != null) >+ *y = sin(x); >+ if (z != null) >+ *z = cos(x); >+} >+void sincos(half2 x, device half2* y, threadgroup half2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+} >+void sincos(half3 x, device half3* y, threadgroup half3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+} >+void sincos(half4 x, device half4* y, threadgroup half4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+ sincos(x[3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3] = sinResult; >+ if (z != null) >+ (*z)[3] = cosResult; >+} >+void sincos(half2x2 x, device half2x2* y, threadgroup half2x2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+} >+void sincos(half2x3 x, device half2x3* y, threadgroup half2x3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+} >+void sincos(half2x4 x, device half2x4* y, threadgroup half2x4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+} >+void sincos(half3x2 x, device half3x2* y, threadgroup half3x2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+} >+void sincos(half3x3 x, device half3x3* y, threadgroup half3x3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+} >+void sincos(half3x4 x, device half3x4* y, threadgroup half3x4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+} >+void sincos(half4x2 x, device half4x2* y, threadgroup half4x2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+} >+void sincos(half4x3 x, device half4x3* y, threadgroup half4x3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+} >+void sincos(half4x4 x, device half4x4* y, threadgroup half4x4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+ sincos(x[3][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][3] = sinResult; >+ if (z != null) >+ (*z)[3][3] = cosResult; >+} >+void sincos(float x, device float* y, threadgroup float* z) { >+ if (y != null) >+ *y = sin(x); >+ if (z != null) >+ *z = cos(x); >+} >+void sincos(float2 x, device float2* y, threadgroup float2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+} >+void sincos(float3 x, device float3* y, threadgroup float3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+} >+void sincos(float4 x, device float4* y, threadgroup float4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+ sincos(x[3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3] = sinResult; >+ if (z != null) >+ (*z)[3] = cosResult; >+} >+void sincos(float2x2 x, device float2x2* y, threadgroup float2x2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+} >+void sincos(float2x3 x, device float2x3* y, threadgroup float2x3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+} >+void sincos(float2x4 x, device float2x4* y, threadgroup float2x4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+} >+void sincos(float3x2 x, device float3x2* y, threadgroup float3x2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+} >+void sincos(float3x3 x, device float3x3* y, threadgroup float3x3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+} >+void sincos(float3x4 x, device float3x4* y, threadgroup float3x4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+} >+void sincos(float4x2 x, device float4x2* y, threadgroup float4x2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+} >+void sincos(float4x3 x, device float4x3* y, threadgroup float4x3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+} >+void sincos(float4x4 x, device float4x4* y, threadgroup float4x4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+ sincos(x[3][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][3] = sinResult; >+ if (z != null) >+ (*z)[3][3] = cosResult; >+} >+void sincos(half x, threadgroup half* y, thread half* z) { >+ if (y != null) >+ *y = sin(x); >+ if (z != null) >+ *z = cos(x); >+} >+void sincos(half2 x, threadgroup half2* y, thread half2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+} >+void sincos(half3 x, threadgroup half3* y, thread half3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+} >+void sincos(half4 x, threadgroup half4* y, thread half4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+ sincos(x[3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3] = sinResult; >+ if (z != null) >+ (*z)[3] = cosResult; >+} >+void sincos(half2x2 x, threadgroup half2x2* y, thread half2x2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+} >+void sincos(half2x3 x, threadgroup half2x3* y, thread half2x3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+} >+void sincos(half2x4 x, threadgroup half2x4* y, thread half2x4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+} >+void sincos(half3x2 x, threadgroup half3x2* y, thread half3x2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+} >+void sincos(half3x3 x, threadgroup half3x3* y, thread half3x3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+} >+void sincos(half3x4 x, threadgroup half3x4* y, thread half3x4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+} >+void sincos(half4x2 x, threadgroup half4x2* y, thread half4x2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+} >+void sincos(half4x3 x, threadgroup half4x3* y, thread half4x3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+} >+void sincos(half4x4 x, threadgroup half4x4* y, thread half4x4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+ sincos(x[3][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][3] = sinResult; >+ if (z != null) >+ (*z)[3][3] = cosResult; >+} >+void sincos(float x, threadgroup float* y, thread float* z) { >+ if (y != null) >+ *y = sin(x); >+ if (z != null) >+ *z = cos(x); >+} >+void sincos(float2 x, threadgroup float2* y, thread float2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+} >+void sincos(float3 x, threadgroup float3* y, thread float3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+} >+void sincos(float4 x, threadgroup float4* y, thread float4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+ sincos(x[3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3] = sinResult; >+ if (z != null) >+ (*z)[3] = cosResult; >+} >+void sincos(float2x2 x, threadgroup float2x2* y, thread float2x2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+} >+void sincos(float2x3 x, threadgroup float2x3* y, thread float2x3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+} >+void sincos(float2x4 x, threadgroup float2x4* y, thread float2x4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+} >+void sincos(float3x2 x, threadgroup float3x2* y, thread float3x2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+} >+void sincos(float3x3 x, threadgroup float3x3* y, thread float3x3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+} >+void sincos(float3x4 x, threadgroup float3x4* y, thread float3x4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+} >+void sincos(float4x2 x, threadgroup float4x2* y, thread float4x2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+} >+void sincos(float4x3 x, threadgroup float4x3* y, thread float4x3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+} >+void sincos(float4x4 x, threadgroup float4x4* y, thread float4x4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+ sincos(x[3][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][3] = sinResult; >+ if (z != null) >+ (*z)[3][3] = cosResult; >+} >+void sincos(half x, threadgroup half* y, device half* z) { >+ if (y != null) >+ *y = sin(x); >+ if (z != null) >+ *z = cos(x); >+} >+void sincos(half2 x, threadgroup half2* y, device half2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+} >+void sincos(half3 x, threadgroup half3* y, device half3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+} >+void sincos(half4 x, threadgroup half4* y, device half4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+ sincos(x[3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3] = sinResult; >+ if (z != null) >+ (*z)[3] = cosResult; >+} >+void sincos(half2x2 x, threadgroup half2x2* y, device half2x2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+} >+void sincos(half2x3 x, threadgroup half2x3* y, device half2x3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+} >+void sincos(half2x4 x, threadgroup half2x4* y, device half2x4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+} >+void sincos(half3x2 x, threadgroup half3x2* y, device half3x2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+} >+void sincos(half3x3 x, threadgroup half3x3* y, device half3x3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+} >+void sincos(half3x4 x, threadgroup half3x4* y, device half3x4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+} >+void sincos(half4x2 x, threadgroup half4x2* y, device half4x2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+} >+void sincos(half4x3 x, threadgroup half4x3* y, device half4x3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+} >+void sincos(half4x4 x, threadgroup half4x4* y, device half4x4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+ sincos(x[3][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][3] = sinResult; >+ if (z != null) >+ (*z)[3][3] = cosResult; >+} >+void sincos(float x, threadgroup float* y, device float* z) { >+ if (y != null) >+ *y = sin(x); >+ if (z != null) >+ *z = cos(x); >+} >+void sincos(float2 x, threadgroup float2* y, device float2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+} >+void sincos(float3 x, threadgroup float3* y, device float3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+} >+void sincos(float4 x, threadgroup float4* y, device float4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+ sincos(x[3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3] = sinResult; >+ if (z != null) >+ (*z)[3] = cosResult; >+} >+void sincos(float2x2 x, threadgroup float2x2* y, device float2x2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+} >+void sincos(float2x3 x, threadgroup float2x3* y, device float2x3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+} >+void sincos(float2x4 x, threadgroup float2x4* y, device float2x4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+} >+void sincos(float3x2 x, threadgroup float3x2* y, device float3x2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+} >+void sincos(float3x3 x, threadgroup float3x3* y, device float3x3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+} >+void sincos(float3x4 x, threadgroup float3x4* y, device float3x4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+} >+void sincos(float4x2 x, threadgroup float4x2* y, device float4x2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+} >+void sincos(float4x3 x, threadgroup float4x3* y, device float4x3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+} >+void sincos(float4x4 x, threadgroup float4x4* y, device float4x4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+ sincos(x[3][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][3] = sinResult; >+ if (z != null) >+ (*z)[3][3] = cosResult; >+} >+void sincos(half x, threadgroup half* y, threadgroup half* z) { >+ if (y != null) >+ *y = sin(x); >+ if (z != null) >+ *z = cos(x); >+} >+void sincos(half2 x, threadgroup half2* y, threadgroup half2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+} >+void sincos(half3 x, threadgroup half3* y, threadgroup half3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+} >+void sincos(half4 x, threadgroup half4* y, threadgroup half4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+ sincos(x[3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3] = sinResult; >+ if (z != null) >+ (*z)[3] = cosResult; >+} >+void sincos(half2x2 x, threadgroup half2x2* y, threadgroup half2x2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+} >+void sincos(half2x3 x, threadgroup half2x3* y, threadgroup half2x3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+} >+void sincos(half2x4 x, threadgroup half2x4* y, threadgroup half2x4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+} >+void sincos(half3x2 x, threadgroup half3x2* y, threadgroup half3x2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+} >+void sincos(half3x3 x, threadgroup half3x3* y, threadgroup half3x3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+} >+void sincos(half3x4 x, threadgroup half3x4* y, threadgroup half3x4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+} >+void sincos(half4x2 x, threadgroup half4x2* y, threadgroup half4x2* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+} >+void sincos(half4x3 x, threadgroup half4x3* y, threadgroup half4x3* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+} >+void sincos(half4x4 x, threadgroup half4x4* y, threadgroup half4x4* z) { >+ half sinResult; >+ half cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+ sincos(x[3][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][3] = sinResult; >+ if (z != null) >+ (*z)[3][3] = cosResult; >+} >+void sincos(float x, threadgroup float* y, threadgroup float* z) { >+ if (y != null) >+ *y = sin(x); >+ if (z != null) >+ *z = cos(x); >+} >+void sincos(float2 x, threadgroup float2* y, threadgroup float2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+} >+void sincos(float3 x, threadgroup float3* y, threadgroup float3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+} >+void sincos(float4 x, threadgroup float4* y, threadgroup float4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0] = sinResult; >+ if (z != null) >+ (*z)[0] = cosResult; >+ sincos(x[1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1] = sinResult; >+ if (z != null) >+ (*z)[1] = cosResult; >+ sincos(x[2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2] = sinResult; >+ if (z != null) >+ (*z)[2] = cosResult; >+ sincos(x[3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3] = sinResult; >+ if (z != null) >+ (*z)[3] = cosResult; >+} >+void sincos(float2x2 x, threadgroup float2x2* y, threadgroup float2x2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+} >+void sincos(float2x3 x, threadgroup float2x3* y, threadgroup float2x3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+} >+void sincos(float2x4 x, threadgroup float2x4* y, threadgroup float2x4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+} >+void sincos(float3x2 x, threadgroup float3x2* y, threadgroup float3x2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+} >+void sincos(float3x3 x, threadgroup float3x3* y, threadgroup float3x3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+} >+void sincos(float3x4 x, threadgroup float3x4* y, threadgroup float3x4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+} >+void sincos(float4x2 x, threadgroup float4x2* y, threadgroup float4x2* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+} >+void sincos(float4x3 x, threadgroup float4x3* y, threadgroup float4x3* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+} >+void sincos(float4x4 x, threadgroup float4x4* y, threadgroup float4x4* z) { >+ float sinResult; >+ float cosResult; >+ sincos(x[0][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][0] = sinResult; >+ if (z != null) >+ (*z)[0][0] = cosResult; >+ sincos(x[0][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][1] = sinResult; >+ if (z != null) >+ (*z)[0][1] = cosResult; >+ sincos(x[0][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][2] = sinResult; >+ if (z != null) >+ (*z)[0][2] = cosResult; >+ sincos(x[0][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[0][3] = sinResult; >+ if (z != null) >+ (*z)[0][3] = cosResult; >+ sincos(x[1][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][0] = sinResult; >+ if (z != null) >+ (*z)[1][0] = cosResult; >+ sincos(x[1][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][1] = sinResult; >+ if (z != null) >+ (*z)[1][1] = cosResult; >+ sincos(x[1][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][2] = sinResult; >+ if (z != null) >+ (*z)[1][2] = cosResult; >+ sincos(x[1][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[1][3] = sinResult; >+ if (z != null) >+ (*z)[1][3] = cosResult; >+ sincos(x[2][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][0] = sinResult; >+ if (z != null) >+ (*z)[2][0] = cosResult; >+ sincos(x[2][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][1] = sinResult; >+ if (z != null) >+ (*z)[2][1] = cosResult; >+ sincos(x[2][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][2] = sinResult; >+ if (z != null) >+ (*z)[2][2] = cosResult; >+ sincos(x[2][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[2][3] = sinResult; >+ if (z != null) >+ (*z)[2][3] = cosResult; >+ sincos(x[3][0], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][0] = sinResult; >+ if (z != null) >+ (*z)[3][0] = cosResult; >+ sincos(x[3][1], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][1] = sinResult; >+ if (z != null) >+ (*z)[3][1] = cosResult; >+ sincos(x[3][2], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][2] = sinResult; >+ if (z != null) >+ (*z)[3][2] = cosResult; >+ sincos(x[3][3], &sinResult, &cosResult); >+ if (y != null) >+ (*y)[3][3] = sinResult; >+ if (z != null) >+ (*z)[3][3] = cosResult; >+} >+ >+bool all(bool x) { >+ return x; >+} >+bool all(bool2 x) { >+ bool result = true; >+ result = result && (x[0]); >+ result = result && (x[1]); >+ return result; >+} >+bool all(bool3 x) { >+ bool result = true; >+ result = result && (x[0]); >+ result = result && (x[1]); >+ result = result && (x[2]); >+ return result; >+} >+bool all(bool4 x) { >+ bool result = true; >+ result = result && (x[0]); >+ result = result && (x[1]); >+ result = result && (x[2]); >+ result = result && (x[3]); >+ return result; >+} >+bool all(uchar x) { >+ return x != 0; >+} >+bool all(uchar2 x) { >+ bool result = true; >+ result = result && (x[0] != 0); >+ result = result && (x[1] != 0); >+ return result; >+} >+bool all(uchar3 x) { >+ bool result = true; >+ result = result && (x[0] != 0); >+ result = result && (x[1] != 0); >+ result = result && (x[2] != 0); >+ return result; >+} >+bool all(uchar4 x) { >+ bool result = true; >+ result = result && (x[0] != 0); >+ result = result && (x[1] != 0); >+ result = result && (x[2] != 0); >+ result = result && (x[3] != 0); >+ return result; >+} >+bool all(ushort x) { >+ return x != 0; >+} >+bool all(ushort2 x) { >+ bool result = true; >+ result = result && (x[0] != 0); >+ result = result && (x[1] != 0); >+ return result; >+} >+bool all(ushort3 x) { >+ bool result = true; >+ result = result && (x[0] != 0); >+ result = result && (x[1] != 0); >+ result = result && (x[2] != 0); >+ return result; >+} >+bool all(ushort4 x) { >+ bool result = true; >+ result = result && (x[0] != 0); >+ result = result && (x[1] != 0); >+ result = result && (x[2] != 0); >+ result = result && (x[3] != 0); >+ return result; >+} >+bool all(uint x) { >+ return x != 0; >+} >+bool all(uint2 x) { >+ bool result = true; >+ result = result && (x[0] != 0); >+ result = result && (x[1] != 0); >+ return result; >+} >+bool all(uint3 x) { >+ bool result = true; >+ result = result && (x[0] != 0); >+ result = result && (x[1] != 0); >+ result = result && (x[2] != 0); >+ return result; >+} >+bool all(uint4 x) { >+ bool result = true; >+ result = result && (x[0] != 0); >+ result = result && (x[1] != 0); >+ result = result && (x[2] != 0); >+ result = result && (x[3] != 0); >+ return result; >+} >+bool all(char x) { >+ return x != 0; >+} >+bool all(char2 x) { >+ bool result = true; >+ result = result && (x[0] != 0); >+ result = result && (x[1] != 0); >+ return result; >+} >+bool all(char3 x) { >+ bool result = true; >+ result = result && (x[0] != 0); >+ result = result && (x[1] != 0); >+ result = result && (x[2] != 0); >+ return result; >+} >+bool all(char4 x) { >+ bool result = true; >+ result = result && (x[0] != 0); >+ result = result && (x[1] != 0); >+ result = result && (x[2] != 0); >+ result = result && (x[3] != 0); >+ return result; >+} >+bool all(short x) { >+ return x != 0; >+} >+bool all(short2 x) { >+ bool result = true; >+ result = result && (x[0] != 0); >+ result = result && (x[1] != 0); >+ return result; >+} >+bool all(short3 x) { >+ bool result = true; >+ result = result && (x[0] != 0); >+ result = result && (x[1] != 0); >+ result = result && (x[2] != 0); >+ return result; >+} >+bool all(short4 x) { >+ bool result = true; >+ result = result && (x[0] != 0); >+ result = result && (x[1] != 0); >+ result = result && (x[2] != 0); >+ result = result && (x[3] != 0); >+ return result; >+} >+bool all(int x) { >+ return x != 0; >+} >+bool all(int2 x) { >+ bool result = true; >+ result = result && (x[0] != 0); >+ result = result && (x[1] != 0); >+ return result; >+} >+bool all(int3 x) { >+ bool result = true; >+ result = result && (x[0] != 0); >+ result = result && (x[1] != 0); >+ result = result && (x[2] != 0); >+ return result; >+} >+bool all(int4 x) { >+ bool result = true; >+ result = result && (x[0] != 0); >+ result = result && (x[1] != 0); >+ result = result && (x[2] != 0); >+ result = result && (x[3] != 0); >+ return result; >+} >+bool all(half x) { >+ return x != 0; >+} >+bool all(half2 x) { >+ bool result = true; >+ result = result && (x[0] != 0); >+ result = result && (x[1] != 0); >+ return result; >+} >+bool all(half3 x) { >+ bool result = true; >+ result = result && (x[0] != 0); >+ result = result && (x[1] != 0); >+ result = result && (x[2] != 0); >+ return result; >+} >+bool all(half4 x) { >+ bool result = true; >+ result = result && (x[0] != 0); >+ result = result && (x[1] != 0); >+ result = result && (x[2] != 0); >+ result = result && (x[3] != 0); >+ return result; >+} >+bool all(half2x2 x) { >+ bool result = true; >+ result = result && (x[0][0] != 0); >+ result = result && (x[0][1] != 0); >+ result = result && (x[1][0] != 0); >+ result = result && (x[1][1] != 0); >+ return result; >+} >+bool all(half2x3 x) { >+ bool result = true; >+ result = result && (x[0][0] != 0); >+ result = result && (x[0][1] != 0); >+ result = result && (x[0][2] != 0); >+ result = result && (x[1][0] != 0); >+ result = result && (x[1][1] != 0); >+ result = result && (x[1][2] != 0); >+ return result; >+} >+bool all(half2x4 x) { >+ bool result = true; >+ result = result && (x[0][0] != 0); >+ result = result && (x[0][1] != 0); >+ result = result && (x[0][2] != 0); >+ result = result && (x[0][3] != 0); >+ result = result && (x[1][0] != 0); >+ result = result && (x[1][1] != 0); >+ result = result && (x[1][2] != 0); >+ result = result && (x[1][3] != 0); >+ return result; >+} >+bool all(half3x2 x) { >+ bool result = true; >+ result = result && (x[0][0] != 0); >+ result = result && (x[0][1] != 0); >+ result = result && (x[1][0] != 0); >+ result = result && (x[1][1] != 0); >+ result = result && (x[2][0] != 0); >+ result = result && (x[2][1] != 0); >+ return result; >+} >+bool all(half3x3 x) { >+ bool result = true; >+ result = result && (x[0][0] != 0); >+ result = result && (x[0][1] != 0); >+ result = result && (x[0][2] != 0); >+ result = result && (x[1][0] != 0); >+ result = result && (x[1][1] != 0); >+ result = result && (x[1][2] != 0); >+ result = result && (x[2][0] != 0); >+ result = result && (x[2][1] != 0); >+ result = result && (x[2][2] != 0); >+ return result; >+} >+bool all(half3x4 x) { >+ bool result = true; >+ result = result && (x[0][0] != 0); >+ result = result && (x[0][1] != 0); >+ result = result && (x[0][2] != 0); >+ result = result && (x[0][3] != 0); >+ result = result && (x[1][0] != 0); >+ result = result && (x[1][1] != 0); >+ result = result && (x[1][2] != 0); >+ result = result && (x[1][3] != 0); >+ result = result && (x[2][0] != 0); >+ result = result && (x[2][1] != 0); >+ result = result && (x[2][2] != 0); >+ result = result && (x[2][3] != 0); >+ return result; >+} >+bool all(half4x2 x) { >+ bool result = true; >+ result = result && (x[0][0] != 0); >+ result = result && (x[0][1] != 0); >+ result = result && (x[1][0] != 0); >+ result = result && (x[1][1] != 0); >+ result = result && (x[2][0] != 0); >+ result = result && (x[2][1] != 0); >+ result = result && (x[3][0] != 0); >+ result = result && (x[3][1] != 0); >+ return result; >+} >+bool all(half4x3 x) { >+ bool result = true; >+ result = result && (x[0][0] != 0); >+ result = result && (x[0][1] != 0); >+ result = result && (x[0][2] != 0); >+ result = result && (x[1][0] != 0); >+ result = result && (x[1][1] != 0); >+ result = result && (x[1][2] != 0); >+ result = result && (x[2][0] != 0); >+ result = result && (x[2][1] != 0); >+ result = result && (x[2][2] != 0); >+ result = result && (x[3][0] != 0); >+ result = result && (x[3][1] != 0); >+ result = result && (x[3][2] != 0); >+ return result; >+} >+bool all(half4x4 x) { >+ bool result = true; >+ result = result && (x[0][0] != 0); >+ result = result && (x[0][1] != 0); >+ result = result && (x[0][2] != 0); >+ result = result && (x[0][3] != 0); >+ result = result && (x[1][0] != 0); >+ result = result && (x[1][1] != 0); >+ result = result && (x[1][2] != 0); >+ result = result && (x[1][3] != 0); >+ result = result && (x[2][0] != 0); >+ result = result && (x[2][1] != 0); >+ result = result && (x[2][2] != 0); >+ result = result && (x[2][3] != 0); >+ result = result && (x[3][0] != 0); >+ result = result && (x[3][1] != 0); >+ result = result && (x[3][2] != 0); >+ result = result && (x[3][3] != 0); >+ return result; >+} >+bool all(float x) { >+ return x != 0; >+} >+bool all(float2 x) { >+ bool result = true; >+ result = result && (x[0] != 0); >+ result = result && (x[1] != 0); >+ return result; >+} >+bool all(float3 x) { >+ bool result = true; >+ result = result && (x[0] != 0); >+ result = result && (x[1] != 0); >+ result = result && (x[2] != 0); >+ return result; >+} >+bool all(float4 x) { >+ bool result = true; >+ result = result && (x[0] != 0); >+ result = result && (x[1] != 0); >+ result = result && (x[2] != 0); >+ result = result && (x[3] != 0); >+ return result; >+} >+bool all(float2x2 x) { >+ bool result = true; >+ result = result && (x[0][0] != 0); >+ result = result && (x[0][1] != 0); >+ result = result && (x[1][0] != 0); >+ result = result && (x[1][1] != 0); >+ return result; >+} >+bool all(float2x3 x) { >+ bool result = true; >+ result = result && (x[0][0] != 0); >+ result = result && (x[0][1] != 0); >+ result = result && (x[0][2] != 0); >+ result = result && (x[1][0] != 0); >+ result = result && (x[1][1] != 0); >+ result = result && (x[1][2] != 0); >+ return result; >+} >+bool all(float2x4 x) { >+ bool result = true; >+ result = result && (x[0][0] != 0); >+ result = result && (x[0][1] != 0); >+ result = result && (x[0][2] != 0); >+ result = result && (x[0][3] != 0); >+ result = result && (x[1][0] != 0); >+ result = result && (x[1][1] != 0); >+ result = result && (x[1][2] != 0); >+ result = result && (x[1][3] != 0); >+ return result; >+} >+bool all(float3x2 x) { >+ bool result = true; >+ result = result && (x[0][0] != 0); >+ result = result && (x[0][1] != 0); >+ result = result && (x[1][0] != 0); >+ result = result && (x[1][1] != 0); >+ result = result && (x[2][0] != 0); >+ result = result && (x[2][1] != 0); >+ return result; >+} >+bool all(float3x3 x) { >+ bool result = true; >+ result = result && (x[0][0] != 0); >+ result = result && (x[0][1] != 0); >+ result = result && (x[0][2] != 0); >+ result = result && (x[1][0] != 0); >+ result = result && (x[1][1] != 0); >+ result = result && (x[1][2] != 0); >+ result = result && (x[2][0] != 0); >+ result = result && (x[2][1] != 0); >+ result = result && (x[2][2] != 0); >+ return result; >+} >+bool all(float3x4 x) { >+ bool result = true; >+ result = result && (x[0][0] != 0); >+ result = result && (x[0][1] != 0); >+ result = result && (x[0][2] != 0); >+ result = result && (x[0][3] != 0); >+ result = result && (x[1][0] != 0); >+ result = result && (x[1][1] != 0); >+ result = result && (x[1][2] != 0); >+ result = result && (x[1][3] != 0); >+ result = result && (x[2][0] != 0); >+ result = result && (x[2][1] != 0); >+ result = result && (x[2][2] != 0); >+ result = result && (x[2][3] != 0); >+ return result; >+} >+bool all(float4x2 x) { >+ bool result = true; >+ result = result && (x[0][0] != 0); >+ result = result && (x[0][1] != 0); >+ result = result && (x[1][0] != 0); >+ result = result && (x[1][1] != 0); >+ result = result && (x[2][0] != 0); >+ result = result && (x[2][1] != 0); >+ result = result && (x[3][0] != 0); >+ result = result && (x[3][1] != 0); >+ return result; >+} >+bool all(float4x3 x) { >+ bool result = true; >+ result = result && (x[0][0] != 0); >+ result = result && (x[0][1] != 0); >+ result = result && (x[0][2] != 0); >+ result = result && (x[1][0] != 0); >+ result = result && (x[1][1] != 0); >+ result = result && (x[1][2] != 0); >+ result = result && (x[2][0] != 0); >+ result = result && (x[2][1] != 0); >+ result = result && (x[2][2] != 0); >+ result = result && (x[3][0] != 0); >+ result = result && (x[3][1] != 0); >+ result = result && (x[3][2] != 0); >+ return result; >+} >+bool all(float4x4 x) { >+ bool result = true; >+ result = result && (x[0][0] != 0); >+ result = result && (x[0][1] != 0); >+ result = result && (x[0][2] != 0); >+ result = result && (x[0][3] != 0); >+ result = result && (x[1][0] != 0); >+ result = result && (x[1][1] != 0); >+ result = result && (x[1][2] != 0); >+ result = result && (x[1][3] != 0); >+ result = result && (x[2][0] != 0); >+ result = result && (x[2][1] != 0); >+ result = result && (x[2][2] != 0); >+ result = result && (x[2][3] != 0); >+ result = result && (x[3][0] != 0); >+ result = result && (x[3][1] != 0); >+ result = result && (x[3][2] != 0); >+ result = result && (x[3][3] != 0); >+ return result; >+} >+ >+bool any(bool x) { >+ return x; >+} >+bool any(bool2 x) { >+ bool result = false; >+ result = result || (x[0]); >+ result = result || (x[1]); >+ return result; >+} >+bool any(bool3 x) { >+ bool result = false; >+ result = result || (x[0]); >+ result = result || (x[1]); >+ result = result || (x[2]); >+ return result; >+} >+bool any(bool4 x) { >+ bool result = false; >+ result = result || (x[0]); >+ result = result || (x[1]); >+ result = result || (x[2]); >+ result = result || (x[3]); >+ return result; >+} >+bool any(uchar x) { >+ return x != 0; >+} >+bool any(uchar2 x) { >+ bool result = false; >+ result = result || (x[0] != 0); >+ result = result || (x[1] != 0); >+ return result; >+} >+bool any(uchar3 x) { >+ bool result = false; >+ result = result || (x[0] != 0); >+ result = result || (x[1] != 0); >+ result = result || (x[2] != 0); >+ return result; >+} >+bool any(uchar4 x) { >+ bool result = false; >+ result = result || (x[0] != 0); >+ result = result || (x[1] != 0); >+ result = result || (x[2] != 0); >+ result = result || (x[3] != 0); >+ return result; >+} >+bool any(ushort x) { >+ return x != 0; >+} >+bool any(ushort2 x) { >+ bool result = false; >+ result = result || (x[0] != 0); >+ result = result || (x[1] != 0); >+ return result; >+} >+bool any(ushort3 x) { >+ bool result = false; >+ result = result || (x[0] != 0); >+ result = result || (x[1] != 0); >+ result = result || (x[2] != 0); >+ return result; >+} >+bool any(ushort4 x) { >+ bool result = false; >+ result = result || (x[0] != 0); >+ result = result || (x[1] != 0); >+ result = result || (x[2] != 0); >+ result = result || (x[3] != 0); >+ return result; >+} >+bool any(uint x) { >+ return x != 0; >+} >+bool any(uint2 x) { >+ bool result = false; >+ result = result || (x[0] != 0); >+ result = result || (x[1] != 0); >+ return result; >+} >+bool any(uint3 x) { >+ bool result = false; >+ result = result || (x[0] != 0); >+ result = result || (x[1] != 0); >+ result = result || (x[2] != 0); >+ return result; >+} >+bool any(uint4 x) { >+ bool result = false; >+ result = result || (x[0] != 0); >+ result = result || (x[1] != 0); >+ result = result || (x[2] != 0); >+ result = result || (x[3] != 0); >+ return result; >+} >+bool any(char x) { >+ return x != 0; >+} >+bool any(char2 x) { >+ bool result = false; >+ result = result || (x[0] != 0); >+ result = result || (x[1] != 0); >+ return result; >+} >+bool any(char3 x) { >+ bool result = false; >+ result = result || (x[0] != 0); >+ result = result || (x[1] != 0); >+ result = result || (x[2] != 0); >+ return result; >+} >+bool any(char4 x) { >+ bool result = false; >+ result = result || (x[0] != 0); >+ result = result || (x[1] != 0); >+ result = result || (x[2] != 0); >+ result = result || (x[3] != 0); >+ return result; >+} >+bool any(short x) { >+ return x != 0; >+} >+bool any(short2 x) { >+ bool result = false; >+ result = result || (x[0] != 0); >+ result = result || (x[1] != 0); >+ return result; >+} >+bool any(short3 x) { >+ bool result = false; >+ result = result || (x[0] != 0); >+ result = result || (x[1] != 0); >+ result = result || (x[2] != 0); >+ return result; >+} >+bool any(short4 x) { >+ bool result = false; >+ result = result || (x[0] != 0); >+ result = result || (x[1] != 0); >+ result = result || (x[2] != 0); >+ result = result || (x[3] != 0); >+ return result; >+} >+bool any(int x) { >+ return x != 0; >+} >+bool any(int2 x) { >+ bool result = false; >+ result = result || (x[0] != 0); >+ result = result || (x[1] != 0); >+ return result; >+} >+bool any(int3 x) { >+ bool result = false; >+ result = result || (x[0] != 0); >+ result = result || (x[1] != 0); >+ result = result || (x[2] != 0); >+ return result; >+} >+bool any(int4 x) { >+ bool result = false; >+ result = result || (x[0] != 0); >+ result = result || (x[1] != 0); >+ result = result || (x[2] != 0); >+ result = result || (x[3] != 0); >+ return result; >+} >+bool any(half x) { >+ return x != 0; >+} >+bool any(half2 x) { >+ bool result = false; >+ result = result || (x[0] != 0); >+ result = result || (x[1] != 0); >+ return result; >+} >+bool any(half3 x) { >+ bool result = false; >+ result = result || (x[0] != 0); >+ result = result || (x[1] != 0); >+ result = result || (x[2] != 0); >+ return result; >+} >+bool any(half4 x) { >+ bool result = false; >+ result = result || (x[0] != 0); >+ result = result || (x[1] != 0); >+ result = result || (x[2] != 0); >+ result = result || (x[3] != 0); >+ return result; >+} >+bool any(half2x2 x) { >+ bool result = false; >+ result = result || (x[0][0] != 0); >+ result = result || (x[0][1] != 0); >+ result = result || (x[1][0] != 0); >+ result = result || (x[1][1] != 0); >+ return result; >+} >+bool any(half2x3 x) { >+ bool result = false; >+ result = result || (x[0][0] != 0); >+ result = result || (x[0][1] != 0); >+ result = result || (x[0][2] != 0); >+ result = result || (x[1][0] != 0); >+ result = result || (x[1][1] != 0); >+ result = result || (x[1][2] != 0); >+ return result; >+} >+bool any(half2x4 x) { >+ bool result = false; >+ result = result || (x[0][0] != 0); >+ result = result || (x[0][1] != 0); >+ result = result || (x[0][2] != 0); >+ result = result || (x[0][3] != 0); >+ result = result || (x[1][0] != 0); >+ result = result || (x[1][1] != 0); >+ result = result || (x[1][2] != 0); >+ result = result || (x[1][3] != 0); >+ return result; >+} >+bool any(half3x2 x) { >+ bool result = false; >+ result = result || (x[0][0] != 0); >+ result = result || (x[0][1] != 0); >+ result = result || (x[1][0] != 0); >+ result = result || (x[1][1] != 0); >+ result = result || (x[2][0] != 0); >+ result = result || (x[2][1] != 0); >+ return result; >+} >+bool any(half3x3 x) { >+ bool result = false; >+ result = result || (x[0][0] != 0); >+ result = result || (x[0][1] != 0); >+ result = result || (x[0][2] != 0); >+ result = result || (x[1][0] != 0); >+ result = result || (x[1][1] != 0); >+ result = result || (x[1][2] != 0); >+ result = result || (x[2][0] != 0); >+ result = result || (x[2][1] != 0); >+ result = result || (x[2][2] != 0); >+ return result; >+} >+bool any(half3x4 x) { >+ bool result = false; >+ result = result || (x[0][0] != 0); >+ result = result || (x[0][1] != 0); >+ result = result || (x[0][2] != 0); >+ result = result || (x[0][3] != 0); >+ result = result || (x[1][0] != 0); >+ result = result || (x[1][1] != 0); >+ result = result || (x[1][2] != 0); >+ result = result || (x[1][3] != 0); >+ result = result || (x[2][0] != 0); >+ result = result || (x[2][1] != 0); >+ result = result || (x[2][2] != 0); >+ result = result || (x[2][3] != 0); >+ return result; >+} >+bool any(half4x2 x) { >+ bool result = false; >+ result = result || (x[0][0] != 0); >+ result = result || (x[0][1] != 0); >+ result = result || (x[1][0] != 0); >+ result = result || (x[1][1] != 0); >+ result = result || (x[2][0] != 0); >+ result = result || (x[2][1] != 0); >+ result = result || (x[3][0] != 0); >+ result = result || (x[3][1] != 0); >+ return result; >+} >+bool any(half4x3 x) { >+ bool result = false; >+ result = result || (x[0][0] != 0); >+ result = result || (x[0][1] != 0); >+ result = result || (x[0][2] != 0); >+ result = result || (x[1][0] != 0); >+ result = result || (x[1][1] != 0); >+ result = result || (x[1][2] != 0); >+ result = result || (x[2][0] != 0); >+ result = result || (x[2][1] != 0); >+ result = result || (x[2][2] != 0); >+ result = result || (x[3][0] != 0); >+ result = result || (x[3][1] != 0); >+ result = result || (x[3][2] != 0); >+ return result; >+} >+bool any(half4x4 x) { >+ bool result = false; >+ result = result || (x[0][0] != 0); >+ result = result || (x[0][1] != 0); >+ result = result || (x[0][2] != 0); >+ result = result || (x[0][3] != 0); >+ result = result || (x[1][0] != 0); >+ result = result || (x[1][1] != 0); >+ result = result || (x[1][2] != 0); >+ result = result || (x[1][3] != 0); >+ result = result || (x[2][0] != 0); >+ result = result || (x[2][1] != 0); >+ result = result || (x[2][2] != 0); >+ result = result || (x[2][3] != 0); >+ result = result || (x[3][0] != 0); >+ result = result || (x[3][1] != 0); >+ result = result || (x[3][2] != 0); >+ result = result || (x[3][3] != 0); >+ return result; >+} >+bool any(float x) { >+ return x != 0; >+} >+bool any(float2 x) { >+ bool result = false; >+ result = result || (x[0] != 0); >+ result = result || (x[1] != 0); >+ return result; >+} >+bool any(float3 x) { >+ bool result = false; >+ result = result || (x[0] != 0); >+ result = result || (x[1] != 0); >+ result = result || (x[2] != 0); >+ return result; >+} >+bool any(float4 x) { >+ bool result = false; >+ result = result || (x[0] != 0); >+ result = result || (x[1] != 0); >+ result = result || (x[2] != 0); >+ result = result || (x[3] != 0); >+ return result; >+} >+bool any(float2x2 x) { >+ bool result = false; >+ result = result || (x[0][0] != 0); >+ result = result || (x[0][1] != 0); >+ result = result || (x[1][0] != 0); >+ result = result || (x[1][1] != 0); >+ return result; >+} >+bool any(float2x3 x) { >+ bool result = false; >+ result = result || (x[0][0] != 0); >+ result = result || (x[0][1] != 0); >+ result = result || (x[0][2] != 0); >+ result = result || (x[1][0] != 0); >+ result = result || (x[1][1] != 0); >+ result = result || (x[1][2] != 0); >+ return result; >+} >+bool any(float2x4 x) { >+ bool result = false; >+ result = result || (x[0][0] != 0); >+ result = result || (x[0][1] != 0); >+ result = result || (x[0][2] != 0); >+ result = result || (x[0][3] != 0); >+ result = result || (x[1][0] != 0); >+ result = result || (x[1][1] != 0); >+ result = result || (x[1][2] != 0); >+ result = result || (x[1][3] != 0); >+ return result; >+} >+bool any(float3x2 x) { >+ bool result = false; >+ result = result || (x[0][0] != 0); >+ result = result || (x[0][1] != 0); >+ result = result || (x[1][0] != 0); >+ result = result || (x[1][1] != 0); >+ result = result || (x[2][0] != 0); >+ result = result || (x[2][1] != 0); >+ return result; >+} >+bool any(float3x3 x) { >+ bool result = false; >+ result = result || (x[0][0] != 0); >+ result = result || (x[0][1] != 0); >+ result = result || (x[0][2] != 0); >+ result = result || (x[1][0] != 0); >+ result = result || (x[1][1] != 0); >+ result = result || (x[1][2] != 0); >+ result = result || (x[2][0] != 0); >+ result = result || (x[2][1] != 0); >+ result = result || (x[2][2] != 0); >+ return result; >+} >+bool any(float3x4 x) { >+ bool result = false; >+ result = result || (x[0][0] != 0); >+ result = result || (x[0][1] != 0); >+ result = result || (x[0][2] != 0); >+ result = result || (x[0][3] != 0); >+ result = result || (x[1][0] != 0); >+ result = result || (x[1][1] != 0); >+ result = result || (x[1][2] != 0); >+ result = result || (x[1][3] != 0); >+ result = result || (x[2][0] != 0); >+ result = result || (x[2][1] != 0); >+ result = result || (x[2][2] != 0); >+ result = result || (x[2][3] != 0); >+ return result; >+} >+bool any(float4x2 x) { >+ bool result = false; >+ result = result || (x[0][0] != 0); >+ result = result || (x[0][1] != 0); >+ result = result || (x[1][0] != 0); >+ result = result || (x[1][1] != 0); >+ result = result || (x[2][0] != 0); >+ result = result || (x[2][1] != 0); >+ result = result || (x[3][0] != 0); >+ result = result || (x[3][1] != 0); >+ return result; >+} >+bool any(float4x3 x) { >+ bool result = false; >+ result = result || (x[0][0] != 0); >+ result = result || (x[0][1] != 0); >+ result = result || (x[0][2] != 0); >+ result = result || (x[1][0] != 0); >+ result = result || (x[1][1] != 0); >+ result = result || (x[1][2] != 0); >+ result = result || (x[2][0] != 0); >+ result = result || (x[2][1] != 0); >+ result = result || (x[2][2] != 0); >+ result = result || (x[3][0] != 0); >+ result = result || (x[3][1] != 0); >+ result = result || (x[3][2] != 0); >+ return result; >+} >+bool any(float4x4 x) { >+ bool result = false; >+ result = result || (x[0][0] != 0); >+ result = result || (x[0][1] != 0); >+ result = result || (x[0][2] != 0); >+ result = result || (x[0][3] != 0); >+ result = result || (x[1][0] != 0); >+ result = result || (x[1][1] != 0); >+ result = result || (x[1][2] != 0); >+ result = result || (x[1][3] != 0); >+ result = result || (x[2][0] != 0); >+ result = result || (x[2][1] != 0); >+ result = result || (x[2][2] != 0); >+ result = result || (x[2][3] != 0); >+ result = result || (x[3][0] != 0); >+ result = result || (x[3][1] != 0); >+ result = result || (x[3][2] != 0); >+ result = result || (x[3][3] != 0); >+ return result; >+} >+ >+uchar abs(uchar x) { >+ return x; >+} >+ushort abs(ushort x) { >+ return x; >+} >+uint abs(uint x) { >+ return x; >+} >+char abs(char x) { >+ if (x < 0) >+ return -x; >+ return x; >+} >+short abs(short x) { >+ if (x < 0) >+ return -x; >+ return x; >+} >+int abs(int x) { >+ if (x < 0) >+ return -x; >+ return x; >+} >+half abs(half x) { >+ if (x < 0) >+ return -x; >+ return x; >+} >+float abs(float x) { >+ if (x < 0) >+ return -x; >+ return x; >+} >+uchar2 abs(uchar2 x) { >+ uchar2 result; >+ result[0] = abs(x[0]); >+ result[1] = abs(x[1]); >+ return result; >+} >+uchar3 abs(uchar3 x) { >+ uchar3 result; >+ result[0] = abs(x[0]); >+ result[1] = abs(x[1]); >+ result[2] = abs(x[2]); >+ return result; >+} >+uchar4 abs(uchar4 x) { >+ uchar4 result; >+ result[0] = abs(x[0]); >+ result[1] = abs(x[1]); >+ result[2] = abs(x[2]); >+ result[3] = abs(x[3]); >+ return result; >+} >+ushort2 abs(ushort2 x) { >+ ushort2 result; >+ result[0] = abs(x[0]); >+ result[1] = abs(x[1]); >+ return result; >+} >+ushort3 abs(ushort3 x) { >+ ushort3 result; >+ result[0] = abs(x[0]); >+ result[1] = abs(x[1]); >+ result[2] = abs(x[2]); >+ return result; >+} >+ushort4 abs(ushort4 x) { >+ ushort4 result; >+ result[0] = abs(x[0]); >+ result[1] = abs(x[1]); >+ result[2] = abs(x[2]); >+ result[3] = abs(x[3]); >+ return result; >+} >+uint2 abs(uint2 x) { >+ uint2 result; >+ result[0] = abs(x[0]); >+ result[1] = abs(x[1]); >+ return result; >+} >+uint3 abs(uint3 x) { >+ uint3 result; >+ result[0] = abs(x[0]); >+ result[1] = abs(x[1]); >+ result[2] = abs(x[2]); >+ return result; >+} >+uint4 abs(uint4 x) { >+ uint4 result; >+ result[0] = abs(x[0]); >+ result[1] = abs(x[1]); >+ result[2] = abs(x[2]); >+ result[3] = abs(x[3]); >+ return result; >+} >+char2 abs(char2 x) { >+ char2 result; >+ result[0] = abs(x[0]); >+ result[1] = abs(x[1]); >+ return result; >+} >+char3 abs(char3 x) { >+ char3 result; >+ result[0] = abs(x[0]); >+ result[1] = abs(x[1]); >+ result[2] = abs(x[2]); >+ return result; >+} >+char4 abs(char4 x) { >+ char4 result; >+ result[0] = abs(x[0]); >+ result[1] = abs(x[1]); >+ result[2] = abs(x[2]); >+ result[3] = abs(x[3]); >+ return result; >+} >+short2 abs(short2 x) { >+ short2 result; >+ result[0] = abs(x[0]); >+ result[1] = abs(x[1]); >+ return result; >+} >+short3 abs(short3 x) { >+ short3 result; >+ result[0] = abs(x[0]); >+ result[1] = abs(x[1]); >+ result[2] = abs(x[2]); >+ return result; >+} >+short4 abs(short4 x) { >+ short4 result; >+ result[0] = abs(x[0]); >+ result[1] = abs(x[1]); >+ result[2] = abs(x[2]); >+ result[3] = abs(x[3]); >+ return result; >+} >+int2 abs(int2 x) { >+ int2 result; >+ result[0] = abs(x[0]); >+ result[1] = abs(x[1]); >+ return result; >+} >+int3 abs(int3 x) { >+ int3 result; >+ result[0] = abs(x[0]); >+ result[1] = abs(x[1]); >+ result[2] = abs(x[2]); >+ return result; >+} >+int4 abs(int4 x) { >+ int4 result; >+ result[0] = abs(x[0]); >+ result[1] = abs(x[1]); >+ result[2] = abs(x[2]); >+ result[3] = abs(x[3]); >+ return result; >+} >+half2 abs(half2 x) { >+ half2 result; >+ result[0] = abs(x[0]); >+ result[1] = abs(x[1]); >+ return result; >+} >+half3 abs(half3 x) { >+ half3 result; >+ result[0] = abs(x[0]); >+ result[1] = abs(x[1]); >+ result[2] = abs(x[2]); >+ return result; >+} >+half4 abs(half4 x) { >+ half4 result; >+ result[0] = abs(x[0]); >+ result[1] = abs(x[1]); >+ result[2] = abs(x[2]); >+ result[3] = abs(x[3]); >+ return result; >+} >+half2x2 abs(half2x2 x) { >+ half2x2 result; >+ result[0][0] = abs(x[0][0]); >+ result[0][1] = abs(x[0][1]); >+ result[1][0] = abs(x[1][0]); >+ result[1][1] = abs(x[1][1]); >+ return result; >+} >+half2x3 abs(half2x3 x) { >+ half2x3 result; >+ result[0][0] = abs(x[0][0]); >+ result[0][1] = abs(x[0][1]); >+ result[0][2] = abs(x[0][2]); >+ result[1][0] = abs(x[1][0]); >+ result[1][1] = abs(x[1][1]); >+ result[1][2] = abs(x[1][2]); >+ return result; >+} >+half2x4 abs(half2x4 x) { >+ half2x4 result; >+ result[0][0] = abs(x[0][0]); >+ result[0][1] = abs(x[0][1]); >+ result[0][2] = abs(x[0][2]); >+ result[0][3] = abs(x[0][3]); >+ result[1][0] = abs(x[1][0]); >+ result[1][1] = abs(x[1][1]); >+ result[1][2] = abs(x[1][2]); >+ result[1][3] = abs(x[1][3]); >+ return result; >+} >+half3x2 abs(half3x2 x) { >+ half3x2 result; >+ result[0][0] = abs(x[0][0]); >+ result[0][1] = abs(x[0][1]); >+ result[1][0] = abs(x[1][0]); >+ result[1][1] = abs(x[1][1]); >+ result[2][0] = abs(x[2][0]); >+ result[2][1] = abs(x[2][1]); >+ return result; >+} >+half3x3 abs(half3x3 x) { >+ half3x3 result; >+ result[0][0] = abs(x[0][0]); >+ result[0][1] = abs(x[0][1]); >+ result[0][2] = abs(x[0][2]); >+ result[1][0] = abs(x[1][0]); >+ result[1][1] = abs(x[1][1]); >+ result[1][2] = abs(x[1][2]); >+ result[2][0] = abs(x[2][0]); >+ result[2][1] = abs(x[2][1]); >+ result[2][2] = abs(x[2][2]); >+ return result; >+} >+half3x4 abs(half3x4 x) { >+ half3x4 result; >+ result[0][0] = abs(x[0][0]); >+ result[0][1] = abs(x[0][1]); >+ result[0][2] = abs(x[0][2]); >+ result[0][3] = abs(x[0][3]); >+ result[1][0] = abs(x[1][0]); >+ result[1][1] = abs(x[1][1]); >+ result[1][2] = abs(x[1][2]); >+ result[1][3] = abs(x[1][3]); >+ result[2][0] = abs(x[2][0]); >+ result[2][1] = abs(x[2][1]); >+ result[2][2] = abs(x[2][2]); >+ result[2][3] = abs(x[2][3]); >+ return result; >+} >+half4x2 abs(half4x2 x) { >+ half4x2 result; >+ result[0][0] = abs(x[0][0]); >+ result[0][1] = abs(x[0][1]); >+ result[1][0] = abs(x[1][0]); >+ result[1][1] = abs(x[1][1]); >+ result[2][0] = abs(x[2][0]); >+ result[2][1] = abs(x[2][1]); >+ result[3][0] = abs(x[3][0]); >+ result[3][1] = abs(x[3][1]); >+ return result; >+} >+half4x3 abs(half4x3 x) { >+ half4x3 result; >+ result[0][0] = abs(x[0][0]); >+ result[0][1] = abs(x[0][1]); >+ result[0][2] = abs(x[0][2]); >+ result[1][0] = abs(x[1][0]); >+ result[1][1] = abs(x[1][1]); >+ result[1][2] = abs(x[1][2]); >+ result[2][0] = abs(x[2][0]); >+ result[2][1] = abs(x[2][1]); >+ result[2][2] = abs(x[2][2]); >+ result[3][0] = abs(x[3][0]); >+ result[3][1] = abs(x[3][1]); >+ result[3][2] = abs(x[3][2]); >+ return result; >+} >+half4x4 abs(half4x4 x) { >+ half4x4 result; >+ result[0][0] = abs(x[0][0]); >+ result[0][1] = abs(x[0][1]); >+ result[0][2] = abs(x[0][2]); >+ result[0][3] = abs(x[0][3]); >+ result[1][0] = abs(x[1][0]); >+ result[1][1] = abs(x[1][1]); >+ result[1][2] = abs(x[1][2]); >+ result[1][3] = abs(x[1][3]); >+ result[2][0] = abs(x[2][0]); >+ result[2][1] = abs(x[2][1]); >+ result[2][2] = abs(x[2][2]); >+ result[2][3] = abs(x[2][3]); >+ result[3][0] = abs(x[3][0]); >+ result[3][1] = abs(x[3][1]); >+ result[3][2] = abs(x[3][2]); >+ result[3][3] = abs(x[3][3]); >+ return result; >+} >+float2 abs(float2 x) { >+ float2 result; >+ result[0] = abs(x[0]); >+ result[1] = abs(x[1]); >+ return result; >+} >+float3 abs(float3 x) { >+ float3 result; >+ result[0] = abs(x[0]); >+ result[1] = abs(x[1]); >+ result[2] = abs(x[2]); >+ return result; >+} >+float4 abs(float4 x) { >+ float4 result; >+ result[0] = abs(x[0]); >+ result[1] = abs(x[1]); >+ result[2] = abs(x[2]); >+ result[3] = abs(x[3]); >+ return result; >+} >+float2x2 abs(float2x2 x) { >+ float2x2 result; >+ result[0][0] = abs(x[0][0]); >+ result[0][1] = abs(x[0][1]); >+ result[1][0] = abs(x[1][0]); >+ result[1][1] = abs(x[1][1]); >+ return result; >+} >+float2x3 abs(float2x3 x) { >+ float2x3 result; >+ result[0][0] = abs(x[0][0]); >+ result[0][1] = abs(x[0][1]); >+ result[0][2] = abs(x[0][2]); >+ result[1][0] = abs(x[1][0]); >+ result[1][1] = abs(x[1][1]); >+ result[1][2] = abs(x[1][2]); >+ return result; >+} >+float2x4 abs(float2x4 x) { >+ float2x4 result; >+ result[0][0] = abs(x[0][0]); >+ result[0][1] = abs(x[0][1]); >+ result[0][2] = abs(x[0][2]); >+ result[0][3] = abs(x[0][3]); >+ result[1][0] = abs(x[1][0]); >+ result[1][1] = abs(x[1][1]); >+ result[1][2] = abs(x[1][2]); >+ result[1][3] = abs(x[1][3]); >+ return result; >+} >+float3x2 abs(float3x2 x) { >+ float3x2 result; >+ result[0][0] = abs(x[0][0]); >+ result[0][1] = abs(x[0][1]); >+ result[1][0] = abs(x[1][0]); >+ result[1][1] = abs(x[1][1]); >+ result[2][0] = abs(x[2][0]); >+ result[2][1] = abs(x[2][1]); >+ return result; >+} >+float3x3 abs(float3x3 x) { >+ float3x3 result; >+ result[0][0] = abs(x[0][0]); >+ result[0][1] = abs(x[0][1]); >+ result[0][2] = abs(x[0][2]); >+ result[1][0] = abs(x[1][0]); >+ result[1][1] = abs(x[1][1]); >+ result[1][2] = abs(x[1][2]); >+ result[2][0] = abs(x[2][0]); >+ result[2][1] = abs(x[2][1]); >+ result[2][2] = abs(x[2][2]); >+ return result; >+} >+float3x4 abs(float3x4 x) { >+ float3x4 result; >+ result[0][0] = abs(x[0][0]); >+ result[0][1] = abs(x[0][1]); >+ result[0][2] = abs(x[0][2]); >+ result[0][3] = abs(x[0][3]); >+ result[1][0] = abs(x[1][0]); >+ result[1][1] = abs(x[1][1]); >+ result[1][2] = abs(x[1][2]); >+ result[1][3] = abs(x[1][3]); >+ result[2][0] = abs(x[2][0]); >+ result[2][1] = abs(x[2][1]); >+ result[2][2] = abs(x[2][2]); >+ result[2][3] = abs(x[2][3]); >+ return result; >+} >+float4x2 abs(float4x2 x) { >+ float4x2 result; >+ result[0][0] = abs(x[0][0]); >+ result[0][1] = abs(x[0][1]); >+ result[1][0] = abs(x[1][0]); >+ result[1][1] = abs(x[1][1]); >+ result[2][0] = abs(x[2][0]); >+ result[2][1] = abs(x[2][1]); >+ result[3][0] = abs(x[3][0]); >+ result[3][1] = abs(x[3][1]); >+ return result; >+} >+float4x3 abs(float4x3 x) { >+ float4x3 result; >+ result[0][0] = abs(x[0][0]); >+ result[0][1] = abs(x[0][1]); >+ result[0][2] = abs(x[0][2]); >+ result[1][0] = abs(x[1][0]); >+ result[1][1] = abs(x[1][1]); >+ result[1][2] = abs(x[1][2]); >+ result[2][0] = abs(x[2][0]); >+ result[2][1] = abs(x[2][1]); >+ result[2][2] = abs(x[2][2]); >+ result[3][0] = abs(x[3][0]); >+ result[3][1] = abs(x[3][1]); >+ result[3][2] = abs(x[3][2]); >+ return result; >+} >+float4x4 abs(float4x4 x) { >+ float4x4 result; >+ result[0][0] = abs(x[0][0]); >+ result[0][1] = abs(x[0][1]); >+ result[0][2] = abs(x[0][2]); >+ result[0][3] = abs(x[0][3]); >+ result[1][0] = abs(x[1][0]); >+ result[1][1] = abs(x[1][1]); >+ result[1][2] = abs(x[1][2]); >+ result[1][3] = abs(x[1][3]); >+ result[2][0] = abs(x[2][0]); >+ result[2][1] = abs(x[2][1]); >+ result[2][2] = abs(x[2][2]); >+ result[2][3] = abs(x[2][3]); >+ result[3][0] = abs(x[3][0]); >+ result[3][1] = abs(x[3][1]); >+ result[3][2] = abs(x[3][2]); >+ result[3][3] = abs(x[3][3]); >+ return result; >+} >+ >+uchar sign(uchar x) { >+ return x == 0 ? 0 : 1; >+} >+ushort sign(ushort x) { >+ return x == 0 ? 0 : 1; >+} >+uint sign(uint x) { >+ return x == 0 ? 0 : 1; >+} >+char sign(char x) { >+ if (x < 0) >+ return -1; >+ if (x == 0) >+ return 0; >+ return 1; >+} >+short sign(short x) { >+ if (x < 0) >+ return -1; >+ if (x == 0) >+ return 0; >+ return 1; >+} >+int sign(int x) { >+ if (x < 0) >+ return -1; >+ if (x == 0) >+ return 0; >+ return 1; >+} >+half sign(half x) { >+ if (x < 0) >+ return -1; >+ if (x == 0) >+ return 0; >+ return 1; >+} >+float sign(float x) { >+ if (x < 0) >+ return -1; >+ if (x == 0) >+ return 0; >+ return 1; >+} >+uchar2 sign(uchar2 x) { >+ uchar2 result; >+ result[0] = sign(x[0]); >+ result[1] = sign(x[1]); >+ return result; >+} >+uchar3 sign(uchar3 x) { >+ uchar3 result; >+ result[0] = sign(x[0]); >+ result[1] = sign(x[1]); >+ result[2] = sign(x[2]); >+ return result; >+} >+uchar4 sign(uchar4 x) { >+ uchar4 result; >+ result[0] = sign(x[0]); >+ result[1] = sign(x[1]); >+ result[2] = sign(x[2]); >+ result[3] = sign(x[3]); >+ return result; >+} >+ushort2 sign(ushort2 x) { >+ ushort2 result; >+ result[0] = sign(x[0]); >+ result[1] = sign(x[1]); >+ return result; >+} >+ushort3 sign(ushort3 x) { >+ ushort3 result; >+ result[0] = sign(x[0]); >+ result[1] = sign(x[1]); >+ result[2] = sign(x[2]); >+ return result; >+} >+ushort4 sign(ushort4 x) { >+ ushort4 result; >+ result[0] = sign(x[0]); >+ result[1] = sign(x[1]); >+ result[2] = sign(x[2]); >+ result[3] = sign(x[3]); >+ return result; >+} >+uint2 sign(uint2 x) { >+ uint2 result; >+ result[0] = sign(x[0]); >+ result[1] = sign(x[1]); >+ return result; >+} >+uint3 sign(uint3 x) { >+ uint3 result; >+ result[0] = sign(x[0]); >+ result[1] = sign(x[1]); >+ result[2] = sign(x[2]); >+ return result; >+} >+uint4 sign(uint4 x) { >+ uint4 result; >+ result[0] = sign(x[0]); >+ result[1] = sign(x[1]); >+ result[2] = sign(x[2]); >+ result[3] = sign(x[3]); >+ return result; >+} >+char2 sign(char2 x) { >+ char2 result; >+ result[0] = sign(x[0]); >+ result[1] = sign(x[1]); >+ return result; >+} >+char3 sign(char3 x) { >+ char3 result; >+ result[0] = sign(x[0]); >+ result[1] = sign(x[1]); >+ result[2] = sign(x[2]); >+ return result; >+} >+char4 sign(char4 x) { >+ char4 result; >+ result[0] = sign(x[0]); >+ result[1] = sign(x[1]); >+ result[2] = sign(x[2]); >+ result[3] = sign(x[3]); >+ return result; >+} >+short2 sign(short2 x) { >+ short2 result; >+ result[0] = sign(x[0]); >+ result[1] = sign(x[1]); >+ return result; >+} >+short3 sign(short3 x) { >+ short3 result; >+ result[0] = sign(x[0]); >+ result[1] = sign(x[1]); >+ result[2] = sign(x[2]); >+ return result; >+} >+short4 sign(short4 x) { >+ short4 result; >+ result[0] = sign(x[0]); >+ result[1] = sign(x[1]); >+ result[2] = sign(x[2]); >+ result[3] = sign(x[3]); >+ return result; >+} >+int2 sign(int2 x) { >+ int2 result; >+ result[0] = sign(x[0]); >+ result[1] = sign(x[1]); >+ return result; >+} >+int3 sign(int3 x) { >+ int3 result; >+ result[0] = sign(x[0]); >+ result[1] = sign(x[1]); >+ result[2] = sign(x[2]); >+ return result; >+} >+int4 sign(int4 x) { >+ int4 result; >+ result[0] = sign(x[0]); >+ result[1] = sign(x[1]); >+ result[2] = sign(x[2]); >+ result[3] = sign(x[3]); >+ return result; >+} >+half2 sign(half2 x) { >+ half2 result; >+ result[0] = sign(x[0]); >+ result[1] = sign(x[1]); >+ return result; >+} >+half3 sign(half3 x) { >+ half3 result; >+ result[0] = sign(x[0]); >+ result[1] = sign(x[1]); >+ result[2] = sign(x[2]); >+ return result; >+} >+half4 sign(half4 x) { >+ half4 result; >+ result[0] = sign(x[0]); >+ result[1] = sign(x[1]); >+ result[2] = sign(x[2]); >+ result[3] = sign(x[3]); >+ return result; >+} >+half2x2 sign(half2x2 x) { >+ half2x2 result; >+ result[0][0] = sign(x[0][0]); >+ result[0][1] = sign(x[0][1]); >+ result[1][0] = sign(x[1][0]); >+ result[1][1] = sign(x[1][1]); >+ return result; >+} >+half2x3 sign(half2x3 x) { >+ half2x3 result; >+ result[0][0] = sign(x[0][0]); >+ result[0][1] = sign(x[0][1]); >+ result[0][2] = sign(x[0][2]); >+ result[1][0] = sign(x[1][0]); >+ result[1][1] = sign(x[1][1]); >+ result[1][2] = sign(x[1][2]); >+ return result; >+} >+half2x4 sign(half2x4 x) { >+ half2x4 result; >+ result[0][0] = sign(x[0][0]); >+ result[0][1] = sign(x[0][1]); >+ result[0][2] = sign(x[0][2]); >+ result[0][3] = sign(x[0][3]); >+ result[1][0] = sign(x[1][0]); >+ result[1][1] = sign(x[1][1]); >+ result[1][2] = sign(x[1][2]); >+ result[1][3] = sign(x[1][3]); >+ return result; >+} >+half3x2 sign(half3x2 x) { >+ half3x2 result; >+ result[0][0] = sign(x[0][0]); >+ result[0][1] = sign(x[0][1]); >+ result[1][0] = sign(x[1][0]); >+ result[1][1] = sign(x[1][1]); >+ result[2][0] = sign(x[2][0]); >+ result[2][1] = sign(x[2][1]); >+ return result; >+} >+half3x3 sign(half3x3 x) { >+ half3x3 result; >+ result[0][0] = sign(x[0][0]); >+ result[0][1] = sign(x[0][1]); >+ result[0][2] = sign(x[0][2]); >+ result[1][0] = sign(x[1][0]); >+ result[1][1] = sign(x[1][1]); >+ result[1][2] = sign(x[1][2]); >+ result[2][0] = sign(x[2][0]); >+ result[2][1] = sign(x[2][1]); >+ result[2][2] = sign(x[2][2]); >+ return result; >+} >+half3x4 sign(half3x4 x) { >+ half3x4 result; >+ result[0][0] = sign(x[0][0]); >+ result[0][1] = sign(x[0][1]); >+ result[0][2] = sign(x[0][2]); >+ result[0][3] = sign(x[0][3]); >+ result[1][0] = sign(x[1][0]); >+ result[1][1] = sign(x[1][1]); >+ result[1][2] = sign(x[1][2]); >+ result[1][3] = sign(x[1][3]); >+ result[2][0] = sign(x[2][0]); >+ result[2][1] = sign(x[2][1]); >+ result[2][2] = sign(x[2][2]); >+ result[2][3] = sign(x[2][3]); >+ return result; >+} >+half4x2 sign(half4x2 x) { >+ half4x2 result; >+ result[0][0] = sign(x[0][0]); >+ result[0][1] = sign(x[0][1]); >+ result[1][0] = sign(x[1][0]); >+ result[1][1] = sign(x[1][1]); >+ result[2][0] = sign(x[2][0]); >+ result[2][1] = sign(x[2][1]); >+ result[3][0] = sign(x[3][0]); >+ result[3][1] = sign(x[3][1]); >+ return result; >+} >+half4x3 sign(half4x3 x) { >+ half4x3 result; >+ result[0][0] = sign(x[0][0]); >+ result[0][1] = sign(x[0][1]); >+ result[0][2] = sign(x[0][2]); >+ result[1][0] = sign(x[1][0]); >+ result[1][1] = sign(x[1][1]); >+ result[1][2] = sign(x[1][2]); >+ result[2][0] = sign(x[2][0]); >+ result[2][1] = sign(x[2][1]); >+ result[2][2] = sign(x[2][2]); >+ result[3][0] = sign(x[3][0]); >+ result[3][1] = sign(x[3][1]); >+ result[3][2] = sign(x[3][2]); >+ return result; >+} >+half4x4 sign(half4x4 x) { >+ half4x4 result; >+ result[0][0] = sign(x[0][0]); >+ result[0][1] = sign(x[0][1]); >+ result[0][2] = sign(x[0][2]); >+ result[0][3] = sign(x[0][3]); >+ result[1][0] = sign(x[1][0]); >+ result[1][1] = sign(x[1][1]); >+ result[1][2] = sign(x[1][2]); >+ result[1][3] = sign(x[1][3]); >+ result[2][0] = sign(x[2][0]); >+ result[2][1] = sign(x[2][1]); >+ result[2][2] = sign(x[2][2]); >+ result[2][3] = sign(x[2][3]); >+ result[3][0] = sign(x[3][0]); >+ result[3][1] = sign(x[3][1]); >+ result[3][2] = sign(x[3][2]); >+ result[3][3] = sign(x[3][3]); >+ return result; >+} >+float2 sign(float2 x) { >+ float2 result; >+ result[0] = sign(x[0]); >+ result[1] = sign(x[1]); >+ return result; >+} >+float3 sign(float3 x) { >+ float3 result; >+ result[0] = sign(x[0]); >+ result[1] = sign(x[1]); >+ result[2] = sign(x[2]); >+ return result; >+} >+float4 sign(float4 x) { >+ float4 result; >+ result[0] = sign(x[0]); >+ result[1] = sign(x[1]); >+ result[2] = sign(x[2]); >+ result[3] = sign(x[3]); >+ return result; >+} >+float2x2 sign(float2x2 x) { >+ float2x2 result; >+ result[0][0] = sign(x[0][0]); >+ result[0][1] = sign(x[0][1]); >+ result[1][0] = sign(x[1][0]); >+ result[1][1] = sign(x[1][1]); >+ return result; >+} >+float2x3 sign(float2x3 x) { >+ float2x3 result; >+ result[0][0] = sign(x[0][0]); >+ result[0][1] = sign(x[0][1]); >+ result[0][2] = sign(x[0][2]); >+ result[1][0] = sign(x[1][0]); >+ result[1][1] = sign(x[1][1]); >+ result[1][2] = sign(x[1][2]); >+ return result; >+} >+float2x4 sign(float2x4 x) { >+ float2x4 result; >+ result[0][0] = sign(x[0][0]); >+ result[0][1] = sign(x[0][1]); >+ result[0][2] = sign(x[0][2]); >+ result[0][3] = sign(x[0][3]); >+ result[1][0] = sign(x[1][0]); >+ result[1][1] = sign(x[1][1]); >+ result[1][2] = sign(x[1][2]); >+ result[1][3] = sign(x[1][3]); >+ return result; >+} >+float3x2 sign(float3x2 x) { >+ float3x2 result; >+ result[0][0] = sign(x[0][0]); >+ result[0][1] = sign(x[0][1]); >+ result[1][0] = sign(x[1][0]); >+ result[1][1] = sign(x[1][1]); >+ result[2][0] = sign(x[2][0]); >+ result[2][1] = sign(x[2][1]); >+ return result; >+} >+float3x3 sign(float3x3 x) { >+ float3x3 result; >+ result[0][0] = sign(x[0][0]); >+ result[0][1] = sign(x[0][1]); >+ result[0][2] = sign(x[0][2]); >+ result[1][0] = sign(x[1][0]); >+ result[1][1] = sign(x[1][1]); >+ result[1][2] = sign(x[1][2]); >+ result[2][0] = sign(x[2][0]); >+ result[2][1] = sign(x[2][1]); >+ result[2][2] = sign(x[2][2]); >+ return result; >+} >+float3x4 sign(float3x4 x) { >+ float3x4 result; >+ result[0][0] = sign(x[0][0]); >+ result[0][1] = sign(x[0][1]); >+ result[0][2] = sign(x[0][2]); >+ result[0][3] = sign(x[0][3]); >+ result[1][0] = sign(x[1][0]); >+ result[1][1] = sign(x[1][1]); >+ result[1][2] = sign(x[1][2]); >+ result[1][3] = sign(x[1][3]); >+ result[2][0] = sign(x[2][0]); >+ result[2][1] = sign(x[2][1]); >+ result[2][2] = sign(x[2][2]); >+ result[2][3] = sign(x[2][3]); >+ return result; >+} >+float4x2 sign(float4x2 x) { >+ float4x2 result; >+ result[0][0] = sign(x[0][0]); >+ result[0][1] = sign(x[0][1]); >+ result[1][0] = sign(x[1][0]); >+ result[1][1] = sign(x[1][1]); >+ result[2][0] = sign(x[2][0]); >+ result[2][1] = sign(x[2][1]); >+ result[3][0] = sign(x[3][0]); >+ result[3][1] = sign(x[3][1]); >+ return result; >+} >+float4x3 sign(float4x3 x) { >+ float4x3 result; >+ result[0][0] = sign(x[0][0]); >+ result[0][1] = sign(x[0][1]); >+ result[0][2] = sign(x[0][2]); >+ result[1][0] = sign(x[1][0]); >+ result[1][1] = sign(x[1][1]); >+ result[1][2] = sign(x[1][2]); >+ result[2][0] = sign(x[2][0]); >+ result[2][1] = sign(x[2][1]); >+ result[2][2] = sign(x[2][2]); >+ result[3][0] = sign(x[3][0]); >+ result[3][1] = sign(x[3][1]); >+ result[3][2] = sign(x[3][2]); >+ return result; >+} >+float4x4 sign(float4x4 x) { >+ float4x4 result; >+ result[0][0] = sign(x[0][0]); >+ result[0][1] = sign(x[0][1]); >+ result[0][2] = sign(x[0][2]); >+ result[0][3] = sign(x[0][3]); >+ result[1][0] = sign(x[1][0]); >+ result[1][1] = sign(x[1][1]); >+ result[1][2] = sign(x[1][2]); >+ result[1][3] = sign(x[1][3]); >+ result[2][0] = sign(x[2][0]); >+ result[2][1] = sign(x[2][1]); >+ result[2][2] = sign(x[2][2]); >+ result[2][3] = sign(x[2][3]); >+ result[3][0] = sign(x[3][0]); >+ result[3][1] = sign(x[3][1]); >+ result[3][2] = sign(x[3][2]); >+ result[3][3] = sign(x[3][3]); >+ return result; >+} >+ >+uchar min(uchar x, uchar y) { >+ return x > y ? y : x; >+} >+uchar max(uchar x, uchar y) { >+ return x > y ? x : y; >+} >+uchar2 min(uchar2 x, uchar2 y) { >+ uchar2 result; >+ result[0] = min(x[0], y[0]); >+ result[1] = min(x[1], y[1]); >+ return result; >+} >+uchar3 min(uchar3 x, uchar3 y) { >+ uchar3 result; >+ result[0] = min(x[0], y[0]); >+ result[1] = min(x[1], y[1]); >+ result[2] = min(x[2], y[2]); >+ return result; >+} >+uchar4 min(uchar4 x, uchar4 y) { >+ uchar4 result; >+ result[0] = min(x[0], y[0]); >+ result[1] = min(x[1], y[1]); >+ result[2] = min(x[2], y[2]); >+ result[3] = min(x[3], y[3]); >+ return result; >+} >+uchar2 max(uchar2 x, uchar2 y) { >+ uchar2 result; >+ result[0] = max(x[0], y[0]); >+ result[1] = max(x[1], y[1]); >+ return result; >+} >+uchar3 max(uchar3 x, uchar3 y) { >+ uchar3 result; >+ result[0] = max(x[0], y[0]); >+ result[1] = max(x[1], y[1]); >+ result[2] = max(x[2], y[2]); >+ return result; >+} >+uchar4 max(uchar4 x, uchar4 y) { >+ uchar4 result; >+ result[0] = max(x[0], y[0]); >+ result[1] = max(x[1], y[1]); >+ result[2] = max(x[2], y[2]); >+ result[3] = max(x[3], y[3]); >+ return result; >+} >+ >+ushort min(ushort x, ushort y) { >+ return x > y ? y : x; >+} >+ushort max(ushort x, ushort y) { >+ return x > y ? x : y; >+} >+ushort2 min(ushort2 x, ushort2 y) { >+ ushort2 result; >+ result[0] = min(x[0], y[0]); >+ result[1] = min(x[1], y[1]); >+ return result; >+} >+ushort3 min(ushort3 x, ushort3 y) { >+ ushort3 result; >+ result[0] = min(x[0], y[0]); >+ result[1] = min(x[1], y[1]); >+ result[2] = min(x[2], y[2]); >+ return result; >+} >+ushort4 min(ushort4 x, ushort4 y) { >+ ushort4 result; >+ result[0] = min(x[0], y[0]); >+ result[1] = min(x[1], y[1]); >+ result[2] = min(x[2], y[2]); >+ result[3] = min(x[3], y[3]); >+ return result; >+} >+ushort2 max(ushort2 x, ushort2 y) { >+ ushort2 result; >+ result[0] = max(x[0], y[0]); >+ result[1] = max(x[1], y[1]); >+ return result; >+} >+ushort3 max(ushort3 x, ushort3 y) { >+ ushort3 result; >+ result[0] = max(x[0], y[0]); >+ result[1] = max(x[1], y[1]); >+ result[2] = max(x[2], y[2]); >+ return result; >+} >+ushort4 max(ushort4 x, ushort4 y) { >+ ushort4 result; >+ result[0] = max(x[0], y[0]); >+ result[1] = max(x[1], y[1]); >+ result[2] = max(x[2], y[2]); >+ result[3] = max(x[3], y[3]); >+ return result; >+} >+ >+uint min(uint x, uint y) { >+ return x > y ? y : x; >+} >+uint max(uint x, uint y) { >+ return x > y ? x : y; >+} >+uint2 min(uint2 x, uint2 y) { >+ uint2 result; >+ result[0] = min(x[0], y[0]); >+ result[1] = min(x[1], y[1]); >+ return result; >+} >+uint3 min(uint3 x, uint3 y) { >+ uint3 result; >+ result[0] = min(x[0], y[0]); >+ result[1] = min(x[1], y[1]); >+ result[2] = min(x[2], y[2]); >+ return result; >+} >+uint4 min(uint4 x, uint4 y) { >+ uint4 result; >+ result[0] = min(x[0], y[0]); >+ result[1] = min(x[1], y[1]); >+ result[2] = min(x[2], y[2]); >+ result[3] = min(x[3], y[3]); >+ return result; >+} >+uint2 max(uint2 x, uint2 y) { >+ uint2 result; >+ result[0] = max(x[0], y[0]); >+ result[1] = max(x[1], y[1]); >+ return result; >+} >+uint3 max(uint3 x, uint3 y) { >+ uint3 result; >+ result[0] = max(x[0], y[0]); >+ result[1] = max(x[1], y[1]); >+ result[2] = max(x[2], y[2]); >+ return result; >+} >+uint4 max(uint4 x, uint4 y) { >+ uint4 result; >+ result[0] = max(x[0], y[0]); >+ result[1] = max(x[1], y[1]); >+ result[2] = max(x[2], y[2]); >+ result[3] = max(x[3], y[3]); >+ return result; >+} >+ >+char min(char x, char y) { >+ return x > y ? y : x; >+} >+char max(char x, char y) { >+ return x > y ? x : y; >+} >+char2 min(char2 x, char2 y) { >+ char2 result; >+ result[0] = min(x[0], y[0]); >+ result[1] = min(x[1], y[1]); >+ return result; >+} >+char3 min(char3 x, char3 y) { >+ char3 result; >+ result[0] = min(x[0], y[0]); >+ result[1] = min(x[1], y[1]); >+ result[2] = min(x[2], y[2]); >+ return result; >+} >+char4 min(char4 x, char4 y) { >+ char4 result; >+ result[0] = min(x[0], y[0]); >+ result[1] = min(x[1], y[1]); >+ result[2] = min(x[2], y[2]); >+ result[3] = min(x[3], y[3]); >+ return result; >+} >+char2 max(char2 x, char2 y) { >+ char2 result; >+ result[0] = max(x[0], y[0]); >+ result[1] = max(x[1], y[1]); >+ return result; >+} >+char3 max(char3 x, char3 y) { >+ char3 result; >+ result[0] = max(x[0], y[0]); >+ result[1] = max(x[1], y[1]); >+ result[2] = max(x[2], y[2]); >+ return result; >+} >+char4 max(char4 x, char4 y) { >+ char4 result; >+ result[0] = max(x[0], y[0]); >+ result[1] = max(x[1], y[1]); >+ result[2] = max(x[2], y[2]); >+ result[3] = max(x[3], y[3]); >+ return result; >+} >+ >+short min(short x, short y) { >+ return x > y ? y : x; >+} >+short max(short x, short y) { >+ return x > y ? x : y; >+} >+short2 min(short2 x, short2 y) { >+ short2 result; >+ result[0] = min(x[0], y[0]); >+ result[1] = min(x[1], y[1]); >+ return result; >+} >+short3 min(short3 x, short3 y) { >+ short3 result; >+ result[0] = min(x[0], y[0]); >+ result[1] = min(x[1], y[1]); >+ result[2] = min(x[2], y[2]); >+ return result; >+} >+short4 min(short4 x, short4 y) { >+ short4 result; >+ result[0] = min(x[0], y[0]); >+ result[1] = min(x[1], y[1]); >+ result[2] = min(x[2], y[2]); >+ result[3] = min(x[3], y[3]); >+ return result; >+} >+short2 max(short2 x, short2 y) { >+ short2 result; >+ result[0] = max(x[0], y[0]); >+ result[1] = max(x[1], y[1]); >+ return result; >+} >+short3 max(short3 x, short3 y) { >+ short3 result; >+ result[0] = max(x[0], y[0]); >+ result[1] = max(x[1], y[1]); >+ result[2] = max(x[2], y[2]); >+ return result; >+} >+short4 max(short4 x, short4 y) { >+ short4 result; >+ result[0] = max(x[0], y[0]); >+ result[1] = max(x[1], y[1]); >+ result[2] = max(x[2], y[2]); >+ result[3] = max(x[3], y[3]); >+ return result; >+} >+ >+int min(int x, int y) { >+ return x > y ? y : x; >+} >+int max(int x, int y) { >+ return x > y ? x : y; >+} >+int2 min(int2 x, int2 y) { >+ int2 result; >+ result[0] = min(x[0], y[0]); >+ result[1] = min(x[1], y[1]); >+ return result; >+} >+int3 min(int3 x, int3 y) { >+ int3 result; >+ result[0] = min(x[0], y[0]); >+ result[1] = min(x[1], y[1]); >+ result[2] = min(x[2], y[2]); >+ return result; >+} >+int4 min(int4 x, int4 y) { >+ int4 result; >+ result[0] = min(x[0], y[0]); >+ result[1] = min(x[1], y[1]); >+ result[2] = min(x[2], y[2]); >+ result[3] = min(x[3], y[3]); >+ return result; >+} >+int2 max(int2 x, int2 y) { >+ int2 result; >+ result[0] = max(x[0], y[0]); >+ result[1] = max(x[1], y[1]); >+ return result; >+} >+int3 max(int3 x, int3 y) { >+ int3 result; >+ result[0] = max(x[0], y[0]); >+ result[1] = max(x[1], y[1]); >+ result[2] = max(x[2], y[2]); >+ return result; >+} >+int4 max(int4 x, int4 y) { >+ int4 result; >+ result[0] = max(x[0], y[0]); >+ result[1] = max(x[1], y[1]); >+ result[2] = max(x[2], y[2]); >+ result[3] = max(x[3], y[3]); >+ return result; >+} >+ >+half min(half x, half y) { >+ return x > y ? y : x; >+} >+half max(half x, half y) { >+ return x > y ? x : y; >+} >+half2 min(half2 x, half2 y) { >+ half2 result; >+ result[0] = min(x[0], y[0]); >+ result[1] = min(x[1], y[1]); >+ return result; >+} >+half3 min(half3 x, half3 y) { >+ half3 result; >+ result[0] = min(x[0], y[0]); >+ result[1] = min(x[1], y[1]); >+ result[2] = min(x[2], y[2]); >+ return result; >+} >+half4 min(half4 x, half4 y) { >+ half4 result; >+ result[0] = min(x[0], y[0]); >+ result[1] = min(x[1], y[1]); >+ result[2] = min(x[2], y[2]); >+ result[3] = min(x[3], y[3]); >+ return result; >+} >+half2x2 min(half2x2 x, half2x2 y) { >+ half2x2 result; >+ result[0][0] = min(x[0][0], y[0][0]); >+ result[0][1] = min(x[0][1], y[0][1]); >+ result[1][0] = min(x[1][0], y[1][0]); >+ result[1][1] = min(x[1][1], y[1][1]); >+ return result; >+} >+half2x3 min(half2x3 x, half2x3 y) { >+ half2x3 result; >+ result[0][0] = min(x[0][0], y[0][0]); >+ result[0][1] = min(x[0][1], y[0][1]); >+ result[0][2] = min(x[0][2], y[0][2]); >+ result[1][0] = min(x[1][0], y[1][0]); >+ result[1][1] = min(x[1][1], y[1][1]); >+ result[1][2] = min(x[1][2], y[1][2]); >+ return result; >+} >+half2x4 min(half2x4 x, half2x4 y) { >+ half2x4 result; >+ result[0][0] = min(x[0][0], y[0][0]); >+ result[0][1] = min(x[0][1], y[0][1]); >+ result[0][2] = min(x[0][2], y[0][2]); >+ result[0][3] = min(x[0][3], y[0][3]); >+ result[1][0] = min(x[1][0], y[1][0]); >+ result[1][1] = min(x[1][1], y[1][1]); >+ result[1][2] = min(x[1][2], y[1][2]); >+ result[1][3] = min(x[1][3], y[1][3]); >+ return result; >+} >+half3x2 min(half3x2 x, half3x2 y) { >+ half3x2 result; >+ result[0][0] = min(x[0][0], y[0][0]); >+ result[0][1] = min(x[0][1], y[0][1]); >+ result[1][0] = min(x[1][0], y[1][0]); >+ result[1][1] = min(x[1][1], y[1][1]); >+ result[2][0] = min(x[2][0], y[2][0]); >+ result[2][1] = min(x[2][1], y[2][1]); >+ return result; >+} >+half3x3 min(half3x3 x, half3x3 y) { >+ half3x3 result; >+ result[0][0] = min(x[0][0], y[0][0]); >+ result[0][1] = min(x[0][1], y[0][1]); >+ result[0][2] = min(x[0][2], y[0][2]); >+ result[1][0] = min(x[1][0], y[1][0]); >+ result[1][1] = min(x[1][1], y[1][1]); >+ result[1][2] = min(x[1][2], y[1][2]); >+ result[2][0] = min(x[2][0], y[2][0]); >+ result[2][1] = min(x[2][1], y[2][1]); >+ result[2][2] = min(x[2][2], y[2][2]); >+ return result; >+} >+half3x4 min(half3x4 x, half3x4 y) { >+ half3x4 result; >+ result[0][0] = min(x[0][0], y[0][0]); >+ result[0][1] = min(x[0][1], y[0][1]); >+ result[0][2] = min(x[0][2], y[0][2]); >+ result[0][3] = min(x[0][3], y[0][3]); >+ result[1][0] = min(x[1][0], y[1][0]); >+ result[1][1] = min(x[1][1], y[1][1]); >+ result[1][2] = min(x[1][2], y[1][2]); >+ result[1][3] = min(x[1][3], y[1][3]); >+ result[2][0] = min(x[2][0], y[2][0]); >+ result[2][1] = min(x[2][1], y[2][1]); >+ result[2][2] = min(x[2][2], y[2][2]); >+ result[2][3] = min(x[2][3], y[2][3]); >+ return result; >+} >+half4x2 min(half4x2 x, half4x2 y) { >+ half4x2 result; >+ result[0][0] = min(x[0][0], y[0][0]); >+ result[0][1] = min(x[0][1], y[0][1]); >+ result[1][0] = min(x[1][0], y[1][0]); >+ result[1][1] = min(x[1][1], y[1][1]); >+ result[2][0] = min(x[2][0], y[2][0]); >+ result[2][1] = min(x[2][1], y[2][1]); >+ result[3][0] = min(x[3][0], y[3][0]); >+ result[3][1] = min(x[3][1], y[3][1]); >+ return result; >+} >+half4x3 min(half4x3 x, half4x3 y) { >+ half4x3 result; >+ result[0][0] = min(x[0][0], y[0][0]); >+ result[0][1] = min(x[0][1], y[0][1]); >+ result[0][2] = min(x[0][2], y[0][2]); >+ result[1][0] = min(x[1][0], y[1][0]); >+ result[1][1] = min(x[1][1], y[1][1]); >+ result[1][2] = min(x[1][2], y[1][2]); >+ result[2][0] = min(x[2][0], y[2][0]); >+ result[2][1] = min(x[2][1], y[2][1]); >+ result[2][2] = min(x[2][2], y[2][2]); >+ result[3][0] = min(x[3][0], y[3][0]); >+ result[3][1] = min(x[3][1], y[3][1]); >+ result[3][2] = min(x[3][2], y[3][2]); >+ return result; >+} >+half4x4 min(half4x4 x, half4x4 y) { >+ half4x4 result; >+ result[0][0] = min(x[0][0], y[0][0]); >+ result[0][1] = min(x[0][1], y[0][1]); >+ result[0][2] = min(x[0][2], y[0][2]); >+ result[0][3] = min(x[0][3], y[0][3]); >+ result[1][0] = min(x[1][0], y[1][0]); >+ result[1][1] = min(x[1][1], y[1][1]); >+ result[1][2] = min(x[1][2], y[1][2]); >+ result[1][3] = min(x[1][3], y[1][3]); >+ result[2][0] = min(x[2][0], y[2][0]); >+ result[2][1] = min(x[2][1], y[2][1]); >+ result[2][2] = min(x[2][2], y[2][2]); >+ result[2][3] = min(x[2][3], y[2][3]); >+ result[3][0] = min(x[3][0], y[3][0]); >+ result[3][1] = min(x[3][1], y[3][1]); >+ result[3][2] = min(x[3][2], y[3][2]); >+ result[3][3] = min(x[3][3], y[3][3]); >+ return result; >+} >+half2 max(half2 x, half2 y) { >+ half2 result; >+ result[0] = max(x[0], y[0]); >+ result[1] = max(x[1], y[1]); >+ return result; >+} >+half3 max(half3 x, half3 y) { >+ half3 result; >+ result[0] = max(x[0], y[0]); >+ result[1] = max(x[1], y[1]); >+ result[2] = max(x[2], y[2]); >+ return result; >+} >+half4 max(half4 x, half4 y) { >+ half4 result; >+ result[0] = max(x[0], y[0]); >+ result[1] = max(x[1], y[1]); >+ result[2] = max(x[2], y[2]); >+ result[3] = max(x[3], y[3]); >+ return result; >+} >+half2x2 max(half2x2 x, half2x2 y) { >+ half2x2 result; >+ result[0][0] = max(x[0][0], y[0][0]); >+ result[0][1] = max(x[0][1], y[0][1]); >+ result[1][0] = max(x[1][0], y[1][0]); >+ result[1][1] = max(x[1][1], y[1][1]); >+ return result; >+} >+half2x3 max(half2x3 x, half2x3 y) { >+ half2x3 result; >+ result[0][0] = max(x[0][0], y[0][0]); >+ result[0][1] = max(x[0][1], y[0][1]); >+ result[0][2] = max(x[0][2], y[0][2]); >+ result[1][0] = max(x[1][0], y[1][0]); >+ result[1][1] = max(x[1][1], y[1][1]); >+ result[1][2] = max(x[1][2], y[1][2]); >+ return result; >+} >+half2x4 max(half2x4 x, half2x4 y) { >+ half2x4 result; >+ result[0][0] = max(x[0][0], y[0][0]); >+ result[0][1] = max(x[0][1], y[0][1]); >+ result[0][2] = max(x[0][2], y[0][2]); >+ result[0][3] = max(x[0][3], y[0][3]); >+ result[1][0] = max(x[1][0], y[1][0]); >+ result[1][1] = max(x[1][1], y[1][1]); >+ result[1][2] = max(x[1][2], y[1][2]); >+ result[1][3] = max(x[1][3], y[1][3]); >+ return result; >+} >+half3x2 max(half3x2 x, half3x2 y) { >+ half3x2 result; >+ result[0][0] = max(x[0][0], y[0][0]); >+ result[0][1] = max(x[0][1], y[0][1]); >+ result[1][0] = max(x[1][0], y[1][0]); >+ result[1][1] = max(x[1][1], y[1][1]); >+ result[2][0] = max(x[2][0], y[2][0]); >+ result[2][1] = max(x[2][1], y[2][1]); >+ return result; >+} >+half3x3 max(half3x3 x, half3x3 y) { >+ half3x3 result; >+ result[0][0] = max(x[0][0], y[0][0]); >+ result[0][1] = max(x[0][1], y[0][1]); >+ result[0][2] = max(x[0][2], y[0][2]); >+ result[1][0] = max(x[1][0], y[1][0]); >+ result[1][1] = max(x[1][1], y[1][1]); >+ result[1][2] = max(x[1][2], y[1][2]); >+ result[2][0] = max(x[2][0], y[2][0]); >+ result[2][1] = max(x[2][1], y[2][1]); >+ result[2][2] = max(x[2][2], y[2][2]); >+ return result; >+} >+half3x4 max(half3x4 x, half3x4 y) { >+ half3x4 result; >+ result[0][0] = max(x[0][0], y[0][0]); >+ result[0][1] = max(x[0][1], y[0][1]); >+ result[0][2] = max(x[0][2], y[0][2]); >+ result[0][3] = max(x[0][3], y[0][3]); >+ result[1][0] = max(x[1][0], y[1][0]); >+ result[1][1] = max(x[1][1], y[1][1]); >+ result[1][2] = max(x[1][2], y[1][2]); >+ result[1][3] = max(x[1][3], y[1][3]); >+ result[2][0] = max(x[2][0], y[2][0]); >+ result[2][1] = max(x[2][1], y[2][1]); >+ result[2][2] = max(x[2][2], y[2][2]); >+ result[2][3] = max(x[2][3], y[2][3]); >+ return result; >+} >+half4x2 max(half4x2 x, half4x2 y) { >+ half4x2 result; >+ result[0][0] = max(x[0][0], y[0][0]); >+ result[0][1] = max(x[0][1], y[0][1]); >+ result[1][0] = max(x[1][0], y[1][0]); >+ result[1][1] = max(x[1][1], y[1][1]); >+ result[2][0] = max(x[2][0], y[2][0]); >+ result[2][1] = max(x[2][1], y[2][1]); >+ result[3][0] = max(x[3][0], y[3][0]); >+ result[3][1] = max(x[3][1], y[3][1]); >+ return result; >+} >+half4x3 max(half4x3 x, half4x3 y) { >+ half4x3 result; >+ result[0][0] = max(x[0][0], y[0][0]); >+ result[0][1] = max(x[0][1], y[0][1]); >+ result[0][2] = max(x[0][2], y[0][2]); >+ result[1][0] = max(x[1][0], y[1][0]); >+ result[1][1] = max(x[1][1], y[1][1]); >+ result[1][2] = max(x[1][2], y[1][2]); >+ result[2][0] = max(x[2][0], y[2][0]); >+ result[2][1] = max(x[2][1], y[2][1]); >+ result[2][2] = max(x[2][2], y[2][2]); >+ result[3][0] = max(x[3][0], y[3][0]); >+ result[3][1] = max(x[3][1], y[3][1]); >+ result[3][2] = max(x[3][2], y[3][2]); >+ return result; >+} >+half4x4 max(half4x4 x, half4x4 y) { >+ half4x4 result; >+ result[0][0] = max(x[0][0], y[0][0]); >+ result[0][1] = max(x[0][1], y[0][1]); >+ result[0][2] = max(x[0][2], y[0][2]); >+ result[0][3] = max(x[0][3], y[0][3]); >+ result[1][0] = max(x[1][0], y[1][0]); >+ result[1][1] = max(x[1][1], y[1][1]); >+ result[1][2] = max(x[1][2], y[1][2]); >+ result[1][3] = max(x[1][3], y[1][3]); >+ result[2][0] = max(x[2][0], y[2][0]); >+ result[2][1] = max(x[2][1], y[2][1]); >+ result[2][2] = max(x[2][2], y[2][2]); >+ result[2][3] = max(x[2][3], y[2][3]); >+ result[3][0] = max(x[3][0], y[3][0]); >+ result[3][1] = max(x[3][1], y[3][1]); >+ result[3][2] = max(x[3][2], y[3][2]); >+ result[3][3] = max(x[3][3], y[3][3]); >+ return result; >+} >+ >+float min(float x, float y) { >+ return x > y ? y : x; >+} >+float max(float x, float y) { >+ return x > y ? x : y; >+} >+float2 min(float2 x, float2 y) { >+ float2 result; >+ result[0] = min(x[0], y[0]); >+ result[1] = min(x[1], y[1]); >+ return result; >+} >+float3 min(float3 x, float3 y) { >+ float3 result; >+ result[0] = min(x[0], y[0]); >+ result[1] = min(x[1], y[1]); >+ result[2] = min(x[2], y[2]); >+ return result; >+} >+float4 min(float4 x, float4 y) { >+ float4 result; >+ result[0] = min(x[0], y[0]); >+ result[1] = min(x[1], y[1]); >+ result[2] = min(x[2], y[2]); >+ result[3] = min(x[3], y[3]); >+ return result; >+} >+float2x2 min(float2x2 x, float2x2 y) { >+ float2x2 result; >+ result[0][0] = min(x[0][0], y[0][0]); >+ result[0][1] = min(x[0][1], y[0][1]); >+ result[1][0] = min(x[1][0], y[1][0]); >+ result[1][1] = min(x[1][1], y[1][1]); >+ return result; >+} >+float2x3 min(float2x3 x, float2x3 y) { >+ float2x3 result; >+ result[0][0] = min(x[0][0], y[0][0]); >+ result[0][1] = min(x[0][1], y[0][1]); >+ result[0][2] = min(x[0][2], y[0][2]); >+ result[1][0] = min(x[1][0], y[1][0]); >+ result[1][1] = min(x[1][1], y[1][1]); >+ result[1][2] = min(x[1][2], y[1][2]); >+ return result; >+} >+float2x4 min(float2x4 x, float2x4 y) { >+ float2x4 result; >+ result[0][0] = min(x[0][0], y[0][0]); >+ result[0][1] = min(x[0][1], y[0][1]); >+ result[0][2] = min(x[0][2], y[0][2]); >+ result[0][3] = min(x[0][3], y[0][3]); >+ result[1][0] = min(x[1][0], y[1][0]); >+ result[1][1] = min(x[1][1], y[1][1]); >+ result[1][2] = min(x[1][2], y[1][2]); >+ result[1][3] = min(x[1][3], y[1][3]); >+ return result; >+} >+float3x2 min(float3x2 x, float3x2 y) { >+ float3x2 result; >+ result[0][0] = min(x[0][0], y[0][0]); >+ result[0][1] = min(x[0][1], y[0][1]); >+ result[1][0] = min(x[1][0], y[1][0]); >+ result[1][1] = min(x[1][1], y[1][1]); >+ result[2][0] = min(x[2][0], y[2][0]); >+ result[2][1] = min(x[2][1], y[2][1]); >+ return result; >+} >+float3x3 min(float3x3 x, float3x3 y) { >+ float3x3 result; >+ result[0][0] = min(x[0][0], y[0][0]); >+ result[0][1] = min(x[0][1], y[0][1]); >+ result[0][2] = min(x[0][2], y[0][2]); >+ result[1][0] = min(x[1][0], y[1][0]); >+ result[1][1] = min(x[1][1], y[1][1]); >+ result[1][2] = min(x[1][2], y[1][2]); >+ result[2][0] = min(x[2][0], y[2][0]); >+ result[2][1] = min(x[2][1], y[2][1]); >+ result[2][2] = min(x[2][2], y[2][2]); >+ return result; >+} >+float3x4 min(float3x4 x, float3x4 y) { >+ float3x4 result; >+ result[0][0] = min(x[0][0], y[0][0]); >+ result[0][1] = min(x[0][1], y[0][1]); >+ result[0][2] = min(x[0][2], y[0][2]); >+ result[0][3] = min(x[0][3], y[0][3]); >+ result[1][0] = min(x[1][0], y[1][0]); >+ result[1][1] = min(x[1][1], y[1][1]); >+ result[1][2] = min(x[1][2], y[1][2]); >+ result[1][3] = min(x[1][3], y[1][3]); >+ result[2][0] = min(x[2][0], y[2][0]); >+ result[2][1] = min(x[2][1], y[2][1]); >+ result[2][2] = min(x[2][2], y[2][2]); >+ result[2][3] = min(x[2][3], y[2][3]); >+ return result; >+} >+float4x2 min(float4x2 x, float4x2 y) { >+ float4x2 result; >+ result[0][0] = min(x[0][0], y[0][0]); >+ result[0][1] = min(x[0][1], y[0][1]); >+ result[1][0] = min(x[1][0], y[1][0]); >+ result[1][1] = min(x[1][1], y[1][1]); >+ result[2][0] = min(x[2][0], y[2][0]); >+ result[2][1] = min(x[2][1], y[2][1]); >+ result[3][0] = min(x[3][0], y[3][0]); >+ result[3][1] = min(x[3][1], y[3][1]); >+ return result; >+} >+float4x3 min(float4x3 x, float4x3 y) { >+ float4x3 result; >+ result[0][0] = min(x[0][0], y[0][0]); >+ result[0][1] = min(x[0][1], y[0][1]); >+ result[0][2] = min(x[0][2], y[0][2]); >+ result[1][0] = min(x[1][0], y[1][0]); >+ result[1][1] = min(x[1][1], y[1][1]); >+ result[1][2] = min(x[1][2], y[1][2]); >+ result[2][0] = min(x[2][0], y[2][0]); >+ result[2][1] = min(x[2][1], y[2][1]); >+ result[2][2] = min(x[2][2], y[2][2]); >+ result[3][0] = min(x[3][0], y[3][0]); >+ result[3][1] = min(x[3][1], y[3][1]); >+ result[3][2] = min(x[3][2], y[3][2]); >+ return result; >+} >+float4x4 min(float4x4 x, float4x4 y) { >+ float4x4 result; >+ result[0][0] = min(x[0][0], y[0][0]); >+ result[0][1] = min(x[0][1], y[0][1]); >+ result[0][2] = min(x[0][2], y[0][2]); >+ result[0][3] = min(x[0][3], y[0][3]); >+ result[1][0] = min(x[1][0], y[1][0]); >+ result[1][1] = min(x[1][1], y[1][1]); >+ result[1][2] = min(x[1][2], y[1][2]); >+ result[1][3] = min(x[1][3], y[1][3]); >+ result[2][0] = min(x[2][0], y[2][0]); >+ result[2][1] = min(x[2][1], y[2][1]); >+ result[2][2] = min(x[2][2], y[2][2]); >+ result[2][3] = min(x[2][3], y[2][3]); >+ result[3][0] = min(x[3][0], y[3][0]); >+ result[3][1] = min(x[3][1], y[3][1]); >+ result[3][2] = min(x[3][2], y[3][2]); >+ result[3][3] = min(x[3][3], y[3][3]); >+ return result; >+} >+float2 max(float2 x, float2 y) { >+ float2 result; >+ result[0] = max(x[0], y[0]); >+ result[1] = max(x[1], y[1]); >+ return result; >+} >+float3 max(float3 x, float3 y) { >+ float3 result; >+ result[0] = max(x[0], y[0]); >+ result[1] = max(x[1], y[1]); >+ result[2] = max(x[2], y[2]); >+ return result; >+} >+float4 max(float4 x, float4 y) { >+ float4 result; >+ result[0] = max(x[0], y[0]); >+ result[1] = max(x[1], y[1]); >+ result[2] = max(x[2], y[2]); >+ result[3] = max(x[3], y[3]); >+ return result; >+} >+float2x2 max(float2x2 x, float2x2 y) { >+ float2x2 result; >+ result[0][0] = max(x[0][0], y[0][0]); >+ result[0][1] = max(x[0][1], y[0][1]); >+ result[1][0] = max(x[1][0], y[1][0]); >+ result[1][1] = max(x[1][1], y[1][1]); >+ return result; >+} >+float2x3 max(float2x3 x, float2x3 y) { >+ float2x3 result; >+ result[0][0] = max(x[0][0], y[0][0]); >+ result[0][1] = max(x[0][1], y[0][1]); >+ result[0][2] = max(x[0][2], y[0][2]); >+ result[1][0] = max(x[1][0], y[1][0]); >+ result[1][1] = max(x[1][1], y[1][1]); >+ result[1][2] = max(x[1][2], y[1][2]); >+ return result; >+} >+float2x4 max(float2x4 x, float2x4 y) { >+ float2x4 result; >+ result[0][0] = max(x[0][0], y[0][0]); >+ result[0][1] = max(x[0][1], y[0][1]); >+ result[0][2] = max(x[0][2], y[0][2]); >+ result[0][3] = max(x[0][3], y[0][3]); >+ result[1][0] = max(x[1][0], y[1][0]); >+ result[1][1] = max(x[1][1], y[1][1]); >+ result[1][2] = max(x[1][2], y[1][2]); >+ result[1][3] = max(x[1][3], y[1][3]); >+ return result; >+} >+float3x2 max(float3x2 x, float3x2 y) { >+ float3x2 result; >+ result[0][0] = max(x[0][0], y[0][0]); >+ result[0][1] = max(x[0][1], y[0][1]); >+ result[1][0] = max(x[1][0], y[1][0]); >+ result[1][1] = max(x[1][1], y[1][1]); >+ result[2][0] = max(x[2][0], y[2][0]); >+ result[2][1] = max(x[2][1], y[2][1]); >+ return result; >+} >+float3x3 max(float3x3 x, float3x3 y) { >+ float3x3 result; >+ result[0][0] = max(x[0][0], y[0][0]); >+ result[0][1] = max(x[0][1], y[0][1]); >+ result[0][2] = max(x[0][2], y[0][2]); >+ result[1][0] = max(x[1][0], y[1][0]); >+ result[1][1] = max(x[1][1], y[1][1]); >+ result[1][2] = max(x[1][2], y[1][2]); >+ result[2][0] = max(x[2][0], y[2][0]); >+ result[2][1] = max(x[2][1], y[2][1]); >+ result[2][2] = max(x[2][2], y[2][2]); >+ return result; >+} >+float3x4 max(float3x4 x, float3x4 y) { >+ float3x4 result; >+ result[0][0] = max(x[0][0], y[0][0]); >+ result[0][1] = max(x[0][1], y[0][1]); >+ result[0][2] = max(x[0][2], y[0][2]); >+ result[0][3] = max(x[0][3], y[0][3]); >+ result[1][0] = max(x[1][0], y[1][0]); >+ result[1][1] = max(x[1][1], y[1][1]); >+ result[1][2] = max(x[1][2], y[1][2]); >+ result[1][3] = max(x[1][3], y[1][3]); >+ result[2][0] = max(x[2][0], y[2][0]); >+ result[2][1] = max(x[2][1], y[2][1]); >+ result[2][2] = max(x[2][2], y[2][2]); >+ result[2][3] = max(x[2][3], y[2][3]); >+ return result; >+} >+float4x2 max(float4x2 x, float4x2 y) { >+ float4x2 result; >+ result[0][0] = max(x[0][0], y[0][0]); >+ result[0][1] = max(x[0][1], y[0][1]); >+ result[1][0] = max(x[1][0], y[1][0]); >+ result[1][1] = max(x[1][1], y[1][1]); >+ result[2][0] = max(x[2][0], y[2][0]); >+ result[2][1] = max(x[2][1], y[2][1]); >+ result[3][0] = max(x[3][0], y[3][0]); >+ result[3][1] = max(x[3][1], y[3][1]); >+ return result; >+} >+float4x3 max(float4x3 x, float4x3 y) { >+ float4x3 result; >+ result[0][0] = max(x[0][0], y[0][0]); >+ result[0][1] = max(x[0][1], y[0][1]); >+ result[0][2] = max(x[0][2], y[0][2]); >+ result[1][0] = max(x[1][0], y[1][0]); >+ result[1][1] = max(x[1][1], y[1][1]); >+ result[1][2] = max(x[1][2], y[1][2]); >+ result[2][0] = max(x[2][0], y[2][0]); >+ result[2][1] = max(x[2][1], y[2][1]); >+ result[2][2] = max(x[2][2], y[2][2]); >+ result[3][0] = max(x[3][0], y[3][0]); >+ result[3][1] = max(x[3][1], y[3][1]); >+ result[3][2] = max(x[3][2], y[3][2]); >+ return result; >+} >+float4x4 max(float4x4 x, float4x4 y) { >+ float4x4 result; >+ result[0][0] = max(x[0][0], y[0][0]); >+ result[0][1] = max(x[0][1], y[0][1]); >+ result[0][2] = max(x[0][2], y[0][2]); >+ result[0][3] = max(x[0][3], y[0][3]); >+ result[1][0] = max(x[1][0], y[1][0]); >+ result[1][1] = max(x[1][1], y[1][1]); >+ result[1][2] = max(x[1][2], y[1][2]); >+ result[1][3] = max(x[1][3], y[1][3]); >+ result[2][0] = max(x[2][0], y[2][0]); >+ result[2][1] = max(x[2][1], y[2][1]); >+ result[2][2] = max(x[2][2], y[2][2]); >+ result[2][3] = max(x[2][3], y[2][3]); >+ result[3][0] = max(x[3][0], y[3][0]); >+ result[3][1] = max(x[3][1], y[3][1]); >+ result[3][2] = max(x[3][2], y[3][2]); >+ result[3][3] = max(x[3][3], y[3][3]); >+ return result; >+} >+ >+uchar clamp(uchar x, uchar lower, uchar upper) { >+ return max(min(upper, x), lower); >+} >+uchar2 clamp(uchar2 x, uchar2 y, uchar2 z) { >+ uchar2 result; >+ result[0] = clamp(x[0], y[0], z[0]); >+ result[1] = clamp(x[1], y[1], z[1]); >+ return result; >+} >+uchar3 clamp(uchar3 x, uchar3 y, uchar3 z) { >+ uchar3 result; >+ result[0] = clamp(x[0], y[0], z[0]); >+ result[1] = clamp(x[1], y[1], z[1]); >+ result[2] = clamp(x[2], y[2], z[2]); >+ return result; >+} >+uchar4 clamp(uchar4 x, uchar4 y, uchar4 z) { >+ uchar4 result; >+ result[0] = clamp(x[0], y[0], z[0]); >+ result[1] = clamp(x[1], y[1], z[1]); >+ result[2] = clamp(x[2], y[2], z[2]); >+ result[3] = clamp(x[3], y[3], z[3]); >+ return result; >+} >+ >+ushort clamp(ushort x, ushort lower, ushort upper) { >+ return max(min(upper, x), lower); >+} >+ushort2 clamp(ushort2 x, ushort2 y, ushort2 z) { >+ ushort2 result; >+ result[0] = clamp(x[0], y[0], z[0]); >+ result[1] = clamp(x[1], y[1], z[1]); >+ return result; >+} >+ushort3 clamp(ushort3 x, ushort3 y, ushort3 z) { >+ ushort3 result; >+ result[0] = clamp(x[0], y[0], z[0]); >+ result[1] = clamp(x[1], y[1], z[1]); >+ result[2] = clamp(x[2], y[2], z[2]); >+ return result; >+} >+ushort4 clamp(ushort4 x, ushort4 y, ushort4 z) { >+ ushort4 result; >+ result[0] = clamp(x[0], y[0], z[0]); >+ result[1] = clamp(x[1], y[1], z[1]); >+ result[2] = clamp(x[2], y[2], z[2]); >+ result[3] = clamp(x[3], y[3], z[3]); >+ return result; >+} >+ >+uint clamp(uint x, uint lower, uint upper) { >+ return max(min(upper, x), lower); >+} >+uint2 clamp(uint2 x, uint2 y, uint2 z) { >+ uint2 result; >+ result[0] = clamp(x[0], y[0], z[0]); >+ result[1] = clamp(x[1], y[1], z[1]); >+ return result; >+} >+uint3 clamp(uint3 x, uint3 y, uint3 z) { >+ uint3 result; >+ result[0] = clamp(x[0], y[0], z[0]); >+ result[1] = clamp(x[1], y[1], z[1]); >+ result[2] = clamp(x[2], y[2], z[2]); >+ return result; >+} >+uint4 clamp(uint4 x, uint4 y, uint4 z) { >+ uint4 result; >+ result[0] = clamp(x[0], y[0], z[0]); >+ result[1] = clamp(x[1], y[1], z[1]); >+ result[2] = clamp(x[2], y[2], z[2]); >+ result[3] = clamp(x[3], y[3], z[3]); >+ return result; >+} >+ >+char clamp(char x, char lower, char upper) { >+ return max(min(upper, x), lower); >+} >+char2 clamp(char2 x, char2 y, char2 z) { >+ char2 result; >+ result[0] = clamp(x[0], y[0], z[0]); >+ result[1] = clamp(x[1], y[1], z[1]); >+ return result; >+} >+char3 clamp(char3 x, char3 y, char3 z) { >+ char3 result; >+ result[0] = clamp(x[0], y[0], z[0]); >+ result[1] = clamp(x[1], y[1], z[1]); >+ result[2] = clamp(x[2], y[2], z[2]); >+ return result; >+} >+char4 clamp(char4 x, char4 y, char4 z) { >+ char4 result; >+ result[0] = clamp(x[0], y[0], z[0]); >+ result[1] = clamp(x[1], y[1], z[1]); >+ result[2] = clamp(x[2], y[2], z[2]); >+ result[3] = clamp(x[3], y[3], z[3]); >+ return result; >+} >+ >+short clamp(short x, short lower, short upper) { >+ return max(min(upper, x), lower); >+} >+short2 clamp(short2 x, short2 y, short2 z) { >+ short2 result; >+ result[0] = clamp(x[0], y[0], z[0]); >+ result[1] = clamp(x[1], y[1], z[1]); >+ return result; >+} >+short3 clamp(short3 x, short3 y, short3 z) { >+ short3 result; >+ result[0] = clamp(x[0], y[0], z[0]); >+ result[1] = clamp(x[1], y[1], z[1]); >+ result[2] = clamp(x[2], y[2], z[2]); >+ return result; >+} >+short4 clamp(short4 x, short4 y, short4 z) { >+ short4 result; >+ result[0] = clamp(x[0], y[0], z[0]); >+ result[1] = clamp(x[1], y[1], z[1]); >+ result[2] = clamp(x[2], y[2], z[2]); >+ result[3] = clamp(x[3], y[3], z[3]); >+ return result; >+} >+ >+int clamp(int x, int lower, int upper) { >+ return max(min(upper, x), lower); >+} >+int2 clamp(int2 x, int2 y, int2 z) { >+ int2 result; >+ result[0] = clamp(x[0], y[0], z[0]); >+ result[1] = clamp(x[1], y[1], z[1]); >+ return result; >+} >+int3 clamp(int3 x, int3 y, int3 z) { >+ int3 result; >+ result[0] = clamp(x[0], y[0], z[0]); >+ result[1] = clamp(x[1], y[1], z[1]); >+ result[2] = clamp(x[2], y[2], z[2]); >+ return result; >+} >+int4 clamp(int4 x, int4 y, int4 z) { >+ int4 result; >+ result[0] = clamp(x[0], y[0], z[0]); >+ result[1] = clamp(x[1], y[1], z[1]); >+ result[2] = clamp(x[2], y[2], z[2]); >+ result[3] = clamp(x[3], y[3], z[3]); >+ return result; >+} >+ >+half clamp(half x, half lower, half upper) { >+ return max(min(upper, x), lower); >+} >+half2 clamp(half2 x, half2 y, half2 z) { >+ half2 result; >+ result[0] = clamp(x[0], y[0], z[0]); >+ result[1] = clamp(x[1], y[1], z[1]); >+ return result; >+} >+half3 clamp(half3 x, half3 y, half3 z) { >+ half3 result; >+ result[0] = clamp(x[0], y[0], z[0]); >+ result[1] = clamp(x[1], y[1], z[1]); >+ result[2] = clamp(x[2], y[2], z[2]); >+ return result; >+} >+half4 clamp(half4 x, half4 y, half4 z) { >+ half4 result; >+ result[0] = clamp(x[0], y[0], z[0]); >+ result[1] = clamp(x[1], y[1], z[1]); >+ result[2] = clamp(x[2], y[2], z[2]); >+ result[3] = clamp(x[3], y[3], z[3]); >+ return result; >+} >+half2x2 clamp(half2x2 x, half2x2 y, half2x2 z) { >+ half2x2 result; >+ result[0][0] = clamp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = clamp(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = clamp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = clamp(x[1][1], y[1][1], z[1][1]); >+ return result; >+} >+half2x3 clamp(half2x3 x, half2x3 y, half2x3 z) { >+ half2x3 result; >+ result[0][0] = clamp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = clamp(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = clamp(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = clamp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = clamp(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = clamp(x[1][2], y[1][2], z[1][2]); >+ return result; >+} >+half2x4 clamp(half2x4 x, half2x4 y, half2x4 z) { >+ half2x4 result; >+ result[0][0] = clamp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = clamp(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = clamp(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = clamp(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = clamp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = clamp(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = clamp(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = clamp(x[1][3], y[1][3], z[1][3]); >+ return result; >+} >+half3x2 clamp(half3x2 x, half3x2 y, half3x2 z) { >+ half3x2 result; >+ result[0][0] = clamp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = clamp(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = clamp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = clamp(x[1][1], y[1][1], z[1][1]); >+ result[2][0] = clamp(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = clamp(x[2][1], y[2][1], z[2][1]); >+ return result; >+} >+half3x3 clamp(half3x3 x, half3x3 y, half3x3 z) { >+ half3x3 result; >+ result[0][0] = clamp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = clamp(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = clamp(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = clamp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = clamp(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = clamp(x[1][2], y[1][2], z[1][2]); >+ result[2][0] = clamp(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = clamp(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = clamp(x[2][2], y[2][2], z[2][2]); >+ return result; >+} >+half3x4 clamp(half3x4 x, half3x4 y, half3x4 z) { >+ half3x4 result; >+ result[0][0] = clamp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = clamp(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = clamp(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = clamp(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = clamp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = clamp(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = clamp(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = clamp(x[1][3], y[1][3], z[1][3]); >+ result[2][0] = clamp(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = clamp(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = clamp(x[2][2], y[2][2], z[2][2]); >+ result[2][3] = clamp(x[2][3], y[2][3], z[2][3]); >+ return result; >+} >+half4x2 clamp(half4x2 x, half4x2 y, half4x2 z) { >+ half4x2 result; >+ result[0][0] = clamp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = clamp(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = clamp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = clamp(x[1][1], y[1][1], z[1][1]); >+ result[2][0] = clamp(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = clamp(x[2][1], y[2][1], z[2][1]); >+ result[3][0] = clamp(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = clamp(x[3][1], y[3][1], z[3][1]); >+ return result; >+} >+half4x3 clamp(half4x3 x, half4x3 y, half4x3 z) { >+ half4x3 result; >+ result[0][0] = clamp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = clamp(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = clamp(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = clamp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = clamp(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = clamp(x[1][2], y[1][2], z[1][2]); >+ result[2][0] = clamp(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = clamp(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = clamp(x[2][2], y[2][2], z[2][2]); >+ result[3][0] = clamp(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = clamp(x[3][1], y[3][1], z[3][1]); >+ result[3][2] = clamp(x[3][2], y[3][2], z[3][2]); >+ return result; >+} >+half4x4 clamp(half4x4 x, half4x4 y, half4x4 z) { >+ half4x4 result; >+ result[0][0] = clamp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = clamp(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = clamp(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = clamp(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = clamp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = clamp(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = clamp(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = clamp(x[1][3], y[1][3], z[1][3]); >+ result[2][0] = clamp(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = clamp(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = clamp(x[2][2], y[2][2], z[2][2]); >+ result[2][3] = clamp(x[2][3], y[2][3], z[2][3]); >+ result[3][0] = clamp(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = clamp(x[3][1], y[3][1], z[3][1]); >+ result[3][2] = clamp(x[3][2], y[3][2], z[3][2]); >+ result[3][3] = clamp(x[3][3], y[3][3], z[3][3]); >+ return result; >+} >+ >+float clamp(float x, float lower, float upper) { >+ return max(min(upper, x), lower); >+} >+float2 clamp(float2 x, float2 y, float2 z) { >+ float2 result; >+ result[0] = clamp(x[0], y[0], z[0]); >+ result[1] = clamp(x[1], y[1], z[1]); >+ return result; >+} >+float3 clamp(float3 x, float3 y, float3 z) { >+ float3 result; >+ result[0] = clamp(x[0], y[0], z[0]); >+ result[1] = clamp(x[1], y[1], z[1]); >+ result[2] = clamp(x[2], y[2], z[2]); >+ return result; >+} >+float4 clamp(float4 x, float4 y, float4 z) { >+ float4 result; >+ result[0] = clamp(x[0], y[0], z[0]); >+ result[1] = clamp(x[1], y[1], z[1]); >+ result[2] = clamp(x[2], y[2], z[2]); >+ result[3] = clamp(x[3], y[3], z[3]); >+ return result; >+} >+float2x2 clamp(float2x2 x, float2x2 y, float2x2 z) { >+ float2x2 result; >+ result[0][0] = clamp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = clamp(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = clamp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = clamp(x[1][1], y[1][1], z[1][1]); >+ return result; >+} >+float2x3 clamp(float2x3 x, float2x3 y, float2x3 z) { >+ float2x3 result; >+ result[0][0] = clamp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = clamp(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = clamp(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = clamp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = clamp(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = clamp(x[1][2], y[1][2], z[1][2]); >+ return result; >+} >+float2x4 clamp(float2x4 x, float2x4 y, float2x4 z) { >+ float2x4 result; >+ result[0][0] = clamp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = clamp(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = clamp(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = clamp(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = clamp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = clamp(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = clamp(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = clamp(x[1][3], y[1][3], z[1][3]); >+ return result; >+} >+float3x2 clamp(float3x2 x, float3x2 y, float3x2 z) { >+ float3x2 result; >+ result[0][0] = clamp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = clamp(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = clamp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = clamp(x[1][1], y[1][1], z[1][1]); >+ result[2][0] = clamp(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = clamp(x[2][1], y[2][1], z[2][1]); >+ return result; >+} >+float3x3 clamp(float3x3 x, float3x3 y, float3x3 z) { >+ float3x3 result; >+ result[0][0] = clamp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = clamp(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = clamp(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = clamp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = clamp(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = clamp(x[1][2], y[1][2], z[1][2]); >+ result[2][0] = clamp(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = clamp(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = clamp(x[2][2], y[2][2], z[2][2]); >+ return result; >+} >+float3x4 clamp(float3x4 x, float3x4 y, float3x4 z) { >+ float3x4 result; >+ result[0][0] = clamp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = clamp(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = clamp(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = clamp(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = clamp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = clamp(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = clamp(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = clamp(x[1][3], y[1][3], z[1][3]); >+ result[2][0] = clamp(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = clamp(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = clamp(x[2][2], y[2][2], z[2][2]); >+ result[2][3] = clamp(x[2][3], y[2][3], z[2][3]); >+ return result; >+} >+float4x2 clamp(float4x2 x, float4x2 y, float4x2 z) { >+ float4x2 result; >+ result[0][0] = clamp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = clamp(x[0][1], y[0][1], z[0][1]); >+ result[1][0] = clamp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = clamp(x[1][1], y[1][1], z[1][1]); >+ result[2][0] = clamp(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = clamp(x[2][1], y[2][1], z[2][1]); >+ result[3][0] = clamp(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = clamp(x[3][1], y[3][1], z[3][1]); >+ return result; >+} >+float4x3 clamp(float4x3 x, float4x3 y, float4x3 z) { >+ float4x3 result; >+ result[0][0] = clamp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = clamp(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = clamp(x[0][2], y[0][2], z[0][2]); >+ result[1][0] = clamp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = clamp(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = clamp(x[1][2], y[1][2], z[1][2]); >+ result[2][0] = clamp(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = clamp(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = clamp(x[2][2], y[2][2], z[2][2]); >+ result[3][0] = clamp(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = clamp(x[3][1], y[3][1], z[3][1]); >+ result[3][2] = clamp(x[3][2], y[3][2], z[3][2]); >+ return result; >+} >+float4x4 clamp(float4x4 x, float4x4 y, float4x4 z) { >+ float4x4 result; >+ result[0][0] = clamp(x[0][0], y[0][0], z[0][0]); >+ result[0][1] = clamp(x[0][1], y[0][1], z[0][1]); >+ result[0][2] = clamp(x[0][2], y[0][2], z[0][2]); >+ result[0][3] = clamp(x[0][3], y[0][3], z[0][3]); >+ result[1][0] = clamp(x[1][0], y[1][0], z[1][0]); >+ result[1][1] = clamp(x[1][1], y[1][1], z[1][1]); >+ result[1][2] = clamp(x[1][2], y[1][2], z[1][2]); >+ result[1][3] = clamp(x[1][3], y[1][3], z[1][3]); >+ result[2][0] = clamp(x[2][0], y[2][0], z[2][0]); >+ result[2][1] = clamp(x[2][1], y[2][1], z[2][1]); >+ result[2][2] = clamp(x[2][2], y[2][2], z[2][2]); >+ result[2][3] = clamp(x[2][3], y[2][3], z[2][3]); >+ result[3][0] = clamp(x[3][0], y[3][0], z[3][0]); >+ result[3][1] = clamp(x[3][1], y[3][1], z[3][1]); >+ result[3][2] = clamp(x[3][2], y[3][2], z[3][2]); >+ result[3][3] = clamp(x[3][3], y[3][3], z[3][3]); >+ return result; >+} >+ >+half modf(half x, thread half* ip) { >+ uint result = uint(x); >+ if (ip != null) >+ *ip = x - half(result); >+ return half(result); >+} >+half2 modf(half2 x, thread half2* y) { >+ half2 result; >+ half buffer; >+ result[0] = modf(x[0], &buffer); >+ if (y != null) >+ (*y)[0] = buffer; >+ result[1] = modf(x[1], &buffer); >+ if (y != null) >+ (*y)[1] = buffer; >+ return result; >+} >+half3 modf(half3 x, thread half3* y) { >+ half3 result; >+ half buffer; >+ result[0] = modf(x[0], &buffer); >+ if (y != null) >+ (*y)[0] = buffer; >+ result[1] = modf(x[1], &buffer); >+ if (y != null) >+ (*y)[1] = buffer; >+ result[2] = modf(x[2], &buffer); >+ if (y != null) >+ (*y)[2] = buffer; >+ return result; >+} >+half4 modf(half4 x, thread half4* y) { >+ half4 result; >+ half buffer; >+ result[0] = modf(x[0], &buffer); >+ if (y != null) >+ (*y)[0] = buffer; >+ result[1] = modf(x[1], &buffer); >+ if (y != null) >+ (*y)[1] = buffer; >+ result[2] = modf(x[2], &buffer); >+ if (y != null) >+ (*y)[2] = buffer; >+ result[3] = modf(x[3], &buffer); >+ if (y != null) >+ (*y)[3] = buffer; >+ return result; >+} >+half2x2 modf(half2x2 x, thread half2x2* y) { >+ half2x2 result; >+ half buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ return result; >+} >+half2x3 modf(half2x3 x, thread half2x3* y) { >+ half2x3 result; >+ half buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ return result; >+} >+half2x4 modf(half2x4 x, thread half2x4* y) { >+ half2x4 result; >+ half buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[0][3] = modf(x[0][3], &buffer); >+ if (y != null) >+ (*y)[0][3] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[1][3] = modf(x[1][3], &buffer); >+ if (y != null) >+ (*y)[1][3] = buffer; >+ return result; >+} >+half3x2 modf(half3x2 x, thread half3x2* y) { >+ half3x2 result; >+ half buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ return result; >+} >+half3x3 modf(half3x3 x, thread half3x3* y) { >+ half3x3 result; >+ half buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[2][2] = modf(x[2][2], &buffer); >+ if (y != null) >+ (*y)[2][2] = buffer; >+ return result; >+} >+half3x4 modf(half3x4 x, thread half3x4* y) { >+ half3x4 result; >+ half buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[0][3] = modf(x[0][3], &buffer); >+ if (y != null) >+ (*y)[0][3] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[1][3] = modf(x[1][3], &buffer); >+ if (y != null) >+ (*y)[1][3] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[2][2] = modf(x[2][2], &buffer); >+ if (y != null) >+ (*y)[2][2] = buffer; >+ result[2][3] = modf(x[2][3], &buffer); >+ if (y != null) >+ (*y)[2][3] = buffer; >+ return result; >+} >+half4x2 modf(half4x2 x, thread half4x2* y) { >+ half4x2 result; >+ half buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[3][0] = modf(x[3][0], &buffer); >+ if (y != null) >+ (*y)[3][0] = buffer; >+ result[3][1] = modf(x[3][1], &buffer); >+ if (y != null) >+ (*y)[3][1] = buffer; >+ return result; >+} >+half4x3 modf(half4x3 x, thread half4x3* y) { >+ half4x3 result; >+ half buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[2][2] = modf(x[2][2], &buffer); >+ if (y != null) >+ (*y)[2][2] = buffer; >+ result[3][0] = modf(x[3][0], &buffer); >+ if (y != null) >+ (*y)[3][0] = buffer; >+ result[3][1] = modf(x[3][1], &buffer); >+ if (y != null) >+ (*y)[3][1] = buffer; >+ result[3][2] = modf(x[3][2], &buffer); >+ if (y != null) >+ (*y)[3][2] = buffer; >+ return result; >+} >+half4x4 modf(half4x4 x, thread half4x4* y) { >+ half4x4 result; >+ half buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[0][3] = modf(x[0][3], &buffer); >+ if (y != null) >+ (*y)[0][3] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[1][3] = modf(x[1][3], &buffer); >+ if (y != null) >+ (*y)[1][3] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[2][2] = modf(x[2][2], &buffer); >+ if (y != null) >+ (*y)[2][2] = buffer; >+ result[2][3] = modf(x[2][3], &buffer); >+ if (y != null) >+ (*y)[2][3] = buffer; >+ result[3][0] = modf(x[3][0], &buffer); >+ if (y != null) >+ (*y)[3][0] = buffer; >+ result[3][1] = modf(x[3][1], &buffer); >+ if (y != null) >+ (*y)[3][1] = buffer; >+ result[3][2] = modf(x[3][2], &buffer); >+ if (y != null) >+ (*y)[3][2] = buffer; >+ result[3][3] = modf(x[3][3], &buffer); >+ if (y != null) >+ (*y)[3][3] = buffer; >+ return result; >+} >+ >+float modf(float x, thread float* ip) { >+ uint result = uint(x); >+ if (ip != null) >+ *ip = x - float(result); >+ return float(result); >+} >+float2 modf(float2 x, thread float2* y) { >+ float2 result; >+ float buffer; >+ result[0] = modf(x[0], &buffer); >+ if (y != null) >+ (*y)[0] = buffer; >+ result[1] = modf(x[1], &buffer); >+ if (y != null) >+ (*y)[1] = buffer; >+ return result; >+} >+float3 modf(float3 x, thread float3* y) { >+ float3 result; >+ float buffer; >+ result[0] = modf(x[0], &buffer); >+ if (y != null) >+ (*y)[0] = buffer; >+ result[1] = modf(x[1], &buffer); >+ if (y != null) >+ (*y)[1] = buffer; >+ result[2] = modf(x[2], &buffer); >+ if (y != null) >+ (*y)[2] = buffer; >+ return result; >+} >+float4 modf(float4 x, thread float4* y) { >+ float4 result; >+ float buffer; >+ result[0] = modf(x[0], &buffer); >+ if (y != null) >+ (*y)[0] = buffer; >+ result[1] = modf(x[1], &buffer); >+ if (y != null) >+ (*y)[1] = buffer; >+ result[2] = modf(x[2], &buffer); >+ if (y != null) >+ (*y)[2] = buffer; >+ result[3] = modf(x[3], &buffer); >+ if (y != null) >+ (*y)[3] = buffer; >+ return result; >+} >+float2x2 modf(float2x2 x, thread float2x2* y) { >+ float2x2 result; >+ float buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ return result; >+} >+float2x3 modf(float2x3 x, thread float2x3* y) { >+ float2x3 result; >+ float buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ return result; >+} >+float2x4 modf(float2x4 x, thread float2x4* y) { >+ float2x4 result; >+ float buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[0][3] = modf(x[0][3], &buffer); >+ if (y != null) >+ (*y)[0][3] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[1][3] = modf(x[1][3], &buffer); >+ if (y != null) >+ (*y)[1][3] = buffer; >+ return result; >+} >+float3x2 modf(float3x2 x, thread float3x2* y) { >+ float3x2 result; >+ float buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ return result; >+} >+float3x3 modf(float3x3 x, thread float3x3* y) { >+ float3x3 result; >+ float buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[2][2] = modf(x[2][2], &buffer); >+ if (y != null) >+ (*y)[2][2] = buffer; >+ return result; >+} >+float3x4 modf(float3x4 x, thread float3x4* y) { >+ float3x4 result; >+ float buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[0][3] = modf(x[0][3], &buffer); >+ if (y != null) >+ (*y)[0][3] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[1][3] = modf(x[1][3], &buffer); >+ if (y != null) >+ (*y)[1][3] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[2][2] = modf(x[2][2], &buffer); >+ if (y != null) >+ (*y)[2][2] = buffer; >+ result[2][3] = modf(x[2][3], &buffer); >+ if (y != null) >+ (*y)[2][3] = buffer; >+ return result; >+} >+float4x2 modf(float4x2 x, thread float4x2* y) { >+ float4x2 result; >+ float buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[3][0] = modf(x[3][0], &buffer); >+ if (y != null) >+ (*y)[3][0] = buffer; >+ result[3][1] = modf(x[3][1], &buffer); >+ if (y != null) >+ (*y)[3][1] = buffer; >+ return result; >+} >+float4x3 modf(float4x3 x, thread float4x3* y) { >+ float4x3 result; >+ float buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[2][2] = modf(x[2][2], &buffer); >+ if (y != null) >+ (*y)[2][2] = buffer; >+ result[3][0] = modf(x[3][0], &buffer); >+ if (y != null) >+ (*y)[3][0] = buffer; >+ result[3][1] = modf(x[3][1], &buffer); >+ if (y != null) >+ (*y)[3][1] = buffer; >+ result[3][2] = modf(x[3][2], &buffer); >+ if (y != null) >+ (*y)[3][2] = buffer; >+ return result; >+} >+float4x4 modf(float4x4 x, thread float4x4* y) { >+ float4x4 result; >+ float buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[0][3] = modf(x[0][3], &buffer); >+ if (y != null) >+ (*y)[0][3] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[1][3] = modf(x[1][3], &buffer); >+ if (y != null) >+ (*y)[1][3] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[2][2] = modf(x[2][2], &buffer); >+ if (y != null) >+ (*y)[2][2] = buffer; >+ result[2][3] = modf(x[2][3], &buffer); >+ if (y != null) >+ (*y)[2][3] = buffer; >+ result[3][0] = modf(x[3][0], &buffer); >+ if (y != null) >+ (*y)[3][0] = buffer; >+ result[3][1] = modf(x[3][1], &buffer); >+ if (y != null) >+ (*y)[3][1] = buffer; >+ result[3][2] = modf(x[3][2], &buffer); >+ if (y != null) >+ (*y)[3][2] = buffer; >+ result[3][3] = modf(x[3][3], &buffer); >+ if (y != null) >+ (*y)[3][3] = buffer; >+ return result; >+} >+ >+half modf(half x, device half* ip) { >+ uint result = uint(x); >+ if (ip != null) >+ *ip = x - half(result); >+ return half(result); >+} >+half2 modf(half2 x, device half2* y) { >+ half2 result; >+ half buffer; >+ result[0] = modf(x[0], &buffer); >+ if (y != null) >+ (*y)[0] = buffer; >+ result[1] = modf(x[1], &buffer); >+ if (y != null) >+ (*y)[1] = buffer; >+ return result; >+} >+half3 modf(half3 x, device half3* y) { >+ half3 result; >+ half buffer; >+ result[0] = modf(x[0], &buffer); >+ if (y != null) >+ (*y)[0] = buffer; >+ result[1] = modf(x[1], &buffer); >+ if (y != null) >+ (*y)[1] = buffer; >+ result[2] = modf(x[2], &buffer); >+ if (y != null) >+ (*y)[2] = buffer; >+ return result; >+} >+half4 modf(half4 x, device half4* y) { >+ half4 result; >+ half buffer; >+ result[0] = modf(x[0], &buffer); >+ if (y != null) >+ (*y)[0] = buffer; >+ result[1] = modf(x[1], &buffer); >+ if (y != null) >+ (*y)[1] = buffer; >+ result[2] = modf(x[2], &buffer); >+ if (y != null) >+ (*y)[2] = buffer; >+ result[3] = modf(x[3], &buffer); >+ if (y != null) >+ (*y)[3] = buffer; >+ return result; >+} >+half2x2 modf(half2x2 x, device half2x2* y) { >+ half2x2 result; >+ half buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ return result; >+} >+half2x3 modf(half2x3 x, device half2x3* y) { >+ half2x3 result; >+ half buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ return result; >+} >+half2x4 modf(half2x4 x, device half2x4* y) { >+ half2x4 result; >+ half buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[0][3] = modf(x[0][3], &buffer); >+ if (y != null) >+ (*y)[0][3] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[1][3] = modf(x[1][3], &buffer); >+ if (y != null) >+ (*y)[1][3] = buffer; >+ return result; >+} >+half3x2 modf(half3x2 x, device half3x2* y) { >+ half3x2 result; >+ half buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ return result; >+} >+half3x3 modf(half3x3 x, device half3x3* y) { >+ half3x3 result; >+ half buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[2][2] = modf(x[2][2], &buffer); >+ if (y != null) >+ (*y)[2][2] = buffer; >+ return result; >+} >+half3x4 modf(half3x4 x, device half3x4* y) { >+ half3x4 result; >+ half buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[0][3] = modf(x[0][3], &buffer); >+ if (y != null) >+ (*y)[0][3] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[1][3] = modf(x[1][3], &buffer); >+ if (y != null) >+ (*y)[1][3] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[2][2] = modf(x[2][2], &buffer); >+ if (y != null) >+ (*y)[2][2] = buffer; >+ result[2][3] = modf(x[2][3], &buffer); >+ if (y != null) >+ (*y)[2][3] = buffer; >+ return result; >+} >+half4x2 modf(half4x2 x, device half4x2* y) { >+ half4x2 result; >+ half buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[3][0] = modf(x[3][0], &buffer); >+ if (y != null) >+ (*y)[3][0] = buffer; >+ result[3][1] = modf(x[3][1], &buffer); >+ if (y != null) >+ (*y)[3][1] = buffer; >+ return result; >+} >+half4x3 modf(half4x3 x, device half4x3* y) { >+ half4x3 result; >+ half buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[2][2] = modf(x[2][2], &buffer); >+ if (y != null) >+ (*y)[2][2] = buffer; >+ result[3][0] = modf(x[3][0], &buffer); >+ if (y != null) >+ (*y)[3][0] = buffer; >+ result[3][1] = modf(x[3][1], &buffer); >+ if (y != null) >+ (*y)[3][1] = buffer; >+ result[3][2] = modf(x[3][2], &buffer); >+ if (y != null) >+ (*y)[3][2] = buffer; >+ return result; >+} >+half4x4 modf(half4x4 x, device half4x4* y) { >+ half4x4 result; >+ half buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[0][3] = modf(x[0][3], &buffer); >+ if (y != null) >+ (*y)[0][3] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[1][3] = modf(x[1][3], &buffer); >+ if (y != null) >+ (*y)[1][3] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[2][2] = modf(x[2][2], &buffer); >+ if (y != null) >+ (*y)[2][2] = buffer; >+ result[2][3] = modf(x[2][3], &buffer); >+ if (y != null) >+ (*y)[2][3] = buffer; >+ result[3][0] = modf(x[3][0], &buffer); >+ if (y != null) >+ (*y)[3][0] = buffer; >+ result[3][1] = modf(x[3][1], &buffer); >+ if (y != null) >+ (*y)[3][1] = buffer; >+ result[3][2] = modf(x[3][2], &buffer); >+ if (y != null) >+ (*y)[3][2] = buffer; >+ result[3][3] = modf(x[3][3], &buffer); >+ if (y != null) >+ (*y)[3][3] = buffer; >+ return result; >+} >+ >+float modf(float x, device float* ip) { >+ uint result = uint(x); >+ if (ip != null) >+ *ip = x - float(result); >+ return float(result); >+} >+float2 modf(float2 x, device float2* y) { >+ float2 result; >+ float buffer; >+ result[0] = modf(x[0], &buffer); >+ if (y != null) >+ (*y)[0] = buffer; >+ result[1] = modf(x[1], &buffer); >+ if (y != null) >+ (*y)[1] = buffer; >+ return result; >+} >+float3 modf(float3 x, device float3* y) { >+ float3 result; >+ float buffer; >+ result[0] = modf(x[0], &buffer); >+ if (y != null) >+ (*y)[0] = buffer; >+ result[1] = modf(x[1], &buffer); >+ if (y != null) >+ (*y)[1] = buffer; >+ result[2] = modf(x[2], &buffer); >+ if (y != null) >+ (*y)[2] = buffer; >+ return result; >+} >+float4 modf(float4 x, device float4* y) { >+ float4 result; >+ float buffer; >+ result[0] = modf(x[0], &buffer); >+ if (y != null) >+ (*y)[0] = buffer; >+ result[1] = modf(x[1], &buffer); >+ if (y != null) >+ (*y)[1] = buffer; >+ result[2] = modf(x[2], &buffer); >+ if (y != null) >+ (*y)[2] = buffer; >+ result[3] = modf(x[3], &buffer); >+ if (y != null) >+ (*y)[3] = buffer; >+ return result; >+} >+float2x2 modf(float2x2 x, device float2x2* y) { >+ float2x2 result; >+ float buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ return result; >+} >+float2x3 modf(float2x3 x, device float2x3* y) { >+ float2x3 result; >+ float buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ return result; >+} >+float2x4 modf(float2x4 x, device float2x4* y) { >+ float2x4 result; >+ float buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[0][3] = modf(x[0][3], &buffer); >+ if (y != null) >+ (*y)[0][3] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[1][3] = modf(x[1][3], &buffer); >+ if (y != null) >+ (*y)[1][3] = buffer; >+ return result; >+} >+float3x2 modf(float3x2 x, device float3x2* y) { >+ float3x2 result; >+ float buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ return result; >+} >+float3x3 modf(float3x3 x, device float3x3* y) { >+ float3x3 result; >+ float buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[2][2] = modf(x[2][2], &buffer); >+ if (y != null) >+ (*y)[2][2] = buffer; >+ return result; >+} >+float3x4 modf(float3x4 x, device float3x4* y) { >+ float3x4 result; >+ float buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[0][3] = modf(x[0][3], &buffer); >+ if (y != null) >+ (*y)[0][3] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[1][3] = modf(x[1][3], &buffer); >+ if (y != null) >+ (*y)[1][3] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[2][2] = modf(x[2][2], &buffer); >+ if (y != null) >+ (*y)[2][2] = buffer; >+ result[2][3] = modf(x[2][3], &buffer); >+ if (y != null) >+ (*y)[2][3] = buffer; >+ return result; >+} >+float4x2 modf(float4x2 x, device float4x2* y) { >+ float4x2 result; >+ float buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[3][0] = modf(x[3][0], &buffer); >+ if (y != null) >+ (*y)[3][0] = buffer; >+ result[3][1] = modf(x[3][1], &buffer); >+ if (y != null) >+ (*y)[3][1] = buffer; >+ return result; >+} >+float4x3 modf(float4x3 x, device float4x3* y) { >+ float4x3 result; >+ float buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[2][2] = modf(x[2][2], &buffer); >+ if (y != null) >+ (*y)[2][2] = buffer; >+ result[3][0] = modf(x[3][0], &buffer); >+ if (y != null) >+ (*y)[3][0] = buffer; >+ result[3][1] = modf(x[3][1], &buffer); >+ if (y != null) >+ (*y)[3][1] = buffer; >+ result[3][2] = modf(x[3][2], &buffer); >+ if (y != null) >+ (*y)[3][2] = buffer; >+ return result; >+} >+float4x4 modf(float4x4 x, device float4x4* y) { >+ float4x4 result; >+ float buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[0][3] = modf(x[0][3], &buffer); >+ if (y != null) >+ (*y)[0][3] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[1][3] = modf(x[1][3], &buffer); >+ if (y != null) >+ (*y)[1][3] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[2][2] = modf(x[2][2], &buffer); >+ if (y != null) >+ (*y)[2][2] = buffer; >+ result[2][3] = modf(x[2][3], &buffer); >+ if (y != null) >+ (*y)[2][3] = buffer; >+ result[3][0] = modf(x[3][0], &buffer); >+ if (y != null) >+ (*y)[3][0] = buffer; >+ result[3][1] = modf(x[3][1], &buffer); >+ if (y != null) >+ (*y)[3][1] = buffer; >+ result[3][2] = modf(x[3][2], &buffer); >+ if (y != null) >+ (*y)[3][2] = buffer; >+ result[3][3] = modf(x[3][3], &buffer); >+ if (y != null) >+ (*y)[3][3] = buffer; >+ return result; >+} >+ >+half modf(half x, threadgroup half* ip) { >+ uint result = uint(x); >+ if (ip != null) >+ *ip = x - half(result); >+ return half(result); >+} >+half2 modf(half2 x, threadgroup half2* y) { >+ half2 result; >+ half buffer; >+ result[0] = modf(x[0], &buffer); >+ if (y != null) >+ (*y)[0] = buffer; >+ result[1] = modf(x[1], &buffer); >+ if (y != null) >+ (*y)[1] = buffer; >+ return result; >+} >+half3 modf(half3 x, threadgroup half3* y) { >+ half3 result; >+ half buffer; >+ result[0] = modf(x[0], &buffer); >+ if (y != null) >+ (*y)[0] = buffer; >+ result[1] = modf(x[1], &buffer); >+ if (y != null) >+ (*y)[1] = buffer; >+ result[2] = modf(x[2], &buffer); >+ if (y != null) >+ (*y)[2] = buffer; >+ return result; >+} >+half4 modf(half4 x, threadgroup half4* y) { >+ half4 result; >+ half buffer; >+ result[0] = modf(x[0], &buffer); >+ if (y != null) >+ (*y)[0] = buffer; >+ result[1] = modf(x[1], &buffer); >+ if (y != null) >+ (*y)[1] = buffer; >+ result[2] = modf(x[2], &buffer); >+ if (y != null) >+ (*y)[2] = buffer; >+ result[3] = modf(x[3], &buffer); >+ if (y != null) >+ (*y)[3] = buffer; >+ return result; >+} >+half2x2 modf(half2x2 x, threadgroup half2x2* y) { >+ half2x2 result; >+ half buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ return result; >+} >+half2x3 modf(half2x3 x, threadgroup half2x3* y) { >+ half2x3 result; >+ half buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ return result; >+} >+half2x4 modf(half2x4 x, threadgroup half2x4* y) { >+ half2x4 result; >+ half buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[0][3] = modf(x[0][3], &buffer); >+ if (y != null) >+ (*y)[0][3] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[1][3] = modf(x[1][3], &buffer); >+ if (y != null) >+ (*y)[1][3] = buffer; >+ return result; >+} >+half3x2 modf(half3x2 x, threadgroup half3x2* y) { >+ half3x2 result; >+ half buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ return result; >+} >+half3x3 modf(half3x3 x, threadgroup half3x3* y) { >+ half3x3 result; >+ half buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[2][2] = modf(x[2][2], &buffer); >+ if (y != null) >+ (*y)[2][2] = buffer; >+ return result; >+} >+half3x4 modf(half3x4 x, threadgroup half3x4* y) { >+ half3x4 result; >+ half buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[0][3] = modf(x[0][3], &buffer); >+ if (y != null) >+ (*y)[0][3] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[1][3] = modf(x[1][3], &buffer); >+ if (y != null) >+ (*y)[1][3] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[2][2] = modf(x[2][2], &buffer); >+ if (y != null) >+ (*y)[2][2] = buffer; >+ result[2][3] = modf(x[2][3], &buffer); >+ if (y != null) >+ (*y)[2][3] = buffer; >+ return result; >+} >+half4x2 modf(half4x2 x, threadgroup half4x2* y) { >+ half4x2 result; >+ half buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[3][0] = modf(x[3][0], &buffer); >+ if (y != null) >+ (*y)[3][0] = buffer; >+ result[3][1] = modf(x[3][1], &buffer); >+ if (y != null) >+ (*y)[3][1] = buffer; >+ return result; >+} >+half4x3 modf(half4x3 x, threadgroup half4x3* y) { >+ half4x3 result; >+ half buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[2][2] = modf(x[2][2], &buffer); >+ if (y != null) >+ (*y)[2][2] = buffer; >+ result[3][0] = modf(x[3][0], &buffer); >+ if (y != null) >+ (*y)[3][0] = buffer; >+ result[3][1] = modf(x[3][1], &buffer); >+ if (y != null) >+ (*y)[3][1] = buffer; >+ result[3][2] = modf(x[3][2], &buffer); >+ if (y != null) >+ (*y)[3][2] = buffer; >+ return result; >+} >+half4x4 modf(half4x4 x, threadgroup half4x4* y) { >+ half4x4 result; >+ half buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[0][3] = modf(x[0][3], &buffer); >+ if (y != null) >+ (*y)[0][3] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[1][3] = modf(x[1][3], &buffer); >+ if (y != null) >+ (*y)[1][3] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[2][2] = modf(x[2][2], &buffer); >+ if (y != null) >+ (*y)[2][2] = buffer; >+ result[2][3] = modf(x[2][3], &buffer); >+ if (y != null) >+ (*y)[2][3] = buffer; >+ result[3][0] = modf(x[3][0], &buffer); >+ if (y != null) >+ (*y)[3][0] = buffer; >+ result[3][1] = modf(x[3][1], &buffer); >+ if (y != null) >+ (*y)[3][1] = buffer; >+ result[3][2] = modf(x[3][2], &buffer); >+ if (y != null) >+ (*y)[3][2] = buffer; >+ result[3][3] = modf(x[3][3], &buffer); >+ if (y != null) >+ (*y)[3][3] = buffer; >+ return result; >+} >+ >+float modf(float x, threadgroup float* ip) { >+ uint result = uint(x); >+ if (ip != null) >+ *ip = x - float(result); >+ return float(result); >+} >+float2 modf(float2 x, threadgroup float2* y) { >+ float2 result; >+ float buffer; >+ result[0] = modf(x[0], &buffer); >+ if (y != null) >+ (*y)[0] = buffer; >+ result[1] = modf(x[1], &buffer); >+ if (y != null) >+ (*y)[1] = buffer; >+ return result; >+} >+float3 modf(float3 x, threadgroup float3* y) { >+ float3 result; >+ float buffer; >+ result[0] = modf(x[0], &buffer); >+ if (y != null) >+ (*y)[0] = buffer; >+ result[1] = modf(x[1], &buffer); >+ if (y != null) >+ (*y)[1] = buffer; >+ result[2] = modf(x[2], &buffer); >+ if (y != null) >+ (*y)[2] = buffer; >+ return result; >+} >+float4 modf(float4 x, threadgroup float4* y) { >+ float4 result; >+ float buffer; >+ result[0] = modf(x[0], &buffer); >+ if (y != null) >+ (*y)[0] = buffer; >+ result[1] = modf(x[1], &buffer); >+ if (y != null) >+ (*y)[1] = buffer; >+ result[2] = modf(x[2], &buffer); >+ if (y != null) >+ (*y)[2] = buffer; >+ result[3] = modf(x[3], &buffer); >+ if (y != null) >+ (*y)[3] = buffer; >+ return result; >+} >+float2x2 modf(float2x2 x, threadgroup float2x2* y) { >+ float2x2 result; >+ float buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ return result; >+} >+float2x3 modf(float2x3 x, threadgroup float2x3* y) { >+ float2x3 result; >+ float buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ return result; >+} >+float2x4 modf(float2x4 x, threadgroup float2x4* y) { >+ float2x4 result; >+ float buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[0][3] = modf(x[0][3], &buffer); >+ if (y != null) >+ (*y)[0][3] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[1][3] = modf(x[1][3], &buffer); >+ if (y != null) >+ (*y)[1][3] = buffer; >+ return result; >+} >+float3x2 modf(float3x2 x, threadgroup float3x2* y) { >+ float3x2 result; >+ float buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ return result; >+} >+float3x3 modf(float3x3 x, threadgroup float3x3* y) { >+ float3x3 result; >+ float buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[2][2] = modf(x[2][2], &buffer); >+ if (y != null) >+ (*y)[2][2] = buffer; >+ return result; >+} >+float3x4 modf(float3x4 x, threadgroup float3x4* y) { >+ float3x4 result; >+ float buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[0][3] = modf(x[0][3], &buffer); >+ if (y != null) >+ (*y)[0][3] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[1][3] = modf(x[1][3], &buffer); >+ if (y != null) >+ (*y)[1][3] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[2][2] = modf(x[2][2], &buffer); >+ if (y != null) >+ (*y)[2][2] = buffer; >+ result[2][3] = modf(x[2][3], &buffer); >+ if (y != null) >+ (*y)[2][3] = buffer; >+ return result; >+} >+float4x2 modf(float4x2 x, threadgroup float4x2* y) { >+ float4x2 result; >+ float buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[3][0] = modf(x[3][0], &buffer); >+ if (y != null) >+ (*y)[3][0] = buffer; >+ result[3][1] = modf(x[3][1], &buffer); >+ if (y != null) >+ (*y)[3][1] = buffer; >+ return result; >+} >+float4x3 modf(float4x3 x, threadgroup float4x3* y) { >+ float4x3 result; >+ float buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[2][2] = modf(x[2][2], &buffer); >+ if (y != null) >+ (*y)[2][2] = buffer; >+ result[3][0] = modf(x[3][0], &buffer); >+ if (y != null) >+ (*y)[3][0] = buffer; >+ result[3][1] = modf(x[3][1], &buffer); >+ if (y != null) >+ (*y)[3][1] = buffer; >+ result[3][2] = modf(x[3][2], &buffer); >+ if (y != null) >+ (*y)[3][2] = buffer; >+ return result; >+} >+float4x4 modf(float4x4 x, threadgroup float4x4* y) { >+ float4x4 result; >+ float buffer; >+ result[0][0] = modf(x[0][0], &buffer); >+ if (y != null) >+ (*y)[0][0] = buffer; >+ result[0][1] = modf(x[0][1], &buffer); >+ if (y != null) >+ (*y)[0][1] = buffer; >+ result[0][2] = modf(x[0][2], &buffer); >+ if (y != null) >+ (*y)[0][2] = buffer; >+ result[0][3] = modf(x[0][3], &buffer); >+ if (y != null) >+ (*y)[0][3] = buffer; >+ result[1][0] = modf(x[1][0], &buffer); >+ if (y != null) >+ (*y)[1][0] = buffer; >+ result[1][1] = modf(x[1][1], &buffer); >+ if (y != null) >+ (*y)[1][1] = buffer; >+ result[1][2] = modf(x[1][2], &buffer); >+ if (y != null) >+ (*y)[1][2] = buffer; >+ result[1][3] = modf(x[1][3], &buffer); >+ if (y != null) >+ (*y)[1][3] = buffer; >+ result[2][0] = modf(x[2][0], &buffer); >+ if (y != null) >+ (*y)[2][0] = buffer; >+ result[2][1] = modf(x[2][1], &buffer); >+ if (y != null) >+ (*y)[2][1] = buffer; >+ result[2][2] = modf(x[2][2], &buffer); >+ if (y != null) >+ (*y)[2][2] = buffer; >+ result[2][3] = modf(x[2][3], &buffer); >+ if (y != null) >+ (*y)[2][3] = buffer; >+ result[3][0] = modf(x[3][0], &buffer); >+ if (y != null) >+ (*y)[3][0] = buffer; >+ result[3][1] = modf(x[3][1], &buffer); >+ if (y != null) >+ (*y)[3][1] = buffer; >+ result[3][2] = modf(x[3][2], &buffer); >+ if (y != null) >+ (*y)[3][2] = buffer; >+ result[3][3] = modf(x[3][3], &buffer); >+ if (y != null) >+ (*y)[3][3] = buffer; >+ return result; >+} >+ >+uchar count_bits(uchar x) { >+ return uchar(((x | uchar(1 << 0)) == 0 ? 0 : 1) + >+ ((x | uchar(1 << 1)) == 0 ? 0 : 1) + >+ ((x | uchar(1 << 2)) == 0 ? 0 : 1) + >+ ((x | uchar(1 << 3)) == 0 ? 0 : 1) + >+ ((x | uchar(1 << 4)) == 0 ? 0 : 1) + >+ ((x | uchar(1 << 5)) == 0 ? 0 : 1) + >+ ((x | uchar(1 << 6)) == 0 ? 0 : 1) + >+ ((x | uchar(1 << 7)) == 0 ? 0 : 1)); >+} >+uchar count_bits(ushort x) { >+ return uchar(((x | ushort(1 << 0)) == 0 ? 0 : 1) + >+ ((x | ushort(1 << 1)) == 0 ? 0 : 1) + >+ ((x | ushort(1 << 2)) == 0 ? 0 : 1) + >+ ((x | ushort(1 << 3)) == 0 ? 0 : 1) + >+ ((x | ushort(1 << 4)) == 0 ? 0 : 1) + >+ ((x | ushort(1 << 5)) == 0 ? 0 : 1) + >+ ((x | ushort(1 << 6)) == 0 ? 0 : 1) + >+ ((x | ushort(1 << 7)) == 0 ? 0 : 1) + >+ ((x | ushort(1 << 8)) == 0 ? 0 : 1) + >+ ((x | ushort(1 << 9)) == 0 ? 0 : 1) + >+ ((x | ushort(1 << 10)) == 0 ? 0 : 1) + >+ ((x | ushort(1 << 11)) == 0 ? 0 : 1) + >+ ((x | ushort(1 << 12)) == 0 ? 0 : 1) + >+ ((x | ushort(1 << 13)) == 0 ? 0 : 1) + >+ ((x | ushort(1 << 14)) == 0 ? 0 : 1) + >+ ((x | ushort(1 << 15)) == 0 ? 0 : 1)); >+} >+uchar count_bits(uint x) { >+ return uchar(((x | uint(1 << 0)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 1)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 2)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 3)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 4)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 5)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 6)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 7)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 8)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 9)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 10)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 11)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 12)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 13)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 14)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 15)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 16)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 17)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 18)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 19)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 20)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 21)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 22)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 23)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 24)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 25)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 26)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 27)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 28)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 29)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 30)) == 0 ? 0 : 1) + >+ ((x | uint(1 << 31)) == 0 ? 0 : 1)); >+} >+uchar reversebits(uchar x) { >+ return uchar(((x & uchar(1 << 0)) << 7) | >+ ((x & uchar(1 << 1)) << 5) | >+ ((x & uchar(1 << 2)) << 3) | >+ ((x & uchar(1 << 3)) << 1) | >+ ((x & uchar(1 << 4)) >> 1) | >+ ((x & uchar(1 << 5)) >> 3) | >+ ((x & uchar(1 << 6)) >> 5) | >+ ((x & uchar(1 << 7)) >> 7)); >+} >+ushort reversebits(ushort x) { >+ return ushort(((x & ushort(1 << 0)) << 15) | >+ ((x & ushort(1 << 1)) << 13) | >+ ((x & ushort(1 << 2)) << 11) | >+ ((x & ushort(1 << 3)) << 9) | >+ ((x & ushort(1 << 4)) << 7) | >+ ((x & ushort(1 << 5)) << 5) | >+ ((x & ushort(1 << 6)) << 3) | >+ ((x & ushort(1 << 7)) << 1) | >+ ((x & ushort(1 << 8)) >> 1) | >+ ((x & ushort(1 << 9)) >> 3) | >+ ((x & ushort(1 << 10)) >> 5) | >+ ((x & ushort(1 << 11)) >> 7) | >+ ((x & ushort(1 << 12)) >> 9) | >+ ((x & ushort(1 << 13)) >> 11) | >+ ((x & ushort(1 << 14)) >> 13) | >+ ((x & ushort(1 << 15)) >> 15)); >+} >+uint reversebits(uint x) { >+ return uint(((x & uint(1 << 0)) << 31) | >+ ((x & uint(1 << 1)) << 29) | >+ ((x & uint(1 << 2)) << 27) | >+ ((x & uint(1 << 3)) << 25) | >+ ((x & uint(1 << 4)) << 23) | >+ ((x & uint(1 << 5)) << 21) | >+ ((x & uint(1 << 6)) << 19) | >+ ((x & uint(1 << 7)) << 17) | >+ ((x & uint(1 << 8)) << 15) | >+ ((x & uint(1 << 9)) << 13) | >+ ((x & uint(1 << 10)) << 11) | >+ ((x & uint(1 << 11)) << 9) | >+ ((x & uint(1 << 12)) << 7) | >+ ((x & uint(1 << 13)) << 5) | >+ ((x & uint(1 << 14)) << 3) | >+ ((x & uint(1 << 15)) << 1) | >+ ((x & uint(1 << 16)) >> 1) | >+ ((x & uint(1 << 17)) >> 3) | >+ ((x & uint(1 << 18)) >> 5) | >+ ((x & uint(1 << 19)) >> 7) | >+ ((x & uint(1 << 20)) >> 9) | >+ ((x & uint(1 << 21)) >> 11) | >+ ((x & uint(1 << 22)) >> 13) | >+ ((x & uint(1 << 23)) >> 15) | >+ ((x & uint(1 << 24)) >> 17) | >+ ((x & uint(1 << 25)) >> 19) | >+ ((x & uint(1 << 26)) >> 21) | >+ ((x & uint(1 << 27)) >> 23) | >+ ((x & uint(1 << 28)) >> 25) | >+ ((x & uint(1 << 29)) >> 27) | >+ ((x & uint(1 << 30)) >> 29) | >+ ((x & uint(1 << 31)) >> 31)); >+} >+uchar2 count_bits(uchar2 x) { >+ uchar2 result; >+ result[0] = count_bits(x[0]); >+ result[1] = count_bits(x[1]); >+ return result; >+} >+uchar3 count_bits(uchar3 x) { >+ uchar3 result; >+ result[0] = count_bits(x[0]); >+ result[1] = count_bits(x[1]); >+ result[2] = count_bits(x[2]); >+ return result; >+} >+uchar4 count_bits(uchar4 x) { >+ uchar4 result; >+ result[0] = count_bits(x[0]); >+ result[1] = count_bits(x[1]); >+ result[2] = count_bits(x[2]); >+ result[3] = count_bits(x[3]); >+ return result; >+} >+uchar2 count_bits(ushort2 x) { >+ uchar2 result; >+ result[0] = count_bits(x[0]); >+ result[1] = count_bits(x[1]); >+ return result; >+} >+uchar3 count_bits(ushort3 x) { >+ uchar3 result; >+ result[0] = count_bits(x[0]); >+ result[1] = count_bits(x[1]); >+ result[2] = count_bits(x[2]); >+ return result; >+} >+uchar4 count_bits(ushort4 x) { >+ uchar4 result; >+ result[0] = count_bits(x[0]); >+ result[1] = count_bits(x[1]); >+ result[2] = count_bits(x[2]); >+ result[3] = count_bits(x[3]); >+ return result; >+} >+uchar2 count_bits(uint2 x) { >+ uchar2 result; >+ result[0] = count_bits(x[0]); >+ result[1] = count_bits(x[1]); >+ return result; >+} >+uchar3 count_bits(uint3 x) { >+ uchar3 result; >+ result[0] = count_bits(x[0]); >+ result[1] = count_bits(x[1]); >+ result[2] = count_bits(x[2]); >+ return result; >+} >+uchar4 count_bits(uint4 x) { >+ uchar4 result; >+ result[0] = count_bits(x[0]); >+ result[1] = count_bits(x[1]); >+ result[2] = count_bits(x[2]); >+ result[3] = count_bits(x[3]); >+ return result; >+} >+uchar2 reversebits(uchar2 x) { >+ uchar2 result; >+ result[0] = reversebits(x[0]); >+ result[1] = reversebits(x[1]); >+ return result; >+} >+uchar3 reversebits(uchar3 x) { >+ uchar3 result; >+ result[0] = reversebits(x[0]); >+ result[1] = reversebits(x[1]); >+ result[2] = reversebits(x[2]); >+ return result; >+} >+uchar4 reversebits(uchar4 x) { >+ uchar4 result; >+ result[0] = reversebits(x[0]); >+ result[1] = reversebits(x[1]); >+ result[2] = reversebits(x[2]); >+ result[3] = reversebits(x[3]); >+ return result; >+} >+ushort2 reversebits(ushort2 x) { >+ ushort2 result; >+ result[0] = reversebits(x[0]); >+ result[1] = reversebits(x[1]); >+ return result; >+} >+ushort3 reversebits(ushort3 x) { >+ ushort3 result; >+ result[0] = reversebits(x[0]); >+ result[1] = reversebits(x[1]); >+ result[2] = reversebits(x[2]); >+ return result; >+} >+ushort4 reversebits(ushort4 x) { >+ ushort4 result; >+ result[0] = reversebits(x[0]); >+ result[1] = reversebits(x[1]); >+ result[2] = reversebits(x[2]); >+ result[3] = reversebits(x[3]); >+ return result; >+} >+uint2 reversebits(uint2 x) { >+ uint2 result; >+ result[0] = reversebits(x[0]); >+ result[1] = reversebits(x[1]); >+ return result; >+} >+uint3 reversebits(uint3 x) { >+ uint3 result; >+ result[0] = reversebits(x[0]); >+ result[1] = reversebits(x[1]); >+ result[2] = reversebits(x[2]); >+ return result; >+} >+uint4 reversebits(uint4 x) { >+ uint4 result; >+ result[0] = reversebits(x[0]); >+ result[1] = reversebits(x[1]); >+ result[2] = reversebits(x[2]); >+ result[3] = reversebits(x[3]); >+ return result; >+} >+ >+uint firstbithigh(uchar x) { >+ if ((x & uchar(1 << 7)) != 0) >+ return 0; >+ if ((x & uchar(1 << 6)) != 0) >+ return 1; >+ if ((x & uchar(1 << 5)) != 0) >+ return 2; >+ if ((x & uchar(1 << 4)) != 0) >+ return 3; >+ if ((x & uchar(1 << 3)) != 0) >+ return 4; >+ if ((x & uchar(1 << 2)) != 0) >+ return 5; >+ if ((x & uchar(1 << 1)) != 0) >+ return 6; >+ if ((x & uchar(1 << 0)) != 0) >+ return 7; >+ return 8; >+} >+uint firstbithigh(ushort x) { >+ if ((x & ushort(1 << 15)) != 0) >+ return 0; >+ if ((x & ushort(1 << 14)) != 0) >+ return 1; >+ if ((x & ushort(1 << 13)) != 0) >+ return 2; >+ if ((x & ushort(1 << 12)) != 0) >+ return 3; >+ if ((x & ushort(1 << 11)) != 0) >+ return 4; >+ if ((x & ushort(1 << 10)) != 0) >+ return 5; >+ if ((x & ushort(1 << 9)) != 0) >+ return 6; >+ if ((x & ushort(1 << 8)) != 0) >+ return 7; >+ if ((x & ushort(1 << 7)) != 0) >+ return 8; >+ if ((x & ushort(1 << 6)) != 0) >+ return 9; >+ if ((x & ushort(1 << 5)) != 0) >+ return 10; >+ if ((x & ushort(1 << 4)) != 0) >+ return 11; >+ if ((x & ushort(1 << 3)) != 0) >+ return 12; >+ if ((x & ushort(1 << 2)) != 0) >+ return 13; >+ if ((x & ushort(1 << 1)) != 0) >+ return 14; >+ if ((x & ushort(1 << 0)) != 0) >+ return 15; >+ return 16; >+} >+uint firstbithigh(uint x) { >+ if ((x & uint(1 << 31)) != 0) >+ return 0; >+ if ((x & uint(1 << 30)) != 0) >+ return 1; >+ if ((x & uint(1 << 29)) != 0) >+ return 2; >+ if ((x & uint(1 << 28)) != 0) >+ return 3; >+ if ((x & uint(1 << 27)) != 0) >+ return 4; >+ if ((x & uint(1 << 26)) != 0) >+ return 5; >+ if ((x & uint(1 << 25)) != 0) >+ return 6; >+ if ((x & uint(1 << 24)) != 0) >+ return 7; >+ if ((x & uint(1 << 23)) != 0) >+ return 8; >+ if ((x & uint(1 << 22)) != 0) >+ return 9; >+ if ((x & uint(1 << 21)) != 0) >+ return 10; >+ if ((x & uint(1 << 20)) != 0) >+ return 11; >+ if ((x & uint(1 << 19)) != 0) >+ return 12; >+ if ((x & uint(1 << 18)) != 0) >+ return 13; >+ if ((x & uint(1 << 17)) != 0) >+ return 14; >+ if ((x & uint(1 << 16)) != 0) >+ return 15; >+ if ((x & uint(1 << 15)) != 0) >+ return 16; >+ if ((x & uint(1 << 14)) != 0) >+ return 17; >+ if ((x & uint(1 << 13)) != 0) >+ return 18; >+ if ((x & uint(1 << 12)) != 0) >+ return 19; >+ if ((x & uint(1 << 11)) != 0) >+ return 20; >+ if ((x & uint(1 << 10)) != 0) >+ return 21; >+ if ((x & uint(1 << 9)) != 0) >+ return 22; >+ if ((x & uint(1 << 8)) != 0) >+ return 23; >+ if ((x & uint(1 << 7)) != 0) >+ return 24; >+ if ((x & uint(1 << 6)) != 0) >+ return 25; >+ if ((x & uint(1 << 5)) != 0) >+ return 26; >+ if ((x & uint(1 << 4)) != 0) >+ return 27; >+ if ((x & uint(1 << 3)) != 0) >+ return 28; >+ if ((x & uint(1 << 2)) != 0) >+ return 29; >+ if ((x & uint(1 << 1)) != 0) >+ return 30; >+ if ((x & uint(1 << 0)) != 0) >+ return 31; >+ return 32; >+} >+uint firstbithigh(char x) { >+ return firstbithigh(uchar(x)); >+} >+uint firstbithigh(short x) { >+ return firstbithigh(ushort(x)); >+} >+uint firstbithigh(int x) { >+ return firstbithigh(uint(x)); >+} >+uint firstbitlow(uchar x) { >+ if ((x & uchar(1 << 0)) != 0) >+ return 7; >+ if ((x & uchar(1 << 1)) != 0) >+ return 6; >+ if ((x & uchar(1 << 2)) != 0) >+ return 5; >+ if ((x & uchar(1 << 3)) != 0) >+ return 4; >+ if ((x & uchar(1 << 4)) != 0) >+ return 3; >+ if ((x & uchar(1 << 5)) != 0) >+ return 2; >+ if ((x & uchar(1 << 6)) != 0) >+ return 1; >+ if ((x & uchar(1 << 7)) != 0) >+ return 0; >+ return 8; >+} >+uint firstbitlow(ushort x) { >+ if ((x & ushort(1 << 0)) != 0) >+ return 15; >+ if ((x & ushort(1 << 1)) != 0) >+ return 14; >+ if ((x & ushort(1 << 2)) != 0) >+ return 13; >+ if ((x & ushort(1 << 3)) != 0) >+ return 12; >+ if ((x & ushort(1 << 4)) != 0) >+ return 11; >+ if ((x & ushort(1 << 5)) != 0) >+ return 10; >+ if ((x & ushort(1 << 6)) != 0) >+ return 9; >+ if ((x & ushort(1 << 7)) != 0) >+ return 8; >+ if ((x & ushort(1 << 8)) != 0) >+ return 7; >+ if ((x & ushort(1 << 9)) != 0) >+ return 6; >+ if ((x & ushort(1 << 10)) != 0) >+ return 5; >+ if ((x & ushort(1 << 11)) != 0) >+ return 4; >+ if ((x & ushort(1 << 12)) != 0) >+ return 3; >+ if ((x & ushort(1 << 13)) != 0) >+ return 2; >+ if ((x & ushort(1 << 14)) != 0) >+ return 1; >+ if ((x & ushort(1 << 15)) != 0) >+ return 0; >+ return 16; >+} >+uint firstbitlow(uint x) { >+ if ((x & uint(1 << 0)) != 0) >+ return 31; >+ if ((x & uint(1 << 1)) != 0) >+ return 30; >+ if ((x & uint(1 << 2)) != 0) >+ return 29; >+ if ((x & uint(1 << 3)) != 0) >+ return 28; >+ if ((x & uint(1 << 4)) != 0) >+ return 27; >+ if ((x & uint(1 << 5)) != 0) >+ return 26; >+ if ((x & uint(1 << 6)) != 0) >+ return 25; >+ if ((x & uint(1 << 7)) != 0) >+ return 24; >+ if ((x & uint(1 << 8)) != 0) >+ return 23; >+ if ((x & uint(1 << 9)) != 0) >+ return 22; >+ if ((x & uint(1 << 10)) != 0) >+ return 21; >+ if ((x & uint(1 << 11)) != 0) >+ return 20; >+ if ((x & uint(1 << 12)) != 0) >+ return 19; >+ if ((x & uint(1 << 13)) != 0) >+ return 18; >+ if ((x & uint(1 << 14)) != 0) >+ return 17; >+ if ((x & uint(1 << 15)) != 0) >+ return 16; >+ if ((x & uint(1 << 16)) != 0) >+ return 15; >+ if ((x & uint(1 << 17)) != 0) >+ return 14; >+ if ((x & uint(1 << 18)) != 0) >+ return 13; >+ if ((x & uint(1 << 19)) != 0) >+ return 12; >+ if ((x & uint(1 << 20)) != 0) >+ return 11; >+ if ((x & uint(1 << 21)) != 0) >+ return 10; >+ if ((x & uint(1 << 22)) != 0) >+ return 9; >+ if ((x & uint(1 << 23)) != 0) >+ return 8; >+ if ((x & uint(1 << 24)) != 0) >+ return 7; >+ if ((x & uint(1 << 25)) != 0) >+ return 6; >+ if ((x & uint(1 << 26)) != 0) >+ return 5; >+ if ((x & uint(1 << 27)) != 0) >+ return 4; >+ if ((x & uint(1 << 28)) != 0) >+ return 3; >+ if ((x & uint(1 << 29)) != 0) >+ return 2; >+ if ((x & uint(1 << 30)) != 0) >+ return 1; >+ if ((x & uint(1 << 31)) != 0) >+ return 0; >+ return 32; >+} >+uint firstbitlow(char x) { >+ return firstbitlow(uchar(x)); >+} >+uint firstbitlow(short x) { >+ return firstbitlow(ushort(x)); >+} >+uint firstbitlow(int x) { >+ return firstbitlow(uint(x)); >+} >+uint2 firstbithigh(uchar2 x) { >+ uint2 result; >+ result[0] = firstbithigh(x[0]); >+ result[1] = firstbithigh(x[1]); >+ return result; >+} >+uint3 firstbithigh(uchar3 x) { >+ uint3 result; >+ result[0] = firstbithigh(x[0]); >+ result[1] = firstbithigh(x[1]); >+ result[2] = firstbithigh(x[2]); >+ return result; >+} >+uint4 firstbithigh(uchar4 x) { >+ uint4 result; >+ result[0] = firstbithigh(x[0]); >+ result[1] = firstbithigh(x[1]); >+ result[2] = firstbithigh(x[2]); >+ result[3] = firstbithigh(x[3]); >+ return result; >+} >+uint2 firstbithigh(ushort2 x) { >+ uint2 result; >+ result[0] = firstbithigh(x[0]); >+ result[1] = firstbithigh(x[1]); >+ return result; >+} >+uint3 firstbithigh(ushort3 x) { >+ uint3 result; >+ result[0] = firstbithigh(x[0]); >+ result[1] = firstbithigh(x[1]); >+ result[2] = firstbithigh(x[2]); >+ return result; >+} >+uint4 firstbithigh(ushort4 x) { >+ uint4 result; >+ result[0] = firstbithigh(x[0]); >+ result[1] = firstbithigh(x[1]); >+ result[2] = firstbithigh(x[2]); >+ result[3] = firstbithigh(x[3]); >+ return result; >+} >+uint2 firstbithigh(uint2 x) { >+ uint2 result; >+ result[0] = firstbithigh(x[0]); >+ result[1] = firstbithigh(x[1]); >+ return result; >+} >+uint3 firstbithigh(uint3 x) { >+ uint3 result; >+ result[0] = firstbithigh(x[0]); >+ result[1] = firstbithigh(x[1]); >+ result[2] = firstbithigh(x[2]); >+ return result; >+} >+uint4 firstbithigh(uint4 x) { >+ uint4 result; >+ result[0] = firstbithigh(x[0]); >+ result[1] = firstbithigh(x[1]); >+ result[2] = firstbithigh(x[2]); >+ result[3] = firstbithigh(x[3]); >+ return result; >+} >+uint2 firstbithigh(char2 x) { >+ uint2 result; >+ result[0] = firstbithigh(x[0]); >+ result[1] = firstbithigh(x[1]); >+ return result; >+} >+uint3 firstbithigh(char3 x) { >+ uint3 result; >+ result[0] = firstbithigh(x[0]); >+ result[1] = firstbithigh(x[1]); >+ result[2] = firstbithigh(x[2]); >+ return result; >+} >+uint4 firstbithigh(char4 x) { >+ uint4 result; >+ result[0] = firstbithigh(x[0]); >+ result[1] = firstbithigh(x[1]); >+ result[2] = firstbithigh(x[2]); >+ result[3] = firstbithigh(x[3]); >+ return result; >+} >+uint2 firstbithigh(short2 x) { >+ uint2 result; >+ result[0] = firstbithigh(x[0]); >+ result[1] = firstbithigh(x[1]); >+ return result; >+} >+uint3 firstbithigh(short3 x) { >+ uint3 result; >+ result[0] = firstbithigh(x[0]); >+ result[1] = firstbithigh(x[1]); >+ result[2] = firstbithigh(x[2]); >+ return result; >+} >+uint4 firstbithigh(short4 x) { >+ uint4 result; >+ result[0] = firstbithigh(x[0]); >+ result[1] = firstbithigh(x[1]); >+ result[2] = firstbithigh(x[2]); >+ result[3] = firstbithigh(x[3]); >+ return result; >+} >+uint2 firstbithigh(int2 x) { >+ uint2 result; >+ result[0] = firstbithigh(x[0]); >+ result[1] = firstbithigh(x[1]); >+ return result; >+} >+uint3 firstbithigh(int3 x) { >+ uint3 result; >+ result[0] = firstbithigh(x[0]); >+ result[1] = firstbithigh(x[1]); >+ result[2] = firstbithigh(x[2]); >+ return result; >+} >+uint4 firstbithigh(int4 x) { >+ uint4 result; >+ result[0] = firstbithigh(x[0]); >+ result[1] = firstbithigh(x[1]); >+ result[2] = firstbithigh(x[2]); >+ result[3] = firstbithigh(x[3]); >+ return result; >+} >+uint2 firstbitlow(uchar2 x) { >+ uint2 result; >+ result[0] = firstbitlow(x[0]); >+ result[1] = firstbitlow(x[1]); >+ return result; >+} >+uint3 firstbitlow(uchar3 x) { >+ uint3 result; >+ result[0] = firstbitlow(x[0]); >+ result[1] = firstbitlow(x[1]); >+ result[2] = firstbitlow(x[2]); >+ return result; >+} >+uint4 firstbitlow(uchar4 x) { >+ uint4 result; >+ result[0] = firstbitlow(x[0]); >+ result[1] = firstbitlow(x[1]); >+ result[2] = firstbitlow(x[2]); >+ result[3] = firstbitlow(x[3]); >+ return result; >+} >+uint2 firstbitlow(ushort2 x) { >+ uint2 result; >+ result[0] = firstbitlow(x[0]); >+ result[1] = firstbitlow(x[1]); >+ return result; >+} >+uint3 firstbitlow(ushort3 x) { >+ uint3 result; >+ result[0] = firstbitlow(x[0]); >+ result[1] = firstbitlow(x[1]); >+ result[2] = firstbitlow(x[2]); >+ return result; >+} >+uint4 firstbitlow(ushort4 x) { >+ uint4 result; >+ result[0] = firstbitlow(x[0]); >+ result[1] = firstbitlow(x[1]); >+ result[2] = firstbitlow(x[2]); >+ result[3] = firstbitlow(x[3]); >+ return result; >+} >+uint2 firstbitlow(uint2 x) { >+ uint2 result; >+ result[0] = firstbitlow(x[0]); >+ result[1] = firstbitlow(x[1]); >+ return result; >+} >+uint3 firstbitlow(uint3 x) { >+ uint3 result; >+ result[0] = firstbitlow(x[0]); >+ result[1] = firstbitlow(x[1]); >+ result[2] = firstbitlow(x[2]); >+ return result; >+} >+uint4 firstbitlow(uint4 x) { >+ uint4 result; >+ result[0] = firstbitlow(x[0]); >+ result[1] = firstbitlow(x[1]); >+ result[2] = firstbitlow(x[2]); >+ result[3] = firstbitlow(x[3]); >+ return result; >+} >+uint2 firstbitlow(char2 x) { >+ uint2 result; >+ result[0] = firstbitlow(x[0]); >+ result[1] = firstbitlow(x[1]); >+ return result; >+} >+uint3 firstbitlow(char3 x) { >+ uint3 result; >+ result[0] = firstbitlow(x[0]); >+ result[1] = firstbitlow(x[1]); >+ result[2] = firstbitlow(x[2]); >+ return result; >+} >+uint4 firstbitlow(char4 x) { >+ uint4 result; >+ result[0] = firstbitlow(x[0]); >+ result[1] = firstbitlow(x[1]); >+ result[2] = firstbitlow(x[2]); >+ result[3] = firstbitlow(x[3]); >+ return result; >+} >+uint2 firstbitlow(short2 x) { >+ uint2 result; >+ result[0] = firstbitlow(x[0]); >+ result[1] = firstbitlow(x[1]); >+ return result; >+} >+uint3 firstbitlow(short3 x) { >+ uint3 result; >+ result[0] = firstbitlow(x[0]); >+ result[1] = firstbitlow(x[1]); >+ result[2] = firstbitlow(x[2]); >+ return result; >+} >+uint4 firstbitlow(short4 x) { >+ uint4 result; >+ result[0] = firstbitlow(x[0]); >+ result[1] = firstbitlow(x[1]); >+ result[2] = firstbitlow(x[2]); >+ result[3] = firstbitlow(x[3]); >+ return result; >+} >+uint2 firstbitlow(int2 x) { >+ uint2 result; >+ result[0] = firstbitlow(x[0]); >+ result[1] = firstbitlow(x[1]); >+ return result; >+} >+uint3 firstbitlow(int3 x) { >+ uint3 result; >+ result[0] = firstbitlow(x[0]); >+ result[1] = firstbitlow(x[1]); >+ result[2] = firstbitlow(x[2]); >+ return result; >+} >+uint4 firstbitlow(int4 x) { >+ uint4 result; >+ result[0] = firstbitlow(x[0]); >+ result[1] = firstbitlow(x[1]); >+ result[2] = firstbitlow(x[2]); >+ result[3] = firstbitlow(x[3]); >+ return result; >+} >+ >+half determinant(half x) { >+ return x; >+} >+half determinant(half2x2 x) { >+ return x[0][0] * x[1][1] - x[0][1] * x[1][0]; >+} >+half determinant(half3x3 x) { >+ return x[0][0] * x[1][1] * x[2][2] + >+ x[0][1] * x[1][2] * x[2][0] + >+ x[0][2] * x[1][0] * x[2][1] - >+ x[2][0] * x[1][1] * x[0][2] - >+ x[2][1] * x[1][2] * x[0][0] - >+ x[2][2] * x[1][0] * x[0][1]; >+} >+half determinant(half4x4 x) { >+ half result; >+ half3x3 minor; >+ minor[0][0] = x[1][1]; >+ minor[0][1] = x[1][2]; >+ minor[0][2] = x[1][3]; >+ minor[1][0] = x[2][1]; >+ minor[1][1] = x[2][2]; >+ minor[1][2] = x[2][3]; >+ minor[2][0] = x[3][1]; >+ minor[2][1] = x[3][2]; >+ minor[2][2] = x[3][3]; >+ result = result + x[0][0] * determinant(minor); >+ minor[0][0] = x[1][0]; >+ minor[0][1] = x[1][2]; >+ minor[0][2] = x[1][3]; >+ minor[1][0] = x[2][0]; >+ minor[1][1] = x[2][2]; >+ minor[1][2] = x[2][3]; >+ minor[2][0] = x[3][0]; >+ minor[2][1] = x[3][2]; >+ minor[2][2] = x[3][3]; >+ result = result - x[0][1] * determinant(minor); >+ minor[0][0] = x[1][0]; >+ minor[0][1] = x[1][1]; >+ minor[0][2] = x[1][3]; >+ minor[1][0] = x[2][0]; >+ minor[1][1] = x[2][1]; >+ minor[1][2] = x[2][3]; >+ minor[2][0] = x[3][0]; >+ minor[2][1] = x[3][1]; >+ minor[2][2] = x[3][3]; >+ result = result + x[0][2] * determinant(minor); >+ minor[0][0] = x[1][0]; >+ minor[0][1] = x[1][1]; >+ minor[0][2] = x[1][2]; >+ minor[1][0] = x[2][0]; >+ minor[1][1] = x[2][1]; >+ minor[1][2] = x[2][2]; >+ minor[2][0] = x[3][0]; >+ minor[2][1] = x[3][1]; >+ minor[2][2] = x[3][2]; >+ result = result - x[0][3] * determinant(minor); >+ return result; >+} >+float determinant(float x) { >+ return x; >+} >+float determinant(float2x2 x) { >+ return x[0][0] * x[1][1] - x[0][1] * x[1][0]; >+} >+float determinant(float3x3 x) { >+ return x[0][0] * x[1][1] * x[2][2] + >+ x[0][1] * x[1][2] * x[2][0] + >+ x[0][2] * x[1][0] * x[2][1] - >+ x[2][0] * x[1][1] * x[0][2] - >+ x[2][1] * x[1][2] * x[0][0] - >+ x[2][2] * x[1][0] * x[0][1]; >+} >+float determinant(float4x4 x) { >+ float result; >+ float3x3 minor; >+ minor[0][0] = x[1][1]; >+ minor[0][1] = x[1][2]; >+ minor[0][2] = x[1][3]; >+ minor[1][0] = x[2][1]; >+ minor[1][1] = x[2][2]; >+ minor[1][2] = x[2][3]; >+ minor[2][0] = x[3][1]; >+ minor[2][1] = x[3][2]; >+ minor[2][2] = x[3][3]; >+ result = result + x[0][0] * determinant(minor); >+ minor[0][0] = x[1][0]; >+ minor[0][1] = x[1][2]; >+ minor[0][2] = x[1][3]; >+ minor[1][0] = x[2][0]; >+ minor[1][1] = x[2][2]; >+ minor[1][2] = x[2][3]; >+ minor[2][0] = x[3][0]; >+ minor[2][1] = x[3][2]; >+ minor[2][2] = x[3][3]; >+ result = result - x[0][1] * determinant(minor); >+ minor[0][0] = x[1][0]; >+ minor[0][1] = x[1][1]; >+ minor[0][2] = x[1][3]; >+ minor[1][0] = x[2][0]; >+ minor[1][1] = x[2][1]; >+ minor[1][2] = x[2][3]; >+ minor[2][0] = x[3][0]; >+ minor[2][1] = x[3][1]; >+ minor[2][2] = x[3][3]; >+ result = result + x[0][2] * determinant(minor); >+ minor[0][0] = x[1][0]; >+ minor[0][1] = x[1][1]; >+ minor[0][2] = x[1][2]; >+ minor[1][0] = x[2][0]; >+ minor[1][1] = x[2][1]; >+ minor[1][2] = x[2][2]; >+ minor[2][0] = x[3][0]; >+ minor[2][1] = x[3][1]; >+ minor[2][2] = x[3][2]; >+ result = result - x[0][3] * determinant(minor); >+ return result; >+} >+ >+uchar4 dst(uchar4 src0, uchar4 src1) { >+ uchar4 result; >+ result.x = 1; >+ result.y = src0.y * src1.y; >+ result.z = src0.z; >+ result.w = src1.w; >+ return result; >+} >+ushort4 dst(ushort4 src0, ushort4 src1) { >+ ushort4 result; >+ result.x = 1; >+ result.y = src0.y * src1.y; >+ result.z = src0.z; >+ result.w = src1.w; >+ return result; >+} >+uint4 dst(uint4 src0, uint4 src1) { >+ uint4 result; >+ result.x = 1; >+ result.y = src0.y * src1.y; >+ result.z = src0.z; >+ result.w = src1.w; >+ return result; >+} >+char4 dst(char4 src0, char4 src1) { >+ char4 result; >+ result.x = 1; >+ result.y = src0.y * src1.y; >+ result.z = src0.z; >+ result.w = src1.w; >+ return result; >+} >+short4 dst(short4 src0, short4 src1) { >+ short4 result; >+ result.x = 1; >+ result.y = src0.y * src1.y; >+ result.z = src0.z; >+ result.w = src1.w; >+ return result; >+} >+int4 dst(int4 src0, int4 src1) { >+ int4 result; >+ result.x = 1; >+ result.y = src0.y * src1.y; >+ result.z = src0.z; >+ result.w = src1.w; >+ return result; >+} >+half4 dst(half4 src0, half4 src1) { >+ half4 result; >+ result.x = 1; >+ result.y = src0.y * src1.y; >+ result.z = src0.z; >+ result.w = src1.w; >+ return result; >+} >+float4 dst(float4 src0, float4 src1) { >+ float4 result; >+ result.x = 1; >+ result.y = src0.y * src1.y; >+ result.z = src0.z; >+ result.w = src1.w; >+ return result; >+} >+ >+half distance(half x, half y) { >+ return length(x - y); >+} >+half distance(half2 x, half2 y) { >+ return length(x - y); >+} >+half distance(half3 x, half3 y) { >+ return length(x - y); >+} >+half distance(half4 x, half4 y) { >+ return length(x - y); >+} >+float distance(float x, float y) { >+ return length(x - y); >+} >+float distance(float2 x, float2 y) { >+ return length(x - y); >+} >+float distance(float3 x, float3 y) { >+ return length(x - y); >+} >+float distance(float4 x, float4 y) { >+ return length(x - y); >+} >+ >+half3 cross(half3 u, half3 v) { >+ half3 result; >+ result.x = u.y * v.z - u.z * v.y; >+ result.y = u.z * v.x - u.x * v.z; >+ result.z = u.x * v.y - u.y * v.x; >+ return result; >+} >+float3 cross(float3 u, float3 v) { >+ float3 result; >+ result.x = u.y * v.z - u.z * v.y; >+ result.y = u.z * v.x - u.x * v.z; >+ result.z = u.x * v.y - u.y * v.x; >+ return result; >+} >+ >+uchar dot(uchar a, uchar b) { >+ return a * b; >+} >+uchar dot(uchar2 a, uchar2 b) { >+ uchar result = 0; >+ result = result + a[0] * b[0]; >+ result = result + a[1] * b[1]; >+ return result; >+} >+uchar dot(uchar3 a, uchar3 b) { >+ uchar result = 0; >+ result = result + a[0] * b[0]; >+ result = result + a[1] * b[1]; >+ result = result + a[2] * b[2]; >+ return result; >+} >+uchar dot(uchar4 a, uchar4 b) { >+ uchar result = 0; >+ result = result + a[0] * b[0]; >+ result = result + a[1] * b[1]; >+ result = result + a[2] * b[2]; >+ result = result + a[3] * b[3]; >+ return result; >+} >+ushort dot(ushort a, ushort b) { >+ return a * b; >+} >+ushort dot(ushort2 a, ushort2 b) { >+ ushort result = 0; >+ result = result + a[0] * b[0]; >+ result = result + a[1] * b[1]; >+ return result; >+} >+ushort dot(ushort3 a, ushort3 b) { >+ ushort result = 0; >+ result = result + a[0] * b[0]; >+ result = result + a[1] * b[1]; >+ result = result + a[2] * b[2]; >+ return result; >+} >+ushort dot(ushort4 a, ushort4 b) { >+ ushort result = 0; >+ result = result + a[0] * b[0]; >+ result = result + a[1] * b[1]; >+ result = result + a[2] * b[2]; >+ result = result + a[3] * b[3]; >+ return result; >+} >+uint dot(uint a, uint b) { >+ return a * b; >+} >+uint dot(uint2 a, uint2 b) { >+ uint result = 0; >+ result = result + a[0] * b[0]; >+ result = result + a[1] * b[1]; >+ return result; >+} >+uint dot(uint3 a, uint3 b) { >+ uint result = 0; >+ result = result + a[0] * b[0]; >+ result = result + a[1] * b[1]; >+ result = result + a[2] * b[2]; >+ return result; >+} >+uint dot(uint4 a, uint4 b) { >+ uint result = 0; >+ result = result + a[0] * b[0]; >+ result = result + a[1] * b[1]; >+ result = result + a[2] * b[2]; >+ result = result + a[3] * b[3]; >+ return result; >+} >+char dot(char a, char b) { >+ return a * b; >+} >+char dot(char2 a, char2 b) { >+ char result = 0; >+ result = result + a[0] * b[0]; >+ result = result + a[1] * b[1]; >+ return result; >+} >+char dot(char3 a, char3 b) { >+ char result = 0; >+ result = result + a[0] * b[0]; >+ result = result + a[1] * b[1]; >+ result = result + a[2] * b[2]; >+ return result; >+} >+char dot(char4 a, char4 b) { >+ char result = 0; >+ result = result + a[0] * b[0]; >+ result = result + a[1] * b[1]; >+ result = result + a[2] * b[2]; >+ result = result + a[3] * b[3]; >+ return result; >+} >+short dot(short a, short b) { >+ return a * b; >+} >+short dot(short2 a, short2 b) { >+ short result = 0; >+ result = result + a[0] * b[0]; >+ result = result + a[1] * b[1]; >+ return result; >+} >+short dot(short3 a, short3 b) { >+ short result = 0; >+ result = result + a[0] * b[0]; >+ result = result + a[1] * b[1]; >+ result = result + a[2] * b[2]; >+ return result; >+} >+short dot(short4 a, short4 b) { >+ short result = 0; >+ result = result + a[0] * b[0]; >+ result = result + a[1] * b[1]; >+ result = result + a[2] * b[2]; >+ result = result + a[3] * b[3]; >+ return result; >+} >+int dot(int a, int b) { >+ return a * b; >+} >+int dot(int2 a, int2 b) { >+ int result = 0; >+ result = result + a[0] * b[0]; >+ result = result + a[1] * b[1]; >+ return result; >+} >+int dot(int3 a, int3 b) { >+ int result = 0; >+ result = result + a[0] * b[0]; >+ result = result + a[1] * b[1]; >+ result = result + a[2] * b[2]; >+ return result; >+} >+int dot(int4 a, int4 b) { >+ int result = 0; >+ result = result + a[0] * b[0]; >+ result = result + a[1] * b[1]; >+ result = result + a[2] * b[2]; >+ result = result + a[3] * b[3]; >+ return result; >+} >+half dot(half a, half b) { >+ return a * b; >+} >+half dot(half2 a, half2 b) { >+ half result = 0; >+ result = result + a[0] * b[0]; >+ result = result + a[1] * b[1]; >+ return result; >+} >+half dot(half3 a, half3 b) { >+ half result = 0; >+ result = result + a[0] * b[0]; >+ result = result + a[1] * b[1]; >+ result = result + a[2] * b[2]; >+ return result; >+} >+half dot(half4 a, half4 b) { >+ half result = 0; >+ result = result + a[0] * b[0]; >+ result = result + a[1] * b[1]; >+ result = result + a[2] * b[2]; >+ result = result + a[3] * b[3]; >+ return result; >+} >+float dot(float a, float b) { >+ return a * b; >+} >+float dot(float2 a, float2 b) { >+ float result = 0; >+ result = result + a[0] * b[0]; >+ result = result + a[1] * b[1]; >+ return result; >+} >+float dot(float3 a, float3 b) { >+ float result = 0; >+ result = result + a[0] * b[0]; >+ result = result + a[1] * b[1]; >+ result = result + a[2] * b[2]; >+ return result; >+} >+float dot(float4 a, float4 b) { >+ float result = 0; >+ result = result + a[0] * b[0]; >+ result = result + a[1] * b[1]; >+ result = result + a[2] * b[2]; >+ result = result + a[3] * b[3]; >+ return result; >+} >+ >+half faceforward(half n, half i, half ng) { >+ return -n * sign(dot(i, ng)); >+} >+half2 faceforward(half2 n, half2 i, half2 ng) { >+ return -n * sign(dot(i, ng)); >+} >+half3 faceforward(half3 n, half3 i, half3 ng) { >+ return -n * sign(dot(i, ng)); >+} >+half4 faceforward(half4 n, half4 i, half4 ng) { >+ return -n * sign(dot(i, ng)); >+} >+float faceforward(float n, float i, float ng) { >+ return -n * sign(dot(i, ng)); >+} >+float2 faceforward(float2 n, float2 i, float2 ng) { >+ return -n * sign(dot(i, ng)); >+} >+float3 faceforward(float3 n, float3 i, float3 ng) { >+ return -n * sign(dot(i, ng)); >+} >+float4 faceforward(float4 n, float4 i, float4 ng) { >+ return -n * sign(dot(i, ng)); >+} >+ >+half length(half x) { >+ return sqrt(dot(x, x)); >+} >+half length(half2 x) { >+ return sqrt(dot(x, x)); >+} >+half length(half3 x) { >+ return sqrt(dot(x, x)); >+} >+half length(half4 x) { >+ return sqrt(dot(x, x)); >+} >+float length(float x) { >+ return sqrt(dot(x, x)); >+} >+float length(float2 x) { >+ return sqrt(dot(x, x)); >+} >+float length(float3 x) { >+ return sqrt(dot(x, x)); >+} >+float length(float4 x) { >+ return sqrt(dot(x, x)); >+} >+ >+half4 lit(half n_dot_l, half n_dot_h, half m) { >+ half ambient = 1; >+ half diffuse = max(0, n_dot_l); >+ half specular = n_dot_l < 0 || n_dot_h < 0 ? 0 : n_dot_h * m; >+ half4 result; >+ result.x = ambient; >+ result.y = diffuse; >+ result.z = specular; >+ result.w = 1; >+ return result; >+} >+float4 lit(float n_dot_l, float n_dot_h, float m) { >+ float ambient = 1; >+ float diffuse = max(0, n_dot_l); >+ float specular = n_dot_l < 0 || n_dot_h < 0 ? 0 : n_dot_h * m; >+ float4 result; >+ result.x = ambient; >+ result.y = diffuse; >+ result.z = specular; >+ result.w = 1; >+ return result; >+} >+ >+half normalize(half x) { >+ return x / length(x); >+} >+half2 normalize(half2 x) { >+ return x / length(x); >+} >+half3 normalize(half3 x) { >+ return x / length(x); >+} >+half4 normalize(half4 x) { >+ return x / length(x); >+} >+float normalize(float x) { >+ return x / length(x); >+} >+float2 normalize(float2 x) { >+ return x / length(x); >+} >+float3 normalize(float3 x) { >+ return x / length(x); >+} >+float4 normalize(float4 x) { >+ return x / length(x); >+} >+ >+half reflect(half i, half n) { >+ return i - 2 * n * dot(i, n); >+} >+half2 reflect(half2 i, half2 n) { >+ return i - 2 * n * dot(i, n); >+} >+half3 reflect(half3 i, half3 n) { >+ return i - 2 * n * dot(i, n); >+} >+half4 reflect(half4 i, half4 n) { >+ return i - 2 * n * dot(i, n); >+} >+float reflect(float i, float n) { >+ return i - 2 * n * dot(i, n); >+} >+float2 reflect(float2 i, float2 n) { >+ return i - 2 * n * dot(i, n); >+} >+float3 reflect(float3 i, float3 n) { >+ return i - 2 * n * dot(i, n); >+} >+float4 reflect(float4 i, float4 n) { >+ return i - 2 * n * dot(i, n); >+} >+ >+half refract(half i, half n, half eta) { >+ half result; >+ half k = 1 - eta * eta * (1 - dot(n, i) * dot(n, i)); >+ if (k < 0) >+ return result; >+ return eta * i - (eta * dot(n, i) + sqrt(k)) * n; >+} >+half2 refract(half2 i, half2 n, half eta) { >+ half2 result; >+ half k = 1 - eta * eta * (1 - dot(n, i) * dot(n, i)); >+ if (k < 0) >+ return result; >+ return eta * i - (eta * dot(n, i) + sqrt(k)) * n; >+} >+half3 refract(half3 i, half3 n, half eta) { >+ half3 result; >+ half k = 1 - eta * eta * (1 - dot(n, i) * dot(n, i)); >+ if (k < 0) >+ return result; >+ return eta * i - (eta * dot(n, i) + sqrt(k)) * n; >+} >+half4 refract(half4 i, half4 n, half eta) { >+ half4 result; >+ half k = 1 - eta * eta * (1 - dot(n, i) * dot(n, i)); >+ if (k < 0) >+ return result; >+ return eta * i - (eta * dot(n, i) + sqrt(k)) * n; >+} >+float refract(float i, float n, float eta) { >+ float result; >+ float k = 1 - eta * eta * (1 - dot(n, i) * dot(n, i)); >+ if (k < 0) >+ return result; >+ return eta * i - (eta * dot(n, i) + sqrt(k)) * n; >+} >+float2 refract(float2 i, float2 n, float eta) { >+ float2 result; >+ float k = 1 - eta * eta * (1 - dot(n, i) * dot(n, i)); >+ if (k < 0) >+ return result; >+ return eta * i - (eta * dot(n, i) + sqrt(k)) * n; >+} >+float3 refract(float3 i, float3 n, float eta) { >+ float3 result; >+ float k = 1 - eta * eta * (1 - dot(n, i) * dot(n, i)); >+ if (k < 0) >+ return result; >+ return eta * i - (eta * dot(n, i) + sqrt(k)) * n; >+} >+float4 refract(float4 i, float4 n, float eta) { >+ float4 result; >+ float k = 1 - eta * eta * (1 - dot(n, i) * dot(n, i)); >+ if (k < 0) >+ return result; >+ return eta * i - (eta * dot(n, i) + sqrt(k)) * n; >+} >+ >+half transpose(half x) { >+ return x; >+} >+half2x2 transpose(half2x2 x) { >+ half2x2 result; >+ result[0][0] = x[0][0]; >+ result[0][1] = x[1][0]; >+ result[1][0] = x[0][1]; >+ result[1][1] = x[1][1]; >+ return result; >+} >+half2x3 transpose(half3x2 x) { >+ half2x3 result; >+ result[0][0] = x[0][0]; >+ result[0][1] = x[1][0]; >+ result[0][2] = x[2][0]; >+ result[1][0] = x[0][1]; >+ result[1][1] = x[1][1]; >+ result[1][2] = x[2][1]; >+ return result; >+} >+half2x4 transpose(half4x2 x) { >+ half2x4 result; >+ result[0][0] = x[0][0]; >+ result[0][1] = x[1][0]; >+ result[0][2] = x[2][0]; >+ result[0][3] = x[3][0]; >+ result[1][0] = x[0][1]; >+ result[1][1] = x[1][1]; >+ result[1][2] = x[2][1]; >+ result[1][3] = x[3][1]; >+ return result; >+} >+half3x2 transpose(half2x3 x) { >+ half3x2 result; >+ result[0][0] = x[0][0]; >+ result[0][1] = x[1][0]; >+ result[1][0] = x[0][1]; >+ result[1][1] = x[1][1]; >+ result[2][0] = x[0][2]; >+ result[2][1] = x[1][2]; >+ return result; >+} >+half3x3 transpose(half3x3 x) { >+ half3x3 result; >+ result[0][0] = x[0][0]; >+ result[0][1] = x[1][0]; >+ result[0][2] = x[2][0]; >+ result[1][0] = x[0][1]; >+ result[1][1] = x[1][1]; >+ result[1][2] = x[2][1]; >+ result[2][0] = x[0][2]; >+ result[2][1] = x[1][2]; >+ result[2][2] = x[2][2]; >+ return result; >+} >+half3x4 transpose(half4x3 x) { >+ half3x4 result; >+ result[0][0] = x[0][0]; >+ result[0][1] = x[1][0]; >+ result[0][2] = x[2][0]; >+ result[0][3] = x[3][0]; >+ result[1][0] = x[0][1]; >+ result[1][1] = x[1][1]; >+ result[1][2] = x[2][1]; >+ result[1][3] = x[3][1]; >+ result[2][0] = x[0][2]; >+ result[2][1] = x[1][2]; >+ result[2][2] = x[2][2]; >+ result[2][3] = x[3][2]; >+ return result; >+} >+half4x2 transpose(half2x4 x) { >+ half4x2 result; >+ result[0][0] = x[0][0]; >+ result[0][1] = x[1][0]; >+ result[1][0] = x[0][1]; >+ result[1][1] = x[1][1]; >+ result[2][0] = x[0][2]; >+ result[2][1] = x[1][2]; >+ result[3][0] = x[0][3]; >+ result[3][1] = x[1][3]; >+ return result; >+} >+half4x3 transpose(half3x4 x) { >+ half4x3 result; >+ result[0][0] = x[0][0]; >+ result[0][1] = x[1][0]; >+ result[0][2] = x[2][0]; >+ result[1][0] = x[0][1]; >+ result[1][1] = x[1][1]; >+ result[1][2] = x[2][1]; >+ result[2][0] = x[0][2]; >+ result[2][1] = x[1][2]; >+ result[2][2] = x[2][2]; >+ result[3][0] = x[0][3]; >+ result[3][1] = x[1][3]; >+ result[3][2] = x[2][3]; >+ return result; >+} >+half4x4 transpose(half4x4 x) { >+ half4x4 result; >+ result[0][0] = x[0][0]; >+ result[0][1] = x[1][0]; >+ result[0][2] = x[2][0]; >+ result[0][3] = x[3][0]; >+ result[1][0] = x[0][1]; >+ result[1][1] = x[1][1]; >+ result[1][2] = x[2][1]; >+ result[1][3] = x[3][1]; >+ result[2][0] = x[0][2]; >+ result[2][1] = x[1][2]; >+ result[2][2] = x[2][2]; >+ result[2][3] = x[3][2]; >+ result[3][0] = x[0][3]; >+ result[3][1] = x[1][3]; >+ result[3][2] = x[2][3]; >+ result[3][3] = x[3][3]; >+ return result; >+} >+float transpose(float x) { >+ return x; >+} >+float2x2 transpose(float2x2 x) { >+ float2x2 result; >+ result[0][0] = x[0][0]; >+ result[0][1] = x[1][0]; >+ result[1][0] = x[0][1]; >+ result[1][1] = x[1][1]; >+ return result; >+} >+float2x3 transpose(float3x2 x) { >+ float2x3 result; >+ result[0][0] = x[0][0]; >+ result[0][1] = x[1][0]; >+ result[0][2] = x[2][0]; >+ result[1][0] = x[0][1]; >+ result[1][1] = x[1][1]; >+ result[1][2] = x[2][1]; >+ return result; >+} >+float2x4 transpose(float4x2 x) { >+ float2x4 result; >+ result[0][0] = x[0][0]; >+ result[0][1] = x[1][0]; >+ result[0][2] = x[2][0]; >+ result[0][3] = x[3][0]; >+ result[1][0] = x[0][1]; >+ result[1][1] = x[1][1]; >+ result[1][2] = x[2][1]; >+ result[1][3] = x[3][1]; >+ return result; >+} >+float3x2 transpose(float2x3 x) { >+ float3x2 result; >+ result[0][0] = x[0][0]; >+ result[0][1] = x[1][0]; >+ result[1][0] = x[0][1]; >+ result[1][1] = x[1][1]; >+ result[2][0] = x[0][2]; >+ result[2][1] = x[1][2]; >+ return result; >+} >+float3x3 transpose(float3x3 x) { >+ float3x3 result; >+ result[0][0] = x[0][0]; >+ result[0][1] = x[1][0]; >+ result[0][2] = x[2][0]; >+ result[1][0] = x[0][1]; >+ result[1][1] = x[1][1]; >+ result[1][2] = x[2][1]; >+ result[2][0] = x[0][2]; >+ result[2][1] = x[1][2]; >+ result[2][2] = x[2][2]; >+ return result; >+} >+float3x4 transpose(float4x3 x) { >+ float3x4 result; >+ result[0][0] = x[0][0]; >+ result[0][1] = x[1][0]; >+ result[0][2] = x[2][0]; >+ result[0][3] = x[3][0]; >+ result[1][0] = x[0][1]; >+ result[1][1] = x[1][1]; >+ result[1][2] = x[2][1]; >+ result[1][3] = x[3][1]; >+ result[2][0] = x[0][2]; >+ result[2][1] = x[1][2]; >+ result[2][2] = x[2][2]; >+ result[2][3] = x[3][2]; >+ return result; >+} >+float4x2 transpose(float2x4 x) { >+ float4x2 result; >+ result[0][0] = x[0][0]; >+ result[0][1] = x[1][0]; >+ result[1][0] = x[0][1]; >+ result[1][1] = x[1][1]; >+ result[2][0] = x[0][2]; >+ result[2][1] = x[1][2]; >+ result[3][0] = x[0][3]; >+ result[3][1] = x[1][3]; >+ return result; >+} >+float4x3 transpose(float3x4 x) { >+ float4x3 result; >+ result[0][0] = x[0][0]; >+ result[0][1] = x[1][0]; >+ result[0][2] = x[2][0]; >+ result[1][0] = x[0][1]; >+ result[1][1] = x[1][1]; >+ result[1][2] = x[2][1]; >+ result[2][0] = x[0][2]; >+ result[2][1] = x[1][2]; >+ result[2][2] = x[2][2]; >+ result[3][0] = x[0][3]; >+ result[3][1] = x[1][3]; >+ result[3][2] = x[2][3]; >+ return result; >+} >+float4x4 transpose(float4x4 x) { >+ float4x4 result; >+ result[0][0] = x[0][0]; >+ result[0][1] = x[1][0]; >+ result[0][2] = x[2][0]; >+ result[0][3] = x[3][0]; >+ result[1][0] = x[0][1]; >+ result[1][1] = x[1][1]; >+ result[1][2] = x[2][1]; >+ result[1][3] = x[3][1]; >+ result[2][0] = x[0][2]; >+ result[2][1] = x[1][2]; >+ result[2][2] = x[2][2]; >+ result[2][3] = x[3][2]; >+ result[3][0] = x[0][3]; >+ result[3][1] = x[1][3]; >+ result[3][2] = x[2][3]; >+ result[3][3] = x[3][3]; >+ return result; >+} >+ >+int asint(int x) { >+ return x; >+} >+int2 asint(int2 x) { >+ return x; >+} >+int3 asint(int3 x) { >+ return x; >+} >+int4 asint(int4 x) { >+ return x; >+} >+int asint(uint x) { >+ return int(x); >+} >+int2 asint(uint2 x) { >+ int2 result; >+ result[0] = asint(x[0]); >+ result[1] = asint(x[1]); >+ return result; >+} >+int3 asint(uint3 x) { >+ int3 result; >+ result[0] = asint(x[0]); >+ result[1] = asint(x[1]); >+ result[2] = asint(x[2]); >+ return result; >+} >+int4 asint(uint4 x) { >+ int4 result; >+ result[0] = asint(x[0]); >+ result[1] = asint(x[1]); >+ result[2] = asint(x[2]); >+ result[3] = asint(x[3]); >+ return result; >+} >+native int asint(float); >+int2 asint(float2 x) { >+ int2 result; >+ result[0] = asint(x[0]); >+ result[1] = asint(x[1]); >+ return result; >+} >+int3 asint(float3 x) { >+ int3 result; >+ result[0] = asint(x[0]); >+ result[1] = asint(x[1]); >+ result[2] = asint(x[2]); >+ return result; >+} >+int4 asint(float4 x) { >+ int4 result; >+ result[0] = asint(x[0]); >+ result[1] = asint(x[1]); >+ result[2] = asint(x[2]); >+ result[3] = asint(x[3]); >+ return result; >+} >+uint asuint(int x) { >+ return uint(x); >+} >+uint2 asuint(int2 x) { >+ uint2 result; >+ result[0] = asuint(x[0]); >+ result[1] = asuint(x[1]); >+ return result; >+} >+uint3 asuint(int3 x) { >+ uint3 result; >+ result[0] = asuint(x[0]); >+ result[1] = asuint(x[1]); >+ result[2] = asuint(x[2]); >+ return result; >+} >+uint4 asuint(int4 x) { >+ uint4 result; >+ result[0] = asuint(x[0]); >+ result[1] = asuint(x[1]); >+ result[2] = asuint(x[2]); >+ result[3] = asuint(x[3]); >+ return result; >+} >+uint asuint(uint x) { >+ return x; >+} >+uint2 asuint(uint2 x) { >+ return x; >+} >+uint3 asuint(uint3 x) { >+ return x; >+} >+uint4 asuint(uint4 x) { >+ return x; >+} >+native uint asuint(float); >+uint2 asuint(float2 x) { >+ uint2 result; >+ result[0] = asuint(x[0]); >+ result[1] = asuint(x[1]); >+ return result; >+} >+uint3 asuint(float3 x) { >+ uint3 result; >+ result[0] = asuint(x[0]); >+ result[1] = asuint(x[1]); >+ result[2] = asuint(x[2]); >+ return result; >+} >+uint4 asuint(float4 x) { >+ uint4 result; >+ result[0] = asuint(x[0]); >+ result[1] = asuint(x[1]); >+ result[2] = asuint(x[2]); >+ result[3] = asuint(x[3]); >+ return result; >+} >+native float asfloat(int); >+float2 asfloat(int2 x) { >+ float2 result; >+ result[0] = asfloat(x[0]); >+ result[1] = asfloat(x[1]); >+ return result; >+} >+float3 asfloat(int3 x) { >+ float3 result; >+ result[0] = asfloat(x[0]); >+ result[1] = asfloat(x[1]); >+ result[2] = asfloat(x[2]); >+ return result; >+} >+float4 asfloat(int4 x) { >+ float4 result; >+ result[0] = asfloat(x[0]); >+ result[1] = asfloat(x[1]); >+ result[2] = asfloat(x[2]); >+ result[3] = asfloat(x[3]); >+ return result; >+} >+native float asfloat(uint); >+float2 asfloat(uint2 x) { >+ float2 result; >+ result[0] = asfloat(x[0]); >+ result[1] = asfloat(x[1]); >+ return result; >+} >+float3 asfloat(uint3 x) { >+ float3 result; >+ result[0] = asfloat(x[0]); >+ result[1] = asfloat(x[1]); >+ result[2] = asfloat(x[2]); >+ return result; >+} >+float4 asfloat(uint4 x) { >+ float4 result; >+ result[0] = asfloat(x[0]); >+ result[1] = asfloat(x[1]); >+ result[2] = asfloat(x[2]); >+ result[3] = asfloat(x[3]); >+ return result; >+} >+float asfloat(float x) { >+ return x; >+} >+float2 asfloat(float2 x) { >+ return x; >+} >+float3 asfloat(float3 x) { >+ return x; >+} >+float4 asfloat(float4 x) { >+ return x; >+} >+float2x2 asfloat(float2x2 x) { >+ return x; >+} >+float2x3 asfloat(float2x3 x) { >+ return x; >+} >+float2x4 asfloat(float2x4 x) { >+ return x; >+} >+float3x2 asfloat(float3x2 x) { >+ return x; >+} >+float3x3 asfloat(float3x3 x) { >+ return x; >+} >+float3x4 asfloat(float3x4 x) { >+ return x; >+} >+float4x2 asfloat(float4x2 x) { >+ return x; >+} >+float4x3 asfloat(float4x3 x) { >+ return x; >+} >+float4x4 asfloat(float4x4 x) { >+ return x; >+} >+ >+native float f16tof32(uint); >+native uint f32tof16(float); >+float2 f16tof32(uint2 x) { >+ float2 result; >+ result[0] = f16tof32(x[0]); >+ result[1] = f16tof32(x[1]); >+ return result; >+} >+uint2 f32tof16(float2 x) { >+ uint2 result; >+ result[0] = f32tof16(x[0]); >+ result[1] = f32tof16(x[1]); >+ return result; >+} >+float3 f16tof32(uint3 x) { >+ float3 result; >+ result[0] = f16tof32(x[0]); >+ result[1] = f16tof32(x[1]); >+ result[2] = f16tof32(x[2]); >+ return result; >+} >+uint3 f32tof16(float3 x) { >+ uint3 result; >+ result[0] = f32tof16(x[0]); >+ result[1] = f32tof16(x[1]); >+ result[2] = f32tof16(x[2]); >+ return result; >+} >+float4 f16tof32(uint4 x) { >+ float4 result; >+ result[0] = f16tof32(x[0]); >+ result[1] = f16tof32(x[1]); >+ result[2] = f16tof32(x[2]); >+ result[3] = f16tof32(x[3]); >+ return result; >+} >+uint4 f32tof16(float4 x) { >+ uint4 result; >+ result[0] = f32tof16(x[0]); >+ result[1] = f32tof16(x[1]); >+ result[2] = f32tof16(x[2]); >+ result[3] = f32tof16(x[3]); >+ return result; >+} >+ >+native void AllMemoryBarrierWithGroupSync(); >+native void DeviceMemoryBarrierWithGroupSync(); >+native void GroupMemoryBarrierWithGroupSync(); >+ >+uchar mul(uchar x, uchar y) { >+ return x * y; >+} >+ushort mul(ushort x, ushort y) { >+ return x * y; >+} >+uint mul(uint x, uint y) { >+ return x * y; >+} >+char mul(char x, char y) { >+ return x * y; >+} >+short mul(short x, short y) { >+ return x * y; >+} >+int mul(int x, int y) { >+ return x * y; >+} >+half mul(half x, half y) { >+ return x * y; >+} >+float mul(float x, float y) { >+ return x * y; >+} >+uchar2 mul(uchar x, uchar2 y) { >+ uchar2 result; >+ result[0] = x * y[0]; >+ result[1] = x * y[1]; >+ return result; >+} >+uchar2 mul(uchar2 x, uchar y) { >+ uchar2 result; >+ result[0] = x[0] * y; >+ result[1] = x[1] * y; >+ return result; >+} >+uchar3 mul(uchar x, uchar3 y) { >+ uchar3 result; >+ result[0] = x * y[0]; >+ result[1] = x * y[1]; >+ result[2] = x * y[2]; >+ return result; >+} >+uchar3 mul(uchar3 x, uchar y) { >+ uchar3 result; >+ result[0] = x[0] * y; >+ result[1] = x[1] * y; >+ result[2] = x[2] * y; >+ return result; >+} >+uchar4 mul(uchar x, uchar4 y) { >+ uchar4 result; >+ result[0] = x * y[0]; >+ result[1] = x * y[1]; >+ result[2] = x * y[2]; >+ result[3] = x * y[3]; >+ return result; >+} >+uchar4 mul(uchar4 x, uchar y) { >+ uchar4 result; >+ result[0] = x[0] * y; >+ result[1] = x[1] * y; >+ result[2] = x[2] * y; >+ result[3] = x[3] * y; >+ return result; >+} >+ushort2 mul(ushort x, ushort2 y) { >+ ushort2 result; >+ result[0] = x * y[0]; >+ result[1] = x * y[1]; >+ return result; >+} >+ushort2 mul(ushort2 x, ushort y) { >+ ushort2 result; >+ result[0] = x[0] * y; >+ result[1] = x[1] * y; >+ return result; >+} >+ushort3 mul(ushort x, ushort3 y) { >+ ushort3 result; >+ result[0] = x * y[0]; >+ result[1] = x * y[1]; >+ result[2] = x * y[2]; >+ return result; >+} >+ushort3 mul(ushort3 x, ushort y) { >+ ushort3 result; >+ result[0] = x[0] * y; >+ result[1] = x[1] * y; >+ result[2] = x[2] * y; >+ return result; >+} >+ushort4 mul(ushort x, ushort4 y) { >+ ushort4 result; >+ result[0] = x * y[0]; >+ result[1] = x * y[1]; >+ result[2] = x * y[2]; >+ result[3] = x * y[3]; >+ return result; >+} >+ushort4 mul(ushort4 x, ushort y) { >+ ushort4 result; >+ result[0] = x[0] * y; >+ result[1] = x[1] * y; >+ result[2] = x[2] * y; >+ result[3] = x[3] * y; >+ return result; >+} >+uint2 mul(uint x, uint2 y) { >+ uint2 result; >+ result[0] = x * y[0]; >+ result[1] = x * y[1]; >+ return result; >+} >+uint2 mul(uint2 x, uint y) { >+ uint2 result; >+ result[0] = x[0] * y; >+ result[1] = x[1] * y; >+ return result; >+} >+uint3 mul(uint x, uint3 y) { >+ uint3 result; >+ result[0] = x * y[0]; >+ result[1] = x * y[1]; >+ result[2] = x * y[2]; >+ return result; >+} >+uint3 mul(uint3 x, uint y) { >+ uint3 result; >+ result[0] = x[0] * y; >+ result[1] = x[1] * y; >+ result[2] = x[2] * y; >+ return result; >+} >+uint4 mul(uint x, uint4 y) { >+ uint4 result; >+ result[0] = x * y[0]; >+ result[1] = x * y[1]; >+ result[2] = x * y[2]; >+ result[3] = x * y[3]; >+ return result; >+} >+uint4 mul(uint4 x, uint y) { >+ uint4 result; >+ result[0] = x[0] * y; >+ result[1] = x[1] * y; >+ result[2] = x[2] * y; >+ result[3] = x[3] * y; >+ return result; >+} >+char2 mul(char x, char2 y) { >+ char2 result; >+ result[0] = x * y[0]; >+ result[1] = x * y[1]; >+ return result; >+} >+char2 mul(char2 x, char y) { >+ char2 result; >+ result[0] = x[0] * y; >+ result[1] = x[1] * y; >+ return result; >+} >+char3 mul(char x, char3 y) { >+ char3 result; >+ result[0] = x * y[0]; >+ result[1] = x * y[1]; >+ result[2] = x * y[2]; >+ return result; >+} >+char3 mul(char3 x, char y) { >+ char3 result; >+ result[0] = x[0] * y; >+ result[1] = x[1] * y; >+ result[2] = x[2] * y; >+ return result; >+} >+char4 mul(char x, char4 y) { >+ char4 result; >+ result[0] = x * y[0]; >+ result[1] = x * y[1]; >+ result[2] = x * y[2]; >+ result[3] = x * y[3]; >+ return result; >+} >+char4 mul(char4 x, char y) { >+ char4 result; >+ result[0] = x[0] * y; >+ result[1] = x[1] * y; >+ result[2] = x[2] * y; >+ result[3] = x[3] * y; >+ return result; >+} >+short2 mul(short x, short2 y) { >+ short2 result; >+ result[0] = x * y[0]; >+ result[1] = x * y[1]; >+ return result; >+} >+short2 mul(short2 x, short y) { >+ short2 result; >+ result[0] = x[0] * y; >+ result[1] = x[1] * y; >+ return result; >+} >+short3 mul(short x, short3 y) { >+ short3 result; >+ result[0] = x * y[0]; >+ result[1] = x * y[1]; >+ result[2] = x * y[2]; >+ return result; >+} >+short3 mul(short3 x, short y) { >+ short3 result; >+ result[0] = x[0] * y; >+ result[1] = x[1] * y; >+ result[2] = x[2] * y; >+ return result; >+} >+short4 mul(short x, short4 y) { >+ short4 result; >+ result[0] = x * y[0]; >+ result[1] = x * y[1]; >+ result[2] = x * y[2]; >+ result[3] = x * y[3]; >+ return result; >+} >+short4 mul(short4 x, short y) { >+ short4 result; >+ result[0] = x[0] * y; >+ result[1] = x[1] * y; >+ result[2] = x[2] * y; >+ result[3] = x[3] * y; >+ return result; >+} >+int2 mul(int x, int2 y) { >+ int2 result; >+ result[0] = x * y[0]; >+ result[1] = x * y[1]; >+ return result; >+} >+int2 mul(int2 x, int y) { >+ int2 result; >+ result[0] = x[0] * y; >+ result[1] = x[1] * y; >+ return result; >+} >+int3 mul(int x, int3 y) { >+ int3 result; >+ result[0] = x * y[0]; >+ result[1] = x * y[1]; >+ result[2] = x * y[2]; >+ return result; >+} >+int3 mul(int3 x, int y) { >+ int3 result; >+ result[0] = x[0] * y; >+ result[1] = x[1] * y; >+ result[2] = x[2] * y; >+ return result; >+} >+int4 mul(int x, int4 y) { >+ int4 result; >+ result[0] = x * y[0]; >+ result[1] = x * y[1]; >+ result[2] = x * y[2]; >+ result[3] = x * y[3]; >+ return result; >+} >+int4 mul(int4 x, int y) { >+ int4 result; >+ result[0] = x[0] * y; >+ result[1] = x[1] * y; >+ result[2] = x[2] * y; >+ result[3] = x[3] * y; >+ return result; >+} >+half2 mul(half x, half2 y) { >+ half2 result; >+ result[0] = x * y[0]; >+ result[1] = x * y[1]; >+ return result; >+} >+half2 mul(half2 x, half y) { >+ half2 result; >+ result[0] = x[0] * y; >+ result[1] = x[1] * y; >+ return result; >+} >+half3 mul(half x, half3 y) { >+ half3 result; >+ result[0] = x * y[0]; >+ result[1] = x * y[1]; >+ result[2] = x * y[2]; >+ return result; >+} >+half3 mul(half3 x, half y) { >+ half3 result; >+ result[0] = x[0] * y; >+ result[1] = x[1] * y; >+ result[2] = x[2] * y; >+ return result; >+} >+half4 mul(half x, half4 y) { >+ half4 result; >+ result[0] = x * y[0]; >+ result[1] = x * y[1]; >+ result[2] = x * y[2]; >+ result[3] = x * y[3]; >+ return result; >+} >+half4 mul(half4 x, half y) { >+ half4 result; >+ result[0] = x[0] * y; >+ result[1] = x[1] * y; >+ result[2] = x[2] * y; >+ result[3] = x[3] * y; >+ return result; >+} >+float2 mul(float x, float2 y) { >+ float2 result; >+ result[0] = x * y[0]; >+ result[1] = x * y[1]; >+ return result; >+} >+float2 mul(float2 x, float y) { >+ float2 result; >+ result[0] = x[0] * y; >+ result[1] = x[1] * y; >+ return result; >+} >+float3 mul(float x, float3 y) { >+ float3 result; >+ result[0] = x * y[0]; >+ result[1] = x * y[1]; >+ result[2] = x * y[2]; >+ return result; >+} >+float3 mul(float3 x, float y) { >+ float3 result; >+ result[0] = x[0] * y; >+ result[1] = x[1] * y; >+ result[2] = x[2] * y; >+ return result; >+} >+float4 mul(float x, float4 y) { >+ float4 result; >+ result[0] = x * y[0]; >+ result[1] = x * y[1]; >+ result[2] = x * y[2]; >+ result[3] = x * y[3]; >+ return result; >+} >+float4 mul(float4 x, float y) { >+ float4 result; >+ result[0] = x[0] * y; >+ result[1] = x[1] * y; >+ result[2] = x[2] * y; >+ result[3] = x[3] * y; >+ return result; >+} >+half2x2 mul(half x, half2x2 y) { >+ half2x2 result; >+ result[0][0] = x * y[0][0]; >+ result[0][1] = x * y[0][1]; >+ result[1][0] = x * y[1][0]; >+ result[1][1] = x * y[1][1]; >+ return result; >+} >+half2x2 mul(half2x2 x, half y) { >+ half2x2 result; >+ result[0][0] = x[0][0] * y; >+ result[0][1] = x[0][1] * y; >+ result[1][0] = x[1][0] * y; >+ result[1][1] = x[1][1] * y; >+ return result; >+} >+half2x3 mul(half x, half2x3 y) { >+ half2x3 result; >+ result[0][0] = x * y[0][0]; >+ result[0][1] = x * y[0][1]; >+ result[0][2] = x * y[0][2]; >+ result[1][0] = x * y[1][0]; >+ result[1][1] = x * y[1][1]; >+ result[1][2] = x * y[1][2]; >+ return result; >+} >+half2x3 mul(half2x3 x, half y) { >+ half2x3 result; >+ result[0][0] = x[0][0] * y; >+ result[0][1] = x[0][1] * y; >+ result[0][2] = x[0][2] * y; >+ result[1][0] = x[1][0] * y; >+ result[1][1] = x[1][1] * y; >+ result[1][2] = x[1][2] * y; >+ return result; >+} >+half2x4 mul(half x, half2x4 y) { >+ half2x4 result; >+ result[0][0] = x * y[0][0]; >+ result[0][1] = x * y[0][1]; >+ result[0][2] = x * y[0][2]; >+ result[0][3] = x * y[0][3]; >+ result[1][0] = x * y[1][0]; >+ result[1][1] = x * y[1][1]; >+ result[1][2] = x * y[1][2]; >+ result[1][3] = x * y[1][3]; >+ return result; >+} >+half2x4 mul(half2x4 x, half y) { >+ half2x4 result; >+ result[0][0] = x[0][0] * y; >+ result[0][1] = x[0][1] * y; >+ result[0][2] = x[0][2] * y; >+ result[0][3] = x[0][3] * y; >+ result[1][0] = x[1][0] * y; >+ result[1][1] = x[1][1] * y; >+ result[1][2] = x[1][2] * y; >+ result[1][3] = x[1][3] * y; >+ return result; >+} >+half3x2 mul(half x, half3x2 y) { >+ half3x2 result; >+ result[0][0] = x * y[0][0]; >+ result[0][1] = x * y[0][1]; >+ result[1][0] = x * y[1][0]; >+ result[1][1] = x * y[1][1]; >+ result[2][0] = x * y[2][0]; >+ result[2][1] = x * y[2][1]; >+ return result; >+} >+half3x2 mul(half3x2 x, half y) { >+ half3x2 result; >+ result[0][0] = x[0][0] * y; >+ result[0][1] = x[0][1] * y; >+ result[1][0] = x[1][0] * y; >+ result[1][1] = x[1][1] * y; >+ result[2][0] = x[2][0] * y; >+ result[2][1] = x[2][1] * y; >+ return result; >+} >+half3x3 mul(half x, half3x3 y) { >+ half3x3 result; >+ result[0][0] = x * y[0][0]; >+ result[0][1] = x * y[0][1]; >+ result[0][2] = x * y[0][2]; >+ result[1][0] = x * y[1][0]; >+ result[1][1] = x * y[1][1]; >+ result[1][2] = x * y[1][2]; >+ result[2][0] = x * y[2][0]; >+ result[2][1] = x * y[2][1]; >+ result[2][2] = x * y[2][2]; >+ return result; >+} >+half3x3 mul(half3x3 x, half y) { >+ half3x3 result; >+ result[0][0] = x[0][0] * y; >+ result[0][1] = x[0][1] * y; >+ result[0][2] = x[0][2] * y; >+ result[1][0] = x[1][0] * y; >+ result[1][1] = x[1][1] * y; >+ result[1][2] = x[1][2] * y; >+ result[2][0] = x[2][0] * y; >+ result[2][1] = x[2][1] * y; >+ result[2][2] = x[2][2] * y; >+ return result; >+} >+half3x4 mul(half x, half3x4 y) { >+ half3x4 result; >+ result[0][0] = x * y[0][0]; >+ result[0][1] = x * y[0][1]; >+ result[0][2] = x * y[0][2]; >+ result[0][3] = x * y[0][3]; >+ result[1][0] = x * y[1][0]; >+ result[1][1] = x * y[1][1]; >+ result[1][2] = x * y[1][2]; >+ result[1][3] = x * y[1][3]; >+ result[2][0] = x * y[2][0]; >+ result[2][1] = x * y[2][1]; >+ result[2][2] = x * y[2][2]; >+ result[2][3] = x * y[2][3]; >+ return result; >+} >+half3x4 mul(half3x4 x, half y) { >+ half3x4 result; >+ result[0][0] = x[0][0] * y; >+ result[0][1] = x[0][1] * y; >+ result[0][2] = x[0][2] * y; >+ result[0][3] = x[0][3] * y; >+ result[1][0] = x[1][0] * y; >+ result[1][1] = x[1][1] * y; >+ result[1][2] = x[1][2] * y; >+ result[1][3] = x[1][3] * y; >+ result[2][0] = x[2][0] * y; >+ result[2][1] = x[2][1] * y; >+ result[2][2] = x[2][2] * y; >+ result[2][3] = x[2][3] * y; >+ return result; >+} >+half4x2 mul(half x, half4x2 y) { >+ half4x2 result; >+ result[0][0] = x * y[0][0]; >+ result[0][1] = x * y[0][1]; >+ result[1][0] = x * y[1][0]; >+ result[1][1] = x * y[1][1]; >+ result[2][0] = x * y[2][0]; >+ result[2][1] = x * y[2][1]; >+ result[3][0] = x * y[3][0]; >+ result[3][1] = x * y[3][1]; >+ return result; >+} >+half4x2 mul(half4x2 x, half y) { >+ half4x2 result; >+ result[0][0] = x[0][0] * y; >+ result[0][1] = x[0][1] * y; >+ result[1][0] = x[1][0] * y; >+ result[1][1] = x[1][1] * y; >+ result[2][0] = x[2][0] * y; >+ result[2][1] = x[2][1] * y; >+ result[3][0] = x[3][0] * y; >+ result[3][1] = x[3][1] * y; >+ return result; >+} >+half4x3 mul(half x, half4x3 y) { >+ half4x3 result; >+ result[0][0] = x * y[0][0]; >+ result[0][1] = x * y[0][1]; >+ result[0][2] = x * y[0][2]; >+ result[1][0] = x * y[1][0]; >+ result[1][1] = x * y[1][1]; >+ result[1][2] = x * y[1][2]; >+ result[2][0] = x * y[2][0]; >+ result[2][1] = x * y[2][1]; >+ result[2][2] = x * y[2][2]; >+ result[3][0] = x * y[3][0]; >+ result[3][1] = x * y[3][1]; >+ result[3][2] = x * y[3][2]; >+ return result; >+} >+half4x3 mul(half4x3 x, half y) { >+ half4x3 result; >+ result[0][0] = x[0][0] * y; >+ result[0][1] = x[0][1] * y; >+ result[0][2] = x[0][2] * y; >+ result[1][0] = x[1][0] * y; >+ result[1][1] = x[1][1] * y; >+ result[1][2] = x[1][2] * y; >+ result[2][0] = x[2][0] * y; >+ result[2][1] = x[2][1] * y; >+ result[2][2] = x[2][2] * y; >+ result[3][0] = x[3][0] * y; >+ result[3][1] = x[3][1] * y; >+ result[3][2] = x[3][2] * y; >+ return result; >+} >+half4x4 mul(half x, half4x4 y) { >+ half4x4 result; >+ result[0][0] = x * y[0][0]; >+ result[0][1] = x * y[0][1]; >+ result[0][2] = x * y[0][2]; >+ result[0][3] = x * y[0][3]; >+ result[1][0] = x * y[1][0]; >+ result[1][1] = x * y[1][1]; >+ result[1][2] = x * y[1][2]; >+ result[1][3] = x * y[1][3]; >+ result[2][0] = x * y[2][0]; >+ result[2][1] = x * y[2][1]; >+ result[2][2] = x * y[2][2]; >+ result[2][3] = x * y[2][3]; >+ result[3][0] = x * y[3][0]; >+ result[3][1] = x * y[3][1]; >+ result[3][2] = x * y[3][2]; >+ result[3][3] = x * y[3][3]; >+ return result; >+} >+half4x4 mul(half4x4 x, half y) { >+ half4x4 result; >+ result[0][0] = x[0][0] * y; >+ result[0][1] = x[0][1] * y; >+ result[0][2] = x[0][2] * y; >+ result[0][3] = x[0][3] * y; >+ result[1][0] = x[1][0] * y; >+ result[1][1] = x[1][1] * y; >+ result[1][2] = x[1][2] * y; >+ result[1][3] = x[1][3] * y; >+ result[2][0] = x[2][0] * y; >+ result[2][1] = x[2][1] * y; >+ result[2][2] = x[2][2] * y; >+ result[2][3] = x[2][3] * y; >+ result[3][0] = x[3][0] * y; >+ result[3][1] = x[3][1] * y; >+ result[3][2] = x[3][2] * y; >+ result[3][3] = x[3][3] * y; >+ return result; >+} >+float2x2 mul(float x, float2x2 y) { >+ float2x2 result; >+ result[0][0] = x * y[0][0]; >+ result[0][1] = x * y[0][1]; >+ result[1][0] = x * y[1][0]; >+ result[1][1] = x * y[1][1]; >+ return result; >+} >+float2x2 mul(float2x2 x, float y) { >+ float2x2 result; >+ result[0][0] = x[0][0] * y; >+ result[0][1] = x[0][1] * y; >+ result[1][0] = x[1][0] * y; >+ result[1][1] = x[1][1] * y; >+ return result; >+} >+float2x3 mul(float x, float2x3 y) { >+ float2x3 result; >+ result[0][0] = x * y[0][0]; >+ result[0][1] = x * y[0][1]; >+ result[0][2] = x * y[0][2]; >+ result[1][0] = x * y[1][0]; >+ result[1][1] = x * y[1][1]; >+ result[1][2] = x * y[1][2]; >+ return result; >+} >+float2x3 mul(float2x3 x, float y) { >+ float2x3 result; >+ result[0][0] = x[0][0] * y; >+ result[0][1] = x[0][1] * y; >+ result[0][2] = x[0][2] * y; >+ result[1][0] = x[1][0] * y; >+ result[1][1] = x[1][1] * y; >+ result[1][2] = x[1][2] * y; >+ return result; >+} >+float2x4 mul(float x, float2x4 y) { >+ float2x4 result; >+ result[0][0] = x * y[0][0]; >+ result[0][1] = x * y[0][1]; >+ result[0][2] = x * y[0][2]; >+ result[0][3] = x * y[0][3]; >+ result[1][0] = x * y[1][0]; >+ result[1][1] = x * y[1][1]; >+ result[1][2] = x * y[1][2]; >+ result[1][3] = x * y[1][3]; >+ return result; >+} >+float2x4 mul(float2x4 x, float y) { >+ float2x4 result; >+ result[0][0] = x[0][0] * y; >+ result[0][1] = x[0][1] * y; >+ result[0][2] = x[0][2] * y; >+ result[0][3] = x[0][3] * y; >+ result[1][0] = x[1][0] * y; >+ result[1][1] = x[1][1] * y; >+ result[1][2] = x[1][2] * y; >+ result[1][3] = x[1][3] * y; >+ return result; >+} >+float3x2 mul(float x, float3x2 y) { >+ float3x2 result; >+ result[0][0] = x * y[0][0]; >+ result[0][1] = x * y[0][1]; >+ result[1][0] = x * y[1][0]; >+ result[1][1] = x * y[1][1]; >+ result[2][0] = x * y[2][0]; >+ result[2][1] = x * y[2][1]; >+ return result; >+} >+float3x2 mul(float3x2 x, float y) { >+ float3x2 result; >+ result[0][0] = x[0][0] * y; >+ result[0][1] = x[0][1] * y; >+ result[1][0] = x[1][0] * y; >+ result[1][1] = x[1][1] * y; >+ result[2][0] = x[2][0] * y; >+ result[2][1] = x[2][1] * y; >+ return result; >+} >+float3x3 mul(float x, float3x3 y) { >+ float3x3 result; >+ result[0][0] = x * y[0][0]; >+ result[0][1] = x * y[0][1]; >+ result[0][2] = x * y[0][2]; >+ result[1][0] = x * y[1][0]; >+ result[1][1] = x * y[1][1]; >+ result[1][2] = x * y[1][2]; >+ result[2][0] = x * y[2][0]; >+ result[2][1] = x * y[2][1]; >+ result[2][2] = x * y[2][2]; >+ return result; >+} >+float3x3 mul(float3x3 x, float y) { >+ float3x3 result; >+ result[0][0] = x[0][0] * y; >+ result[0][1] = x[0][1] * y; >+ result[0][2] = x[0][2] * y; >+ result[1][0] = x[1][0] * y; >+ result[1][1] = x[1][1] * y; >+ result[1][2] = x[1][2] * y; >+ result[2][0] = x[2][0] * y; >+ result[2][1] = x[2][1] * y; >+ result[2][2] = x[2][2] * y; >+ return result; >+} >+float3x4 mul(float x, float3x4 y) { >+ float3x4 result; >+ result[0][0] = x * y[0][0]; >+ result[0][1] = x * y[0][1]; >+ result[0][2] = x * y[0][2]; >+ result[0][3] = x * y[0][3]; >+ result[1][0] = x * y[1][0]; >+ result[1][1] = x * y[1][1]; >+ result[1][2] = x * y[1][2]; >+ result[1][3] = x * y[1][3]; >+ result[2][0] = x * y[2][0]; >+ result[2][1] = x * y[2][1]; >+ result[2][2] = x * y[2][2]; >+ result[2][3] = x * y[2][3]; >+ return result; >+} >+float3x4 mul(float3x4 x, float y) { >+ float3x4 result; >+ result[0][0] = x[0][0] * y; >+ result[0][1] = x[0][1] * y; >+ result[0][2] = x[0][2] * y; >+ result[0][3] = x[0][3] * y; >+ result[1][0] = x[1][0] * y; >+ result[1][1] = x[1][1] * y; >+ result[1][2] = x[1][2] * y; >+ result[1][3] = x[1][3] * y; >+ result[2][0] = x[2][0] * y; >+ result[2][1] = x[2][1] * y; >+ result[2][2] = x[2][2] * y; >+ result[2][3] = x[2][3] * y; >+ return result; >+} >+float4x2 mul(float x, float4x2 y) { >+ float4x2 result; >+ result[0][0] = x * y[0][0]; >+ result[0][1] = x * y[0][1]; >+ result[1][0] = x * y[1][0]; >+ result[1][1] = x * y[1][1]; >+ result[2][0] = x * y[2][0]; >+ result[2][1] = x * y[2][1]; >+ result[3][0] = x * y[3][0]; >+ result[3][1] = x * y[3][1]; >+ return result; >+} >+float4x2 mul(float4x2 x, float y) { >+ float4x2 result; >+ result[0][0] = x[0][0] * y; >+ result[0][1] = x[0][1] * y; >+ result[1][0] = x[1][0] * y; >+ result[1][1] = x[1][1] * y; >+ result[2][0] = x[2][0] * y; >+ result[2][1] = x[2][1] * y; >+ result[3][0] = x[3][0] * y; >+ result[3][1] = x[3][1] * y; >+ return result; >+} >+float4x3 mul(float x, float4x3 y) { >+ float4x3 result; >+ result[0][0] = x * y[0][0]; >+ result[0][1] = x * y[0][1]; >+ result[0][2] = x * y[0][2]; >+ result[1][0] = x * y[1][0]; >+ result[1][1] = x * y[1][1]; >+ result[1][2] = x * y[1][2]; >+ result[2][0] = x * y[2][0]; >+ result[2][1] = x * y[2][1]; >+ result[2][2] = x * y[2][2]; >+ result[3][0] = x * y[3][0]; >+ result[3][1] = x * y[3][1]; >+ result[3][2] = x * y[3][2]; >+ return result; >+} >+float4x3 mul(float4x3 x, float y) { >+ float4x3 result; >+ result[0][0] = x[0][0] * y; >+ result[0][1] = x[0][1] * y; >+ result[0][2] = x[0][2] * y; >+ result[1][0] = x[1][0] * y; >+ result[1][1] = x[1][1] * y; >+ result[1][2] = x[1][2] * y; >+ result[2][0] = x[2][0] * y; >+ result[2][1] = x[2][1] * y; >+ result[2][2] = x[2][2] * y; >+ result[3][0] = x[3][0] * y; >+ result[3][1] = x[3][1] * y; >+ result[3][2] = x[3][2] * y; >+ return result; >+} >+float4x4 mul(float x, float4x4 y) { >+ float4x4 result; >+ result[0][0] = x * y[0][0]; >+ result[0][1] = x * y[0][1]; >+ result[0][2] = x * y[0][2]; >+ result[0][3] = x * y[0][3]; >+ result[1][0] = x * y[1][0]; >+ result[1][1] = x * y[1][1]; >+ result[1][2] = x * y[1][2]; >+ result[1][3] = x * y[1][3]; >+ result[2][0] = x * y[2][0]; >+ result[2][1] = x * y[2][1]; >+ result[2][2] = x * y[2][2]; >+ result[2][3] = x * y[2][3]; >+ result[3][0] = x * y[3][0]; >+ result[3][1] = x * y[3][1]; >+ result[3][2] = x * y[3][2]; >+ result[3][3] = x * y[3][3]; >+ return result; >+} >+float4x4 mul(float4x4 x, float y) { >+ float4x4 result; >+ result[0][0] = x[0][0] * y; >+ result[0][1] = x[0][1] * y; >+ result[0][2] = x[0][2] * y; >+ result[0][3] = x[0][3] * y; >+ result[1][0] = x[1][0] * y; >+ result[1][1] = x[1][1] * y; >+ result[1][2] = x[1][2] * y; >+ result[1][3] = x[1][3] * y; >+ result[2][0] = x[2][0] * y; >+ result[2][1] = x[2][1] * y; >+ result[2][2] = x[2][2] * y; >+ result[2][3] = x[2][3] * y; >+ result[3][0] = x[3][0] * y; >+ result[3][1] = x[3][1] * y; >+ result[3][2] = x[3][2] * y; >+ result[3][3] = x[3][3] * y; >+ return result; >+} >+uchar mul(uchar2 x, uchar2 y) { >+ return dot(x, y); >+} >+uchar mul(uchar3 x, uchar3 y) { >+ return dot(x, y); >+} >+uchar mul(uchar4 x, uchar4 y) { >+ return dot(x, y); >+} >+ushort mul(ushort2 x, ushort2 y) { >+ return dot(x, y); >+} >+ushort mul(ushort3 x, ushort3 y) { >+ return dot(x, y); >+} >+ushort mul(ushort4 x, ushort4 y) { >+ return dot(x, y); >+} >+uint mul(uint2 x, uint2 y) { >+ return dot(x, y); >+} >+uint mul(uint3 x, uint3 y) { >+ return dot(x, y); >+} >+uint mul(uint4 x, uint4 y) { >+ return dot(x, y); >+} >+char mul(char2 x, char2 y) { >+ return dot(x, y); >+} >+char mul(char3 x, char3 y) { >+ return dot(x, y); >+} >+char mul(char4 x, char4 y) { >+ return dot(x, y); >+} >+short mul(short2 x, short2 y) { >+ return dot(x, y); >+} >+short mul(short3 x, short3 y) { >+ return dot(x, y); >+} >+short mul(short4 x, short4 y) { >+ return dot(x, y); >+} >+int mul(int2 x, int2 y) { >+ return dot(x, y); >+} >+int mul(int3 x, int3 y) { >+ return dot(x, y); >+} >+int mul(int4 x, int4 y) { >+ return dot(x, y); >+} >+half mul(half2 x, half2 y) { >+ return dot(x, y); >+} >+half mul(half3 x, half3 y) { >+ return dot(x, y); >+} >+half mul(half4 x, half4 y) { >+ return dot(x, y); >+} >+float mul(float2 x, float2 y) { >+ return dot(x, y); >+} >+float mul(float3 x, float3 y) { >+ return dot(x, y); >+} >+float mul(float4 x, float4 y) { >+ return dot(x, y); >+} >+half2 mul(half2 x, half2x2 y) { >+ half2 result; >+ result[0] = 0; >+ result[0] += x[0] * y[0][0]; >+ result[0] += x[1] * y[1][0]; >+ result[1] = 0; >+ result[1] += x[0] * y[0][1]; >+ result[1] += x[1] * y[1][1]; >+ return result; >+} >+half2 mul(half2x2 x, half2 y) { >+ half2 result; >+ result[0] = 0; >+ result[0] += x[0][0] * y[0]; >+ result[0] += x[0][1] * y[1]; >+ result[1] = 0; >+ result[1] += x[1][0] * y[0]; >+ result[1] += x[1][1] * y[1]; >+ return result; >+} >+half3 mul(half2 x, half2x3 y) { >+ half3 result; >+ result[0] = 0; >+ result[0] += x[0] * y[0][0]; >+ result[0] += x[1] * y[1][0]; >+ result[1] = 0; >+ result[1] += x[0] * y[0][1]; >+ result[1] += x[1] * y[1][1]; >+ result[2] = 0; >+ result[2] += x[0] * y[0][2]; >+ result[2] += x[1] * y[1][2]; >+ return result; >+} >+half2 mul(half2x3 x, half3 y) { >+ half2 result; >+ result[0] = 0; >+ result[0] += x[0][0] * y[0]; >+ result[0] += x[0][1] * y[1]; >+ result[0] += x[0][2] * y[2]; >+ result[1] = 0; >+ result[1] += x[1][0] * y[0]; >+ result[1] += x[1][1] * y[1]; >+ result[1] += x[1][2] * y[2]; >+ return result; >+} >+half4 mul(half2 x, half2x4 y) { >+ half4 result; >+ result[0] = 0; >+ result[0] += x[0] * y[0][0]; >+ result[0] += x[1] * y[1][0]; >+ result[1] = 0; >+ result[1] += x[0] * y[0][1]; >+ result[1] += x[1] * y[1][1]; >+ result[2] = 0; >+ result[2] += x[0] * y[0][2]; >+ result[2] += x[1] * y[1][2]; >+ result[3] = 0; >+ result[3] += x[0] * y[0][3]; >+ result[3] += x[1] * y[1][3]; >+ return result; >+} >+half2 mul(half2x4 x, half4 y) { >+ half2 result; >+ result[0] = 0; >+ result[0] += x[0][0] * y[0]; >+ result[0] += x[0][1] * y[1]; >+ result[0] += x[0][2] * y[2]; >+ result[0] += x[0][3] * y[3]; >+ result[1] = 0; >+ result[1] += x[1][0] * y[0]; >+ result[1] += x[1][1] * y[1]; >+ result[1] += x[1][2] * y[2]; >+ result[1] += x[1][3] * y[3]; >+ return result; >+} >+half2 mul(half3 x, half3x2 y) { >+ half2 result; >+ result[0] = 0; >+ result[0] += x[0] * y[0][0]; >+ result[0] += x[1] * y[1][0]; >+ result[0] += x[2] * y[2][0]; >+ result[1] = 0; >+ result[1] += x[0] * y[0][1]; >+ result[1] += x[1] * y[1][1]; >+ result[1] += x[2] * y[2][1]; >+ return result; >+} >+half3 mul(half3x2 x, half2 y) { >+ half3 result; >+ result[0] = 0; >+ result[0] += x[0][0] * y[0]; >+ result[0] += x[0][1] * y[1]; >+ result[1] = 0; >+ result[1] += x[1][0] * y[0]; >+ result[1] += x[1][1] * y[1]; >+ result[2] = 0; >+ result[2] += x[2][0] * y[0]; >+ result[2] += x[2][1] * y[1]; >+ return result; >+} >+half3 mul(half3 x, half3x3 y) { >+ half3 result; >+ result[0] = 0; >+ result[0] += x[0] * y[0][0]; >+ result[0] += x[1] * y[1][0]; >+ result[0] += x[2] * y[2][0]; >+ result[1] = 0; >+ result[1] += x[0] * y[0][1]; >+ result[1] += x[1] * y[1][1]; >+ result[1] += x[2] * y[2][1]; >+ result[2] = 0; >+ result[2] += x[0] * y[0][2]; >+ result[2] += x[1] * y[1][2]; >+ result[2] += x[2] * y[2][2]; >+ return result; >+} >+half3 mul(half3x3 x, half3 y) { >+ half3 result; >+ result[0] = 0; >+ result[0] += x[0][0] * y[0]; >+ result[0] += x[0][1] * y[1]; >+ result[0] += x[0][2] * y[2]; >+ result[1] = 0; >+ result[1] += x[1][0] * y[0]; >+ result[1] += x[1][1] * y[1]; >+ result[1] += x[1][2] * y[2]; >+ result[2] = 0; >+ result[2] += x[2][0] * y[0]; >+ result[2] += x[2][1] * y[1]; >+ result[2] += x[2][2] * y[2]; >+ return result; >+} >+half4 mul(half3 x, half3x4 y) { >+ half4 result; >+ result[0] = 0; >+ result[0] += x[0] * y[0][0]; >+ result[0] += x[1] * y[1][0]; >+ result[0] += x[2] * y[2][0]; >+ result[1] = 0; >+ result[1] += x[0] * y[0][1]; >+ result[1] += x[1] * y[1][1]; >+ result[1] += x[2] * y[2][1]; >+ result[2] = 0; >+ result[2] += x[0] * y[0][2]; >+ result[2] += x[1] * y[1][2]; >+ result[2] += x[2] * y[2][2]; >+ result[3] = 0; >+ result[3] += x[0] * y[0][3]; >+ result[3] += x[1] * y[1][3]; >+ result[3] += x[2] * y[2][3]; >+ return result; >+} >+half3 mul(half3x4 x, half4 y) { >+ half3 result; >+ result[0] = 0; >+ result[0] += x[0][0] * y[0]; >+ result[0] += x[0][1] * y[1]; >+ result[0] += x[0][2] * y[2]; >+ result[0] += x[0][3] * y[3]; >+ result[1] = 0; >+ result[1] += x[1][0] * y[0]; >+ result[1] += x[1][1] * y[1]; >+ result[1] += x[1][2] * y[2]; >+ result[1] += x[1][3] * y[3]; >+ result[2] = 0; >+ result[2] += x[2][0] * y[0]; >+ result[2] += x[2][1] * y[1]; >+ result[2] += x[2][2] * y[2]; >+ result[2] += x[2][3] * y[3]; >+ return result; >+} >+half2 mul(half4 x, half4x2 y) { >+ half2 result; >+ result[0] = 0; >+ result[0] += x[0] * y[0][0]; >+ result[0] += x[1] * y[1][0]; >+ result[0] += x[2] * y[2][0]; >+ result[0] += x[3] * y[3][0]; >+ result[1] = 0; >+ result[1] += x[0] * y[0][1]; >+ result[1] += x[1] * y[1][1]; >+ result[1] += x[2] * y[2][1]; >+ result[1] += x[3] * y[3][1]; >+ return result; >+} >+half4 mul(half4x2 x, half2 y) { >+ half4 result; >+ result[0] = 0; >+ result[0] += x[0][0] * y[0]; >+ result[0] += x[0][1] * y[1]; >+ result[1] = 0; >+ result[1] += x[1][0] * y[0]; >+ result[1] += x[1][1] * y[1]; >+ result[2] = 0; >+ result[2] += x[2][0] * y[0]; >+ result[2] += x[2][1] * y[1]; >+ result[3] = 0; >+ result[3] += x[3][0] * y[0]; >+ result[3] += x[3][1] * y[1]; >+ return result; >+} >+half3 mul(half4 x, half4x3 y) { >+ half3 result; >+ result[0] = 0; >+ result[0] += x[0] * y[0][0]; >+ result[0] += x[1] * y[1][0]; >+ result[0] += x[2] * y[2][0]; >+ result[0] += x[3] * y[3][0]; >+ result[1] = 0; >+ result[1] += x[0] * y[0][1]; >+ result[1] += x[1] * y[1][1]; >+ result[1] += x[2] * y[2][1]; >+ result[1] += x[3] * y[3][1]; >+ result[2] = 0; >+ result[2] += x[0] * y[0][2]; >+ result[2] += x[1] * y[1][2]; >+ result[2] += x[2] * y[2][2]; >+ result[2] += x[3] * y[3][2]; >+ return result; >+} >+half4 mul(half4x3 x, half3 y) { >+ half4 result; >+ result[0] = 0; >+ result[0] += x[0][0] * y[0]; >+ result[0] += x[0][1] * y[1]; >+ result[0] += x[0][2] * y[2]; >+ result[1] = 0; >+ result[1] += x[1][0] * y[0]; >+ result[1] += x[1][1] * y[1]; >+ result[1] += x[1][2] * y[2]; >+ result[2] = 0; >+ result[2] += x[2][0] * y[0]; >+ result[2] += x[2][1] * y[1]; >+ result[2] += x[2][2] * y[2]; >+ result[3] = 0; >+ result[3] += x[3][0] * y[0]; >+ result[3] += x[3][1] * y[1]; >+ result[3] += x[3][2] * y[2]; >+ return result; >+} >+half4 mul(half4 x, half4x4 y) { >+ half4 result; >+ result[0] = 0; >+ result[0] += x[0] * y[0][0]; >+ result[0] += x[1] * y[1][0]; >+ result[0] += x[2] * y[2][0]; >+ result[0] += x[3] * y[3][0]; >+ result[1] = 0; >+ result[1] += x[0] * y[0][1]; >+ result[1] += x[1] * y[1][1]; >+ result[1] += x[2] * y[2][1]; >+ result[1] += x[3] * y[3][1]; >+ result[2] = 0; >+ result[2] += x[0] * y[0][2]; >+ result[2] += x[1] * y[1][2]; >+ result[2] += x[2] * y[2][2]; >+ result[2] += x[3] * y[3][2]; >+ result[3] = 0; >+ result[3] += x[0] * y[0][3]; >+ result[3] += x[1] * y[1][3]; >+ result[3] += x[2] * y[2][3]; >+ result[3] += x[3] * y[3][3]; >+ return result; >+} >+half4 mul(half4x4 x, half4 y) { >+ half4 result; >+ result[0] = 0; >+ result[0] += x[0][0] * y[0]; >+ result[0] += x[0][1] * y[1]; >+ result[0] += x[0][2] * y[2]; >+ result[0] += x[0][3] * y[3]; >+ result[1] = 0; >+ result[1] += x[1][0] * y[0]; >+ result[1] += x[1][1] * y[1]; >+ result[1] += x[1][2] * y[2]; >+ result[1] += x[1][3] * y[3]; >+ result[2] = 0; >+ result[2] += x[2][0] * y[0]; >+ result[2] += x[2][1] * y[1]; >+ result[2] += x[2][2] * y[2]; >+ result[2] += x[2][3] * y[3]; >+ result[3] = 0; >+ result[3] += x[3][0] * y[0]; >+ result[3] += x[3][1] * y[1]; >+ result[3] += x[3][2] * y[2]; >+ result[3] += x[3][3] * y[3]; >+ return result; >+} >+float2 mul(float2 x, float2x2 y) { >+ float2 result; >+ result[0] = 0; >+ result[0] += x[0] * y[0][0]; >+ result[0] += x[1] * y[1][0]; >+ result[1] = 0; >+ result[1] += x[0] * y[0][1]; >+ result[1] += x[1] * y[1][1]; >+ return result; >+} >+float2 mul(float2x2 x, float2 y) { >+ float2 result; >+ result[0] = 0; >+ result[0] += x[0][0] * y[0]; >+ result[0] += x[0][1] * y[1]; >+ result[1] = 0; >+ result[1] += x[1][0] * y[0]; >+ result[1] += x[1][1] * y[1]; >+ return result; >+} >+float3 mul(float2 x, float2x3 y) { >+ float3 result; >+ result[0] = 0; >+ result[0] += x[0] * y[0][0]; >+ result[0] += x[1] * y[1][0]; >+ result[1] = 0; >+ result[1] += x[0] * y[0][1]; >+ result[1] += x[1] * y[1][1]; >+ result[2] = 0; >+ result[2] += x[0] * y[0][2]; >+ result[2] += x[1] * y[1][2]; >+ return result; >+} >+float2 mul(float2x3 x, float3 y) { >+ float2 result; >+ result[0] = 0; >+ result[0] += x[0][0] * y[0]; >+ result[0] += x[0][1] * y[1]; >+ result[0] += x[0][2] * y[2]; >+ result[1] = 0; >+ result[1] += x[1][0] * y[0]; >+ result[1] += x[1][1] * y[1]; >+ result[1] += x[1][2] * y[2]; >+ return result; >+} >+float4 mul(float2 x, float2x4 y) { >+ float4 result; >+ result[0] = 0; >+ result[0] += x[0] * y[0][0]; >+ result[0] += x[1] * y[1][0]; >+ result[1] = 0; >+ result[1] += x[0] * y[0][1]; >+ result[1] += x[1] * y[1][1]; >+ result[2] = 0; >+ result[2] += x[0] * y[0][2]; >+ result[2] += x[1] * y[1][2]; >+ result[3] = 0; >+ result[3] += x[0] * y[0][3]; >+ result[3] += x[1] * y[1][3]; >+ return result; >+} >+float2 mul(float2x4 x, float4 y) { >+ float2 result; >+ result[0] = 0; >+ result[0] += x[0][0] * y[0]; >+ result[0] += x[0][1] * y[1]; >+ result[0] += x[0][2] * y[2]; >+ result[0] += x[0][3] * y[3]; >+ result[1] = 0; >+ result[1] += x[1][0] * y[0]; >+ result[1] += x[1][1] * y[1]; >+ result[1] += x[1][2] * y[2]; >+ result[1] += x[1][3] * y[3]; >+ return result; >+} >+float2 mul(float3 x, float3x2 y) { >+ float2 result; >+ result[0] = 0; >+ result[0] += x[0] * y[0][0]; >+ result[0] += x[1] * y[1][0]; >+ result[0] += x[2] * y[2][0]; >+ result[1] = 0; >+ result[1] += x[0] * y[0][1]; >+ result[1] += x[1] * y[1][1]; >+ result[1] += x[2] * y[2][1]; >+ return result; >+} >+float3 mul(float3x2 x, float2 y) { >+ float3 result; >+ result[0] = 0; >+ result[0] += x[0][0] * y[0]; >+ result[0] += x[0][1] * y[1]; >+ result[1] = 0; >+ result[1] += x[1][0] * y[0]; >+ result[1] += x[1][1] * y[1]; >+ result[2] = 0; >+ result[2] += x[2][0] * y[0]; >+ result[2] += x[2][1] * y[1]; >+ return result; >+} >+float3 mul(float3 x, float3x3 y) { >+ float3 result; >+ result[0] = 0; >+ result[0] += x[0] * y[0][0]; >+ result[0] += x[1] * y[1][0]; >+ result[0] += x[2] * y[2][0]; >+ result[1] = 0; >+ result[1] += x[0] * y[0][1]; >+ result[1] += x[1] * y[1][1]; >+ result[1] += x[2] * y[2][1]; >+ result[2] = 0; >+ result[2] += x[0] * y[0][2]; >+ result[2] += x[1] * y[1][2]; >+ result[2] += x[2] * y[2][2]; >+ return result; >+} >+float3 mul(float3x3 x, float3 y) { >+ float3 result; >+ result[0] = 0; >+ result[0] += x[0][0] * y[0]; >+ result[0] += x[0][1] * y[1]; >+ result[0] += x[0][2] * y[2]; >+ result[1] = 0; >+ result[1] += x[1][0] * y[0]; >+ result[1] += x[1][1] * y[1]; >+ result[1] += x[1][2] * y[2]; >+ result[2] = 0; >+ result[2] += x[2][0] * y[0]; >+ result[2] += x[2][1] * y[1]; >+ result[2] += x[2][2] * y[2]; >+ return result; >+} >+float4 mul(float3 x, float3x4 y) { >+ float4 result; >+ result[0] = 0; >+ result[0] += x[0] * y[0][0]; >+ result[0] += x[1] * y[1][0]; >+ result[0] += x[2] * y[2][0]; >+ result[1] = 0; >+ result[1] += x[0] * y[0][1]; >+ result[1] += x[1] * y[1][1]; >+ result[1] += x[2] * y[2][1]; >+ result[2] = 0; >+ result[2] += x[0] * y[0][2]; >+ result[2] += x[1] * y[1][2]; >+ result[2] += x[2] * y[2][2]; >+ result[3] = 0; >+ result[3] += x[0] * y[0][3]; >+ result[3] += x[1] * y[1][3]; >+ result[3] += x[2] * y[2][3]; >+ return result; >+} >+float3 mul(float3x4 x, float4 y) { >+ float3 result; >+ result[0] = 0; >+ result[0] += x[0][0] * y[0]; >+ result[0] += x[0][1] * y[1]; >+ result[0] += x[0][2] * y[2]; >+ result[0] += x[0][3] * y[3]; >+ result[1] = 0; >+ result[1] += x[1][0] * y[0]; >+ result[1] += x[1][1] * y[1]; >+ result[1] += x[1][2] * y[2]; >+ result[1] += x[1][3] * y[3]; >+ result[2] = 0; >+ result[2] += x[2][0] * y[0]; >+ result[2] += x[2][1] * y[1]; >+ result[2] += x[2][2] * y[2]; >+ result[2] += x[2][3] * y[3]; >+ return result; >+} >+float2 mul(float4 x, float4x2 y) { >+ float2 result; >+ result[0] = 0; >+ result[0] += x[0] * y[0][0]; >+ result[0] += x[1] * y[1][0]; >+ result[0] += x[2] * y[2][0]; >+ result[0] += x[3] * y[3][0]; >+ result[1] = 0; >+ result[1] += x[0] * y[0][1]; >+ result[1] += x[1] * y[1][1]; >+ result[1] += x[2] * y[2][1]; >+ result[1] += x[3] * y[3][1]; >+ return result; >+} >+float4 mul(float4x2 x, float2 y) { >+ float4 result; >+ result[0] = 0; >+ result[0] += x[0][0] * y[0]; >+ result[0] += x[0][1] * y[1]; >+ result[1] = 0; >+ result[1] += x[1][0] * y[0]; >+ result[1] += x[1][1] * y[1]; >+ result[2] = 0; >+ result[2] += x[2][0] * y[0]; >+ result[2] += x[2][1] * y[1]; >+ result[3] = 0; >+ result[3] += x[3][0] * y[0]; >+ result[3] += x[3][1] * y[1]; >+ return result; >+} >+float3 mul(float4 x, float4x3 y) { >+ float3 result; >+ result[0] = 0; >+ result[0] += x[0] * y[0][0]; >+ result[0] += x[1] * y[1][0]; >+ result[0] += x[2] * y[2][0]; >+ result[0] += x[3] * y[3][0]; >+ result[1] = 0; >+ result[1] += x[0] * y[0][1]; >+ result[1] += x[1] * y[1][1]; >+ result[1] += x[2] * y[2][1]; >+ result[1] += x[3] * y[3][1]; >+ result[2] = 0; >+ result[2] += x[0] * y[0][2]; >+ result[2] += x[1] * y[1][2]; >+ result[2] += x[2] * y[2][2]; >+ result[2] += x[3] * y[3][2]; >+ return result; >+} >+float4 mul(float4x3 x, float3 y) { >+ float4 result; >+ result[0] = 0; >+ result[0] += x[0][0] * y[0]; >+ result[0] += x[0][1] * y[1]; >+ result[0] += x[0][2] * y[2]; >+ result[1] = 0; >+ result[1] += x[1][0] * y[0]; >+ result[1] += x[1][1] * y[1]; >+ result[1] += x[1][2] * y[2]; >+ result[2] = 0; >+ result[2] += x[2][0] * y[0]; >+ result[2] += x[2][1] * y[1]; >+ result[2] += x[2][2] * y[2]; >+ result[3] = 0; >+ result[3] += x[3][0] * y[0]; >+ result[3] += x[3][1] * y[1]; >+ result[3] += x[3][2] * y[2]; >+ return result; >+} >+float4 mul(float4 x, float4x4 y) { >+ float4 result; >+ result[0] = 0; >+ result[0] += x[0] * y[0][0]; >+ result[0] += x[1] * y[1][0]; >+ result[0] += x[2] * y[2][0]; >+ result[0] += x[3] * y[3][0]; >+ result[1] = 0; >+ result[1] += x[0] * y[0][1]; >+ result[1] += x[1] * y[1][1]; >+ result[1] += x[2] * y[2][1]; >+ result[1] += x[3] * y[3][1]; >+ result[2] = 0; >+ result[2] += x[0] * y[0][2]; >+ result[2] += x[1] * y[1][2]; >+ result[2] += x[2] * y[2][2]; >+ result[2] += x[3] * y[3][2]; >+ result[3] = 0; >+ result[3] += x[0] * y[0][3]; >+ result[3] += x[1] * y[1][3]; >+ result[3] += x[2] * y[2][3]; >+ result[3] += x[3] * y[3][3]; >+ return result; >+} >+float4 mul(float4x4 x, float4 y) { >+ float4 result; >+ result[0] = 0; >+ result[0] += x[0][0] * y[0]; >+ result[0] += x[0][1] * y[1]; >+ result[0] += x[0][2] * y[2]; >+ result[0] += x[0][3] * y[3]; >+ result[1] = 0; >+ result[1] += x[1][0] * y[0]; >+ result[1] += x[1][1] * y[1]; >+ result[1] += x[1][2] * y[2]; >+ result[1] += x[1][3] * y[3]; >+ result[2] = 0; >+ result[2] += x[2][0] * y[0]; >+ result[2] += x[2][1] * y[1]; >+ result[2] += x[2][2] * y[2]; >+ result[2] += x[2][3] * y[3]; >+ result[3] = 0; >+ result[3] += x[3][0] * y[0]; >+ result[3] += x[3][1] * y[1]; >+ result[3] += x[3][2] * y[2]; >+ result[3] += x[3][3] * y[3]; >+ return result; >+} >+half2x2 mul(half2x2 x, half2x2 y) { >+ half2x2 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ return result; >+} >+half2x3 mul(half2x2 x, half2x3 y) { >+ half2x3 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ return result; >+} >+half2x4 mul(half2x2 x, half2x4 y) { >+ half2x4 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][3] = 0; >+ result[0][3] += x[0][0] * y[0][3]; >+ result[0][3] += x[0][1] * y[1][3]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][3] = 0; >+ result[1][3] += x[1][0] * y[0][3]; >+ result[1][3] += x[1][1] * y[1][3]; >+ return result; >+} >+half2x2 mul(half2x3 x, half3x2 y) { >+ half2x2 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ return result; >+} >+half2x3 mul(half2x3 x, half3x3 y) { >+ half2x3 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][2] += x[0][2] * y[2][2]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][2] += x[1][2] * y[2][2]; >+ return result; >+} >+half2x4 mul(half2x3 x, half3x4 y) { >+ half2x4 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][2] += x[0][2] * y[2][2]; >+ result[0][3] = 0; >+ result[0][3] += x[0][0] * y[0][3]; >+ result[0][3] += x[0][1] * y[1][3]; >+ result[0][3] += x[0][2] * y[2][3]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][2] += x[1][2] * y[2][2]; >+ result[1][3] = 0; >+ result[1][3] += x[1][0] * y[0][3]; >+ result[1][3] += x[1][1] * y[1][3]; >+ result[1][3] += x[1][2] * y[2][3]; >+ return result; >+} >+half2x2 mul(half2x4 x, half4x2 y) { >+ half2x2 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][0] += x[0][3] * y[3][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][1] += x[0][3] * y[3][1]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][0] += x[1][3] * y[3][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][1] += x[1][3] * y[3][1]; >+ return result; >+} >+half2x3 mul(half2x4 x, half4x3 y) { >+ half2x3 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][0] += x[0][3] * y[3][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][1] += x[0][3] * y[3][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][2] += x[0][2] * y[2][2]; >+ result[0][2] += x[0][3] * y[3][2]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][0] += x[1][3] * y[3][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][1] += x[1][3] * y[3][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][2] += x[1][2] * y[2][2]; >+ result[1][2] += x[1][3] * y[3][2]; >+ return result; >+} >+half2x4 mul(half2x4 x, half4x4 y) { >+ half2x4 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][0] += x[0][3] * y[3][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][1] += x[0][3] * y[3][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][2] += x[0][2] * y[2][2]; >+ result[0][2] += x[0][3] * y[3][2]; >+ result[0][3] = 0; >+ result[0][3] += x[0][0] * y[0][3]; >+ result[0][3] += x[0][1] * y[1][3]; >+ result[0][3] += x[0][2] * y[2][3]; >+ result[0][3] += x[0][3] * y[3][3]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][0] += x[1][3] * y[3][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][1] += x[1][3] * y[3][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][2] += x[1][2] * y[2][2]; >+ result[1][2] += x[1][3] * y[3][2]; >+ result[1][3] = 0; >+ result[1][3] += x[1][0] * y[0][3]; >+ result[1][3] += x[1][1] * y[1][3]; >+ result[1][3] += x[1][2] * y[2][3]; >+ result[1][3] += x[1][3] * y[3][3]; >+ return result; >+} >+half3x2 mul(half3x2 x, half2x2 y) { >+ half3x2 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ return result; >+} >+half3x3 mul(half3x2 x, half2x3 y) { >+ half3x3 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][2] = 0; >+ result[2][2] += x[2][0] * y[0][2]; >+ result[2][2] += x[2][1] * y[1][2]; >+ return result; >+} >+half3x4 mul(half3x2 x, half2x4 y) { >+ half3x4 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][3] = 0; >+ result[0][3] += x[0][0] * y[0][3]; >+ result[0][3] += x[0][1] * y[1][3]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][3] = 0; >+ result[1][3] += x[1][0] * y[0][3]; >+ result[1][3] += x[1][1] * y[1][3]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][2] = 0; >+ result[2][2] += x[2][0] * y[0][2]; >+ result[2][2] += x[2][1] * y[1][2]; >+ result[2][3] = 0; >+ result[2][3] += x[2][0] * y[0][3]; >+ result[2][3] += x[2][1] * y[1][3]; >+ return result; >+} >+half3x2 mul(half3x3 x, half3x2 y) { >+ half3x2 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][0] += x[2][2] * y[2][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][1] += x[2][2] * y[2][1]; >+ return result; >+} >+half3x3 mul(half3x3 x, half3x3 y) { >+ half3x3 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][2] += x[0][2] * y[2][2]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][2] += x[1][2] * y[2][2]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][0] += x[2][2] * y[2][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][1] += x[2][2] * y[2][1]; >+ result[2][2] = 0; >+ result[2][2] += x[2][0] * y[0][2]; >+ result[2][2] += x[2][1] * y[1][2]; >+ result[2][2] += x[2][2] * y[2][2]; >+ return result; >+} >+half3x4 mul(half3x3 x, half3x4 y) { >+ half3x4 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][2] += x[0][2] * y[2][2]; >+ result[0][3] = 0; >+ result[0][3] += x[0][0] * y[0][3]; >+ result[0][3] += x[0][1] * y[1][3]; >+ result[0][3] += x[0][2] * y[2][3]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][2] += x[1][2] * y[2][2]; >+ result[1][3] = 0; >+ result[1][3] += x[1][0] * y[0][3]; >+ result[1][3] += x[1][1] * y[1][3]; >+ result[1][3] += x[1][2] * y[2][3]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][0] += x[2][2] * y[2][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][1] += x[2][2] * y[2][1]; >+ result[2][2] = 0; >+ result[2][2] += x[2][0] * y[0][2]; >+ result[2][2] += x[2][1] * y[1][2]; >+ result[2][2] += x[2][2] * y[2][2]; >+ result[2][3] = 0; >+ result[2][3] += x[2][0] * y[0][3]; >+ result[2][3] += x[2][1] * y[1][3]; >+ result[2][3] += x[2][2] * y[2][3]; >+ return result; >+} >+half3x2 mul(half3x4 x, half4x2 y) { >+ half3x2 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][0] += x[0][3] * y[3][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][1] += x[0][3] * y[3][1]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][0] += x[1][3] * y[3][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][1] += x[1][3] * y[3][1]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][0] += x[2][2] * y[2][0]; >+ result[2][0] += x[2][3] * y[3][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][1] += x[2][2] * y[2][1]; >+ result[2][1] += x[2][3] * y[3][1]; >+ return result; >+} >+half3x3 mul(half3x4 x, half4x3 y) { >+ half3x3 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][0] += x[0][3] * y[3][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][1] += x[0][3] * y[3][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][2] += x[0][2] * y[2][2]; >+ result[0][2] += x[0][3] * y[3][2]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][0] += x[1][3] * y[3][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][1] += x[1][3] * y[3][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][2] += x[1][2] * y[2][2]; >+ result[1][2] += x[1][3] * y[3][2]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][0] += x[2][2] * y[2][0]; >+ result[2][0] += x[2][3] * y[3][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][1] += x[2][2] * y[2][1]; >+ result[2][1] += x[2][3] * y[3][1]; >+ result[2][2] = 0; >+ result[2][2] += x[2][0] * y[0][2]; >+ result[2][2] += x[2][1] * y[1][2]; >+ result[2][2] += x[2][2] * y[2][2]; >+ result[2][2] += x[2][3] * y[3][2]; >+ return result; >+} >+half3x4 mul(half3x4 x, half4x4 y) { >+ half3x4 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][0] += x[0][3] * y[3][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][1] += x[0][3] * y[3][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][2] += x[0][2] * y[2][2]; >+ result[0][2] += x[0][3] * y[3][2]; >+ result[0][3] = 0; >+ result[0][3] += x[0][0] * y[0][3]; >+ result[0][3] += x[0][1] * y[1][3]; >+ result[0][3] += x[0][2] * y[2][3]; >+ result[0][3] += x[0][3] * y[3][3]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][0] += x[1][3] * y[3][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][1] += x[1][3] * y[3][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][2] += x[1][2] * y[2][2]; >+ result[1][2] += x[1][3] * y[3][2]; >+ result[1][3] = 0; >+ result[1][3] += x[1][0] * y[0][3]; >+ result[1][3] += x[1][1] * y[1][3]; >+ result[1][3] += x[1][2] * y[2][3]; >+ result[1][3] += x[1][3] * y[3][3]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][0] += x[2][2] * y[2][0]; >+ result[2][0] += x[2][3] * y[3][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][1] += x[2][2] * y[2][1]; >+ result[2][1] += x[2][3] * y[3][1]; >+ result[2][2] = 0; >+ result[2][2] += x[2][0] * y[0][2]; >+ result[2][2] += x[2][1] * y[1][2]; >+ result[2][2] += x[2][2] * y[2][2]; >+ result[2][2] += x[2][3] * y[3][2]; >+ result[2][3] = 0; >+ result[2][3] += x[2][0] * y[0][3]; >+ result[2][3] += x[2][1] * y[1][3]; >+ result[2][3] += x[2][2] * y[2][3]; >+ result[2][3] += x[2][3] * y[3][3]; >+ return result; >+} >+half4x2 mul(half4x2 x, half2x2 y) { >+ half4x2 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[3][0] = 0; >+ result[3][0] += x[3][0] * y[0][0]; >+ result[3][0] += x[3][1] * y[1][0]; >+ result[3][1] = 0; >+ result[3][1] += x[3][0] * y[0][1]; >+ result[3][1] += x[3][1] * y[1][1]; >+ return result; >+} >+half4x3 mul(half4x2 x, half2x3 y) { >+ half4x3 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][2] = 0; >+ result[2][2] += x[2][0] * y[0][2]; >+ result[2][2] += x[2][1] * y[1][2]; >+ result[3][0] = 0; >+ result[3][0] += x[3][0] * y[0][0]; >+ result[3][0] += x[3][1] * y[1][0]; >+ result[3][1] = 0; >+ result[3][1] += x[3][0] * y[0][1]; >+ result[3][1] += x[3][1] * y[1][1]; >+ result[3][2] = 0; >+ result[3][2] += x[3][0] * y[0][2]; >+ result[3][2] += x[3][1] * y[1][2]; >+ return result; >+} >+half4x4 mul(half4x2 x, half2x4 y) { >+ half4x4 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][3] = 0; >+ result[0][3] += x[0][0] * y[0][3]; >+ result[0][3] += x[0][1] * y[1][3]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][3] = 0; >+ result[1][3] += x[1][0] * y[0][3]; >+ result[1][3] += x[1][1] * y[1][3]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][2] = 0; >+ result[2][2] += x[2][0] * y[0][2]; >+ result[2][2] += x[2][1] * y[1][2]; >+ result[2][3] = 0; >+ result[2][3] += x[2][0] * y[0][3]; >+ result[2][3] += x[2][1] * y[1][3]; >+ result[3][0] = 0; >+ result[3][0] += x[3][0] * y[0][0]; >+ result[3][0] += x[3][1] * y[1][0]; >+ result[3][1] = 0; >+ result[3][1] += x[3][0] * y[0][1]; >+ result[3][1] += x[3][1] * y[1][1]; >+ result[3][2] = 0; >+ result[3][2] += x[3][0] * y[0][2]; >+ result[3][2] += x[3][1] * y[1][2]; >+ result[3][3] = 0; >+ result[3][3] += x[3][0] * y[0][3]; >+ result[3][3] += x[3][1] * y[1][3]; >+ return result; >+} >+half4x2 mul(half4x3 x, half3x2 y) { >+ half4x2 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][0] += x[2][2] * y[2][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][1] += x[2][2] * y[2][1]; >+ result[3][0] = 0; >+ result[3][0] += x[3][0] * y[0][0]; >+ result[3][0] += x[3][1] * y[1][0]; >+ result[3][0] += x[3][2] * y[2][0]; >+ result[3][1] = 0; >+ result[3][1] += x[3][0] * y[0][1]; >+ result[3][1] += x[3][1] * y[1][1]; >+ result[3][1] += x[3][2] * y[2][1]; >+ return result; >+} >+half4x3 mul(half4x3 x, half3x3 y) { >+ half4x3 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][2] += x[0][2] * y[2][2]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][2] += x[1][2] * y[2][2]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][0] += x[2][2] * y[2][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][1] += x[2][2] * y[2][1]; >+ result[2][2] = 0; >+ result[2][2] += x[2][0] * y[0][2]; >+ result[2][2] += x[2][1] * y[1][2]; >+ result[2][2] += x[2][2] * y[2][2]; >+ result[3][0] = 0; >+ result[3][0] += x[3][0] * y[0][0]; >+ result[3][0] += x[3][1] * y[1][0]; >+ result[3][0] += x[3][2] * y[2][0]; >+ result[3][1] = 0; >+ result[3][1] += x[3][0] * y[0][1]; >+ result[3][1] += x[3][1] * y[1][1]; >+ result[3][1] += x[3][2] * y[2][1]; >+ result[3][2] = 0; >+ result[3][2] += x[3][0] * y[0][2]; >+ result[3][2] += x[3][1] * y[1][2]; >+ result[3][2] += x[3][2] * y[2][2]; >+ return result; >+} >+half4x4 mul(half4x3 x, half3x4 y) { >+ half4x4 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][2] += x[0][2] * y[2][2]; >+ result[0][3] = 0; >+ result[0][3] += x[0][0] * y[0][3]; >+ result[0][3] += x[0][1] * y[1][3]; >+ result[0][3] += x[0][2] * y[2][3]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][2] += x[1][2] * y[2][2]; >+ result[1][3] = 0; >+ result[1][3] += x[1][0] * y[0][3]; >+ result[1][3] += x[1][1] * y[1][3]; >+ result[1][3] += x[1][2] * y[2][3]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][0] += x[2][2] * y[2][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][1] += x[2][2] * y[2][1]; >+ result[2][2] = 0; >+ result[2][2] += x[2][0] * y[0][2]; >+ result[2][2] += x[2][1] * y[1][2]; >+ result[2][2] += x[2][2] * y[2][2]; >+ result[2][3] = 0; >+ result[2][3] += x[2][0] * y[0][3]; >+ result[2][3] += x[2][1] * y[1][3]; >+ result[2][3] += x[2][2] * y[2][3]; >+ result[3][0] = 0; >+ result[3][0] += x[3][0] * y[0][0]; >+ result[3][0] += x[3][1] * y[1][0]; >+ result[3][0] += x[3][2] * y[2][0]; >+ result[3][1] = 0; >+ result[3][1] += x[3][0] * y[0][1]; >+ result[3][1] += x[3][1] * y[1][1]; >+ result[3][1] += x[3][2] * y[2][1]; >+ result[3][2] = 0; >+ result[3][2] += x[3][0] * y[0][2]; >+ result[3][2] += x[3][1] * y[1][2]; >+ result[3][2] += x[3][2] * y[2][2]; >+ result[3][3] = 0; >+ result[3][3] += x[3][0] * y[0][3]; >+ result[3][3] += x[3][1] * y[1][3]; >+ result[3][3] += x[3][2] * y[2][3]; >+ return result; >+} >+half4x2 mul(half4x4 x, half4x2 y) { >+ half4x2 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][0] += x[0][3] * y[3][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][1] += x[0][3] * y[3][1]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][0] += x[1][3] * y[3][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][1] += x[1][3] * y[3][1]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][0] += x[2][2] * y[2][0]; >+ result[2][0] += x[2][3] * y[3][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][1] += x[2][2] * y[2][1]; >+ result[2][1] += x[2][3] * y[3][1]; >+ result[3][0] = 0; >+ result[3][0] += x[3][0] * y[0][0]; >+ result[3][0] += x[3][1] * y[1][0]; >+ result[3][0] += x[3][2] * y[2][0]; >+ result[3][0] += x[3][3] * y[3][0]; >+ result[3][1] = 0; >+ result[3][1] += x[3][0] * y[0][1]; >+ result[3][1] += x[3][1] * y[1][1]; >+ result[3][1] += x[3][2] * y[2][1]; >+ result[3][1] += x[3][3] * y[3][1]; >+ return result; >+} >+half4x3 mul(half4x4 x, half4x3 y) { >+ half4x3 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][0] += x[0][3] * y[3][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][1] += x[0][3] * y[3][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][2] += x[0][2] * y[2][2]; >+ result[0][2] += x[0][3] * y[3][2]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][0] += x[1][3] * y[3][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][1] += x[1][3] * y[3][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][2] += x[1][2] * y[2][2]; >+ result[1][2] += x[1][3] * y[3][2]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][0] += x[2][2] * y[2][0]; >+ result[2][0] += x[2][3] * y[3][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][1] += x[2][2] * y[2][1]; >+ result[2][1] += x[2][3] * y[3][1]; >+ result[2][2] = 0; >+ result[2][2] += x[2][0] * y[0][2]; >+ result[2][2] += x[2][1] * y[1][2]; >+ result[2][2] += x[2][2] * y[2][2]; >+ result[2][2] += x[2][3] * y[3][2]; >+ result[3][0] = 0; >+ result[3][0] += x[3][0] * y[0][0]; >+ result[3][0] += x[3][1] * y[1][0]; >+ result[3][0] += x[3][2] * y[2][0]; >+ result[3][0] += x[3][3] * y[3][0]; >+ result[3][1] = 0; >+ result[3][1] += x[3][0] * y[0][1]; >+ result[3][1] += x[3][1] * y[1][1]; >+ result[3][1] += x[3][2] * y[2][1]; >+ result[3][1] += x[3][3] * y[3][1]; >+ result[3][2] = 0; >+ result[3][2] += x[3][0] * y[0][2]; >+ result[3][2] += x[3][1] * y[1][2]; >+ result[3][2] += x[3][2] * y[2][2]; >+ result[3][2] += x[3][3] * y[3][2]; >+ return result; >+} >+half4x4 mul(half4x4 x, half4x4 y) { >+ half4x4 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][0] += x[0][3] * y[3][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][1] += x[0][3] * y[3][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][2] += x[0][2] * y[2][2]; >+ result[0][2] += x[0][3] * y[3][2]; >+ result[0][3] = 0; >+ result[0][3] += x[0][0] * y[0][3]; >+ result[0][3] += x[0][1] * y[1][3]; >+ result[0][3] += x[0][2] * y[2][3]; >+ result[0][3] += x[0][3] * y[3][3]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][0] += x[1][3] * y[3][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][1] += x[1][3] * y[3][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][2] += x[1][2] * y[2][2]; >+ result[1][2] += x[1][3] * y[3][2]; >+ result[1][3] = 0; >+ result[1][3] += x[1][0] * y[0][3]; >+ result[1][3] += x[1][1] * y[1][3]; >+ result[1][3] += x[1][2] * y[2][3]; >+ result[1][3] += x[1][3] * y[3][3]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][0] += x[2][2] * y[2][0]; >+ result[2][0] += x[2][3] * y[3][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][1] += x[2][2] * y[2][1]; >+ result[2][1] += x[2][3] * y[3][1]; >+ result[2][2] = 0; >+ result[2][2] += x[2][0] * y[0][2]; >+ result[2][2] += x[2][1] * y[1][2]; >+ result[2][2] += x[2][2] * y[2][2]; >+ result[2][2] += x[2][3] * y[3][2]; >+ result[2][3] = 0; >+ result[2][3] += x[2][0] * y[0][3]; >+ result[2][3] += x[2][1] * y[1][3]; >+ result[2][3] += x[2][2] * y[2][3]; >+ result[2][3] += x[2][3] * y[3][3]; >+ result[3][0] = 0; >+ result[3][0] += x[3][0] * y[0][0]; >+ result[3][0] += x[3][1] * y[1][0]; >+ result[3][0] += x[3][2] * y[2][0]; >+ result[3][0] += x[3][3] * y[3][0]; >+ result[3][1] = 0; >+ result[3][1] += x[3][0] * y[0][1]; >+ result[3][1] += x[3][1] * y[1][1]; >+ result[3][1] += x[3][2] * y[2][1]; >+ result[3][1] += x[3][3] * y[3][1]; >+ result[3][2] = 0; >+ result[3][2] += x[3][0] * y[0][2]; >+ result[3][2] += x[3][1] * y[1][2]; >+ result[3][2] += x[3][2] * y[2][2]; >+ result[3][2] += x[3][3] * y[3][2]; >+ result[3][3] = 0; >+ result[3][3] += x[3][0] * y[0][3]; >+ result[3][3] += x[3][1] * y[1][3]; >+ result[3][3] += x[3][2] * y[2][3]; >+ result[3][3] += x[3][3] * y[3][3]; >+ return result; >+} >+float2x2 mul(float2x2 x, float2x2 y) { >+ float2x2 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ return result; >+} >+float2x3 mul(float2x2 x, float2x3 y) { >+ float2x3 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ return result; >+} >+float2x4 mul(float2x2 x, float2x4 y) { >+ float2x4 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][3] = 0; >+ result[0][3] += x[0][0] * y[0][3]; >+ result[0][3] += x[0][1] * y[1][3]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][3] = 0; >+ result[1][3] += x[1][0] * y[0][3]; >+ result[1][3] += x[1][1] * y[1][3]; >+ return result; >+} >+float2x2 mul(float2x3 x, float3x2 y) { >+ float2x2 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ return result; >+} >+float2x3 mul(float2x3 x, float3x3 y) { >+ float2x3 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][2] += x[0][2] * y[2][2]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][2] += x[1][2] * y[2][2]; >+ return result; >+} >+float2x4 mul(float2x3 x, float3x4 y) { >+ float2x4 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][2] += x[0][2] * y[2][2]; >+ result[0][3] = 0; >+ result[0][3] += x[0][0] * y[0][3]; >+ result[0][3] += x[0][1] * y[1][3]; >+ result[0][3] += x[0][2] * y[2][3]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][2] += x[1][2] * y[2][2]; >+ result[1][3] = 0; >+ result[1][3] += x[1][0] * y[0][3]; >+ result[1][3] += x[1][1] * y[1][3]; >+ result[1][3] += x[1][2] * y[2][3]; >+ return result; >+} >+float2x2 mul(float2x4 x, float4x2 y) { >+ float2x2 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][0] += x[0][3] * y[3][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][1] += x[0][3] * y[3][1]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][0] += x[1][3] * y[3][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][1] += x[1][3] * y[3][1]; >+ return result; >+} >+float2x3 mul(float2x4 x, float4x3 y) { >+ float2x3 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][0] += x[0][3] * y[3][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][1] += x[0][3] * y[3][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][2] += x[0][2] * y[2][2]; >+ result[0][2] += x[0][3] * y[3][2]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][0] += x[1][3] * y[3][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][1] += x[1][3] * y[3][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][2] += x[1][2] * y[2][2]; >+ result[1][2] += x[1][3] * y[3][2]; >+ return result; >+} >+float2x4 mul(float2x4 x, float4x4 y) { >+ float2x4 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][0] += x[0][3] * y[3][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][1] += x[0][3] * y[3][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][2] += x[0][2] * y[2][2]; >+ result[0][2] += x[0][3] * y[3][2]; >+ result[0][3] = 0; >+ result[0][3] += x[0][0] * y[0][3]; >+ result[0][3] += x[0][1] * y[1][3]; >+ result[0][3] += x[0][2] * y[2][3]; >+ result[0][3] += x[0][3] * y[3][3]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][0] += x[1][3] * y[3][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][1] += x[1][3] * y[3][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][2] += x[1][2] * y[2][2]; >+ result[1][2] += x[1][3] * y[3][2]; >+ result[1][3] = 0; >+ result[1][3] += x[1][0] * y[0][3]; >+ result[1][3] += x[1][1] * y[1][3]; >+ result[1][3] += x[1][2] * y[2][3]; >+ result[1][3] += x[1][3] * y[3][3]; >+ return result; >+} >+float3x2 mul(float3x2 x, float2x2 y) { >+ float3x2 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ return result; >+} >+float3x3 mul(float3x2 x, float2x3 y) { >+ float3x3 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][2] = 0; >+ result[2][2] += x[2][0] * y[0][2]; >+ result[2][2] += x[2][1] * y[1][2]; >+ return result; >+} >+float3x4 mul(float3x2 x, float2x4 y) { >+ float3x4 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][3] = 0; >+ result[0][3] += x[0][0] * y[0][3]; >+ result[0][3] += x[0][1] * y[1][3]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][3] = 0; >+ result[1][3] += x[1][0] * y[0][3]; >+ result[1][3] += x[1][1] * y[1][3]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][2] = 0; >+ result[2][2] += x[2][0] * y[0][2]; >+ result[2][2] += x[2][1] * y[1][2]; >+ result[2][3] = 0; >+ result[2][3] += x[2][0] * y[0][3]; >+ result[2][3] += x[2][1] * y[1][3]; >+ return result; >+} >+float3x2 mul(float3x3 x, float3x2 y) { >+ float3x2 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][0] += x[2][2] * y[2][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][1] += x[2][2] * y[2][1]; >+ return result; >+} >+float3x3 mul(float3x3 x, float3x3 y) { >+ float3x3 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][2] += x[0][2] * y[2][2]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][2] += x[1][2] * y[2][2]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][0] += x[2][2] * y[2][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][1] += x[2][2] * y[2][1]; >+ result[2][2] = 0; >+ result[2][2] += x[2][0] * y[0][2]; >+ result[2][2] += x[2][1] * y[1][2]; >+ result[2][2] += x[2][2] * y[2][2]; >+ return result; >+} >+float3x4 mul(float3x3 x, float3x4 y) { >+ float3x4 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][2] += x[0][2] * y[2][2]; >+ result[0][3] = 0; >+ result[0][3] += x[0][0] * y[0][3]; >+ result[0][3] += x[0][1] * y[1][3]; >+ result[0][3] += x[0][2] * y[2][3]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][2] += x[1][2] * y[2][2]; >+ result[1][3] = 0; >+ result[1][3] += x[1][0] * y[0][3]; >+ result[1][3] += x[1][1] * y[1][3]; >+ result[1][3] += x[1][2] * y[2][3]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][0] += x[2][2] * y[2][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][1] += x[2][2] * y[2][1]; >+ result[2][2] = 0; >+ result[2][2] += x[2][0] * y[0][2]; >+ result[2][2] += x[2][1] * y[1][2]; >+ result[2][2] += x[2][2] * y[2][2]; >+ result[2][3] = 0; >+ result[2][3] += x[2][0] * y[0][3]; >+ result[2][3] += x[2][1] * y[1][3]; >+ result[2][3] += x[2][2] * y[2][3]; >+ return result; >+} >+float3x2 mul(float3x4 x, float4x2 y) { >+ float3x2 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][0] += x[0][3] * y[3][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][1] += x[0][3] * y[3][1]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][0] += x[1][3] * y[3][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][1] += x[1][3] * y[3][1]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][0] += x[2][2] * y[2][0]; >+ result[2][0] += x[2][3] * y[3][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][1] += x[2][2] * y[2][1]; >+ result[2][1] += x[2][3] * y[3][1]; >+ return result; >+} >+float3x3 mul(float3x4 x, float4x3 y) { >+ float3x3 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][0] += x[0][3] * y[3][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][1] += x[0][3] * y[3][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][2] += x[0][2] * y[2][2]; >+ result[0][2] += x[0][3] * y[3][2]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][0] += x[1][3] * y[3][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][1] += x[1][3] * y[3][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][2] += x[1][2] * y[2][2]; >+ result[1][2] += x[1][3] * y[3][2]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][0] += x[2][2] * y[2][0]; >+ result[2][0] += x[2][3] * y[3][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][1] += x[2][2] * y[2][1]; >+ result[2][1] += x[2][3] * y[3][1]; >+ result[2][2] = 0; >+ result[2][2] += x[2][0] * y[0][2]; >+ result[2][2] += x[2][1] * y[1][2]; >+ result[2][2] += x[2][2] * y[2][2]; >+ result[2][2] += x[2][3] * y[3][2]; >+ return result; >+} >+float3x4 mul(float3x4 x, float4x4 y) { >+ float3x4 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][0] += x[0][3] * y[3][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][1] += x[0][3] * y[3][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][2] += x[0][2] * y[2][2]; >+ result[0][2] += x[0][3] * y[3][2]; >+ result[0][3] = 0; >+ result[0][3] += x[0][0] * y[0][3]; >+ result[0][3] += x[0][1] * y[1][3]; >+ result[0][3] += x[0][2] * y[2][3]; >+ result[0][3] += x[0][3] * y[3][3]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][0] += x[1][3] * y[3][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][1] += x[1][3] * y[3][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][2] += x[1][2] * y[2][2]; >+ result[1][2] += x[1][3] * y[3][2]; >+ result[1][3] = 0; >+ result[1][3] += x[1][0] * y[0][3]; >+ result[1][3] += x[1][1] * y[1][3]; >+ result[1][3] += x[1][2] * y[2][3]; >+ result[1][3] += x[1][3] * y[3][3]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][0] += x[2][2] * y[2][0]; >+ result[2][0] += x[2][3] * y[3][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][1] += x[2][2] * y[2][1]; >+ result[2][1] += x[2][3] * y[3][1]; >+ result[2][2] = 0; >+ result[2][2] += x[2][0] * y[0][2]; >+ result[2][2] += x[2][1] * y[1][2]; >+ result[2][2] += x[2][2] * y[2][2]; >+ result[2][2] += x[2][3] * y[3][2]; >+ result[2][3] = 0; >+ result[2][3] += x[2][0] * y[0][3]; >+ result[2][3] += x[2][1] * y[1][3]; >+ result[2][3] += x[2][2] * y[2][3]; >+ result[2][3] += x[2][3] * y[3][3]; >+ return result; >+} >+float4x2 mul(float4x2 x, float2x2 y) { >+ float4x2 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[3][0] = 0; >+ result[3][0] += x[3][0] * y[0][0]; >+ result[3][0] += x[3][1] * y[1][0]; >+ result[3][1] = 0; >+ result[3][1] += x[3][0] * y[0][1]; >+ result[3][1] += x[3][1] * y[1][1]; >+ return result; >+} >+float4x3 mul(float4x2 x, float2x3 y) { >+ float4x3 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][2] = 0; >+ result[2][2] += x[2][0] * y[0][2]; >+ result[2][2] += x[2][1] * y[1][2]; >+ result[3][0] = 0; >+ result[3][0] += x[3][0] * y[0][0]; >+ result[3][0] += x[3][1] * y[1][0]; >+ result[3][1] = 0; >+ result[3][1] += x[3][0] * y[0][1]; >+ result[3][1] += x[3][1] * y[1][1]; >+ result[3][2] = 0; >+ result[3][2] += x[3][0] * y[0][2]; >+ result[3][2] += x[3][1] * y[1][2]; >+ return result; >+} >+float4x4 mul(float4x2 x, float2x4 y) { >+ float4x4 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][3] = 0; >+ result[0][3] += x[0][0] * y[0][3]; >+ result[0][3] += x[0][1] * y[1][3]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][3] = 0; >+ result[1][3] += x[1][0] * y[0][3]; >+ result[1][3] += x[1][1] * y[1][3]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][2] = 0; >+ result[2][2] += x[2][0] * y[0][2]; >+ result[2][2] += x[2][1] * y[1][2]; >+ result[2][3] = 0; >+ result[2][3] += x[2][0] * y[0][3]; >+ result[2][3] += x[2][1] * y[1][3]; >+ result[3][0] = 0; >+ result[3][0] += x[3][0] * y[0][0]; >+ result[3][0] += x[3][1] * y[1][0]; >+ result[3][1] = 0; >+ result[3][1] += x[3][0] * y[0][1]; >+ result[3][1] += x[3][1] * y[1][1]; >+ result[3][2] = 0; >+ result[3][2] += x[3][0] * y[0][2]; >+ result[3][2] += x[3][1] * y[1][2]; >+ result[3][3] = 0; >+ result[3][3] += x[3][0] * y[0][3]; >+ result[3][3] += x[3][1] * y[1][3]; >+ return result; >+} >+float4x2 mul(float4x3 x, float3x2 y) { >+ float4x2 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][0] += x[2][2] * y[2][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][1] += x[2][2] * y[2][1]; >+ result[3][0] = 0; >+ result[3][0] += x[3][0] * y[0][0]; >+ result[3][0] += x[3][1] * y[1][0]; >+ result[3][0] += x[3][2] * y[2][0]; >+ result[3][1] = 0; >+ result[3][1] += x[3][0] * y[0][1]; >+ result[3][1] += x[3][1] * y[1][1]; >+ result[3][1] += x[3][2] * y[2][1]; >+ return result; >+} >+float4x3 mul(float4x3 x, float3x3 y) { >+ float4x3 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][2] += x[0][2] * y[2][2]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][2] += x[1][2] * y[2][2]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][0] += x[2][2] * y[2][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][1] += x[2][2] * y[2][1]; >+ result[2][2] = 0; >+ result[2][2] += x[2][0] * y[0][2]; >+ result[2][2] += x[2][1] * y[1][2]; >+ result[2][2] += x[2][2] * y[2][2]; >+ result[3][0] = 0; >+ result[3][0] += x[3][0] * y[0][0]; >+ result[3][0] += x[3][1] * y[1][0]; >+ result[3][0] += x[3][2] * y[2][0]; >+ result[3][1] = 0; >+ result[3][1] += x[3][0] * y[0][1]; >+ result[3][1] += x[3][1] * y[1][1]; >+ result[3][1] += x[3][2] * y[2][1]; >+ result[3][2] = 0; >+ result[3][2] += x[3][0] * y[0][2]; >+ result[3][2] += x[3][1] * y[1][2]; >+ result[3][2] += x[3][2] * y[2][2]; >+ return result; >+} >+float4x4 mul(float4x3 x, float3x4 y) { >+ float4x4 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][2] += x[0][2] * y[2][2]; >+ result[0][3] = 0; >+ result[0][3] += x[0][0] * y[0][3]; >+ result[0][3] += x[0][1] * y[1][3]; >+ result[0][3] += x[0][2] * y[2][3]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][2] += x[1][2] * y[2][2]; >+ result[1][3] = 0; >+ result[1][3] += x[1][0] * y[0][3]; >+ result[1][3] += x[1][1] * y[1][3]; >+ result[1][3] += x[1][2] * y[2][3]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][0] += x[2][2] * y[2][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][1] += x[2][2] * y[2][1]; >+ result[2][2] = 0; >+ result[2][2] += x[2][0] * y[0][2]; >+ result[2][2] += x[2][1] * y[1][2]; >+ result[2][2] += x[2][2] * y[2][2]; >+ result[2][3] = 0; >+ result[2][3] += x[2][0] * y[0][3]; >+ result[2][3] += x[2][1] * y[1][3]; >+ result[2][3] += x[2][2] * y[2][3]; >+ result[3][0] = 0; >+ result[3][0] += x[3][0] * y[0][0]; >+ result[3][0] += x[3][1] * y[1][0]; >+ result[3][0] += x[3][2] * y[2][0]; >+ result[3][1] = 0; >+ result[3][1] += x[3][0] * y[0][1]; >+ result[3][1] += x[3][1] * y[1][1]; >+ result[3][1] += x[3][2] * y[2][1]; >+ result[3][2] = 0; >+ result[3][2] += x[3][0] * y[0][2]; >+ result[3][2] += x[3][1] * y[1][2]; >+ result[3][2] += x[3][2] * y[2][2]; >+ result[3][3] = 0; >+ result[3][3] += x[3][0] * y[0][3]; >+ result[3][3] += x[3][1] * y[1][3]; >+ result[3][3] += x[3][2] * y[2][3]; >+ return result; >+} >+float4x2 mul(float4x4 x, float4x2 y) { >+ float4x2 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][0] += x[0][3] * y[3][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][1] += x[0][3] * y[3][1]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][0] += x[1][3] * y[3][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][1] += x[1][3] * y[3][1]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][0] += x[2][2] * y[2][0]; >+ result[2][0] += x[2][3] * y[3][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][1] += x[2][2] * y[2][1]; >+ result[2][1] += x[2][3] * y[3][1]; >+ result[3][0] = 0; >+ result[3][0] += x[3][0] * y[0][0]; >+ result[3][0] += x[3][1] * y[1][0]; >+ result[3][0] += x[3][2] * y[2][0]; >+ result[3][0] += x[3][3] * y[3][0]; >+ result[3][1] = 0; >+ result[3][1] += x[3][0] * y[0][1]; >+ result[3][1] += x[3][1] * y[1][1]; >+ result[3][1] += x[3][2] * y[2][1]; >+ result[3][1] += x[3][3] * y[3][1]; >+ return result; >+} >+float4x3 mul(float4x4 x, float4x3 y) { >+ float4x3 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][0] += x[0][3] * y[3][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][1] += x[0][3] * y[3][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][2] += x[0][2] * y[2][2]; >+ result[0][2] += x[0][3] * y[3][2]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][0] += x[1][3] * y[3][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][1] += x[1][3] * y[3][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][2] += x[1][2] * y[2][2]; >+ result[1][2] += x[1][3] * y[3][2]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][0] += x[2][2] * y[2][0]; >+ result[2][0] += x[2][3] * y[3][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][1] += x[2][2] * y[2][1]; >+ result[2][1] += x[2][3] * y[3][1]; >+ result[2][2] = 0; >+ result[2][2] += x[2][0] * y[0][2]; >+ result[2][2] += x[2][1] * y[1][2]; >+ result[2][2] += x[2][2] * y[2][2]; >+ result[2][2] += x[2][3] * y[3][2]; >+ result[3][0] = 0; >+ result[3][0] += x[3][0] * y[0][0]; >+ result[3][0] += x[3][1] * y[1][0]; >+ result[3][0] += x[3][2] * y[2][0]; >+ result[3][0] += x[3][3] * y[3][0]; >+ result[3][1] = 0; >+ result[3][1] += x[3][0] * y[0][1]; >+ result[3][1] += x[3][1] * y[1][1]; >+ result[3][1] += x[3][2] * y[2][1]; >+ result[3][1] += x[3][3] * y[3][1]; >+ result[3][2] = 0; >+ result[3][2] += x[3][0] * y[0][2]; >+ result[3][2] += x[3][1] * y[1][2]; >+ result[3][2] += x[3][2] * y[2][2]; >+ result[3][2] += x[3][3] * y[3][2]; >+ return result; >+} >+float4x4 mul(float4x4 x, float4x4 y) { >+ float4x4 result; >+ result[0][0] = 0; >+ result[0][0] += x[0][0] * y[0][0]; >+ result[0][0] += x[0][1] * y[1][0]; >+ result[0][0] += x[0][2] * y[2][0]; >+ result[0][0] += x[0][3] * y[3][0]; >+ result[0][1] = 0; >+ result[0][1] += x[0][0] * y[0][1]; >+ result[0][1] += x[0][1] * y[1][1]; >+ result[0][1] += x[0][2] * y[2][1]; >+ result[0][1] += x[0][3] * y[3][1]; >+ result[0][2] = 0; >+ result[0][2] += x[0][0] * y[0][2]; >+ result[0][2] += x[0][1] * y[1][2]; >+ result[0][2] += x[0][2] * y[2][2]; >+ result[0][2] += x[0][3] * y[3][2]; >+ result[0][3] = 0; >+ result[0][3] += x[0][0] * y[0][3]; >+ result[0][3] += x[0][1] * y[1][3]; >+ result[0][3] += x[0][2] * y[2][3]; >+ result[0][3] += x[0][3] * y[3][3]; >+ result[1][0] = 0; >+ result[1][0] += x[1][0] * y[0][0]; >+ result[1][0] += x[1][1] * y[1][0]; >+ result[1][0] += x[1][2] * y[2][0]; >+ result[1][0] += x[1][3] * y[3][0]; >+ result[1][1] = 0; >+ result[1][1] += x[1][0] * y[0][1]; >+ result[1][1] += x[1][1] * y[1][1]; >+ result[1][1] += x[1][2] * y[2][1]; >+ result[1][1] += x[1][3] * y[3][1]; >+ result[1][2] = 0; >+ result[1][2] += x[1][0] * y[0][2]; >+ result[1][2] += x[1][1] * y[1][2]; >+ result[1][2] += x[1][2] * y[2][2]; >+ result[1][2] += x[1][3] * y[3][2]; >+ result[1][3] = 0; >+ result[1][3] += x[1][0] * y[0][3]; >+ result[1][3] += x[1][1] * y[1][3]; >+ result[1][3] += x[1][2] * y[2][3]; >+ result[1][3] += x[1][3] * y[3][3]; >+ result[2][0] = 0; >+ result[2][0] += x[2][0] * y[0][0]; >+ result[2][0] += x[2][1] * y[1][0]; >+ result[2][0] += x[2][2] * y[2][0]; >+ result[2][0] += x[2][3] * y[3][0]; >+ result[2][1] = 0; >+ result[2][1] += x[2][0] * y[0][1]; >+ result[2][1] += x[2][1] * y[1][1]; >+ result[2][1] += x[2][2] * y[2][1]; >+ result[2][1] += x[2][3] * y[3][1]; >+ result[2][2] = 0; >+ result[2][2] += x[2][0] * y[0][2]; >+ result[2][2] += x[2][1] * y[1][2]; >+ result[2][2] += x[2][2] * y[2][2]; >+ result[2][2] += x[2][3] * y[3][2]; >+ result[2][3] = 0; >+ result[2][3] += x[2][0] * y[0][3]; >+ result[2][3] += x[2][1] * y[1][3]; >+ result[2][3] += x[2][2] * y[2][3]; >+ result[2][3] += x[2][3] * y[3][3]; >+ result[3][0] = 0; >+ result[3][0] += x[3][0] * y[0][0]; >+ result[3][0] += x[3][1] * y[1][0]; >+ result[3][0] += x[3][2] * y[2][0]; >+ result[3][0] += x[3][3] * y[3][0]; >+ result[3][1] = 0; >+ result[3][1] += x[3][0] * y[0][1]; >+ result[3][1] += x[3][1] * y[1][1]; >+ result[3][1] += x[3][2] * y[2][1]; >+ result[3][1] += x[3][3] * y[3][1]; >+ result[3][2] = 0; >+ result[3][2] += x[3][0] * y[0][2]; >+ result[3][2] += x[3][1] * y[1][2]; >+ result[3][2] += x[3][2] * y[2][2]; >+ result[3][2] += x[3][3] * y[3][2]; >+ result[3][3] = 0; >+ result[3][3] += x[3][0] * y[0][3]; >+ result[3][3] += x[3][1] * y[1][3]; >+ result[3][3] += x[3][2] * y[2][3]; >+ result[3][3] += x[3][3] * y[3][3]; >+ return result; >+} >+ >+native void InterlockedAdd(thread atomic_uint*, uint, thread uint*); >+native void InterlockedAnd(thread atomic_uint*, uint, thread uint*); >+native void InterlockedExchange(thread atomic_uint*, uint, thread uint*); >+native void InterlockedMax(thread atomic_uint*, uint, thread uint*); >+native void InterlockedMin(thread atomic_uint*, uint, thread uint*); >+native void InterlockedOr(thread atomic_uint*, uint, thread uint*); >+native void InterlockedXor(thread atomic_uint*, uint, thread uint*); >+native void InterlockedCompareExchange(thread atomic_uint*, uint, uint, thread uint*); >+native void InterlockedAdd(thread atomic_int*, int, thread int*); >+native void InterlockedAnd(thread atomic_int*, int, thread int*); >+native void InterlockedExchange(thread atomic_int*, int, thread int*); >+native void InterlockedMax(thread atomic_int*, int, thread int*); >+native void InterlockedMin(thread atomic_int*, int, thread int*); >+native void InterlockedOr(thread atomic_int*, int, thread int*); >+native void InterlockedXor(thread atomic_int*, int, thread int*); >+native void InterlockedCompareExchange(thread atomic_int*, int, int, thread int*); >+native void InterlockedAdd(thread atomic_uint*, uint, device uint*); >+native void InterlockedAnd(thread atomic_uint*, uint, device uint*); >+native void InterlockedExchange(thread atomic_uint*, uint, device uint*); >+native void InterlockedMax(thread atomic_uint*, uint, device uint*); >+native void InterlockedMin(thread atomic_uint*, uint, device uint*); >+native void InterlockedOr(thread atomic_uint*, uint, device uint*); >+native void InterlockedXor(thread atomic_uint*, uint, device uint*); >+native void InterlockedCompareExchange(thread atomic_uint*, uint, uint, device uint*); >+native void InterlockedAdd(thread atomic_int*, int, device int*); >+native void InterlockedAnd(thread atomic_int*, int, device int*); >+native void InterlockedExchange(thread atomic_int*, int, device int*); >+native void InterlockedMax(thread atomic_int*, int, device int*); >+native void InterlockedMin(thread atomic_int*, int, device int*); >+native void InterlockedOr(thread atomic_int*, int, device int*); >+native void InterlockedXor(thread atomic_int*, int, device int*); >+native void InterlockedCompareExchange(thread atomic_int*, int, int, device int*); >+native void InterlockedAdd(thread atomic_uint*, uint, threadgroup uint*); >+native void InterlockedAnd(thread atomic_uint*, uint, threadgroup uint*); >+native void InterlockedExchange(thread atomic_uint*, uint, threadgroup uint*); >+native void InterlockedMax(thread atomic_uint*, uint, threadgroup uint*); >+native void InterlockedMin(thread atomic_uint*, uint, threadgroup uint*); >+native void InterlockedOr(thread atomic_uint*, uint, threadgroup uint*); >+native void InterlockedXor(thread atomic_uint*, uint, threadgroup uint*); >+native void InterlockedCompareExchange(thread atomic_uint*, uint, uint, threadgroup uint*); >+native void InterlockedAdd(thread atomic_int*, int, threadgroup int*); >+native void InterlockedAnd(thread atomic_int*, int, threadgroup int*); >+native void InterlockedExchange(thread atomic_int*, int, threadgroup int*); >+native void InterlockedMax(thread atomic_int*, int, threadgroup int*); >+native void InterlockedMin(thread atomic_int*, int, threadgroup int*); >+native void InterlockedOr(thread atomic_int*, int, threadgroup int*); >+native void InterlockedXor(thread atomic_int*, int, threadgroup int*); >+native void InterlockedCompareExchange(thread atomic_int*, int, int, threadgroup int*); >+native void InterlockedAdd(device atomic_uint*, uint, thread uint*); >+native void InterlockedAnd(device atomic_uint*, uint, thread uint*); >+native void InterlockedExchange(device atomic_uint*, uint, thread uint*); >+native void InterlockedMax(device atomic_uint*, uint, thread uint*); >+native void InterlockedMin(device atomic_uint*, uint, thread uint*); >+native void InterlockedOr(device atomic_uint*, uint, thread uint*); >+native void InterlockedXor(device atomic_uint*, uint, thread uint*); >+native void InterlockedCompareExchange(device atomic_uint*, uint, uint, thread uint*); >+native void InterlockedAdd(device atomic_int*, int, thread int*); >+native void InterlockedAnd(device atomic_int*, int, thread int*); >+native void InterlockedExchange(device atomic_int*, int, thread int*); >+native void InterlockedMax(device atomic_int*, int, thread int*); >+native void InterlockedMin(device atomic_int*, int, thread int*); >+native void InterlockedOr(device atomic_int*, int, thread int*); >+native void InterlockedXor(device atomic_int*, int, thread int*); >+native void InterlockedCompareExchange(device atomic_int*, int, int, thread int*); >+native void InterlockedAdd(device atomic_uint*, uint, device uint*); >+native void InterlockedAnd(device atomic_uint*, uint, device uint*); >+native void InterlockedExchange(device atomic_uint*, uint, device uint*); >+native void InterlockedMax(device atomic_uint*, uint, device uint*); >+native void InterlockedMin(device atomic_uint*, uint, device uint*); >+native void InterlockedOr(device atomic_uint*, uint, device uint*); >+native void InterlockedXor(device atomic_uint*, uint, device uint*); >+native void InterlockedCompareExchange(device atomic_uint*, uint, uint, device uint*); >+native void InterlockedAdd(device atomic_int*, int, device int*); >+native void InterlockedAnd(device atomic_int*, int, device int*); >+native void InterlockedExchange(device atomic_int*, int, device int*); >+native void InterlockedMax(device atomic_int*, int, device int*); >+native void InterlockedMin(device atomic_int*, int, device int*); >+native void InterlockedOr(device atomic_int*, int, device int*); >+native void InterlockedXor(device atomic_int*, int, device int*); >+native void InterlockedCompareExchange(device atomic_int*, int, int, device int*); >+native void InterlockedAdd(device atomic_uint*, uint, threadgroup uint*); >+native void InterlockedAnd(device atomic_uint*, uint, threadgroup uint*); >+native void InterlockedExchange(device atomic_uint*, uint, threadgroup uint*); >+native void InterlockedMax(device atomic_uint*, uint, threadgroup uint*); >+native void InterlockedMin(device atomic_uint*, uint, threadgroup uint*); >+native void InterlockedOr(device atomic_uint*, uint, threadgroup uint*); >+native void InterlockedXor(device atomic_uint*, uint, threadgroup uint*); >+native void InterlockedCompareExchange(device atomic_uint*, uint, uint, threadgroup uint*); >+native void InterlockedAdd(device atomic_int*, int, threadgroup int*); >+native void InterlockedAnd(device atomic_int*, int, threadgroup int*); >+native void InterlockedExchange(device atomic_int*, int, threadgroup int*); >+native void InterlockedMax(device atomic_int*, int, threadgroup int*); >+native void InterlockedMin(device atomic_int*, int, threadgroup int*); >+native void InterlockedOr(device atomic_int*, int, threadgroup int*); >+native void InterlockedXor(device atomic_int*, int, threadgroup int*); >+native void InterlockedCompareExchange(device atomic_int*, int, int, threadgroup int*); >+native void InterlockedAdd(threadgroup atomic_uint*, uint, thread uint*); >+native void InterlockedAnd(threadgroup atomic_uint*, uint, thread uint*); >+native void InterlockedExchange(threadgroup atomic_uint*, uint, thread uint*); >+native void InterlockedMax(threadgroup atomic_uint*, uint, thread uint*); >+native void InterlockedMin(threadgroup atomic_uint*, uint, thread uint*); >+native void InterlockedOr(threadgroup atomic_uint*, uint, thread uint*); >+native void InterlockedXor(threadgroup atomic_uint*, uint, thread uint*); >+native void InterlockedCompareExchange(threadgroup atomic_uint*, uint, uint, thread uint*); >+native void InterlockedAdd(threadgroup atomic_int*, int, thread int*); >+native void InterlockedAnd(threadgroup atomic_int*, int, thread int*); >+native void InterlockedExchange(threadgroup atomic_int*, int, thread int*); >+native void InterlockedMax(threadgroup atomic_int*, int, thread int*); >+native void InterlockedMin(threadgroup atomic_int*, int, thread int*); >+native void InterlockedOr(threadgroup atomic_int*, int, thread int*); >+native void InterlockedXor(threadgroup atomic_int*, int, thread int*); >+native void InterlockedCompareExchange(threadgroup atomic_int*, int, int, thread int*); >+native void InterlockedAdd(threadgroup atomic_uint*, uint, device uint*); >+native void InterlockedAnd(threadgroup atomic_uint*, uint, device uint*); >+native void InterlockedExchange(threadgroup atomic_uint*, uint, device uint*); >+native void InterlockedMax(threadgroup atomic_uint*, uint, device uint*); >+native void InterlockedMin(threadgroup atomic_uint*, uint, device uint*); >+native void InterlockedOr(threadgroup atomic_uint*, uint, device uint*); >+native void InterlockedXor(threadgroup atomic_uint*, uint, device uint*); >+native void InterlockedCompareExchange(threadgroup atomic_uint*, uint, uint, device uint*); >+native void InterlockedAdd(threadgroup atomic_int*, int, device int*); >+native void InterlockedAnd(threadgroup atomic_int*, int, device int*); >+native void InterlockedExchange(threadgroup atomic_int*, int, device int*); >+native void InterlockedMax(threadgroup atomic_int*, int, device int*); >+native void InterlockedMin(threadgroup atomic_int*, int, device int*); >+native void InterlockedOr(threadgroup atomic_int*, int, device int*); >+native void InterlockedXor(threadgroup atomic_int*, int, device int*); >+native void InterlockedCompareExchange(threadgroup atomic_int*, int, int, device int*); >+native void InterlockedAdd(threadgroup atomic_uint*, uint, threadgroup uint*); >+native void InterlockedAnd(threadgroup atomic_uint*, uint, threadgroup uint*); >+native void InterlockedExchange(threadgroup atomic_uint*, uint, threadgroup uint*); >+native void InterlockedMax(threadgroup atomic_uint*, uint, threadgroup uint*); >+native void InterlockedMin(threadgroup atomic_uint*, uint, threadgroup uint*); >+native void InterlockedOr(threadgroup atomic_uint*, uint, threadgroup uint*); >+native void InterlockedXor(threadgroup atomic_uint*, uint, threadgroup uint*); >+native void InterlockedCompareExchange(threadgroup atomic_uint*, uint, uint, threadgroup uint*); >+native void InterlockedAdd(threadgroup atomic_int*, int, threadgroup int*); >+native void InterlockedAnd(threadgroup atomic_int*, int, threadgroup int*); >+native void InterlockedExchange(threadgroup atomic_int*, int, threadgroup int*); >+native void InterlockedMax(threadgroup atomic_int*, int, threadgroup int*); >+native void InterlockedMin(threadgroup atomic_int*, int, threadgroup int*); >+native void InterlockedOr(threadgroup atomic_int*, int, threadgroup int*); >+native void InterlockedXor(threadgroup atomic_int*, int, threadgroup int*); >+native void InterlockedCompareExchange(threadgroup atomic_int*, int, int, threadgroup int*); >+ >+native uchar Sample(Texture1D<uchar>, sampler, float location); >+native uchar Sample(Texture1D<uchar>, sampler, float location, int offset); >+native uchar Load(Texture1D<uchar>, int2 location); >+native uchar Load(Texture1D<uchar>, int2 location, int offset); >+native void GetDimensions(Texture1D<uchar>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native uchar Sample(Texture1DArray<uchar>, sampler, float2 location); >+native uchar Sample(Texture1DArray<uchar>, sampler, float2 location, int offset); >+native uchar Load(Texture1DArray<uchar>, int3 location); >+native uchar Load(Texture1DArray<uchar>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<uchar>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native uchar Sample(Texture2D<uchar>, sampler, float2 location); >+native uchar Sample(Texture2D<uchar>, sampler, float2 location, int2 offset); >+native uchar SampleBias(Texture2D<uchar>, sampler, float2 location, float Bias); >+native uchar SampleBias(Texture2D<uchar>, sampler, float2 location, float Bias, int2 offset); >+native uchar SampleGrad(Texture2D<uchar>, sampler, float2 location, float2 DDX, float2 DDY); >+native uchar SampleGrad(Texture2D<uchar>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native uchar SampleLevel(Texture2D<uchar>, sampler, float2 location, float LOD); >+native uchar SampleLevel(Texture2D<uchar>, sampler, float2 location, float LOD, int2 offset); >+native uchar4 Gather(Texture2D<uchar>, sampler, float2 location); >+native uchar4 Gather(Texture2D<uchar>, sampler, float2 location, int2 offset); >+native uchar4 GatherRed(Texture2D<uchar>, sampler, float2 location); >+native uchar4 GatherRed(Texture2D<uchar>, sampler, float2 location, int2 offset); >+native uchar Load(Texture2D<uchar>, int3 location); >+native uchar Load(Texture2D<uchar>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<uchar>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native uchar Sample(Texture2DArray<uchar>, sampler, float3 location); >+native uchar Sample(Texture2DArray<uchar>, sampler, float3 location, int2 offset); >+native uchar SampleBias(Texture2DArray<uchar>, sampler, float3 location, float Bias); >+native uchar SampleBias(Texture2DArray<uchar>, sampler, float3 location, float Bias, int2 offset); >+native uchar SampleGrad(Texture2DArray<uchar>, sampler, float3 location, float2 DDX, float2 DDY); >+native uchar SampleGrad(Texture2DArray<uchar>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native uchar SampleLevel(Texture2DArray<uchar>, sampler, float3 location, float LOD); >+native uchar SampleLevel(Texture2DArray<uchar>, sampler, float3 location, float LOD, int2 offset); >+native uchar4 Gather(Texture2DArray<uchar>, sampler, float3 location); >+native uchar4 Gather(Texture2DArray<uchar>, sampler, float3 location, int2 offset); >+native uchar4 GatherRed(Texture2DArray<uchar>, sampler, float3 location); >+native uchar4 GatherRed(Texture2DArray<uchar>, sampler, float3 location, int2 offset); >+native uchar Load(Texture2DArray<uchar>, int4 location); >+native uchar Load(Texture2DArray<uchar>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native uchar Sample(Texture3D<uchar>, sampler, float3 location); >+native uchar Sample(Texture3D<uchar>, sampler, float3 location, int3 offset); >+native uchar Load(Texture3D<uchar>, int4 location); >+native uchar Load(Texture3D<uchar>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native uchar Sample(TextureCube<uchar>, sampler, float3 location); >+native uchar SampleBias(TextureCube<uchar>, sampler, float3 location, float Bias); >+native uchar SampleGrad(TextureCube<uchar>, sampler, float3 location, float3 DDX, float3 DDY); >+native uchar SampleLevel(TextureCube<uchar>, sampler, float3 location, float LOD); >+native uchar4 Gather(TextureCube<uchar>, sampler, float3 location); >+native uchar4 GatherRed(TextureCube<uchar>, sampler, float3 location); >+native void GetDimensions(TextureCube<uchar>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<uchar>, thread uint* Width); >+native void GetDimensions(RWTexture1D<uchar>, thread float* Width); >+native void GetDimensions(RWTexture1D<uchar>, device uint* Width); >+native void GetDimensions(RWTexture1D<uchar>, device float* Width); >+native void GetDimensions(RWTexture1D<uchar>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<uchar>, threadgroup float* Width); >+native uchar Load(RWTexture1D<uchar>, int location); >+native void Store(RWTexture1D<uchar>, uchar, uint location); >+ >+native void GetDimensions(RWTexture1DArray<uchar>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar>, threadgroup float* Width, threadgroup uint* Elements); >+native uchar Load(RWTexture1DArray<uchar>, int2 location); >+native void Store(RWTexture1DArray<uchar>, uchar, uint2 location); >+ >+native void GetDimensions(RWTexture2D<uchar>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<uchar>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<uchar>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<uchar>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<uchar>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<uchar>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<uchar>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<uchar>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<uchar>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<uchar>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<uchar>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<uchar>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<uchar>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<uchar>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<uchar>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<uchar>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<uchar>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<uchar>, threadgroup float* Width, threadgroup float* Height); >+native uchar Load(RWTexture2D<uchar>, int2 location); >+native void Store(RWTexture2D<uchar>, uchar, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<uchar>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native uchar Load(RWTexture2DArray<uchar>, int3 location); >+native void Store(RWTexture2DArray<uchar>, uchar, uint3 location); >+ >+native void GetDimensions(RWTexture3D<uchar>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native uchar Load(RWTexture3D<uchar>, int3 location); >+native void Store(RWTexture3D<uchar>, uchar, uint3 location); >+ >+native uchar2 Sample(Texture1D<uchar2>, sampler, float location); >+native uchar2 Sample(Texture1D<uchar2>, sampler, float location, int offset); >+native uchar2 Load(Texture1D<uchar2>, int2 location); >+native uchar2 Load(Texture1D<uchar2>, int2 location, int offset); >+native void GetDimensions(Texture1D<uchar2>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar2>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar2>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar2>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar2>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar2>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar2>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar2>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native uchar2 Sample(Texture1DArray<uchar2>, sampler, float2 location); >+native uchar2 Sample(Texture1DArray<uchar2>, sampler, float2 location, int offset); >+native uchar2 Load(Texture1DArray<uchar2>, int3 location); >+native uchar2 Load(Texture1DArray<uchar2>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<uchar2>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar2>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar2>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar2>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar2>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar2>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar2>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar2>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar2>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar2>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar2>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar2>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native uchar2 Sample(Texture2D<uchar2>, sampler, float2 location); >+native uchar2 Sample(Texture2D<uchar2>, sampler, float2 location, int2 offset); >+native uchar2 SampleBias(Texture2D<uchar2>, sampler, float2 location, float Bias); >+native uchar2 SampleBias(Texture2D<uchar2>, sampler, float2 location, float Bias, int2 offset); >+native uchar2 SampleGrad(Texture2D<uchar2>, sampler, float2 location, float2 DDX, float2 DDY); >+native uchar2 SampleGrad(Texture2D<uchar2>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native uchar2 SampleLevel(Texture2D<uchar2>, sampler, float2 location, float LOD); >+native uchar2 SampleLevel(Texture2D<uchar2>, sampler, float2 location, float LOD, int2 offset); >+native uchar4 Gather(Texture2D<uchar2>, sampler, float2 location); >+native uchar4 Gather(Texture2D<uchar2>, sampler, float2 location, int2 offset); >+native uchar4 GatherRed(Texture2D<uchar2>, sampler, float2 location); >+native uchar4 GatherRed(Texture2D<uchar2>, sampler, float2 location, int2 offset); >+native uchar4 GatherGreen(Texture2D<uchar2>, sampler, float2 location); >+native uchar4 GatherGreen(Texture2D<uchar2>, sampler, float2 location, int2 offset); >+native uchar2 Load(Texture2D<uchar2>, int3 location); >+native uchar2 Load(Texture2D<uchar2>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<uchar2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native uchar2 Sample(Texture2DArray<uchar2>, sampler, float3 location); >+native uchar2 Sample(Texture2DArray<uchar2>, sampler, float3 location, int2 offset); >+native uchar2 SampleBias(Texture2DArray<uchar2>, sampler, float3 location, float Bias); >+native uchar2 SampleBias(Texture2DArray<uchar2>, sampler, float3 location, float Bias, int2 offset); >+native uchar2 SampleGrad(Texture2DArray<uchar2>, sampler, float3 location, float2 DDX, float2 DDY); >+native uchar2 SampleGrad(Texture2DArray<uchar2>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native uchar2 SampleLevel(Texture2DArray<uchar2>, sampler, float3 location, float LOD); >+native uchar2 SampleLevel(Texture2DArray<uchar2>, sampler, float3 location, float LOD, int2 offset); >+native uchar4 Gather(Texture2DArray<uchar2>, sampler, float3 location); >+native uchar4 Gather(Texture2DArray<uchar2>, sampler, float3 location, int2 offset); >+native uchar4 GatherRed(Texture2DArray<uchar2>, sampler, float3 location); >+native uchar4 GatherRed(Texture2DArray<uchar2>, sampler, float3 location, int2 offset); >+native uchar4 GatherGreen(Texture2DArray<uchar2>, sampler, float3 location); >+native uchar4 GatherGreen(Texture2DArray<uchar2>, sampler, float3 location, int2 offset); >+native uchar2 Load(Texture2DArray<uchar2>, int4 location); >+native uchar2 Load(Texture2DArray<uchar2>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native uchar2 Sample(Texture3D<uchar2>, sampler, float3 location); >+native uchar2 Sample(Texture3D<uchar2>, sampler, float3 location, int3 offset); >+native uchar2 Load(Texture3D<uchar2>, int4 location); >+native uchar2 Load(Texture3D<uchar2>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native uchar2 Sample(TextureCube<uchar2>, sampler, float3 location); >+native uchar2 SampleBias(TextureCube<uchar2>, sampler, float3 location, float Bias); >+native uchar2 SampleGrad(TextureCube<uchar2>, sampler, float3 location, float3 DDX, float3 DDY); >+native uchar2 SampleLevel(TextureCube<uchar2>, sampler, float3 location, float LOD); >+native uchar4 Gather(TextureCube<uchar2>, sampler, float3 location); >+native uchar4 GatherRed(TextureCube<uchar2>, sampler, float3 location); >+native uchar4 GatherGreen(TextureCube<uchar2>, sampler, float3 location); >+native void GetDimensions(TextureCube<uchar2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<uchar2>, thread uint* Width); >+native void GetDimensions(RWTexture1D<uchar2>, thread float* Width); >+native void GetDimensions(RWTexture1D<uchar2>, device uint* Width); >+native void GetDimensions(RWTexture1D<uchar2>, device float* Width); >+native void GetDimensions(RWTexture1D<uchar2>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<uchar2>, threadgroup float* Width); >+native uchar2 Load(RWTexture1D<uchar2>, int location); >+native void Store(RWTexture1D<uchar2>, uchar2, uint location); >+ >+native void GetDimensions(RWTexture1DArray<uchar2>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar2>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar2>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar2>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar2>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar2>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar2>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar2>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar2>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar2>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar2>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar2>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar2>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar2>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar2>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar2>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar2>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar2>, threadgroup float* Width, threadgroup uint* Elements); >+native uchar2 Load(RWTexture1DArray<uchar2>, int2 location); >+native void Store(RWTexture1DArray<uchar2>, uchar2, uint2 location); >+ >+native void GetDimensions(RWTexture2D<uchar2>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<uchar2>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<uchar2>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<uchar2>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<uchar2>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<uchar2>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<uchar2>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<uchar2>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<uchar2>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<uchar2>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<uchar2>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<uchar2>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<uchar2>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<uchar2>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<uchar2>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<uchar2>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<uchar2>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<uchar2>, threadgroup float* Width, threadgroup float* Height); >+native uchar2 Load(RWTexture2D<uchar2>, int2 location); >+native void Store(RWTexture2D<uchar2>, uchar2, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<uchar2>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar2>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native uchar2 Load(RWTexture2DArray<uchar2>, int3 location); >+native void Store(RWTexture2DArray<uchar2>, uchar2, uint3 location); >+ >+native void GetDimensions(RWTexture3D<uchar2>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar2>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native uchar2 Load(RWTexture3D<uchar2>, int3 location); >+native void Store(RWTexture3D<uchar2>, uchar2, uint3 location); >+ >+native uchar3 Sample(Texture1D<uchar3>, sampler, float location); >+native uchar3 Sample(Texture1D<uchar3>, sampler, float location, int offset); >+native uchar3 Load(Texture1D<uchar3>, int2 location); >+native uchar3 Load(Texture1D<uchar3>, int2 location, int offset); >+native void GetDimensions(Texture1D<uchar3>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar3>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar3>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar3>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar3>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar3>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar3>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar3>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native uchar3 Sample(Texture1DArray<uchar3>, sampler, float2 location); >+native uchar3 Sample(Texture1DArray<uchar3>, sampler, float2 location, int offset); >+native uchar3 Load(Texture1DArray<uchar3>, int3 location); >+native uchar3 Load(Texture1DArray<uchar3>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<uchar3>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar3>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar3>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar3>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar3>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar3>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar3>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar3>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar3>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar3>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar3>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar3>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native uchar3 Sample(Texture2D<uchar3>, sampler, float2 location); >+native uchar3 Sample(Texture2D<uchar3>, sampler, float2 location, int2 offset); >+native uchar3 SampleBias(Texture2D<uchar3>, sampler, float2 location, float Bias); >+native uchar3 SampleBias(Texture2D<uchar3>, sampler, float2 location, float Bias, int2 offset); >+native uchar3 SampleGrad(Texture2D<uchar3>, sampler, float2 location, float2 DDX, float2 DDY); >+native uchar3 SampleGrad(Texture2D<uchar3>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native uchar3 SampleLevel(Texture2D<uchar3>, sampler, float2 location, float LOD); >+native uchar3 SampleLevel(Texture2D<uchar3>, sampler, float2 location, float LOD, int2 offset); >+native uchar4 Gather(Texture2D<uchar3>, sampler, float2 location); >+native uchar4 Gather(Texture2D<uchar3>, sampler, float2 location, int2 offset); >+native uchar4 GatherRed(Texture2D<uchar3>, sampler, float2 location); >+native uchar4 GatherRed(Texture2D<uchar3>, sampler, float2 location, int2 offset); >+native uchar4 GatherGreen(Texture2D<uchar3>, sampler, float2 location); >+native uchar4 GatherGreen(Texture2D<uchar3>, sampler, float2 location, int2 offset); >+native uchar4 GatherBlue(Texture2D<uchar3>, sampler, float2 location); >+native uchar4 GatherBlue(Texture2D<uchar3>, sampler, float2 location, int2 offset); >+native uchar3 Load(Texture2D<uchar3>, int3 location); >+native uchar3 Load(Texture2D<uchar3>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<uchar3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native uchar3 Sample(Texture2DArray<uchar3>, sampler, float3 location); >+native uchar3 Sample(Texture2DArray<uchar3>, sampler, float3 location, int2 offset); >+native uchar3 SampleBias(Texture2DArray<uchar3>, sampler, float3 location, float Bias); >+native uchar3 SampleBias(Texture2DArray<uchar3>, sampler, float3 location, float Bias, int2 offset); >+native uchar3 SampleGrad(Texture2DArray<uchar3>, sampler, float3 location, float2 DDX, float2 DDY); >+native uchar3 SampleGrad(Texture2DArray<uchar3>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native uchar3 SampleLevel(Texture2DArray<uchar3>, sampler, float3 location, float LOD); >+native uchar3 SampleLevel(Texture2DArray<uchar3>, sampler, float3 location, float LOD, int2 offset); >+native uchar4 Gather(Texture2DArray<uchar3>, sampler, float3 location); >+native uchar4 Gather(Texture2DArray<uchar3>, sampler, float3 location, int2 offset); >+native uchar4 GatherRed(Texture2DArray<uchar3>, sampler, float3 location); >+native uchar4 GatherRed(Texture2DArray<uchar3>, sampler, float3 location, int2 offset); >+native uchar4 GatherGreen(Texture2DArray<uchar3>, sampler, float3 location); >+native uchar4 GatherGreen(Texture2DArray<uchar3>, sampler, float3 location, int2 offset); >+native uchar4 GatherBlue(Texture2DArray<uchar3>, sampler, float3 location); >+native uchar4 GatherBlue(Texture2DArray<uchar3>, sampler, float3 location, int2 offset); >+native uchar3 Load(Texture2DArray<uchar3>, int4 location); >+native uchar3 Load(Texture2DArray<uchar3>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native uchar3 Sample(Texture3D<uchar3>, sampler, float3 location); >+native uchar3 Sample(Texture3D<uchar3>, sampler, float3 location, int3 offset); >+native uchar3 Load(Texture3D<uchar3>, int4 location); >+native uchar3 Load(Texture3D<uchar3>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native uchar3 Sample(TextureCube<uchar3>, sampler, float3 location); >+native uchar3 SampleBias(TextureCube<uchar3>, sampler, float3 location, float Bias); >+native uchar3 SampleGrad(TextureCube<uchar3>, sampler, float3 location, float3 DDX, float3 DDY); >+native uchar3 SampleLevel(TextureCube<uchar3>, sampler, float3 location, float LOD); >+native uchar4 Gather(TextureCube<uchar3>, sampler, float3 location); >+native uchar4 GatherRed(TextureCube<uchar3>, sampler, float3 location); >+native uchar4 GatherGreen(TextureCube<uchar3>, sampler, float3 location); >+native uchar4 GatherBlue(TextureCube<uchar3>, sampler, float3 location); >+native void GetDimensions(TextureCube<uchar3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<uchar3>, thread uint* Width); >+native void GetDimensions(RWTexture1D<uchar3>, thread float* Width); >+native void GetDimensions(RWTexture1D<uchar3>, device uint* Width); >+native void GetDimensions(RWTexture1D<uchar3>, device float* Width); >+native void GetDimensions(RWTexture1D<uchar3>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<uchar3>, threadgroup float* Width); >+native uchar3 Load(RWTexture1D<uchar3>, int location); >+native void Store(RWTexture1D<uchar3>, uchar3, uint location); >+ >+native void GetDimensions(RWTexture1DArray<uchar3>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar3>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar3>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar3>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar3>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar3>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar3>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar3>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar3>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar3>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar3>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar3>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar3>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar3>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar3>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar3>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar3>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar3>, threadgroup float* Width, threadgroup uint* Elements); >+native uchar3 Load(RWTexture1DArray<uchar3>, int2 location); >+native void Store(RWTexture1DArray<uchar3>, uchar3, uint2 location); >+ >+native void GetDimensions(RWTexture2D<uchar3>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<uchar3>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<uchar3>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<uchar3>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<uchar3>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<uchar3>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<uchar3>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<uchar3>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<uchar3>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<uchar3>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<uchar3>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<uchar3>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<uchar3>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<uchar3>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<uchar3>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<uchar3>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<uchar3>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<uchar3>, threadgroup float* Width, threadgroup float* Height); >+native uchar3 Load(RWTexture2D<uchar3>, int2 location); >+native void Store(RWTexture2D<uchar3>, uchar3, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<uchar3>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar3>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native uchar3 Load(RWTexture2DArray<uchar3>, int3 location); >+native void Store(RWTexture2DArray<uchar3>, uchar3, uint3 location); >+ >+native void GetDimensions(RWTexture3D<uchar3>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar3>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native uchar3 Load(RWTexture3D<uchar3>, int3 location); >+native void Store(RWTexture3D<uchar3>, uchar3, uint3 location); >+ >+native uchar4 Sample(Texture1D<uchar4>, sampler, float location); >+native uchar4 Sample(Texture1D<uchar4>, sampler, float location, int offset); >+native uchar4 Load(Texture1D<uchar4>, int2 location); >+native uchar4 Load(Texture1D<uchar4>, int2 location, int offset); >+native void GetDimensions(Texture1D<uchar4>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar4>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar4>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar4>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar4>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar4>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar4>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar4>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uchar4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native uchar4 Sample(Texture1DArray<uchar4>, sampler, float2 location); >+native uchar4 Sample(Texture1DArray<uchar4>, sampler, float2 location, int offset); >+native uchar4 Load(Texture1DArray<uchar4>, int3 location); >+native uchar4 Load(Texture1DArray<uchar4>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<uchar4>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar4>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar4>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar4>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar4>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar4>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar4>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar4>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar4>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar4>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar4>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar4>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uchar4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native uchar4 Sample(Texture2D<uchar4>, sampler, float2 location); >+native uchar4 Sample(Texture2D<uchar4>, sampler, float2 location, int2 offset); >+native uchar4 SampleBias(Texture2D<uchar4>, sampler, float2 location, float Bias); >+native uchar4 SampleBias(Texture2D<uchar4>, sampler, float2 location, float Bias, int2 offset); >+native uchar4 SampleGrad(Texture2D<uchar4>, sampler, float2 location, float2 DDX, float2 DDY); >+native uchar4 SampleGrad(Texture2D<uchar4>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native uchar4 SampleLevel(Texture2D<uchar4>, sampler, float2 location, float LOD); >+native uchar4 SampleLevel(Texture2D<uchar4>, sampler, float2 location, float LOD, int2 offset); >+native uchar4 Gather(Texture2D<uchar4>, sampler, float2 location); >+native uchar4 Gather(Texture2D<uchar4>, sampler, float2 location, int2 offset); >+native uchar4 GatherRed(Texture2D<uchar4>, sampler, float2 location); >+native uchar4 GatherRed(Texture2D<uchar4>, sampler, float2 location, int2 offset); >+native uchar4 GatherGreen(Texture2D<uchar4>, sampler, float2 location); >+native uchar4 GatherGreen(Texture2D<uchar4>, sampler, float2 location, int2 offset); >+native uchar4 GatherBlue(Texture2D<uchar4>, sampler, float2 location); >+native uchar4 GatherBlue(Texture2D<uchar4>, sampler, float2 location, int2 offset); >+native uchar4 GatherAlpha(Texture2D<uchar4>, sampler, float2 location); >+native uchar4 GatherAlpha(Texture2D<uchar4>, sampler, float2 location, int2 offset); >+native uchar4 Load(Texture2D<uchar4>, int3 location); >+native uchar4 Load(Texture2D<uchar4>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<uchar4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uchar4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native uchar4 Sample(Texture2DArray<uchar4>, sampler, float3 location); >+native uchar4 Sample(Texture2DArray<uchar4>, sampler, float3 location, int2 offset); >+native uchar4 SampleBias(Texture2DArray<uchar4>, sampler, float3 location, float Bias); >+native uchar4 SampleBias(Texture2DArray<uchar4>, sampler, float3 location, float Bias, int2 offset); >+native uchar4 SampleGrad(Texture2DArray<uchar4>, sampler, float3 location, float2 DDX, float2 DDY); >+native uchar4 SampleGrad(Texture2DArray<uchar4>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native uchar4 SampleLevel(Texture2DArray<uchar4>, sampler, float3 location, float LOD); >+native uchar4 SampleLevel(Texture2DArray<uchar4>, sampler, float3 location, float LOD, int2 offset); >+native uchar4 Gather(Texture2DArray<uchar4>, sampler, float3 location); >+native uchar4 Gather(Texture2DArray<uchar4>, sampler, float3 location, int2 offset); >+native uchar4 GatherRed(Texture2DArray<uchar4>, sampler, float3 location); >+native uchar4 GatherRed(Texture2DArray<uchar4>, sampler, float3 location, int2 offset); >+native uchar4 GatherGreen(Texture2DArray<uchar4>, sampler, float3 location); >+native uchar4 GatherGreen(Texture2DArray<uchar4>, sampler, float3 location, int2 offset); >+native uchar4 GatherBlue(Texture2DArray<uchar4>, sampler, float3 location); >+native uchar4 GatherBlue(Texture2DArray<uchar4>, sampler, float3 location, int2 offset); >+native uchar4 GatherAlpha(Texture2DArray<uchar4>, sampler, float3 location); >+native uchar4 GatherAlpha(Texture2DArray<uchar4>, sampler, float3 location, int2 offset); >+native uchar4 Load(Texture2DArray<uchar4>, int4 location); >+native uchar4 Load(Texture2DArray<uchar4>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uchar4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native uchar4 Sample(Texture3D<uchar4>, sampler, float3 location); >+native uchar4 Sample(Texture3D<uchar4>, sampler, float3 location, int3 offset); >+native uchar4 Load(Texture3D<uchar4>, int4 location); >+native uchar4 Load(Texture3D<uchar4>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uchar4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native uchar4 Sample(TextureCube<uchar4>, sampler, float3 location); >+native uchar4 SampleBias(TextureCube<uchar4>, sampler, float3 location, float Bias); >+native uchar4 SampleGrad(TextureCube<uchar4>, sampler, float3 location, float3 DDX, float3 DDY); >+native uchar4 SampleLevel(TextureCube<uchar4>, sampler, float3 location, float LOD); >+native uchar4 Gather(TextureCube<uchar4>, sampler, float3 location); >+native uchar4 GatherRed(TextureCube<uchar4>, sampler, float3 location); >+native uchar4 GatherGreen(TextureCube<uchar4>, sampler, float3 location); >+native uchar4 GatherBlue(TextureCube<uchar4>, sampler, float3 location); >+native uchar4 GatherAlpha(TextureCube<uchar4>, sampler, float3 location); >+native void GetDimensions(TextureCube<uchar4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uchar4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<uchar4>, thread uint* Width); >+native void GetDimensions(RWTexture1D<uchar4>, thread float* Width); >+native void GetDimensions(RWTexture1D<uchar4>, device uint* Width); >+native void GetDimensions(RWTexture1D<uchar4>, device float* Width); >+native void GetDimensions(RWTexture1D<uchar4>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<uchar4>, threadgroup float* Width); >+native uchar4 Load(RWTexture1D<uchar4>, int location); >+native void Store(RWTexture1D<uchar4>, uchar4, uint location); >+ >+native void GetDimensions(RWTexture1DArray<uchar4>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar4>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar4>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar4>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar4>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar4>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar4>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar4>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar4>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar4>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar4>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar4>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar4>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar4>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar4>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar4>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar4>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uchar4>, threadgroup float* Width, threadgroup uint* Elements); >+native uchar4 Load(RWTexture1DArray<uchar4>, int2 location); >+native void Store(RWTexture1DArray<uchar4>, uchar4, uint2 location); >+ >+native void GetDimensions(RWTexture2D<uchar4>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<uchar4>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<uchar4>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<uchar4>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<uchar4>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<uchar4>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<uchar4>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<uchar4>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<uchar4>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<uchar4>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<uchar4>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<uchar4>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<uchar4>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<uchar4>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<uchar4>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<uchar4>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<uchar4>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<uchar4>, threadgroup float* Width, threadgroup float* Height); >+native uchar4 Load(RWTexture2D<uchar4>, int2 location); >+native void Store(RWTexture2D<uchar4>, uchar4, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<uchar4>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uchar4>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native uchar4 Load(RWTexture2DArray<uchar4>, int3 location); >+native void Store(RWTexture2DArray<uchar4>, uchar4, uint3 location); >+ >+native void GetDimensions(RWTexture3D<uchar4>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uchar4>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native uchar4 Load(RWTexture3D<uchar4>, int3 location); >+native void Store(RWTexture3D<uchar4>, uchar4, uint3 location); >+ >+native ushort Sample(Texture1D<ushort>, sampler, float location); >+native ushort Sample(Texture1D<ushort>, sampler, float location, int offset); >+native ushort Load(Texture1D<ushort>, int2 location); >+native ushort Load(Texture1D<ushort>, int2 location, int offset); >+native void GetDimensions(Texture1D<ushort>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native ushort Sample(Texture1DArray<ushort>, sampler, float2 location); >+native ushort Sample(Texture1DArray<ushort>, sampler, float2 location, int offset); >+native ushort Load(Texture1DArray<ushort>, int3 location); >+native ushort Load(Texture1DArray<ushort>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native ushort Sample(Texture2D<ushort>, sampler, float2 location); >+native ushort Sample(Texture2D<ushort>, sampler, float2 location, int2 offset); >+native ushort SampleBias(Texture2D<ushort>, sampler, float2 location, float Bias); >+native ushort SampleBias(Texture2D<ushort>, sampler, float2 location, float Bias, int2 offset); >+native ushort SampleGrad(Texture2D<ushort>, sampler, float2 location, float2 DDX, float2 DDY); >+native ushort SampleGrad(Texture2D<ushort>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native ushort SampleLevel(Texture2D<ushort>, sampler, float2 location, float LOD); >+native ushort SampleLevel(Texture2D<ushort>, sampler, float2 location, float LOD, int2 offset); >+native ushort4 Gather(Texture2D<ushort>, sampler, float2 location); >+native ushort4 Gather(Texture2D<ushort>, sampler, float2 location, int2 offset); >+native ushort4 GatherRed(Texture2D<ushort>, sampler, float2 location); >+native ushort4 GatherRed(Texture2D<ushort>, sampler, float2 location, int2 offset); >+native ushort Load(Texture2D<ushort>, int3 location); >+native ushort Load(Texture2D<ushort>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native ushort Sample(Texture2DArray<ushort>, sampler, float3 location); >+native ushort Sample(Texture2DArray<ushort>, sampler, float3 location, int2 offset); >+native ushort SampleBias(Texture2DArray<ushort>, sampler, float3 location, float Bias); >+native ushort SampleBias(Texture2DArray<ushort>, sampler, float3 location, float Bias, int2 offset); >+native ushort SampleGrad(Texture2DArray<ushort>, sampler, float3 location, float2 DDX, float2 DDY); >+native ushort SampleGrad(Texture2DArray<ushort>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native ushort SampleLevel(Texture2DArray<ushort>, sampler, float3 location, float LOD); >+native ushort SampleLevel(Texture2DArray<ushort>, sampler, float3 location, float LOD, int2 offset); >+native ushort4 Gather(Texture2DArray<ushort>, sampler, float3 location); >+native ushort4 Gather(Texture2DArray<ushort>, sampler, float3 location, int2 offset); >+native ushort4 GatherRed(Texture2DArray<ushort>, sampler, float3 location); >+native ushort4 GatherRed(Texture2DArray<ushort>, sampler, float3 location, int2 offset); >+native ushort Load(Texture2DArray<ushort>, int4 location); >+native ushort Load(Texture2DArray<ushort>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native ushort Sample(Texture3D<ushort>, sampler, float3 location); >+native ushort Sample(Texture3D<ushort>, sampler, float3 location, int3 offset); >+native ushort Load(Texture3D<ushort>, int4 location); >+native ushort Load(Texture3D<ushort>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native ushort Sample(TextureCube<ushort>, sampler, float3 location); >+native ushort SampleBias(TextureCube<ushort>, sampler, float3 location, float Bias); >+native ushort SampleGrad(TextureCube<ushort>, sampler, float3 location, float3 DDX, float3 DDY); >+native ushort SampleLevel(TextureCube<ushort>, sampler, float3 location, float LOD); >+native ushort4 Gather(TextureCube<ushort>, sampler, float3 location); >+native ushort4 GatherRed(TextureCube<ushort>, sampler, float3 location); >+native void GetDimensions(TextureCube<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<ushort>, thread uint* Width); >+native void GetDimensions(RWTexture1D<ushort>, thread float* Width); >+native void GetDimensions(RWTexture1D<ushort>, device uint* Width); >+native void GetDimensions(RWTexture1D<ushort>, device float* Width); >+native void GetDimensions(RWTexture1D<ushort>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<ushort>, threadgroup float* Width); >+native ushort Load(RWTexture1D<ushort>, int location); >+native void Store(RWTexture1D<ushort>, ushort, uint location); >+ >+native void GetDimensions(RWTexture1DArray<ushort>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort>, threadgroup float* Width, threadgroup uint* Elements); >+native ushort Load(RWTexture1DArray<ushort>, int2 location); >+native void Store(RWTexture1DArray<ushort>, ushort, uint2 location); >+ >+native void GetDimensions(RWTexture2D<ushort>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<ushort>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<ushort>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<ushort>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<ushort>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<ushort>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<ushort>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<ushort>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<ushort>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<ushort>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<ushort>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<ushort>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<ushort>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<ushort>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<ushort>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<ushort>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<ushort>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<ushort>, threadgroup float* Width, threadgroup float* Height); >+native ushort Load(RWTexture2D<ushort>, int2 location); >+native void Store(RWTexture2D<ushort>, ushort, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<ushort>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native ushort Load(RWTexture2DArray<ushort>, int3 location); >+native void Store(RWTexture2DArray<ushort>, ushort, uint3 location); >+ >+native void GetDimensions(RWTexture3D<ushort>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native ushort Load(RWTexture3D<ushort>, int3 location); >+native void Store(RWTexture3D<ushort>, ushort, uint3 location); >+ >+native ushort2 Sample(Texture1D<ushort2>, sampler, float location); >+native ushort2 Sample(Texture1D<ushort2>, sampler, float location, int offset); >+native ushort2 Load(Texture1D<ushort2>, int2 location); >+native ushort2 Load(Texture1D<ushort2>, int2 location, int offset); >+native void GetDimensions(Texture1D<ushort2>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort2>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort2>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort2>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native ushort2 Sample(Texture1DArray<ushort2>, sampler, float2 location); >+native ushort2 Sample(Texture1DArray<ushort2>, sampler, float2 location, int offset); >+native ushort2 Load(Texture1DArray<ushort2>, int3 location); >+native ushort2 Load(Texture1DArray<ushort2>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native ushort2 Sample(Texture2D<ushort2>, sampler, float2 location); >+native ushort2 Sample(Texture2D<ushort2>, sampler, float2 location, int2 offset); >+native ushort2 SampleBias(Texture2D<ushort2>, sampler, float2 location, float Bias); >+native ushort2 SampleBias(Texture2D<ushort2>, sampler, float2 location, float Bias, int2 offset); >+native ushort2 SampleGrad(Texture2D<ushort2>, sampler, float2 location, float2 DDX, float2 DDY); >+native ushort2 SampleGrad(Texture2D<ushort2>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native ushort2 SampleLevel(Texture2D<ushort2>, sampler, float2 location, float LOD); >+native ushort2 SampleLevel(Texture2D<ushort2>, sampler, float2 location, float LOD, int2 offset); >+native ushort4 Gather(Texture2D<ushort2>, sampler, float2 location); >+native ushort4 Gather(Texture2D<ushort2>, sampler, float2 location, int2 offset); >+native ushort4 GatherRed(Texture2D<ushort2>, sampler, float2 location); >+native ushort4 GatherRed(Texture2D<ushort2>, sampler, float2 location, int2 offset); >+native ushort4 GatherGreen(Texture2D<ushort2>, sampler, float2 location); >+native ushort4 GatherGreen(Texture2D<ushort2>, sampler, float2 location, int2 offset); >+native ushort2 Load(Texture2D<ushort2>, int3 location); >+native ushort2 Load(Texture2D<ushort2>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native ushort2 Sample(Texture2DArray<ushort2>, sampler, float3 location); >+native ushort2 Sample(Texture2DArray<ushort2>, sampler, float3 location, int2 offset); >+native ushort2 SampleBias(Texture2DArray<ushort2>, sampler, float3 location, float Bias); >+native ushort2 SampleBias(Texture2DArray<ushort2>, sampler, float3 location, float Bias, int2 offset); >+native ushort2 SampleGrad(Texture2DArray<ushort2>, sampler, float3 location, float2 DDX, float2 DDY); >+native ushort2 SampleGrad(Texture2DArray<ushort2>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native ushort2 SampleLevel(Texture2DArray<ushort2>, sampler, float3 location, float LOD); >+native ushort2 SampleLevel(Texture2DArray<ushort2>, sampler, float3 location, float LOD, int2 offset); >+native ushort4 Gather(Texture2DArray<ushort2>, sampler, float3 location); >+native ushort4 Gather(Texture2DArray<ushort2>, sampler, float3 location, int2 offset); >+native ushort4 GatherRed(Texture2DArray<ushort2>, sampler, float3 location); >+native ushort4 GatherRed(Texture2DArray<ushort2>, sampler, float3 location, int2 offset); >+native ushort4 GatherGreen(Texture2DArray<ushort2>, sampler, float3 location); >+native ushort4 GatherGreen(Texture2DArray<ushort2>, sampler, float3 location, int2 offset); >+native ushort2 Load(Texture2DArray<ushort2>, int4 location); >+native ushort2 Load(Texture2DArray<ushort2>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native ushort2 Sample(Texture3D<ushort2>, sampler, float3 location); >+native ushort2 Sample(Texture3D<ushort2>, sampler, float3 location, int3 offset); >+native ushort2 Load(Texture3D<ushort2>, int4 location); >+native ushort2 Load(Texture3D<ushort2>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native ushort2 Sample(TextureCube<ushort2>, sampler, float3 location); >+native ushort2 SampleBias(TextureCube<ushort2>, sampler, float3 location, float Bias); >+native ushort2 SampleGrad(TextureCube<ushort2>, sampler, float3 location, float3 DDX, float3 DDY); >+native ushort2 SampleLevel(TextureCube<ushort2>, sampler, float3 location, float LOD); >+native ushort4 Gather(TextureCube<ushort2>, sampler, float3 location); >+native ushort4 GatherRed(TextureCube<ushort2>, sampler, float3 location); >+native ushort4 GatherGreen(TextureCube<ushort2>, sampler, float3 location); >+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<ushort2>, thread uint* Width); >+native void GetDimensions(RWTexture1D<ushort2>, thread float* Width); >+native void GetDimensions(RWTexture1D<ushort2>, device uint* Width); >+native void GetDimensions(RWTexture1D<ushort2>, device float* Width); >+native void GetDimensions(RWTexture1D<ushort2>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<ushort2>, threadgroup float* Width); >+native ushort2 Load(RWTexture1D<ushort2>, int location); >+native void Store(RWTexture1D<ushort2>, ushort2, uint location); >+ >+native void GetDimensions(RWTexture1DArray<ushort2>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort2>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort2>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort2>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort2>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort2>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort2>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort2>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort2>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort2>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort2>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort2>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort2>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort2>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort2>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort2>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort2>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort2>, threadgroup float* Width, threadgroup uint* Elements); >+native ushort2 Load(RWTexture1DArray<ushort2>, int2 location); >+native void Store(RWTexture1DArray<ushort2>, ushort2, uint2 location); >+ >+native void GetDimensions(RWTexture2D<ushort2>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<ushort2>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<ushort2>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<ushort2>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<ushort2>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<ushort2>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<ushort2>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<ushort2>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<ushort2>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<ushort2>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<ushort2>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<ushort2>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<ushort2>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<ushort2>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<ushort2>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<ushort2>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<ushort2>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<ushort2>, threadgroup float* Width, threadgroup float* Height); >+native ushort2 Load(RWTexture2D<ushort2>, int2 location); >+native void Store(RWTexture2D<ushort2>, ushort2, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<ushort2>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native ushort2 Load(RWTexture2DArray<ushort2>, int3 location); >+native void Store(RWTexture2DArray<ushort2>, ushort2, uint3 location); >+ >+native void GetDimensions(RWTexture3D<ushort2>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort2>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native ushort2 Load(RWTexture3D<ushort2>, int3 location); >+native void Store(RWTexture3D<ushort2>, ushort2, uint3 location); >+ >+native ushort3 Sample(Texture1D<ushort3>, sampler, float location); >+native ushort3 Sample(Texture1D<ushort3>, sampler, float location, int offset); >+native ushort3 Load(Texture1D<ushort3>, int2 location); >+native ushort3 Load(Texture1D<ushort3>, int2 location, int offset); >+native void GetDimensions(Texture1D<ushort3>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort3>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort3>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort3>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native ushort3 Sample(Texture1DArray<ushort3>, sampler, float2 location); >+native ushort3 Sample(Texture1DArray<ushort3>, sampler, float2 location, int offset); >+native ushort3 Load(Texture1DArray<ushort3>, int3 location); >+native ushort3 Load(Texture1DArray<ushort3>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native ushort3 Sample(Texture2D<ushort3>, sampler, float2 location); >+native ushort3 Sample(Texture2D<ushort3>, sampler, float2 location, int2 offset); >+native ushort3 SampleBias(Texture2D<ushort3>, sampler, float2 location, float Bias); >+native ushort3 SampleBias(Texture2D<ushort3>, sampler, float2 location, float Bias, int2 offset); >+native ushort3 SampleGrad(Texture2D<ushort3>, sampler, float2 location, float2 DDX, float2 DDY); >+native ushort3 SampleGrad(Texture2D<ushort3>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native ushort3 SampleLevel(Texture2D<ushort3>, sampler, float2 location, float LOD); >+native ushort3 SampleLevel(Texture2D<ushort3>, sampler, float2 location, float LOD, int2 offset); >+native ushort4 Gather(Texture2D<ushort3>, sampler, float2 location); >+native ushort4 Gather(Texture2D<ushort3>, sampler, float2 location, int2 offset); >+native ushort4 GatherRed(Texture2D<ushort3>, sampler, float2 location); >+native ushort4 GatherRed(Texture2D<ushort3>, sampler, float2 location, int2 offset); >+native ushort4 GatherGreen(Texture2D<ushort3>, sampler, float2 location); >+native ushort4 GatherGreen(Texture2D<ushort3>, sampler, float2 location, int2 offset); >+native ushort4 GatherBlue(Texture2D<ushort3>, sampler, float2 location); >+native ushort4 GatherBlue(Texture2D<ushort3>, sampler, float2 location, int2 offset); >+native ushort3 Load(Texture2D<ushort3>, int3 location); >+native ushort3 Load(Texture2D<ushort3>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native ushort3 Sample(Texture2DArray<ushort3>, sampler, float3 location); >+native ushort3 Sample(Texture2DArray<ushort3>, sampler, float3 location, int2 offset); >+native ushort3 SampleBias(Texture2DArray<ushort3>, sampler, float3 location, float Bias); >+native ushort3 SampleBias(Texture2DArray<ushort3>, sampler, float3 location, float Bias, int2 offset); >+native ushort3 SampleGrad(Texture2DArray<ushort3>, sampler, float3 location, float2 DDX, float2 DDY); >+native ushort3 SampleGrad(Texture2DArray<ushort3>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native ushort3 SampleLevel(Texture2DArray<ushort3>, sampler, float3 location, float LOD); >+native ushort3 SampleLevel(Texture2DArray<ushort3>, sampler, float3 location, float LOD, int2 offset); >+native ushort4 Gather(Texture2DArray<ushort3>, sampler, float3 location); >+native ushort4 Gather(Texture2DArray<ushort3>, sampler, float3 location, int2 offset); >+native ushort4 GatherRed(Texture2DArray<ushort3>, sampler, float3 location); >+native ushort4 GatherRed(Texture2DArray<ushort3>, sampler, float3 location, int2 offset); >+native ushort4 GatherGreen(Texture2DArray<ushort3>, sampler, float3 location); >+native ushort4 GatherGreen(Texture2DArray<ushort3>, sampler, float3 location, int2 offset); >+native ushort4 GatherBlue(Texture2DArray<ushort3>, sampler, float3 location); >+native ushort4 GatherBlue(Texture2DArray<ushort3>, sampler, float3 location, int2 offset); >+native ushort3 Load(Texture2DArray<ushort3>, int4 location); >+native ushort3 Load(Texture2DArray<ushort3>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native ushort3 Sample(Texture3D<ushort3>, sampler, float3 location); >+native ushort3 Sample(Texture3D<ushort3>, sampler, float3 location, int3 offset); >+native ushort3 Load(Texture3D<ushort3>, int4 location); >+native ushort3 Load(Texture3D<ushort3>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native ushort3 Sample(TextureCube<ushort3>, sampler, float3 location); >+native ushort3 SampleBias(TextureCube<ushort3>, sampler, float3 location, float Bias); >+native ushort3 SampleGrad(TextureCube<ushort3>, sampler, float3 location, float3 DDX, float3 DDY); >+native ushort3 SampleLevel(TextureCube<ushort3>, sampler, float3 location, float LOD); >+native ushort4 Gather(TextureCube<ushort3>, sampler, float3 location); >+native ushort4 GatherRed(TextureCube<ushort3>, sampler, float3 location); >+native ushort4 GatherGreen(TextureCube<ushort3>, sampler, float3 location); >+native ushort4 GatherBlue(TextureCube<ushort3>, sampler, float3 location); >+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<ushort3>, thread uint* Width); >+native void GetDimensions(RWTexture1D<ushort3>, thread float* Width); >+native void GetDimensions(RWTexture1D<ushort3>, device uint* Width); >+native void GetDimensions(RWTexture1D<ushort3>, device float* Width); >+native void GetDimensions(RWTexture1D<ushort3>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<ushort3>, threadgroup float* Width); >+native ushort3 Load(RWTexture1D<ushort3>, int location); >+native void Store(RWTexture1D<ushort3>, ushort3, uint location); >+ >+native void GetDimensions(RWTexture1DArray<ushort3>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort3>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort3>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort3>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort3>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort3>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort3>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort3>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort3>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort3>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort3>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort3>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort3>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort3>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort3>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort3>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort3>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort3>, threadgroup float* Width, threadgroup uint* Elements); >+native ushort3 Load(RWTexture1DArray<ushort3>, int2 location); >+native void Store(RWTexture1DArray<ushort3>, ushort3, uint2 location); >+ >+native void GetDimensions(RWTexture2D<ushort3>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<ushort3>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<ushort3>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<ushort3>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<ushort3>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<ushort3>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<ushort3>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<ushort3>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<ushort3>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<ushort3>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<ushort3>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<ushort3>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<ushort3>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<ushort3>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<ushort3>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<ushort3>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<ushort3>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<ushort3>, threadgroup float* Width, threadgroup float* Height); >+native ushort3 Load(RWTexture2D<ushort3>, int2 location); >+native void Store(RWTexture2D<ushort3>, ushort3, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<ushort3>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native ushort3 Load(RWTexture2DArray<ushort3>, int3 location); >+native void Store(RWTexture2DArray<ushort3>, ushort3, uint3 location); >+ >+native void GetDimensions(RWTexture3D<ushort3>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort3>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native ushort3 Load(RWTexture3D<ushort3>, int3 location); >+native void Store(RWTexture3D<ushort3>, ushort3, uint3 location); >+ >+native ushort4 Sample(Texture1D<ushort4>, sampler, float location); >+native ushort4 Sample(Texture1D<ushort4>, sampler, float location, int offset); >+native ushort4 Load(Texture1D<ushort4>, int2 location); >+native ushort4 Load(Texture1D<ushort4>, int2 location, int offset); >+native void GetDimensions(Texture1D<ushort4>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort4>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort4>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort4>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native ushort4 Sample(Texture1DArray<ushort4>, sampler, float2 location); >+native ushort4 Sample(Texture1DArray<ushort4>, sampler, float2 location, int offset); >+native ushort4 Load(Texture1DArray<ushort4>, int3 location); >+native ushort4 Load(Texture1DArray<ushort4>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native ushort4 Sample(Texture2D<ushort4>, sampler, float2 location); >+native ushort4 Sample(Texture2D<ushort4>, sampler, float2 location, int2 offset); >+native ushort4 SampleBias(Texture2D<ushort4>, sampler, float2 location, float Bias); >+native ushort4 SampleBias(Texture2D<ushort4>, sampler, float2 location, float Bias, int2 offset); >+native ushort4 SampleGrad(Texture2D<ushort4>, sampler, float2 location, float2 DDX, float2 DDY); >+native ushort4 SampleGrad(Texture2D<ushort4>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native ushort4 SampleLevel(Texture2D<ushort4>, sampler, float2 location, float LOD); >+native ushort4 SampleLevel(Texture2D<ushort4>, sampler, float2 location, float LOD, int2 offset); >+native ushort4 Gather(Texture2D<ushort4>, sampler, float2 location); >+native ushort4 Gather(Texture2D<ushort4>, sampler, float2 location, int2 offset); >+native ushort4 GatherRed(Texture2D<ushort4>, sampler, float2 location); >+native ushort4 GatherRed(Texture2D<ushort4>, sampler, float2 location, int2 offset); >+native ushort4 GatherGreen(Texture2D<ushort4>, sampler, float2 location); >+native ushort4 GatherGreen(Texture2D<ushort4>, sampler, float2 location, int2 offset); >+native ushort4 GatherBlue(Texture2D<ushort4>, sampler, float2 location); >+native ushort4 GatherBlue(Texture2D<ushort4>, sampler, float2 location, int2 offset); >+native ushort4 GatherAlpha(Texture2D<ushort4>, sampler, float2 location); >+native ushort4 GatherAlpha(Texture2D<ushort4>, sampler, float2 location, int2 offset); >+native ushort4 Load(Texture2D<ushort4>, int3 location); >+native ushort4 Load(Texture2D<ushort4>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native ushort4 Sample(Texture2DArray<ushort4>, sampler, float3 location); >+native ushort4 Sample(Texture2DArray<ushort4>, sampler, float3 location, int2 offset); >+native ushort4 SampleBias(Texture2DArray<ushort4>, sampler, float3 location, float Bias); >+native ushort4 SampleBias(Texture2DArray<ushort4>, sampler, float3 location, float Bias, int2 offset); >+native ushort4 SampleGrad(Texture2DArray<ushort4>, sampler, float3 location, float2 DDX, float2 DDY); >+native ushort4 SampleGrad(Texture2DArray<ushort4>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native ushort4 SampleLevel(Texture2DArray<ushort4>, sampler, float3 location, float LOD); >+native ushort4 SampleLevel(Texture2DArray<ushort4>, sampler, float3 location, float LOD, int2 offset); >+native ushort4 Gather(Texture2DArray<ushort4>, sampler, float3 location); >+native ushort4 Gather(Texture2DArray<ushort4>, sampler, float3 location, int2 offset); >+native ushort4 GatherRed(Texture2DArray<ushort4>, sampler, float3 location); >+native ushort4 GatherRed(Texture2DArray<ushort4>, sampler, float3 location, int2 offset); >+native ushort4 GatherGreen(Texture2DArray<ushort4>, sampler, float3 location); >+native ushort4 GatherGreen(Texture2DArray<ushort4>, sampler, float3 location, int2 offset); >+native ushort4 GatherBlue(Texture2DArray<ushort4>, sampler, float3 location); >+native ushort4 GatherBlue(Texture2DArray<ushort4>, sampler, float3 location, int2 offset); >+native ushort4 GatherAlpha(Texture2DArray<ushort4>, sampler, float3 location); >+native ushort4 GatherAlpha(Texture2DArray<ushort4>, sampler, float3 location, int2 offset); >+native ushort4 Load(Texture2DArray<ushort4>, int4 location); >+native ushort4 Load(Texture2DArray<ushort4>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native ushort4 Sample(Texture3D<ushort4>, sampler, float3 location); >+native ushort4 Sample(Texture3D<ushort4>, sampler, float3 location, int3 offset); >+native ushort4 Load(Texture3D<ushort4>, int4 location); >+native ushort4 Load(Texture3D<ushort4>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native ushort4 Sample(TextureCube<ushort4>, sampler, float3 location); >+native ushort4 SampleBias(TextureCube<ushort4>, sampler, float3 location, float Bias); >+native ushort4 SampleGrad(TextureCube<ushort4>, sampler, float3 location, float3 DDX, float3 DDY); >+native ushort4 SampleLevel(TextureCube<ushort4>, sampler, float3 location, float LOD); >+native ushort4 Gather(TextureCube<ushort4>, sampler, float3 location); >+native ushort4 GatherRed(TextureCube<ushort4>, sampler, float3 location); >+native ushort4 GatherGreen(TextureCube<ushort4>, sampler, float3 location); >+native ushort4 GatherBlue(TextureCube<ushort4>, sampler, float3 location); >+native ushort4 GatherAlpha(TextureCube<ushort4>, sampler, float3 location); >+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<ushort4>, thread uint* Width); >+native void GetDimensions(RWTexture1D<ushort4>, thread float* Width); >+native void GetDimensions(RWTexture1D<ushort4>, device uint* Width); >+native void GetDimensions(RWTexture1D<ushort4>, device float* Width); >+native void GetDimensions(RWTexture1D<ushort4>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<ushort4>, threadgroup float* Width); >+native ushort4 Load(RWTexture1D<ushort4>, int location); >+native void Store(RWTexture1D<ushort4>, ushort4, uint location); >+ >+native void GetDimensions(RWTexture1DArray<ushort4>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort4>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort4>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort4>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort4>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort4>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort4>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort4>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort4>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort4>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort4>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort4>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort4>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort4>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort4>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort4>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort4>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<ushort4>, threadgroup float* Width, threadgroup uint* Elements); >+native ushort4 Load(RWTexture1DArray<ushort4>, int2 location); >+native void Store(RWTexture1DArray<ushort4>, ushort4, uint2 location); >+ >+native void GetDimensions(RWTexture2D<ushort4>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<ushort4>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<ushort4>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<ushort4>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<ushort4>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<ushort4>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<ushort4>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<ushort4>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<ushort4>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<ushort4>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<ushort4>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<ushort4>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<ushort4>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<ushort4>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<ushort4>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<ushort4>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<ushort4>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<ushort4>, threadgroup float* Width, threadgroup float* Height); >+native ushort4 Load(RWTexture2D<ushort4>, int2 location); >+native void Store(RWTexture2D<ushort4>, ushort4, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<ushort4>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native ushort4 Load(RWTexture2DArray<ushort4>, int3 location); >+native void Store(RWTexture2DArray<ushort4>, ushort4, uint3 location); >+ >+native void GetDimensions(RWTexture3D<ushort4>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<ushort4>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native ushort4 Load(RWTexture3D<ushort4>, int3 location); >+native void Store(RWTexture3D<ushort4>, ushort4, uint3 location); >+ >+native uint Sample(Texture1D<uint>, sampler, float location); >+native uint Sample(Texture1D<uint>, sampler, float location, int offset); >+native uint Load(Texture1D<uint>, int2 location); >+native uint Load(Texture1D<uint>, int2 location, int offset); >+native void GetDimensions(Texture1D<uint>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native uint Sample(Texture1DArray<uint>, sampler, float2 location); >+native uint Sample(Texture1DArray<uint>, sampler, float2 location, int offset); >+native uint Load(Texture1DArray<uint>, int3 location); >+native uint Load(Texture1DArray<uint>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native uint Sample(Texture2D<uint>, sampler, float2 location); >+native uint Sample(Texture2D<uint>, sampler, float2 location, int2 offset); >+native uint SampleBias(Texture2D<uint>, sampler, float2 location, float Bias); >+native uint SampleBias(Texture2D<uint>, sampler, float2 location, float Bias, int2 offset); >+native uint SampleGrad(Texture2D<uint>, sampler, float2 location, float2 DDX, float2 DDY); >+native uint SampleGrad(Texture2D<uint>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native uint SampleLevel(Texture2D<uint>, sampler, float2 location, float LOD); >+native uint SampleLevel(Texture2D<uint>, sampler, float2 location, float LOD, int2 offset); >+native uint4 Gather(Texture2D<uint>, sampler, float2 location); >+native uint4 Gather(Texture2D<uint>, sampler, float2 location, int2 offset); >+native uint4 GatherRed(Texture2D<uint>, sampler, float2 location); >+native uint4 GatherRed(Texture2D<uint>, sampler, float2 location, int2 offset); >+native uint Load(Texture2D<uint>, int3 location); >+native uint Load(Texture2D<uint>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native uint Sample(Texture2DArray<uint>, sampler, float3 location); >+native uint Sample(Texture2DArray<uint>, sampler, float3 location, int2 offset); >+native uint SampleBias(Texture2DArray<uint>, sampler, float3 location, float Bias); >+native uint SampleBias(Texture2DArray<uint>, sampler, float3 location, float Bias, int2 offset); >+native uint SampleGrad(Texture2DArray<uint>, sampler, float3 location, float2 DDX, float2 DDY); >+native uint SampleGrad(Texture2DArray<uint>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native uint SampleLevel(Texture2DArray<uint>, sampler, float3 location, float LOD); >+native uint SampleLevel(Texture2DArray<uint>, sampler, float3 location, float LOD, int2 offset); >+native uint4 Gather(Texture2DArray<uint>, sampler, float3 location); >+native uint4 Gather(Texture2DArray<uint>, sampler, float3 location, int2 offset); >+native uint4 GatherRed(Texture2DArray<uint>, sampler, float3 location); >+native uint4 GatherRed(Texture2DArray<uint>, sampler, float3 location, int2 offset); >+native uint Load(Texture2DArray<uint>, int4 location); >+native uint Load(Texture2DArray<uint>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native uint Sample(Texture3D<uint>, sampler, float3 location); >+native uint Sample(Texture3D<uint>, sampler, float3 location, int3 offset); >+native uint Load(Texture3D<uint>, int4 location); >+native uint Load(Texture3D<uint>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native uint Sample(TextureCube<uint>, sampler, float3 location); >+native uint SampleBias(TextureCube<uint>, sampler, float3 location, float Bias); >+native uint SampleGrad(TextureCube<uint>, sampler, float3 location, float3 DDX, float3 DDY); >+native uint SampleLevel(TextureCube<uint>, sampler, float3 location, float LOD); >+native uint4 Gather(TextureCube<uint>, sampler, float3 location); >+native uint4 GatherRed(TextureCube<uint>, sampler, float3 location); >+native void GetDimensions(TextureCube<uint>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<uint>, thread uint* Width); >+native void GetDimensions(RWTexture1D<uint>, thread float* Width); >+native void GetDimensions(RWTexture1D<uint>, device uint* Width); >+native void GetDimensions(RWTexture1D<uint>, device float* Width); >+native void GetDimensions(RWTexture1D<uint>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<uint>, threadgroup float* Width); >+native uint Load(RWTexture1D<uint>, int location); >+native void Store(RWTexture1D<uint>, uint, uint location); >+ >+native void GetDimensions(RWTexture1DArray<uint>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint>, threadgroup float* Width, threadgroup uint* Elements); >+native uint Load(RWTexture1DArray<uint>, int2 location); >+native void Store(RWTexture1DArray<uint>, uint, uint2 location); >+ >+native void GetDimensions(RWTexture2D<uint>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<uint>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<uint>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<uint>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<uint>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<uint>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<uint>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<uint>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<uint>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<uint>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<uint>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<uint>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<uint>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<uint>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<uint>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<uint>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<uint>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<uint>, threadgroup float* Width, threadgroup float* Height); >+native uint Load(RWTexture2D<uint>, int2 location); >+native void Store(RWTexture2D<uint>, uint, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<uint>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native uint Load(RWTexture2DArray<uint>, int3 location); >+native void Store(RWTexture2DArray<uint>, uint, uint3 location); >+ >+native void GetDimensions(RWTexture3D<uint>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native uint Load(RWTexture3D<uint>, int3 location); >+native void Store(RWTexture3D<uint>, uint, uint3 location); >+ >+native uint2 Sample(Texture1D<uint2>, sampler, float location); >+native uint2 Sample(Texture1D<uint2>, sampler, float location, int offset); >+native uint2 Load(Texture1D<uint2>, int2 location); >+native uint2 Load(Texture1D<uint2>, int2 location, int offset); >+native void GetDimensions(Texture1D<uint2>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint2>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint2>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint2>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native uint2 Sample(Texture1DArray<uint2>, sampler, float2 location); >+native uint2 Sample(Texture1DArray<uint2>, sampler, float2 location, int offset); >+native uint2 Load(Texture1DArray<uint2>, int3 location); >+native uint2 Load(Texture1DArray<uint2>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native uint2 Sample(Texture2D<uint2>, sampler, float2 location); >+native uint2 Sample(Texture2D<uint2>, sampler, float2 location, int2 offset); >+native uint2 SampleBias(Texture2D<uint2>, sampler, float2 location, float Bias); >+native uint2 SampleBias(Texture2D<uint2>, sampler, float2 location, float Bias, int2 offset); >+native uint2 SampleGrad(Texture2D<uint2>, sampler, float2 location, float2 DDX, float2 DDY); >+native uint2 SampleGrad(Texture2D<uint2>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native uint2 SampleLevel(Texture2D<uint2>, sampler, float2 location, float LOD); >+native uint2 SampleLevel(Texture2D<uint2>, sampler, float2 location, float LOD, int2 offset); >+native uint4 Gather(Texture2D<uint2>, sampler, float2 location); >+native uint4 Gather(Texture2D<uint2>, sampler, float2 location, int2 offset); >+native uint4 GatherRed(Texture2D<uint2>, sampler, float2 location); >+native uint4 GatherRed(Texture2D<uint2>, sampler, float2 location, int2 offset); >+native uint4 GatherGreen(Texture2D<uint2>, sampler, float2 location); >+native uint4 GatherGreen(Texture2D<uint2>, sampler, float2 location, int2 offset); >+native uint2 Load(Texture2D<uint2>, int3 location); >+native uint2 Load(Texture2D<uint2>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native uint2 Sample(Texture2DArray<uint2>, sampler, float3 location); >+native uint2 Sample(Texture2DArray<uint2>, sampler, float3 location, int2 offset); >+native uint2 SampleBias(Texture2DArray<uint2>, sampler, float3 location, float Bias); >+native uint2 SampleBias(Texture2DArray<uint2>, sampler, float3 location, float Bias, int2 offset); >+native uint2 SampleGrad(Texture2DArray<uint2>, sampler, float3 location, float2 DDX, float2 DDY); >+native uint2 SampleGrad(Texture2DArray<uint2>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native uint2 SampleLevel(Texture2DArray<uint2>, sampler, float3 location, float LOD); >+native uint2 SampleLevel(Texture2DArray<uint2>, sampler, float3 location, float LOD, int2 offset); >+native uint4 Gather(Texture2DArray<uint2>, sampler, float3 location); >+native uint4 Gather(Texture2DArray<uint2>, sampler, float3 location, int2 offset); >+native uint4 GatherRed(Texture2DArray<uint2>, sampler, float3 location); >+native uint4 GatherRed(Texture2DArray<uint2>, sampler, float3 location, int2 offset); >+native uint4 GatherGreen(Texture2DArray<uint2>, sampler, float3 location); >+native uint4 GatherGreen(Texture2DArray<uint2>, sampler, float3 location, int2 offset); >+native uint2 Load(Texture2DArray<uint2>, int4 location); >+native uint2 Load(Texture2DArray<uint2>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native uint2 Sample(Texture3D<uint2>, sampler, float3 location); >+native uint2 Sample(Texture3D<uint2>, sampler, float3 location, int3 offset); >+native uint2 Load(Texture3D<uint2>, int4 location); >+native uint2 Load(Texture3D<uint2>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native uint2 Sample(TextureCube<uint2>, sampler, float3 location); >+native uint2 SampleBias(TextureCube<uint2>, sampler, float3 location, float Bias); >+native uint2 SampleGrad(TextureCube<uint2>, sampler, float3 location, float3 DDX, float3 DDY); >+native uint2 SampleLevel(TextureCube<uint2>, sampler, float3 location, float LOD); >+native uint4 Gather(TextureCube<uint2>, sampler, float3 location); >+native uint4 GatherRed(TextureCube<uint2>, sampler, float3 location); >+native uint4 GatherGreen(TextureCube<uint2>, sampler, float3 location); >+native void GetDimensions(TextureCube<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<uint2>, thread uint* Width); >+native void GetDimensions(RWTexture1D<uint2>, thread float* Width); >+native void GetDimensions(RWTexture1D<uint2>, device uint* Width); >+native void GetDimensions(RWTexture1D<uint2>, device float* Width); >+native void GetDimensions(RWTexture1D<uint2>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<uint2>, threadgroup float* Width); >+native uint2 Load(RWTexture1D<uint2>, int location); >+native void Store(RWTexture1D<uint2>, uint2, uint location); >+ >+native void GetDimensions(RWTexture1DArray<uint2>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint2>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint2>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint2>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint2>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint2>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint2>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint2>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint2>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint2>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint2>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint2>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint2>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint2>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint2>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint2>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint2>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint2>, threadgroup float* Width, threadgroup uint* Elements); >+native uint2 Load(RWTexture1DArray<uint2>, int2 location); >+native void Store(RWTexture1DArray<uint2>, uint2, uint2 location); >+ >+native void GetDimensions(RWTexture2D<uint2>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<uint2>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<uint2>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<uint2>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<uint2>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<uint2>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<uint2>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<uint2>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<uint2>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<uint2>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<uint2>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<uint2>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<uint2>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<uint2>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<uint2>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<uint2>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<uint2>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<uint2>, threadgroup float* Width, threadgroup float* Height); >+native uint2 Load(RWTexture2D<uint2>, int2 location); >+native void Store(RWTexture2D<uint2>, uint2, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<uint2>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native uint2 Load(RWTexture2DArray<uint2>, int3 location); >+native void Store(RWTexture2DArray<uint2>, uint2, uint3 location); >+ >+native void GetDimensions(RWTexture3D<uint2>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint2>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint2>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint2>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint2>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint2>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint2>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint2>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint2>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint2>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint2>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint2>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint2>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint2>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint2>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint2>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint2>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint2>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint2>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint2>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint2>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint2>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint2>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint2>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint2>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint2>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint2>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint2>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint2>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint2>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint2>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint2>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint2>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint2>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint2>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint2>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint2>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint2>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint2>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint2>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint2>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint2>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint2>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint2>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint2>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint2>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint2>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint2>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint2>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint2>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint2>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint2>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint2>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint2>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native uint2 Load(RWTexture3D<uint2>, int3 location); >+native void Store(RWTexture3D<uint2>, uint2, uint3 location); >+ >+native uint3 Sample(Texture1D<uint3>, sampler, float location); >+native uint3 Sample(Texture1D<uint3>, sampler, float location, int offset); >+native uint3 Load(Texture1D<uint3>, int2 location); >+native uint3 Load(Texture1D<uint3>, int2 location, int offset); >+native void GetDimensions(Texture1D<uint3>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint3>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint3>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint3>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native uint3 Sample(Texture1DArray<uint3>, sampler, float2 location); >+native uint3 Sample(Texture1DArray<uint3>, sampler, float2 location, int offset); >+native uint3 Load(Texture1DArray<uint3>, int3 location); >+native uint3 Load(Texture1DArray<uint3>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native uint3 Sample(Texture2D<uint3>, sampler, float2 location); >+native uint3 Sample(Texture2D<uint3>, sampler, float2 location, int2 offset); >+native uint3 SampleBias(Texture2D<uint3>, sampler, float2 location, float Bias); >+native uint3 SampleBias(Texture2D<uint3>, sampler, float2 location, float Bias, int2 offset); >+native uint3 SampleGrad(Texture2D<uint3>, sampler, float2 location, float2 DDX, float2 DDY); >+native uint3 SampleGrad(Texture2D<uint3>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native uint3 SampleLevel(Texture2D<uint3>, sampler, float2 location, float LOD); >+native uint3 SampleLevel(Texture2D<uint3>, sampler, float2 location, float LOD, int2 offset); >+native uint4 Gather(Texture2D<uint3>, sampler, float2 location); >+native uint4 Gather(Texture2D<uint3>, sampler, float2 location, int2 offset); >+native uint4 GatherRed(Texture2D<uint3>, sampler, float2 location); >+native uint4 GatherRed(Texture2D<uint3>, sampler, float2 location, int2 offset); >+native uint4 GatherGreen(Texture2D<uint3>, sampler, float2 location); >+native uint4 GatherGreen(Texture2D<uint3>, sampler, float2 location, int2 offset); >+native uint4 GatherBlue(Texture2D<uint3>, sampler, float2 location); >+native uint4 GatherBlue(Texture2D<uint3>, sampler, float2 location, int2 offset); >+native uint3 Load(Texture2D<uint3>, int3 location); >+native uint3 Load(Texture2D<uint3>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native uint3 Sample(Texture2DArray<uint3>, sampler, float3 location); >+native uint3 Sample(Texture2DArray<uint3>, sampler, float3 location, int2 offset); >+native uint3 SampleBias(Texture2DArray<uint3>, sampler, float3 location, float Bias); >+native uint3 SampleBias(Texture2DArray<uint3>, sampler, float3 location, float Bias, int2 offset); >+native uint3 SampleGrad(Texture2DArray<uint3>, sampler, float3 location, float2 DDX, float2 DDY); >+native uint3 SampleGrad(Texture2DArray<uint3>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native uint3 SampleLevel(Texture2DArray<uint3>, sampler, float3 location, float LOD); >+native uint3 SampleLevel(Texture2DArray<uint3>, sampler, float3 location, float LOD, int2 offset); >+native uint4 Gather(Texture2DArray<uint3>, sampler, float3 location); >+native uint4 Gather(Texture2DArray<uint3>, sampler, float3 location, int2 offset); >+native uint4 GatherRed(Texture2DArray<uint3>, sampler, float3 location); >+native uint4 GatherRed(Texture2DArray<uint3>, sampler, float3 location, int2 offset); >+native uint4 GatherGreen(Texture2DArray<uint3>, sampler, float3 location); >+native uint4 GatherGreen(Texture2DArray<uint3>, sampler, float3 location, int2 offset); >+native uint4 GatherBlue(Texture2DArray<uint3>, sampler, float3 location); >+native uint4 GatherBlue(Texture2DArray<uint3>, sampler, float3 location, int2 offset); >+native uint3 Load(Texture2DArray<uint3>, int4 location); >+native uint3 Load(Texture2DArray<uint3>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native uint3 Sample(Texture3D<uint3>, sampler, float3 location); >+native uint3 Sample(Texture3D<uint3>, sampler, float3 location, int3 offset); >+native uint3 Load(Texture3D<uint3>, int4 location); >+native uint3 Load(Texture3D<uint3>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native uint3 Sample(TextureCube<uint3>, sampler, float3 location); >+native uint3 SampleBias(TextureCube<uint3>, sampler, float3 location, float Bias); >+native uint3 SampleGrad(TextureCube<uint3>, sampler, float3 location, float3 DDX, float3 DDY); >+native uint3 SampleLevel(TextureCube<uint3>, sampler, float3 location, float LOD); >+native uint4 Gather(TextureCube<uint3>, sampler, float3 location); >+native uint4 GatherRed(TextureCube<uint3>, sampler, float3 location); >+native uint4 GatherGreen(TextureCube<uint3>, sampler, float3 location); >+native uint4 GatherBlue(TextureCube<uint3>, sampler, float3 location); >+native void GetDimensions(TextureCube<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<uint3>, thread uint* Width); >+native void GetDimensions(RWTexture1D<uint3>, thread float* Width); >+native void GetDimensions(RWTexture1D<uint3>, device uint* Width); >+native void GetDimensions(RWTexture1D<uint3>, device float* Width); >+native void GetDimensions(RWTexture1D<uint3>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<uint3>, threadgroup float* Width); >+native uint3 Load(RWTexture1D<uint3>, int location); >+native void Store(RWTexture1D<uint3>, uint3, uint location); >+ >+native void GetDimensions(RWTexture1DArray<uint3>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint3>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint3>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint3>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint3>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint3>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint3>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint3>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint3>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint3>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint3>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint3>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint3>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint3>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint3>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint3>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint3>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint3>, threadgroup float* Width, threadgroup uint* Elements); >+native uint3 Load(RWTexture1DArray<uint3>, int2 location); >+native void Store(RWTexture1DArray<uint3>, uint3, uint2 location); >+ >+native void GetDimensions(RWTexture2D<uint3>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<uint3>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<uint3>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<uint3>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<uint3>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<uint3>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<uint3>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<uint3>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<uint3>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<uint3>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<uint3>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<uint3>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<uint3>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<uint3>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<uint3>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<uint3>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<uint3>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<uint3>, threadgroup float* Width, threadgroup float* Height); >+native uint3 Load(RWTexture2D<uint3>, int2 location); >+native void Store(RWTexture2D<uint3>, uint3, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<uint3>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native uint3 Load(RWTexture2DArray<uint3>, int3 location); >+native void Store(RWTexture2DArray<uint3>, uint3, uint3 location); >+ >+native void GetDimensions(RWTexture3D<uint3>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint3>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint3>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint3>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint3>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint3>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint3>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint3>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint3>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint3>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint3>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint3>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint3>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint3>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint3>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint3>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint3>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint3>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint3>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint3>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint3>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint3>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint3>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint3>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint3>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint3>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint3>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint3>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint3>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint3>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint3>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint3>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint3>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint3>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint3>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint3>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint3>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint3>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint3>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint3>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint3>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint3>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint3>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint3>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint3>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint3>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint3>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint3>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint3>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint3>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint3>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint3>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint3>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint3>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native uint3 Load(RWTexture3D<uint3>, int3 location); >+native void Store(RWTexture3D<uint3>, uint3, uint3 location); >+ >+native uint4 Sample(Texture1D<uint4>, sampler, float location); >+native uint4 Sample(Texture1D<uint4>, sampler, float location, int offset); >+native uint4 Load(Texture1D<uint4>, int2 location); >+native uint4 Load(Texture1D<uint4>, int2 location, int offset); >+native void GetDimensions(Texture1D<uint4>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint4>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint4>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint4>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native uint4 Sample(Texture1DArray<uint4>, sampler, float2 location); >+native uint4 Sample(Texture1DArray<uint4>, sampler, float2 location, int offset); >+native uint4 Load(Texture1DArray<uint4>, int3 location); >+native uint4 Load(Texture1DArray<uint4>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native uint4 Sample(Texture2D<uint4>, sampler, float2 location); >+native uint4 Sample(Texture2D<uint4>, sampler, float2 location, int2 offset); >+native uint4 SampleBias(Texture2D<uint4>, sampler, float2 location, float Bias); >+native uint4 SampleBias(Texture2D<uint4>, sampler, float2 location, float Bias, int2 offset); >+native uint4 SampleGrad(Texture2D<uint4>, sampler, float2 location, float2 DDX, float2 DDY); >+native uint4 SampleGrad(Texture2D<uint4>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native uint4 SampleLevel(Texture2D<uint4>, sampler, float2 location, float LOD); >+native uint4 SampleLevel(Texture2D<uint4>, sampler, float2 location, float LOD, int2 offset); >+native uint4 Gather(Texture2D<uint4>, sampler, float2 location); >+native uint4 Gather(Texture2D<uint4>, sampler, float2 location, int2 offset); >+native uint4 GatherRed(Texture2D<uint4>, sampler, float2 location); >+native uint4 GatherRed(Texture2D<uint4>, sampler, float2 location, int2 offset); >+native uint4 GatherGreen(Texture2D<uint4>, sampler, float2 location); >+native uint4 GatherGreen(Texture2D<uint4>, sampler, float2 location, int2 offset); >+native uint4 GatherBlue(Texture2D<uint4>, sampler, float2 location); >+native uint4 GatherBlue(Texture2D<uint4>, sampler, float2 location, int2 offset); >+native uint4 GatherAlpha(Texture2D<uint4>, sampler, float2 location); >+native uint4 GatherAlpha(Texture2D<uint4>, sampler, float2 location, int2 offset); >+native uint4 Load(Texture2D<uint4>, int3 location); >+native uint4 Load(Texture2D<uint4>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native uint4 Sample(Texture2DArray<uint4>, sampler, float3 location); >+native uint4 Sample(Texture2DArray<uint4>, sampler, float3 location, int2 offset); >+native uint4 SampleBias(Texture2DArray<uint4>, sampler, float3 location, float Bias); >+native uint4 SampleBias(Texture2DArray<uint4>, sampler, float3 location, float Bias, int2 offset); >+native uint4 SampleGrad(Texture2DArray<uint4>, sampler, float3 location, float2 DDX, float2 DDY); >+native uint4 SampleGrad(Texture2DArray<uint4>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native uint4 SampleLevel(Texture2DArray<uint4>, sampler, float3 location, float LOD); >+native uint4 SampleLevel(Texture2DArray<uint4>, sampler, float3 location, float LOD, int2 offset); >+native uint4 Gather(Texture2DArray<uint4>, sampler, float3 location); >+native uint4 Gather(Texture2DArray<uint4>, sampler, float3 location, int2 offset); >+native uint4 GatherRed(Texture2DArray<uint4>, sampler, float3 location); >+native uint4 GatherRed(Texture2DArray<uint4>, sampler, float3 location, int2 offset); >+native uint4 GatherGreen(Texture2DArray<uint4>, sampler, float3 location); >+native uint4 GatherGreen(Texture2DArray<uint4>, sampler, float3 location, int2 offset); >+native uint4 GatherBlue(Texture2DArray<uint4>, sampler, float3 location); >+native uint4 GatherBlue(Texture2DArray<uint4>, sampler, float3 location, int2 offset); >+native uint4 GatherAlpha(Texture2DArray<uint4>, sampler, float3 location); >+native uint4 GatherAlpha(Texture2DArray<uint4>, sampler, float3 location, int2 offset); >+native uint4 Load(Texture2DArray<uint4>, int4 location); >+native uint4 Load(Texture2DArray<uint4>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native uint4 Sample(Texture3D<uint4>, sampler, float3 location); >+native uint4 Sample(Texture3D<uint4>, sampler, float3 location, int3 offset); >+native uint4 Load(Texture3D<uint4>, int4 location); >+native uint4 Load(Texture3D<uint4>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native uint4 Sample(TextureCube<uint4>, sampler, float3 location); >+native uint4 SampleBias(TextureCube<uint4>, sampler, float3 location, float Bias); >+native uint4 SampleGrad(TextureCube<uint4>, sampler, float3 location, float3 DDX, float3 DDY); >+native uint4 SampleLevel(TextureCube<uint4>, sampler, float3 location, float LOD); >+native uint4 Gather(TextureCube<uint4>, sampler, float3 location); >+native uint4 GatherRed(TextureCube<uint4>, sampler, float3 location); >+native uint4 GatherGreen(TextureCube<uint4>, sampler, float3 location); >+native uint4 GatherBlue(TextureCube<uint4>, sampler, float3 location); >+native uint4 GatherAlpha(TextureCube<uint4>, sampler, float3 location); >+native void GetDimensions(TextureCube<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<uint4>, thread uint* Width); >+native void GetDimensions(RWTexture1D<uint4>, thread float* Width); >+native void GetDimensions(RWTexture1D<uint4>, device uint* Width); >+native void GetDimensions(RWTexture1D<uint4>, device float* Width); >+native void GetDimensions(RWTexture1D<uint4>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<uint4>, threadgroup float* Width); >+native uint4 Load(RWTexture1D<uint4>, int location); >+native void Store(RWTexture1D<uint4>, uint4, uint location); >+ >+native void GetDimensions(RWTexture1DArray<uint4>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint4>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint4>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint4>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint4>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint4>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint4>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint4>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint4>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint4>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint4>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint4>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint4>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint4>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint4>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint4>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint4>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<uint4>, threadgroup float* Width, threadgroup uint* Elements); >+native uint4 Load(RWTexture1DArray<uint4>, int2 location); >+native void Store(RWTexture1DArray<uint4>, uint4, uint2 location); >+ >+native void GetDimensions(RWTexture2D<uint4>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<uint4>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<uint4>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<uint4>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<uint4>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<uint4>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<uint4>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<uint4>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<uint4>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<uint4>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<uint4>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<uint4>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<uint4>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<uint4>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<uint4>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<uint4>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<uint4>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<uint4>, threadgroup float* Width, threadgroup float* Height); >+native uint4 Load(RWTexture2D<uint4>, int2 location); >+native void Store(RWTexture2D<uint4>, uint4, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<uint4>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native uint4 Load(RWTexture2DArray<uint4>, int3 location); >+native void Store(RWTexture2DArray<uint4>, uint4, uint3 location); >+ >+native void GetDimensions(RWTexture3D<uint4>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint4>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint4>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint4>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint4>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint4>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint4>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint4>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint4>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint4>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint4>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint4>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint4>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint4>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint4>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint4>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint4>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint4>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint4>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint4>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint4>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint4>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint4>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint4>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint4>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint4>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint4>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint4>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint4>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint4>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint4>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint4>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint4>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint4>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint4>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint4>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint4>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint4>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint4>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint4>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint4>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint4>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint4>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint4>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint4>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint4>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint4>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint4>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<uint4>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<uint4>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<uint4>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<uint4>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<uint4>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<uint4>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native uint4 Load(RWTexture3D<uint4>, int3 location); >+native void Store(RWTexture3D<uint4>, uint4, uint3 location); >+ >+native char Sample(Texture1D<char>, sampler, float location); >+native char Sample(Texture1D<char>, sampler, float location, int offset); >+native char Load(Texture1D<char>, int2 location); >+native char Load(Texture1D<char>, int2 location, int offset); >+native void GetDimensions(Texture1D<char>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native char Sample(Texture1DArray<char>, sampler, float2 location); >+native char Sample(Texture1DArray<char>, sampler, float2 location, int offset); >+native char Load(Texture1DArray<char>, int3 location); >+native char Load(Texture1DArray<char>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<char>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native char Sample(Texture2D<char>, sampler, float2 location); >+native char Sample(Texture2D<char>, sampler, float2 location, int2 offset); >+native char SampleBias(Texture2D<char>, sampler, float2 location, float Bias); >+native char SampleBias(Texture2D<char>, sampler, float2 location, float Bias, int2 offset); >+native char SampleGrad(Texture2D<char>, sampler, float2 location, float2 DDX, float2 DDY); >+native char SampleGrad(Texture2D<char>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native char SampleLevel(Texture2D<char>, sampler, float2 location, float LOD); >+native char SampleLevel(Texture2D<char>, sampler, float2 location, float LOD, int2 offset); >+native char4 Gather(Texture2D<char>, sampler, float2 location); >+native char4 Gather(Texture2D<char>, sampler, float2 location, int2 offset); >+native char4 GatherRed(Texture2D<char>, sampler, float2 location); >+native char4 GatherRed(Texture2D<char>, sampler, float2 location, int2 offset); >+native char Load(Texture2D<char>, int3 location); >+native char Load(Texture2D<char>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<char>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native char Sample(Texture2DArray<char>, sampler, float3 location); >+native char Sample(Texture2DArray<char>, sampler, float3 location, int2 offset); >+native char SampleBias(Texture2DArray<char>, sampler, float3 location, float Bias); >+native char SampleBias(Texture2DArray<char>, sampler, float3 location, float Bias, int2 offset); >+native char SampleGrad(Texture2DArray<char>, sampler, float3 location, float2 DDX, float2 DDY); >+native char SampleGrad(Texture2DArray<char>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native char SampleLevel(Texture2DArray<char>, sampler, float3 location, float LOD); >+native char SampleLevel(Texture2DArray<char>, sampler, float3 location, float LOD, int2 offset); >+native char4 Gather(Texture2DArray<char>, sampler, float3 location); >+native char4 Gather(Texture2DArray<char>, sampler, float3 location, int2 offset); >+native char4 GatherRed(Texture2DArray<char>, sampler, float3 location); >+native char4 GatherRed(Texture2DArray<char>, sampler, float3 location, int2 offset); >+native char Load(Texture2DArray<char>, int4 location); >+native char Load(Texture2DArray<char>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native char Sample(Texture3D<char>, sampler, float3 location); >+native char Sample(Texture3D<char>, sampler, float3 location, int3 offset); >+native char Load(Texture3D<char>, int4 location); >+native char Load(Texture3D<char>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<char>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native char Sample(TextureCube<char>, sampler, float3 location); >+native char SampleBias(TextureCube<char>, sampler, float3 location, float Bias); >+native char SampleGrad(TextureCube<char>, sampler, float3 location, float3 DDX, float3 DDY); >+native char SampleLevel(TextureCube<char>, sampler, float3 location, float LOD); >+native char4 Gather(TextureCube<char>, sampler, float3 location); >+native char4 GatherRed(TextureCube<char>, sampler, float3 location); >+native void GetDimensions(TextureCube<char>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<char>, thread uint* Width); >+native void GetDimensions(RWTexture1D<char>, thread float* Width); >+native void GetDimensions(RWTexture1D<char>, device uint* Width); >+native void GetDimensions(RWTexture1D<char>, device float* Width); >+native void GetDimensions(RWTexture1D<char>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<char>, threadgroup float* Width); >+native char Load(RWTexture1D<char>, int location); >+native void Store(RWTexture1D<char>, char, uint location); >+ >+native void GetDimensions(RWTexture1DArray<char>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<char>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<char>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<char>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<char>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<char>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<char>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<char>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<char>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<char>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<char>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<char>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<char>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<char>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<char>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<char>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<char>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<char>, threadgroup float* Width, threadgroup uint* Elements); >+native char Load(RWTexture1DArray<char>, int2 location); >+native void Store(RWTexture1DArray<char>, char, uint2 location); >+ >+native void GetDimensions(RWTexture2D<char>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<char>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<char>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<char>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<char>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<char>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<char>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<char>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<char>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<char>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<char>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<char>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<char>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<char>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<char>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<char>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<char>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<char>, threadgroup float* Width, threadgroup float* Height); >+native char Load(RWTexture2D<char>, int2 location); >+native void Store(RWTexture2D<char>, char, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<char>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native char Load(RWTexture2DArray<char>, int3 location); >+native void Store(RWTexture2DArray<char>, char, uint3 location); >+ >+native void GetDimensions(RWTexture3D<char>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native char Load(RWTexture3D<char>, int3 location); >+native void Store(RWTexture3D<char>, char, uint3 location); >+ >+native char2 Sample(Texture1D<char2>, sampler, float location); >+native char2 Sample(Texture1D<char2>, sampler, float location, int offset); >+native char2 Load(Texture1D<char2>, int2 location); >+native char2 Load(Texture1D<char2>, int2 location, int offset); >+native void GetDimensions(Texture1D<char2>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char2>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char2>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char2>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char2>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char2>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char2>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char2>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native char2 Sample(Texture1DArray<char2>, sampler, float2 location); >+native char2 Sample(Texture1DArray<char2>, sampler, float2 location, int offset); >+native char2 Load(Texture1DArray<char2>, int3 location); >+native char2 Load(Texture1DArray<char2>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<char2>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char2>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char2>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char2>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char2>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char2>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char2>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char2>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char2>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char2>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char2>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char2>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native char2 Sample(Texture2D<char2>, sampler, float2 location); >+native char2 Sample(Texture2D<char2>, sampler, float2 location, int2 offset); >+native char2 SampleBias(Texture2D<char2>, sampler, float2 location, float Bias); >+native char2 SampleBias(Texture2D<char2>, sampler, float2 location, float Bias, int2 offset); >+native char2 SampleGrad(Texture2D<char2>, sampler, float2 location, float2 DDX, float2 DDY); >+native char2 SampleGrad(Texture2D<char2>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native char2 SampleLevel(Texture2D<char2>, sampler, float2 location, float LOD); >+native char2 SampleLevel(Texture2D<char2>, sampler, float2 location, float LOD, int2 offset); >+native char4 Gather(Texture2D<char2>, sampler, float2 location); >+native char4 Gather(Texture2D<char2>, sampler, float2 location, int2 offset); >+native char4 GatherRed(Texture2D<char2>, sampler, float2 location); >+native char4 GatherRed(Texture2D<char2>, sampler, float2 location, int2 offset); >+native char4 GatherGreen(Texture2D<char2>, sampler, float2 location); >+native char4 GatherGreen(Texture2D<char2>, sampler, float2 location, int2 offset); >+native char2 Load(Texture2D<char2>, int3 location); >+native char2 Load(Texture2D<char2>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<char2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native char2 Sample(Texture2DArray<char2>, sampler, float3 location); >+native char2 Sample(Texture2DArray<char2>, sampler, float3 location, int2 offset); >+native char2 SampleBias(Texture2DArray<char2>, sampler, float3 location, float Bias); >+native char2 SampleBias(Texture2DArray<char2>, sampler, float3 location, float Bias, int2 offset); >+native char2 SampleGrad(Texture2DArray<char2>, sampler, float3 location, float2 DDX, float2 DDY); >+native char2 SampleGrad(Texture2DArray<char2>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native char2 SampleLevel(Texture2DArray<char2>, sampler, float3 location, float LOD); >+native char2 SampleLevel(Texture2DArray<char2>, sampler, float3 location, float LOD, int2 offset); >+native char4 Gather(Texture2DArray<char2>, sampler, float3 location); >+native char4 Gather(Texture2DArray<char2>, sampler, float3 location, int2 offset); >+native char4 GatherRed(Texture2DArray<char2>, sampler, float3 location); >+native char4 GatherRed(Texture2DArray<char2>, sampler, float3 location, int2 offset); >+native char4 GatherGreen(Texture2DArray<char2>, sampler, float3 location); >+native char4 GatherGreen(Texture2DArray<char2>, sampler, float3 location, int2 offset); >+native char2 Load(Texture2DArray<char2>, int4 location); >+native char2 Load(Texture2DArray<char2>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native char2 Sample(Texture3D<char2>, sampler, float3 location); >+native char2 Sample(Texture3D<char2>, sampler, float3 location, int3 offset); >+native char2 Load(Texture3D<char2>, int4 location); >+native char2 Load(Texture3D<char2>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native char2 Sample(TextureCube<char2>, sampler, float3 location); >+native char2 SampleBias(TextureCube<char2>, sampler, float3 location, float Bias); >+native char2 SampleGrad(TextureCube<char2>, sampler, float3 location, float3 DDX, float3 DDY); >+native char2 SampleLevel(TextureCube<char2>, sampler, float3 location, float LOD); >+native char4 Gather(TextureCube<char2>, sampler, float3 location); >+native char4 GatherRed(TextureCube<char2>, sampler, float3 location); >+native char4 GatherGreen(TextureCube<char2>, sampler, float3 location); >+native void GetDimensions(TextureCube<char2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<char2>, thread uint* Width); >+native void GetDimensions(RWTexture1D<char2>, thread float* Width); >+native void GetDimensions(RWTexture1D<char2>, device uint* Width); >+native void GetDimensions(RWTexture1D<char2>, device float* Width); >+native void GetDimensions(RWTexture1D<char2>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<char2>, threadgroup float* Width); >+native char2 Load(RWTexture1D<char2>, int location); >+native void Store(RWTexture1D<char2>, char2, uint location); >+ >+native void GetDimensions(RWTexture1DArray<char2>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<char2>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<char2>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<char2>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<char2>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<char2>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<char2>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<char2>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<char2>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<char2>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<char2>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<char2>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<char2>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<char2>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<char2>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<char2>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<char2>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<char2>, threadgroup float* Width, threadgroup uint* Elements); >+native char2 Load(RWTexture1DArray<char2>, int2 location); >+native void Store(RWTexture1DArray<char2>, char2, uint2 location); >+ >+native void GetDimensions(RWTexture2D<char2>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<char2>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<char2>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<char2>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<char2>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<char2>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<char2>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<char2>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<char2>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<char2>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<char2>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<char2>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<char2>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<char2>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<char2>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<char2>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<char2>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<char2>, threadgroup float* Width, threadgroup float* Height); >+native char2 Load(RWTexture2D<char2>, int2 location); >+native void Store(RWTexture2D<char2>, char2, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<char2>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char2>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native char2 Load(RWTexture2DArray<char2>, int3 location); >+native void Store(RWTexture2DArray<char2>, char2, uint3 location); >+ >+native void GetDimensions(RWTexture3D<char2>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char2>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char2>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char2>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char2>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char2>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char2>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char2>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char2>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char2>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char2>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char2>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char2>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char2>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char2>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char2>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char2>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char2>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char2>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char2>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char2>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char2>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char2>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char2>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char2>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char2>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char2>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char2>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char2>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char2>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char2>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char2>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char2>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char2>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char2>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char2>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char2>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char2>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char2>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char2>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char2>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char2>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char2>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char2>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char2>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char2>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char2>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char2>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char2>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char2>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char2>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char2>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char2>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char2>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native char2 Load(RWTexture3D<char2>, int3 location); >+native void Store(RWTexture3D<char2>, char2, uint3 location); >+ >+native char3 Sample(Texture1D<char3>, sampler, float location); >+native char3 Sample(Texture1D<char3>, sampler, float location, int offset); >+native char3 Load(Texture1D<char3>, int2 location); >+native char3 Load(Texture1D<char3>, int2 location, int offset); >+native void GetDimensions(Texture1D<char3>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char3>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char3>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char3>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char3>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char3>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char3>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char3>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native char3 Sample(Texture1DArray<char3>, sampler, float2 location); >+native char3 Sample(Texture1DArray<char3>, sampler, float2 location, int offset); >+native char3 Load(Texture1DArray<char3>, int3 location); >+native char3 Load(Texture1DArray<char3>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<char3>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char3>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char3>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char3>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char3>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char3>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char3>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char3>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char3>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char3>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char3>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char3>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native char3 Sample(Texture2D<char3>, sampler, float2 location); >+native char3 Sample(Texture2D<char3>, sampler, float2 location, int2 offset); >+native char3 SampleBias(Texture2D<char3>, sampler, float2 location, float Bias); >+native char3 SampleBias(Texture2D<char3>, sampler, float2 location, float Bias, int2 offset); >+native char3 SampleGrad(Texture2D<char3>, sampler, float2 location, float2 DDX, float2 DDY); >+native char3 SampleGrad(Texture2D<char3>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native char3 SampleLevel(Texture2D<char3>, sampler, float2 location, float LOD); >+native char3 SampleLevel(Texture2D<char3>, sampler, float2 location, float LOD, int2 offset); >+native char4 Gather(Texture2D<char3>, sampler, float2 location); >+native char4 Gather(Texture2D<char3>, sampler, float2 location, int2 offset); >+native char4 GatherRed(Texture2D<char3>, sampler, float2 location); >+native char4 GatherRed(Texture2D<char3>, sampler, float2 location, int2 offset); >+native char4 GatherGreen(Texture2D<char3>, sampler, float2 location); >+native char4 GatherGreen(Texture2D<char3>, sampler, float2 location, int2 offset); >+native char4 GatherBlue(Texture2D<char3>, sampler, float2 location); >+native char4 GatherBlue(Texture2D<char3>, sampler, float2 location, int2 offset); >+native char3 Load(Texture2D<char3>, int3 location); >+native char3 Load(Texture2D<char3>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<char3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native char3 Sample(Texture2DArray<char3>, sampler, float3 location); >+native char3 Sample(Texture2DArray<char3>, sampler, float3 location, int2 offset); >+native char3 SampleBias(Texture2DArray<char3>, sampler, float3 location, float Bias); >+native char3 SampleBias(Texture2DArray<char3>, sampler, float3 location, float Bias, int2 offset); >+native char3 SampleGrad(Texture2DArray<char3>, sampler, float3 location, float2 DDX, float2 DDY); >+native char3 SampleGrad(Texture2DArray<char3>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native char3 SampleLevel(Texture2DArray<char3>, sampler, float3 location, float LOD); >+native char3 SampleLevel(Texture2DArray<char3>, sampler, float3 location, float LOD, int2 offset); >+native char4 Gather(Texture2DArray<char3>, sampler, float3 location); >+native char4 Gather(Texture2DArray<char3>, sampler, float3 location, int2 offset); >+native char4 GatherRed(Texture2DArray<char3>, sampler, float3 location); >+native char4 GatherRed(Texture2DArray<char3>, sampler, float3 location, int2 offset); >+native char4 GatherGreen(Texture2DArray<char3>, sampler, float3 location); >+native char4 GatherGreen(Texture2DArray<char3>, sampler, float3 location, int2 offset); >+native char4 GatherBlue(Texture2DArray<char3>, sampler, float3 location); >+native char4 GatherBlue(Texture2DArray<char3>, sampler, float3 location, int2 offset); >+native char3 Load(Texture2DArray<char3>, int4 location); >+native char3 Load(Texture2DArray<char3>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native char3 Sample(Texture3D<char3>, sampler, float3 location); >+native char3 Sample(Texture3D<char3>, sampler, float3 location, int3 offset); >+native char3 Load(Texture3D<char3>, int4 location); >+native char3 Load(Texture3D<char3>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native char3 Sample(TextureCube<char3>, sampler, float3 location); >+native char3 SampleBias(TextureCube<char3>, sampler, float3 location, float Bias); >+native char3 SampleGrad(TextureCube<char3>, sampler, float3 location, float3 DDX, float3 DDY); >+native char3 SampleLevel(TextureCube<char3>, sampler, float3 location, float LOD); >+native char4 Gather(TextureCube<char3>, sampler, float3 location); >+native char4 GatherRed(TextureCube<char3>, sampler, float3 location); >+native char4 GatherGreen(TextureCube<char3>, sampler, float3 location); >+native char4 GatherBlue(TextureCube<char3>, sampler, float3 location); >+native void GetDimensions(TextureCube<char3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<char3>, thread uint* Width); >+native void GetDimensions(RWTexture1D<char3>, thread float* Width); >+native void GetDimensions(RWTexture1D<char3>, device uint* Width); >+native void GetDimensions(RWTexture1D<char3>, device float* Width); >+native void GetDimensions(RWTexture1D<char3>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<char3>, threadgroup float* Width); >+native char3 Load(RWTexture1D<char3>, int location); >+native void Store(RWTexture1D<char3>, char3, uint location); >+ >+native void GetDimensions(RWTexture1DArray<char3>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<char3>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<char3>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<char3>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<char3>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<char3>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<char3>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<char3>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<char3>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<char3>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<char3>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<char3>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<char3>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<char3>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<char3>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<char3>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<char3>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<char3>, threadgroup float* Width, threadgroup uint* Elements); >+native char3 Load(RWTexture1DArray<char3>, int2 location); >+native void Store(RWTexture1DArray<char3>, char3, uint2 location); >+ >+native void GetDimensions(RWTexture2D<char3>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<char3>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<char3>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<char3>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<char3>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<char3>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<char3>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<char3>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<char3>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<char3>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<char3>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<char3>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<char3>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<char3>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<char3>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<char3>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<char3>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<char3>, threadgroup float* Width, threadgroup float* Height); >+native char3 Load(RWTexture2D<char3>, int2 location); >+native void Store(RWTexture2D<char3>, char3, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<char3>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char3>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native char3 Load(RWTexture2DArray<char3>, int3 location); >+native void Store(RWTexture2DArray<char3>, char3, uint3 location); >+ >+native void GetDimensions(RWTexture3D<char3>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char3>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char3>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char3>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char3>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char3>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char3>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char3>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char3>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char3>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char3>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char3>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char3>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char3>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char3>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char3>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char3>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char3>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char3>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char3>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char3>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char3>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char3>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char3>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char3>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char3>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char3>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char3>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char3>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char3>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char3>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char3>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char3>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char3>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char3>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char3>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char3>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char3>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char3>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char3>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char3>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char3>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char3>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char3>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char3>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char3>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char3>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char3>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char3>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char3>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char3>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char3>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char3>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char3>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native char3 Load(RWTexture3D<char3>, int3 location); >+native void Store(RWTexture3D<char3>, char3, uint3 location); >+ >+native char4 Sample(Texture1D<char4>, sampler, float location); >+native char4 Sample(Texture1D<char4>, sampler, float location, int offset); >+native char4 Load(Texture1D<char4>, int2 location); >+native char4 Load(Texture1D<char4>, int2 location, int offset); >+native void GetDimensions(Texture1D<char4>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char4>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char4>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char4>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char4>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char4>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char4>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char4>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<char4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native char4 Sample(Texture1DArray<char4>, sampler, float2 location); >+native char4 Sample(Texture1DArray<char4>, sampler, float2 location, int offset); >+native char4 Load(Texture1DArray<char4>, int3 location); >+native char4 Load(Texture1DArray<char4>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<char4>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char4>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char4>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char4>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char4>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char4>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char4>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char4>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char4>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char4>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char4>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char4>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<char4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native char4 Sample(Texture2D<char4>, sampler, float2 location); >+native char4 Sample(Texture2D<char4>, sampler, float2 location, int2 offset); >+native char4 SampleBias(Texture2D<char4>, sampler, float2 location, float Bias); >+native char4 SampleBias(Texture2D<char4>, sampler, float2 location, float Bias, int2 offset); >+native char4 SampleGrad(Texture2D<char4>, sampler, float2 location, float2 DDX, float2 DDY); >+native char4 SampleGrad(Texture2D<char4>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native char4 SampleLevel(Texture2D<char4>, sampler, float2 location, float LOD); >+native char4 SampleLevel(Texture2D<char4>, sampler, float2 location, float LOD, int2 offset); >+native char4 Gather(Texture2D<char4>, sampler, float2 location); >+native char4 Gather(Texture2D<char4>, sampler, float2 location, int2 offset); >+native char4 GatherRed(Texture2D<char4>, sampler, float2 location); >+native char4 GatherRed(Texture2D<char4>, sampler, float2 location, int2 offset); >+native char4 GatherGreen(Texture2D<char4>, sampler, float2 location); >+native char4 GatherGreen(Texture2D<char4>, sampler, float2 location, int2 offset); >+native char4 GatherBlue(Texture2D<char4>, sampler, float2 location); >+native char4 GatherBlue(Texture2D<char4>, sampler, float2 location, int2 offset); >+native char4 GatherAlpha(Texture2D<char4>, sampler, float2 location); >+native char4 GatherAlpha(Texture2D<char4>, sampler, float2 location, int2 offset); >+native char4 Load(Texture2D<char4>, int3 location); >+native char4 Load(Texture2D<char4>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<char4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<char4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native char4 Sample(Texture2DArray<char4>, sampler, float3 location); >+native char4 Sample(Texture2DArray<char4>, sampler, float3 location, int2 offset); >+native char4 SampleBias(Texture2DArray<char4>, sampler, float3 location, float Bias); >+native char4 SampleBias(Texture2DArray<char4>, sampler, float3 location, float Bias, int2 offset); >+native char4 SampleGrad(Texture2DArray<char4>, sampler, float3 location, float2 DDX, float2 DDY); >+native char4 SampleGrad(Texture2DArray<char4>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native char4 SampleLevel(Texture2DArray<char4>, sampler, float3 location, float LOD); >+native char4 SampleLevel(Texture2DArray<char4>, sampler, float3 location, float LOD, int2 offset); >+native char4 Gather(Texture2DArray<char4>, sampler, float3 location); >+native char4 Gather(Texture2DArray<char4>, sampler, float3 location, int2 offset); >+native char4 GatherRed(Texture2DArray<char4>, sampler, float3 location); >+native char4 GatherRed(Texture2DArray<char4>, sampler, float3 location, int2 offset); >+native char4 GatherGreen(Texture2DArray<char4>, sampler, float3 location); >+native char4 GatherGreen(Texture2DArray<char4>, sampler, float3 location, int2 offset); >+native char4 GatherBlue(Texture2DArray<char4>, sampler, float3 location); >+native char4 GatherBlue(Texture2DArray<char4>, sampler, float3 location, int2 offset); >+native char4 GatherAlpha(Texture2DArray<char4>, sampler, float3 location); >+native char4 GatherAlpha(Texture2DArray<char4>, sampler, float3 location, int2 offset); >+native char4 Load(Texture2DArray<char4>, int4 location); >+native char4 Load(Texture2DArray<char4>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<char4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native char4 Sample(Texture3D<char4>, sampler, float3 location); >+native char4 Sample(Texture3D<char4>, sampler, float3 location, int3 offset); >+native char4 Load(Texture3D<char4>, int4 location); >+native char4 Load(Texture3D<char4>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<char4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native char4 Sample(TextureCube<char4>, sampler, float3 location); >+native char4 SampleBias(TextureCube<char4>, sampler, float3 location, float Bias); >+native char4 SampleGrad(TextureCube<char4>, sampler, float3 location, float3 DDX, float3 DDY); >+native char4 SampleLevel(TextureCube<char4>, sampler, float3 location, float LOD); >+native char4 Gather(TextureCube<char4>, sampler, float3 location); >+native char4 GatherRed(TextureCube<char4>, sampler, float3 location); >+native char4 GatherGreen(TextureCube<char4>, sampler, float3 location); >+native char4 GatherBlue(TextureCube<char4>, sampler, float3 location); >+native char4 GatherAlpha(TextureCube<char4>, sampler, float3 location); >+native void GetDimensions(TextureCube<char4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<char4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<char4>, thread uint* Width); >+native void GetDimensions(RWTexture1D<char4>, thread float* Width); >+native void GetDimensions(RWTexture1D<char4>, device uint* Width); >+native void GetDimensions(RWTexture1D<char4>, device float* Width); >+native void GetDimensions(RWTexture1D<char4>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<char4>, threadgroup float* Width); >+native char4 Load(RWTexture1D<char4>, int location); >+native void Store(RWTexture1D<char4>, char4, uint location); >+ >+native void GetDimensions(RWTexture1DArray<char4>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<char4>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<char4>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<char4>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<char4>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<char4>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<char4>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<char4>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<char4>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<char4>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<char4>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<char4>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<char4>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<char4>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<char4>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<char4>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<char4>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<char4>, threadgroup float* Width, threadgroup uint* Elements); >+native char4 Load(RWTexture1DArray<char4>, int2 location); >+native void Store(RWTexture1DArray<char4>, char4, uint2 location); >+ >+native void GetDimensions(RWTexture2D<char4>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<char4>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<char4>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<char4>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<char4>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<char4>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<char4>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<char4>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<char4>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<char4>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<char4>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<char4>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<char4>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<char4>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<char4>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<char4>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<char4>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<char4>, threadgroup float* Width, threadgroup float* Height); >+native char4 Load(RWTexture2D<char4>, int2 location); >+native void Store(RWTexture2D<char4>, char4, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<char4>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<char4>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native char4 Load(RWTexture2DArray<char4>, int3 location); >+native void Store(RWTexture2DArray<char4>, char4, uint3 location); >+ >+native void GetDimensions(RWTexture3D<char4>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char4>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char4>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char4>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char4>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char4>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char4>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char4>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char4>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char4>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char4>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char4>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char4>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char4>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char4>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char4>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char4>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char4>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char4>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char4>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char4>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char4>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char4>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char4>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char4>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char4>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char4>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char4>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char4>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char4>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char4>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char4>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char4>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char4>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char4>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char4>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char4>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char4>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char4>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char4>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char4>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char4>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char4>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char4>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char4>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char4>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char4>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char4>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<char4>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<char4>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<char4>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<char4>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<char4>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<char4>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native char4 Load(RWTexture3D<char4>, int3 location); >+native void Store(RWTexture3D<char4>, char4, uint3 location); >+ >+native short Sample(Texture1D<short>, sampler, float location); >+native short Sample(Texture1D<short>, sampler, float location, int offset); >+native short Load(Texture1D<short>, int2 location); >+native short Load(Texture1D<short>, int2 location, int offset); >+native void GetDimensions(Texture1D<short>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native short Sample(Texture1DArray<short>, sampler, float2 location); >+native short Sample(Texture1DArray<short>, sampler, float2 location, int offset); >+native short Load(Texture1DArray<short>, int3 location); >+native short Load(Texture1DArray<short>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<short>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native short Sample(Texture2D<short>, sampler, float2 location); >+native short Sample(Texture2D<short>, sampler, float2 location, int2 offset); >+native short SampleBias(Texture2D<short>, sampler, float2 location, float Bias); >+native short SampleBias(Texture2D<short>, sampler, float2 location, float Bias, int2 offset); >+native short SampleGrad(Texture2D<short>, sampler, float2 location, float2 DDX, float2 DDY); >+native short SampleGrad(Texture2D<short>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native short SampleLevel(Texture2D<short>, sampler, float2 location, float LOD); >+native short SampleLevel(Texture2D<short>, sampler, float2 location, float LOD, int2 offset); >+native short4 Gather(Texture2D<short>, sampler, float2 location); >+native short4 Gather(Texture2D<short>, sampler, float2 location, int2 offset); >+native short4 GatherRed(Texture2D<short>, sampler, float2 location); >+native short4 GatherRed(Texture2D<short>, sampler, float2 location, int2 offset); >+native short Load(Texture2D<short>, int3 location); >+native short Load(Texture2D<short>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<short>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native short Sample(Texture2DArray<short>, sampler, float3 location); >+native short Sample(Texture2DArray<short>, sampler, float3 location, int2 offset); >+native short SampleBias(Texture2DArray<short>, sampler, float3 location, float Bias); >+native short SampleBias(Texture2DArray<short>, sampler, float3 location, float Bias, int2 offset); >+native short SampleGrad(Texture2DArray<short>, sampler, float3 location, float2 DDX, float2 DDY); >+native short SampleGrad(Texture2DArray<short>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native short SampleLevel(Texture2DArray<short>, sampler, float3 location, float LOD); >+native short SampleLevel(Texture2DArray<short>, sampler, float3 location, float LOD, int2 offset); >+native short4 Gather(Texture2DArray<short>, sampler, float3 location); >+native short4 Gather(Texture2DArray<short>, sampler, float3 location, int2 offset); >+native short4 GatherRed(Texture2DArray<short>, sampler, float3 location); >+native short4 GatherRed(Texture2DArray<short>, sampler, float3 location, int2 offset); >+native short Load(Texture2DArray<short>, int4 location); >+native short Load(Texture2DArray<short>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native short Sample(Texture3D<short>, sampler, float3 location); >+native short Sample(Texture3D<short>, sampler, float3 location, int3 offset); >+native short Load(Texture3D<short>, int4 location); >+native short Load(Texture3D<short>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native short Sample(TextureCube<short>, sampler, float3 location); >+native short SampleBias(TextureCube<short>, sampler, float3 location, float Bias); >+native short SampleGrad(TextureCube<short>, sampler, float3 location, float3 DDX, float3 DDY); >+native short SampleLevel(TextureCube<short>, sampler, float3 location, float LOD); >+native short4 Gather(TextureCube<short>, sampler, float3 location); >+native short4 GatherRed(TextureCube<short>, sampler, float3 location); >+native void GetDimensions(TextureCube<short>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<short>, thread uint* Width); >+native void GetDimensions(RWTexture1D<short>, thread float* Width); >+native void GetDimensions(RWTexture1D<short>, device uint* Width); >+native void GetDimensions(RWTexture1D<short>, device float* Width); >+native void GetDimensions(RWTexture1D<short>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<short>, threadgroup float* Width); >+native short Load(RWTexture1D<short>, int location); >+native void Store(RWTexture1D<short>, short, uint location); >+ >+native void GetDimensions(RWTexture1DArray<short>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<short>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<short>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<short>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<short>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<short>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<short>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<short>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<short>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<short>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<short>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<short>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<short>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<short>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<short>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<short>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<short>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<short>, threadgroup float* Width, threadgroup uint* Elements); >+native short Load(RWTexture1DArray<short>, int2 location); >+native void Store(RWTexture1DArray<short>, short, uint2 location); >+ >+native void GetDimensions(RWTexture2D<short>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<short>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<short>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<short>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<short>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<short>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<short>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<short>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<short>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<short>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<short>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<short>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<short>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<short>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<short>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<short>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<short>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<short>, threadgroup float* Width, threadgroup float* Height); >+native short Load(RWTexture2D<short>, int2 location); >+native void Store(RWTexture2D<short>, short, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<short>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native short Load(RWTexture2DArray<short>, int3 location); >+native void Store(RWTexture2DArray<short>, short, uint3 location); >+ >+native void GetDimensions(RWTexture3D<short>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native short Load(RWTexture3D<short>, int3 location); >+native void Store(RWTexture3D<short>, short, uint3 location); >+ >+native short2 Sample(Texture1D<short2>, sampler, float location); >+native short2 Sample(Texture1D<short2>, sampler, float location, int offset); >+native short2 Load(Texture1D<short2>, int2 location); >+native short2 Load(Texture1D<short2>, int2 location, int offset); >+native void GetDimensions(Texture1D<short2>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short2>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short2>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short2>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short2>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short2>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native short2 Sample(Texture1DArray<short2>, sampler, float2 location); >+native short2 Sample(Texture1DArray<short2>, sampler, float2 location, int offset); >+native short2 Load(Texture1DArray<short2>, int3 location); >+native short2 Load(Texture1DArray<short2>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native short2 Sample(Texture2D<short2>, sampler, float2 location); >+native short2 Sample(Texture2D<short2>, sampler, float2 location, int2 offset); >+native short2 SampleBias(Texture2D<short2>, sampler, float2 location, float Bias); >+native short2 SampleBias(Texture2D<short2>, sampler, float2 location, float Bias, int2 offset); >+native short2 SampleGrad(Texture2D<short2>, sampler, float2 location, float2 DDX, float2 DDY); >+native short2 SampleGrad(Texture2D<short2>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native short2 SampleLevel(Texture2D<short2>, sampler, float2 location, float LOD); >+native short2 SampleLevel(Texture2D<short2>, sampler, float2 location, float LOD, int2 offset); >+native short4 Gather(Texture2D<short2>, sampler, float2 location); >+native short4 Gather(Texture2D<short2>, sampler, float2 location, int2 offset); >+native short4 GatherRed(Texture2D<short2>, sampler, float2 location); >+native short4 GatherRed(Texture2D<short2>, sampler, float2 location, int2 offset); >+native short4 GatherGreen(Texture2D<short2>, sampler, float2 location); >+native short4 GatherGreen(Texture2D<short2>, sampler, float2 location, int2 offset); >+native short2 Load(Texture2D<short2>, int3 location); >+native short2 Load(Texture2D<short2>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native short2 Sample(Texture2DArray<short2>, sampler, float3 location); >+native short2 Sample(Texture2DArray<short2>, sampler, float3 location, int2 offset); >+native short2 SampleBias(Texture2DArray<short2>, sampler, float3 location, float Bias); >+native short2 SampleBias(Texture2DArray<short2>, sampler, float3 location, float Bias, int2 offset); >+native short2 SampleGrad(Texture2DArray<short2>, sampler, float3 location, float2 DDX, float2 DDY); >+native short2 SampleGrad(Texture2DArray<short2>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native short2 SampleLevel(Texture2DArray<short2>, sampler, float3 location, float LOD); >+native short2 SampleLevel(Texture2DArray<short2>, sampler, float3 location, float LOD, int2 offset); >+native short4 Gather(Texture2DArray<short2>, sampler, float3 location); >+native short4 Gather(Texture2DArray<short2>, sampler, float3 location, int2 offset); >+native short4 GatherRed(Texture2DArray<short2>, sampler, float3 location); >+native short4 GatherRed(Texture2DArray<short2>, sampler, float3 location, int2 offset); >+native short4 GatherGreen(Texture2DArray<short2>, sampler, float3 location); >+native short4 GatherGreen(Texture2DArray<short2>, sampler, float3 location, int2 offset); >+native short2 Load(Texture2DArray<short2>, int4 location); >+native short2 Load(Texture2DArray<short2>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native short2 Sample(Texture3D<short2>, sampler, float3 location); >+native short2 Sample(Texture3D<short2>, sampler, float3 location, int3 offset); >+native short2 Load(Texture3D<short2>, int4 location); >+native short2 Load(Texture3D<short2>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native short2 Sample(TextureCube<short2>, sampler, float3 location); >+native short2 SampleBias(TextureCube<short2>, sampler, float3 location, float Bias); >+native short2 SampleGrad(TextureCube<short2>, sampler, float3 location, float3 DDX, float3 DDY); >+native short2 SampleLevel(TextureCube<short2>, sampler, float3 location, float LOD); >+native short4 Gather(TextureCube<short2>, sampler, float3 location); >+native short4 GatherRed(TextureCube<short2>, sampler, float3 location); >+native short4 GatherGreen(TextureCube<short2>, sampler, float3 location); >+native void GetDimensions(TextureCube<short2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<short2>, thread uint* Width); >+native void GetDimensions(RWTexture1D<short2>, thread float* Width); >+native void GetDimensions(RWTexture1D<short2>, device uint* Width); >+native void GetDimensions(RWTexture1D<short2>, device float* Width); >+native void GetDimensions(RWTexture1D<short2>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<short2>, threadgroup float* Width); >+native short2 Load(RWTexture1D<short2>, int location); >+native void Store(RWTexture1D<short2>, short2, uint location); >+ >+native void GetDimensions(RWTexture1DArray<short2>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<short2>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<short2>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<short2>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<short2>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<short2>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<short2>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<short2>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<short2>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<short2>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<short2>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<short2>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<short2>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<short2>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<short2>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<short2>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<short2>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<short2>, threadgroup float* Width, threadgroup uint* Elements); >+native short2 Load(RWTexture1DArray<short2>, int2 location); >+native void Store(RWTexture1DArray<short2>, short2, uint2 location); >+ >+native void GetDimensions(RWTexture2D<short2>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<short2>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<short2>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<short2>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<short2>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<short2>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<short2>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<short2>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<short2>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<short2>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<short2>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<short2>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<short2>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<short2>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<short2>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<short2>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<short2>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<short2>, threadgroup float* Width, threadgroup float* Height); >+native short2 Load(RWTexture2D<short2>, int2 location); >+native void Store(RWTexture2D<short2>, short2, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<short2>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short2>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native short2 Load(RWTexture2DArray<short2>, int3 location); >+native void Store(RWTexture2DArray<short2>, short2, uint3 location); >+ >+native void GetDimensions(RWTexture3D<short2>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short2>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short2>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short2>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short2>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short2>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short2>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short2>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short2>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short2>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short2>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short2>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short2>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short2>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short2>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short2>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short2>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short2>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short2>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short2>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short2>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short2>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short2>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short2>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short2>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short2>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short2>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short2>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short2>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short2>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short2>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short2>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short2>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short2>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short2>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short2>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short2>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short2>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short2>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short2>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short2>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short2>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short2>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short2>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short2>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short2>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short2>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short2>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short2>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short2>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short2>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short2>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short2>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short2>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native short2 Load(RWTexture3D<short2>, int3 location); >+native void Store(RWTexture3D<short2>, short2, uint3 location); >+ >+native short3 Sample(Texture1D<short3>, sampler, float location); >+native short3 Sample(Texture1D<short3>, sampler, float location, int offset); >+native short3 Load(Texture1D<short3>, int2 location); >+native short3 Load(Texture1D<short3>, int2 location, int offset); >+native void GetDimensions(Texture1D<short3>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short3>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short3>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short3>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short3>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short3>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native short3 Sample(Texture1DArray<short3>, sampler, float2 location); >+native short3 Sample(Texture1DArray<short3>, sampler, float2 location, int offset); >+native short3 Load(Texture1DArray<short3>, int3 location); >+native short3 Load(Texture1DArray<short3>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native short3 Sample(Texture2D<short3>, sampler, float2 location); >+native short3 Sample(Texture2D<short3>, sampler, float2 location, int2 offset); >+native short3 SampleBias(Texture2D<short3>, sampler, float2 location, float Bias); >+native short3 SampleBias(Texture2D<short3>, sampler, float2 location, float Bias, int2 offset); >+native short3 SampleGrad(Texture2D<short3>, sampler, float2 location, float2 DDX, float2 DDY); >+native short3 SampleGrad(Texture2D<short3>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native short3 SampleLevel(Texture2D<short3>, sampler, float2 location, float LOD); >+native short3 SampleLevel(Texture2D<short3>, sampler, float2 location, float LOD, int2 offset); >+native short4 Gather(Texture2D<short3>, sampler, float2 location); >+native short4 Gather(Texture2D<short3>, sampler, float2 location, int2 offset); >+native short4 GatherRed(Texture2D<short3>, sampler, float2 location); >+native short4 GatherRed(Texture2D<short3>, sampler, float2 location, int2 offset); >+native short4 GatherGreen(Texture2D<short3>, sampler, float2 location); >+native short4 GatherGreen(Texture2D<short3>, sampler, float2 location, int2 offset); >+native short4 GatherBlue(Texture2D<short3>, sampler, float2 location); >+native short4 GatherBlue(Texture2D<short3>, sampler, float2 location, int2 offset); >+native short3 Load(Texture2D<short3>, int3 location); >+native short3 Load(Texture2D<short3>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native short3 Sample(Texture2DArray<short3>, sampler, float3 location); >+native short3 Sample(Texture2DArray<short3>, sampler, float3 location, int2 offset); >+native short3 SampleBias(Texture2DArray<short3>, sampler, float3 location, float Bias); >+native short3 SampleBias(Texture2DArray<short3>, sampler, float3 location, float Bias, int2 offset); >+native short3 SampleGrad(Texture2DArray<short3>, sampler, float3 location, float2 DDX, float2 DDY); >+native short3 SampleGrad(Texture2DArray<short3>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native short3 SampleLevel(Texture2DArray<short3>, sampler, float3 location, float LOD); >+native short3 SampleLevel(Texture2DArray<short3>, sampler, float3 location, float LOD, int2 offset); >+native short4 Gather(Texture2DArray<short3>, sampler, float3 location); >+native short4 Gather(Texture2DArray<short3>, sampler, float3 location, int2 offset); >+native short4 GatherRed(Texture2DArray<short3>, sampler, float3 location); >+native short4 GatherRed(Texture2DArray<short3>, sampler, float3 location, int2 offset); >+native short4 GatherGreen(Texture2DArray<short3>, sampler, float3 location); >+native short4 GatherGreen(Texture2DArray<short3>, sampler, float3 location, int2 offset); >+native short4 GatherBlue(Texture2DArray<short3>, sampler, float3 location); >+native short4 GatherBlue(Texture2DArray<short3>, sampler, float3 location, int2 offset); >+native short3 Load(Texture2DArray<short3>, int4 location); >+native short3 Load(Texture2DArray<short3>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native short3 Sample(Texture3D<short3>, sampler, float3 location); >+native short3 Sample(Texture3D<short3>, sampler, float3 location, int3 offset); >+native short3 Load(Texture3D<short3>, int4 location); >+native short3 Load(Texture3D<short3>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native short3 Sample(TextureCube<short3>, sampler, float3 location); >+native short3 SampleBias(TextureCube<short3>, sampler, float3 location, float Bias); >+native short3 SampleGrad(TextureCube<short3>, sampler, float3 location, float3 DDX, float3 DDY); >+native short3 SampleLevel(TextureCube<short3>, sampler, float3 location, float LOD); >+native short4 Gather(TextureCube<short3>, sampler, float3 location); >+native short4 GatherRed(TextureCube<short3>, sampler, float3 location); >+native short4 GatherGreen(TextureCube<short3>, sampler, float3 location); >+native short4 GatherBlue(TextureCube<short3>, sampler, float3 location); >+native void GetDimensions(TextureCube<short3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<short3>, thread uint* Width); >+native void GetDimensions(RWTexture1D<short3>, thread float* Width); >+native void GetDimensions(RWTexture1D<short3>, device uint* Width); >+native void GetDimensions(RWTexture1D<short3>, device float* Width); >+native void GetDimensions(RWTexture1D<short3>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<short3>, threadgroup float* Width); >+native short3 Load(RWTexture1D<short3>, int location); >+native void Store(RWTexture1D<short3>, short3, uint location); >+ >+native void GetDimensions(RWTexture1DArray<short3>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<short3>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<short3>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<short3>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<short3>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<short3>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<short3>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<short3>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<short3>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<short3>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<short3>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<short3>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<short3>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<short3>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<short3>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<short3>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<short3>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<short3>, threadgroup float* Width, threadgroup uint* Elements); >+native short3 Load(RWTexture1DArray<short3>, int2 location); >+native void Store(RWTexture1DArray<short3>, short3, uint2 location); >+ >+native void GetDimensions(RWTexture2D<short3>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<short3>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<short3>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<short3>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<short3>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<short3>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<short3>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<short3>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<short3>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<short3>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<short3>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<short3>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<short3>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<short3>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<short3>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<short3>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<short3>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<short3>, threadgroup float* Width, threadgroup float* Height); >+native short3 Load(RWTexture2D<short3>, int2 location); >+native void Store(RWTexture2D<short3>, short3, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<short3>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short3>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native short3 Load(RWTexture2DArray<short3>, int3 location); >+native void Store(RWTexture2DArray<short3>, short3, uint3 location); >+ >+native void GetDimensions(RWTexture3D<short3>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short3>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short3>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short3>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short3>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short3>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short3>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short3>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short3>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short3>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short3>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short3>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short3>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short3>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short3>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short3>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short3>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short3>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short3>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short3>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short3>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short3>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short3>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short3>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short3>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short3>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short3>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short3>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short3>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short3>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short3>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short3>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short3>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short3>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short3>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short3>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short3>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short3>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short3>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short3>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short3>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short3>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short3>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short3>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short3>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short3>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short3>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short3>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short3>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short3>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short3>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short3>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short3>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short3>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native short3 Load(RWTexture3D<short3>, int3 location); >+native void Store(RWTexture3D<short3>, short3, uint3 location); >+ >+native short4 Sample(Texture1D<short4>, sampler, float location); >+native short4 Sample(Texture1D<short4>, sampler, float location, int offset); >+native short4 Load(Texture1D<short4>, int2 location); >+native short4 Load(Texture1D<short4>, int2 location, int offset); >+native void GetDimensions(Texture1D<short4>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short4>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short4>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short4>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short4>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short4>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native short4 Sample(Texture1DArray<short4>, sampler, float2 location); >+native short4 Sample(Texture1DArray<short4>, sampler, float2 location, int offset); >+native short4 Load(Texture1DArray<short4>, int3 location); >+native short4 Load(Texture1DArray<short4>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native short4 Sample(Texture2D<short4>, sampler, float2 location); >+native short4 Sample(Texture2D<short4>, sampler, float2 location, int2 offset); >+native short4 SampleBias(Texture2D<short4>, sampler, float2 location, float Bias); >+native short4 SampleBias(Texture2D<short4>, sampler, float2 location, float Bias, int2 offset); >+native short4 SampleGrad(Texture2D<short4>, sampler, float2 location, float2 DDX, float2 DDY); >+native short4 SampleGrad(Texture2D<short4>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native short4 SampleLevel(Texture2D<short4>, sampler, float2 location, float LOD); >+native short4 SampleLevel(Texture2D<short4>, sampler, float2 location, float LOD, int2 offset); >+native short4 Gather(Texture2D<short4>, sampler, float2 location); >+native short4 Gather(Texture2D<short4>, sampler, float2 location, int2 offset); >+native short4 GatherRed(Texture2D<short4>, sampler, float2 location); >+native short4 GatherRed(Texture2D<short4>, sampler, float2 location, int2 offset); >+native short4 GatherGreen(Texture2D<short4>, sampler, float2 location); >+native short4 GatherGreen(Texture2D<short4>, sampler, float2 location, int2 offset); >+native short4 GatherBlue(Texture2D<short4>, sampler, float2 location); >+native short4 GatherBlue(Texture2D<short4>, sampler, float2 location, int2 offset); >+native short4 GatherAlpha(Texture2D<short4>, sampler, float2 location); >+native short4 GatherAlpha(Texture2D<short4>, sampler, float2 location, int2 offset); >+native short4 Load(Texture2D<short4>, int3 location); >+native short4 Load(Texture2D<short4>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native short4 Sample(Texture2DArray<short4>, sampler, float3 location); >+native short4 Sample(Texture2DArray<short4>, sampler, float3 location, int2 offset); >+native short4 SampleBias(Texture2DArray<short4>, sampler, float3 location, float Bias); >+native short4 SampleBias(Texture2DArray<short4>, sampler, float3 location, float Bias, int2 offset); >+native short4 SampleGrad(Texture2DArray<short4>, sampler, float3 location, float2 DDX, float2 DDY); >+native short4 SampleGrad(Texture2DArray<short4>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native short4 SampleLevel(Texture2DArray<short4>, sampler, float3 location, float LOD); >+native short4 SampleLevel(Texture2DArray<short4>, sampler, float3 location, float LOD, int2 offset); >+native short4 Gather(Texture2DArray<short4>, sampler, float3 location); >+native short4 Gather(Texture2DArray<short4>, sampler, float3 location, int2 offset); >+native short4 GatherRed(Texture2DArray<short4>, sampler, float3 location); >+native short4 GatherRed(Texture2DArray<short4>, sampler, float3 location, int2 offset); >+native short4 GatherGreen(Texture2DArray<short4>, sampler, float3 location); >+native short4 GatherGreen(Texture2DArray<short4>, sampler, float3 location, int2 offset); >+native short4 GatherBlue(Texture2DArray<short4>, sampler, float3 location); >+native short4 GatherBlue(Texture2DArray<short4>, sampler, float3 location, int2 offset); >+native short4 GatherAlpha(Texture2DArray<short4>, sampler, float3 location); >+native short4 GatherAlpha(Texture2DArray<short4>, sampler, float3 location, int2 offset); >+native short4 Load(Texture2DArray<short4>, int4 location); >+native short4 Load(Texture2DArray<short4>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native short4 Sample(Texture3D<short4>, sampler, float3 location); >+native short4 Sample(Texture3D<short4>, sampler, float3 location, int3 offset); >+native short4 Load(Texture3D<short4>, int4 location); >+native short4 Load(Texture3D<short4>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native short4 Sample(TextureCube<short4>, sampler, float3 location); >+native short4 SampleBias(TextureCube<short4>, sampler, float3 location, float Bias); >+native short4 SampleGrad(TextureCube<short4>, sampler, float3 location, float3 DDX, float3 DDY); >+native short4 SampleLevel(TextureCube<short4>, sampler, float3 location, float LOD); >+native short4 Gather(TextureCube<short4>, sampler, float3 location); >+native short4 GatherRed(TextureCube<short4>, sampler, float3 location); >+native short4 GatherGreen(TextureCube<short4>, sampler, float3 location); >+native short4 GatherBlue(TextureCube<short4>, sampler, float3 location); >+native short4 GatherAlpha(TextureCube<short4>, sampler, float3 location); >+native void GetDimensions(TextureCube<short4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<short4>, thread uint* Width); >+native void GetDimensions(RWTexture1D<short4>, thread float* Width); >+native void GetDimensions(RWTexture1D<short4>, device uint* Width); >+native void GetDimensions(RWTexture1D<short4>, device float* Width); >+native void GetDimensions(RWTexture1D<short4>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<short4>, threadgroup float* Width); >+native short4 Load(RWTexture1D<short4>, int location); >+native void Store(RWTexture1D<short4>, short4, uint location); >+ >+native void GetDimensions(RWTexture1DArray<short4>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<short4>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<short4>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<short4>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<short4>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<short4>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<short4>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<short4>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<short4>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<short4>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<short4>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<short4>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<short4>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<short4>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<short4>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<short4>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<short4>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<short4>, threadgroup float* Width, threadgroup uint* Elements); >+native short4 Load(RWTexture1DArray<short4>, int2 location); >+native void Store(RWTexture1DArray<short4>, short4, uint2 location); >+ >+native void GetDimensions(RWTexture2D<short4>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<short4>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<short4>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<short4>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<short4>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<short4>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<short4>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<short4>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<short4>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<short4>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<short4>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<short4>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<short4>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<short4>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<short4>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<short4>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<short4>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<short4>, threadgroup float* Width, threadgroup float* Height); >+native short4 Load(RWTexture2D<short4>, int2 location); >+native void Store(RWTexture2D<short4>, short4, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<short4>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<short4>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native short4 Load(RWTexture2DArray<short4>, int3 location); >+native void Store(RWTexture2DArray<short4>, short4, uint3 location); >+ >+native void GetDimensions(RWTexture3D<short4>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short4>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short4>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short4>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short4>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short4>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short4>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short4>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short4>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short4>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short4>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short4>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short4>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short4>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short4>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short4>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short4>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short4>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short4>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short4>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short4>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short4>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short4>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short4>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short4>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short4>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short4>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short4>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short4>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short4>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short4>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short4>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short4>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short4>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short4>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short4>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short4>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short4>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short4>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short4>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short4>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short4>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short4>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short4>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short4>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short4>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short4>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short4>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<short4>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<short4>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<short4>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<short4>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<short4>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<short4>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native short4 Load(RWTexture3D<short4>, int3 location); >+native void Store(RWTexture3D<short4>, short4, uint3 location); >+ >+native int Sample(Texture1D<int>, sampler, float location); >+native int Sample(Texture1D<int>, sampler, float location, int offset); >+native int Load(Texture1D<int>, int2 location); >+native int Load(Texture1D<int>, int2 location, int offset); >+native void GetDimensions(Texture1D<int>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native int Sample(Texture1DArray<int>, sampler, float2 location); >+native int Sample(Texture1DArray<int>, sampler, float2 location, int offset); >+native int Load(Texture1DArray<int>, int3 location); >+native int Load(Texture1DArray<int>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<int>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native int Sample(Texture2D<int>, sampler, float2 location); >+native int Sample(Texture2D<int>, sampler, float2 location, int2 offset); >+native int SampleBias(Texture2D<int>, sampler, float2 location, float Bias); >+native int SampleBias(Texture2D<int>, sampler, float2 location, float Bias, int2 offset); >+native int SampleGrad(Texture2D<int>, sampler, float2 location, float2 DDX, float2 DDY); >+native int SampleGrad(Texture2D<int>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native int SampleLevel(Texture2D<int>, sampler, float2 location, float LOD); >+native int SampleLevel(Texture2D<int>, sampler, float2 location, float LOD, int2 offset); >+native int4 Gather(Texture2D<int>, sampler, float2 location); >+native int4 Gather(Texture2D<int>, sampler, float2 location, int2 offset); >+native int4 GatherRed(Texture2D<int>, sampler, float2 location); >+native int4 GatherRed(Texture2D<int>, sampler, float2 location, int2 offset); >+native int Load(Texture2D<int>, int3 location); >+native int Load(Texture2D<int>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<int>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native int Sample(Texture2DArray<int>, sampler, float3 location); >+native int Sample(Texture2DArray<int>, sampler, float3 location, int2 offset); >+native int SampleBias(Texture2DArray<int>, sampler, float3 location, float Bias); >+native int SampleBias(Texture2DArray<int>, sampler, float3 location, float Bias, int2 offset); >+native int SampleGrad(Texture2DArray<int>, sampler, float3 location, float2 DDX, float2 DDY); >+native int SampleGrad(Texture2DArray<int>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native int SampleLevel(Texture2DArray<int>, sampler, float3 location, float LOD); >+native int SampleLevel(Texture2DArray<int>, sampler, float3 location, float LOD, int2 offset); >+native int4 Gather(Texture2DArray<int>, sampler, float3 location); >+native int4 Gather(Texture2DArray<int>, sampler, float3 location, int2 offset); >+native int4 GatherRed(Texture2DArray<int>, sampler, float3 location); >+native int4 GatherRed(Texture2DArray<int>, sampler, float3 location, int2 offset); >+native int Load(Texture2DArray<int>, int4 location); >+native int Load(Texture2DArray<int>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native int Sample(Texture3D<int>, sampler, float3 location); >+native int Sample(Texture3D<int>, sampler, float3 location, int3 offset); >+native int Load(Texture3D<int>, int4 location); >+native int Load(Texture3D<int>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native int Sample(TextureCube<int>, sampler, float3 location); >+native int SampleBias(TextureCube<int>, sampler, float3 location, float Bias); >+native int SampleGrad(TextureCube<int>, sampler, float3 location, float3 DDX, float3 DDY); >+native int SampleLevel(TextureCube<int>, sampler, float3 location, float LOD); >+native int4 Gather(TextureCube<int>, sampler, float3 location); >+native int4 GatherRed(TextureCube<int>, sampler, float3 location); >+native void GetDimensions(TextureCube<int>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<int>, thread uint* Width); >+native void GetDimensions(RWTexture1D<int>, thread float* Width); >+native void GetDimensions(RWTexture1D<int>, device uint* Width); >+native void GetDimensions(RWTexture1D<int>, device float* Width); >+native void GetDimensions(RWTexture1D<int>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<int>, threadgroup float* Width); >+native int Load(RWTexture1D<int>, int location); >+native void Store(RWTexture1D<int>, int, uint location); >+ >+native void GetDimensions(RWTexture1DArray<int>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<int>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<int>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<int>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<int>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<int>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<int>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<int>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<int>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<int>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<int>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<int>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<int>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<int>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<int>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<int>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<int>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<int>, threadgroup float* Width, threadgroup uint* Elements); >+native int Load(RWTexture1DArray<int>, int2 location); >+native void Store(RWTexture1DArray<int>, int, uint2 location); >+ >+native void GetDimensions(RWTexture2D<int>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<int>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<int>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<int>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<int>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<int>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<int>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<int>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<int>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<int>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<int>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<int>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<int>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<int>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<int>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<int>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<int>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<int>, threadgroup float* Width, threadgroup float* Height); >+native int Load(RWTexture2D<int>, int2 location); >+native void Store(RWTexture2D<int>, int, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<int>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native int Load(RWTexture2DArray<int>, int3 location); >+native void Store(RWTexture2DArray<int>, int, uint3 location); >+ >+native void GetDimensions(RWTexture3D<int>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native int Load(RWTexture3D<int>, int3 location); >+native void Store(RWTexture3D<int>, int, uint3 location); >+ >+native int2 Sample(Texture1D<int2>, sampler, float location); >+native int2 Sample(Texture1D<int2>, sampler, float location, int offset); >+native int2 Load(Texture1D<int2>, int2 location); >+native int2 Load(Texture1D<int2>, int2 location, int offset); >+native void GetDimensions(Texture1D<int2>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int2>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int2>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int2>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int2>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int2>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native int2 Sample(Texture1DArray<int2>, sampler, float2 location); >+native int2 Sample(Texture1DArray<int2>, sampler, float2 location, int offset); >+native int2 Load(Texture1DArray<int2>, int3 location); >+native int2 Load(Texture1DArray<int2>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native int2 Sample(Texture2D<int2>, sampler, float2 location); >+native int2 Sample(Texture2D<int2>, sampler, float2 location, int2 offset); >+native int2 SampleBias(Texture2D<int2>, sampler, float2 location, float Bias); >+native int2 SampleBias(Texture2D<int2>, sampler, float2 location, float Bias, int2 offset); >+native int2 SampleGrad(Texture2D<int2>, sampler, float2 location, float2 DDX, float2 DDY); >+native int2 SampleGrad(Texture2D<int2>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native int2 SampleLevel(Texture2D<int2>, sampler, float2 location, float LOD); >+native int2 SampleLevel(Texture2D<int2>, sampler, float2 location, float LOD, int2 offset); >+native int4 Gather(Texture2D<int2>, sampler, float2 location); >+native int4 Gather(Texture2D<int2>, sampler, float2 location, int2 offset); >+native int4 GatherRed(Texture2D<int2>, sampler, float2 location); >+native int4 GatherRed(Texture2D<int2>, sampler, float2 location, int2 offset); >+native int4 GatherGreen(Texture2D<int2>, sampler, float2 location); >+native int4 GatherGreen(Texture2D<int2>, sampler, float2 location, int2 offset); >+native int2 Load(Texture2D<int2>, int3 location); >+native int2 Load(Texture2D<int2>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native int2 Sample(Texture2DArray<int2>, sampler, float3 location); >+native int2 Sample(Texture2DArray<int2>, sampler, float3 location, int2 offset); >+native int2 SampleBias(Texture2DArray<int2>, sampler, float3 location, float Bias); >+native int2 SampleBias(Texture2DArray<int2>, sampler, float3 location, float Bias, int2 offset); >+native int2 SampleGrad(Texture2DArray<int2>, sampler, float3 location, float2 DDX, float2 DDY); >+native int2 SampleGrad(Texture2DArray<int2>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native int2 SampleLevel(Texture2DArray<int2>, sampler, float3 location, float LOD); >+native int2 SampleLevel(Texture2DArray<int2>, sampler, float3 location, float LOD, int2 offset); >+native int4 Gather(Texture2DArray<int2>, sampler, float3 location); >+native int4 Gather(Texture2DArray<int2>, sampler, float3 location, int2 offset); >+native int4 GatherRed(Texture2DArray<int2>, sampler, float3 location); >+native int4 GatherRed(Texture2DArray<int2>, sampler, float3 location, int2 offset); >+native int4 GatherGreen(Texture2DArray<int2>, sampler, float3 location); >+native int4 GatherGreen(Texture2DArray<int2>, sampler, float3 location, int2 offset); >+native int2 Load(Texture2DArray<int2>, int4 location); >+native int2 Load(Texture2DArray<int2>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native int2 Sample(Texture3D<int2>, sampler, float3 location); >+native int2 Sample(Texture3D<int2>, sampler, float3 location, int3 offset); >+native int2 Load(Texture3D<int2>, int4 location); >+native int2 Load(Texture3D<int2>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native int2 Sample(TextureCube<int2>, sampler, float3 location); >+native int2 SampleBias(TextureCube<int2>, sampler, float3 location, float Bias); >+native int2 SampleGrad(TextureCube<int2>, sampler, float3 location, float3 DDX, float3 DDY); >+native int2 SampleLevel(TextureCube<int2>, sampler, float3 location, float LOD); >+native int4 Gather(TextureCube<int2>, sampler, float3 location); >+native int4 GatherRed(TextureCube<int2>, sampler, float3 location); >+native int4 GatherGreen(TextureCube<int2>, sampler, float3 location); >+native void GetDimensions(TextureCube<int2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<int2>, thread uint* Width); >+native void GetDimensions(RWTexture1D<int2>, thread float* Width); >+native void GetDimensions(RWTexture1D<int2>, device uint* Width); >+native void GetDimensions(RWTexture1D<int2>, device float* Width); >+native void GetDimensions(RWTexture1D<int2>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<int2>, threadgroup float* Width); >+native int2 Load(RWTexture1D<int2>, int location); >+native void Store(RWTexture1D<int2>, int2, uint location); >+ >+native void GetDimensions(RWTexture1DArray<int2>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<int2>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<int2>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<int2>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<int2>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<int2>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<int2>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<int2>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<int2>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<int2>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<int2>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<int2>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<int2>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<int2>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<int2>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<int2>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<int2>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<int2>, threadgroup float* Width, threadgroup uint* Elements); >+native int2 Load(RWTexture1DArray<int2>, int2 location); >+native void Store(RWTexture1DArray<int2>, int2, uint2 location); >+ >+native void GetDimensions(RWTexture2D<int2>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<int2>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<int2>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<int2>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<int2>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<int2>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<int2>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<int2>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<int2>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<int2>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<int2>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<int2>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<int2>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<int2>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<int2>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<int2>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<int2>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<int2>, threadgroup float* Width, threadgroup float* Height); >+native int2 Load(RWTexture2D<int2>, int2 location); >+native void Store(RWTexture2D<int2>, int2, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<int2>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int2>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native int2 Load(RWTexture2DArray<int2>, int3 location); >+native void Store(RWTexture2DArray<int2>, int2, uint3 location); >+ >+native void GetDimensions(RWTexture3D<int2>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int2>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int2>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int2>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int2>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int2>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int2>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int2>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int2>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int2>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int2>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int2>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int2>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int2>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int2>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int2>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int2>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int2>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int2>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int2>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int2>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int2>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int2>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int2>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int2>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int2>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int2>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int2>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int2>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int2>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int2>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int2>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int2>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int2>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int2>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int2>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int2>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int2>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int2>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int2>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int2>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int2>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int2>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int2>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int2>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int2>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int2>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int2>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int2>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int2>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int2>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int2>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int2>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int2>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native int2 Load(RWTexture3D<int2>, int3 location); >+native void Store(RWTexture3D<int2>, int2, uint3 location); >+ >+native int3 Sample(Texture1D<int3>, sampler, float location); >+native int3 Sample(Texture1D<int3>, sampler, float location, int offset); >+native int3 Load(Texture1D<int3>, int2 location); >+native int3 Load(Texture1D<int3>, int2 location, int offset); >+native void GetDimensions(Texture1D<int3>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int3>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int3>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int3>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int3>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int3>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native int3 Sample(Texture1DArray<int3>, sampler, float2 location); >+native int3 Sample(Texture1DArray<int3>, sampler, float2 location, int offset); >+native int3 Load(Texture1DArray<int3>, int3 location); >+native int3 Load(Texture1DArray<int3>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native int3 Sample(Texture2D<int3>, sampler, float2 location); >+native int3 Sample(Texture2D<int3>, sampler, float2 location, int2 offset); >+native int3 SampleBias(Texture2D<int3>, sampler, float2 location, float Bias); >+native int3 SampleBias(Texture2D<int3>, sampler, float2 location, float Bias, int2 offset); >+native int3 SampleGrad(Texture2D<int3>, sampler, float2 location, float2 DDX, float2 DDY); >+native int3 SampleGrad(Texture2D<int3>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native int3 SampleLevel(Texture2D<int3>, sampler, float2 location, float LOD); >+native int3 SampleLevel(Texture2D<int3>, sampler, float2 location, float LOD, int2 offset); >+native int4 Gather(Texture2D<int3>, sampler, float2 location); >+native int4 Gather(Texture2D<int3>, sampler, float2 location, int2 offset); >+native int4 GatherRed(Texture2D<int3>, sampler, float2 location); >+native int4 GatherRed(Texture2D<int3>, sampler, float2 location, int2 offset); >+native int4 GatherGreen(Texture2D<int3>, sampler, float2 location); >+native int4 GatherGreen(Texture2D<int3>, sampler, float2 location, int2 offset); >+native int4 GatherBlue(Texture2D<int3>, sampler, float2 location); >+native int4 GatherBlue(Texture2D<int3>, sampler, float2 location, int2 offset); >+native int3 Load(Texture2D<int3>, int3 location); >+native int3 Load(Texture2D<int3>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native int3 Sample(Texture2DArray<int3>, sampler, float3 location); >+native int3 Sample(Texture2DArray<int3>, sampler, float3 location, int2 offset); >+native int3 SampleBias(Texture2DArray<int3>, sampler, float3 location, float Bias); >+native int3 SampleBias(Texture2DArray<int3>, sampler, float3 location, float Bias, int2 offset); >+native int3 SampleGrad(Texture2DArray<int3>, sampler, float3 location, float2 DDX, float2 DDY); >+native int3 SampleGrad(Texture2DArray<int3>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native int3 SampleLevel(Texture2DArray<int3>, sampler, float3 location, float LOD); >+native int3 SampleLevel(Texture2DArray<int3>, sampler, float3 location, float LOD, int2 offset); >+native int4 Gather(Texture2DArray<int3>, sampler, float3 location); >+native int4 Gather(Texture2DArray<int3>, sampler, float3 location, int2 offset); >+native int4 GatherRed(Texture2DArray<int3>, sampler, float3 location); >+native int4 GatherRed(Texture2DArray<int3>, sampler, float3 location, int2 offset); >+native int4 GatherGreen(Texture2DArray<int3>, sampler, float3 location); >+native int4 GatherGreen(Texture2DArray<int3>, sampler, float3 location, int2 offset); >+native int4 GatherBlue(Texture2DArray<int3>, sampler, float3 location); >+native int4 GatherBlue(Texture2DArray<int3>, sampler, float3 location, int2 offset); >+native int3 Load(Texture2DArray<int3>, int4 location); >+native int3 Load(Texture2DArray<int3>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native int3 Sample(Texture3D<int3>, sampler, float3 location); >+native int3 Sample(Texture3D<int3>, sampler, float3 location, int3 offset); >+native int3 Load(Texture3D<int3>, int4 location); >+native int3 Load(Texture3D<int3>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native int3 Sample(TextureCube<int3>, sampler, float3 location); >+native int3 SampleBias(TextureCube<int3>, sampler, float3 location, float Bias); >+native int3 SampleGrad(TextureCube<int3>, sampler, float3 location, float3 DDX, float3 DDY); >+native int3 SampleLevel(TextureCube<int3>, sampler, float3 location, float LOD); >+native int4 Gather(TextureCube<int3>, sampler, float3 location); >+native int4 GatherRed(TextureCube<int3>, sampler, float3 location); >+native int4 GatherGreen(TextureCube<int3>, sampler, float3 location); >+native int4 GatherBlue(TextureCube<int3>, sampler, float3 location); >+native void GetDimensions(TextureCube<int3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<int3>, thread uint* Width); >+native void GetDimensions(RWTexture1D<int3>, thread float* Width); >+native void GetDimensions(RWTexture1D<int3>, device uint* Width); >+native void GetDimensions(RWTexture1D<int3>, device float* Width); >+native void GetDimensions(RWTexture1D<int3>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<int3>, threadgroup float* Width); >+native int3 Load(RWTexture1D<int3>, int location); >+native void Store(RWTexture1D<int3>, int3, uint location); >+ >+native void GetDimensions(RWTexture1DArray<int3>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<int3>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<int3>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<int3>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<int3>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<int3>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<int3>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<int3>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<int3>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<int3>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<int3>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<int3>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<int3>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<int3>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<int3>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<int3>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<int3>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<int3>, threadgroup float* Width, threadgroup uint* Elements); >+native int3 Load(RWTexture1DArray<int3>, int2 location); >+native void Store(RWTexture1DArray<int3>, int3, uint2 location); >+ >+native void GetDimensions(RWTexture2D<int3>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<int3>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<int3>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<int3>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<int3>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<int3>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<int3>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<int3>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<int3>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<int3>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<int3>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<int3>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<int3>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<int3>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<int3>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<int3>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<int3>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<int3>, threadgroup float* Width, threadgroup float* Height); >+native int3 Load(RWTexture2D<int3>, int2 location); >+native void Store(RWTexture2D<int3>, int3, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<int3>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int3>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native int3 Load(RWTexture2DArray<int3>, int3 location); >+native void Store(RWTexture2DArray<int3>, int3, uint3 location); >+ >+native void GetDimensions(RWTexture3D<int3>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int3>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int3>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int3>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int3>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int3>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int3>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int3>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int3>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int3>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int3>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int3>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int3>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int3>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int3>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int3>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int3>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int3>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int3>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int3>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int3>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int3>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int3>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int3>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int3>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int3>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int3>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int3>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int3>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int3>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int3>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int3>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int3>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int3>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int3>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int3>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int3>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int3>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int3>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int3>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int3>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int3>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int3>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int3>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int3>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int3>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int3>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int3>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int3>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int3>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int3>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int3>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int3>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int3>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native int3 Load(RWTexture3D<int3>, int3 location); >+native void Store(RWTexture3D<int3>, int3, uint3 location); >+ >+native int4 Sample(Texture1D<int4>, sampler, float location); >+native int4 Sample(Texture1D<int4>, sampler, float location, int offset); >+native int4 Load(Texture1D<int4>, int2 location); >+native int4 Load(Texture1D<int4>, int2 location, int offset); >+native void GetDimensions(Texture1D<int4>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int4>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int4>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int4>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int4>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int4>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native int4 Sample(Texture1DArray<int4>, sampler, float2 location); >+native int4 Sample(Texture1DArray<int4>, sampler, float2 location, int offset); >+native int4 Load(Texture1DArray<int4>, int3 location); >+native int4 Load(Texture1DArray<int4>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native int4 Sample(Texture2D<int4>, sampler, float2 location); >+native int4 Sample(Texture2D<int4>, sampler, float2 location, int2 offset); >+native int4 SampleBias(Texture2D<int4>, sampler, float2 location, float Bias); >+native int4 SampleBias(Texture2D<int4>, sampler, float2 location, float Bias, int2 offset); >+native int4 SampleGrad(Texture2D<int4>, sampler, float2 location, float2 DDX, float2 DDY); >+native int4 SampleGrad(Texture2D<int4>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native int4 SampleLevel(Texture2D<int4>, sampler, float2 location, float LOD); >+native int4 SampleLevel(Texture2D<int4>, sampler, float2 location, float LOD, int2 offset); >+native int4 Gather(Texture2D<int4>, sampler, float2 location); >+native int4 Gather(Texture2D<int4>, sampler, float2 location, int2 offset); >+native int4 GatherRed(Texture2D<int4>, sampler, float2 location); >+native int4 GatherRed(Texture2D<int4>, sampler, float2 location, int2 offset); >+native int4 GatherGreen(Texture2D<int4>, sampler, float2 location); >+native int4 GatherGreen(Texture2D<int4>, sampler, float2 location, int2 offset); >+native int4 GatherBlue(Texture2D<int4>, sampler, float2 location); >+native int4 GatherBlue(Texture2D<int4>, sampler, float2 location, int2 offset); >+native int4 GatherAlpha(Texture2D<int4>, sampler, float2 location); >+native int4 GatherAlpha(Texture2D<int4>, sampler, float2 location, int2 offset); >+native int4 Load(Texture2D<int4>, int3 location); >+native int4 Load(Texture2D<int4>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native int4 Sample(Texture2DArray<int4>, sampler, float3 location); >+native int4 Sample(Texture2DArray<int4>, sampler, float3 location, int2 offset); >+native int4 SampleBias(Texture2DArray<int4>, sampler, float3 location, float Bias); >+native int4 SampleBias(Texture2DArray<int4>, sampler, float3 location, float Bias, int2 offset); >+native int4 SampleGrad(Texture2DArray<int4>, sampler, float3 location, float2 DDX, float2 DDY); >+native int4 SampleGrad(Texture2DArray<int4>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native int4 SampleLevel(Texture2DArray<int4>, sampler, float3 location, float LOD); >+native int4 SampleLevel(Texture2DArray<int4>, sampler, float3 location, float LOD, int2 offset); >+native int4 Gather(Texture2DArray<int4>, sampler, float3 location); >+native int4 Gather(Texture2DArray<int4>, sampler, float3 location, int2 offset); >+native int4 GatherRed(Texture2DArray<int4>, sampler, float3 location); >+native int4 GatherRed(Texture2DArray<int4>, sampler, float3 location, int2 offset); >+native int4 GatherGreen(Texture2DArray<int4>, sampler, float3 location); >+native int4 GatherGreen(Texture2DArray<int4>, sampler, float3 location, int2 offset); >+native int4 GatherBlue(Texture2DArray<int4>, sampler, float3 location); >+native int4 GatherBlue(Texture2DArray<int4>, sampler, float3 location, int2 offset); >+native int4 GatherAlpha(Texture2DArray<int4>, sampler, float3 location); >+native int4 GatherAlpha(Texture2DArray<int4>, sampler, float3 location, int2 offset); >+native int4 Load(Texture2DArray<int4>, int4 location); >+native int4 Load(Texture2DArray<int4>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native int4 Sample(Texture3D<int4>, sampler, float3 location); >+native int4 Sample(Texture3D<int4>, sampler, float3 location, int3 offset); >+native int4 Load(Texture3D<int4>, int4 location); >+native int4 Load(Texture3D<int4>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native int4 Sample(TextureCube<int4>, sampler, float3 location); >+native int4 SampleBias(TextureCube<int4>, sampler, float3 location, float Bias); >+native int4 SampleGrad(TextureCube<int4>, sampler, float3 location, float3 DDX, float3 DDY); >+native int4 SampleLevel(TextureCube<int4>, sampler, float3 location, float LOD); >+native int4 Gather(TextureCube<int4>, sampler, float3 location); >+native int4 GatherRed(TextureCube<int4>, sampler, float3 location); >+native int4 GatherGreen(TextureCube<int4>, sampler, float3 location); >+native int4 GatherBlue(TextureCube<int4>, sampler, float3 location); >+native int4 GatherAlpha(TextureCube<int4>, sampler, float3 location); >+native void GetDimensions(TextureCube<int4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<int4>, thread uint* Width); >+native void GetDimensions(RWTexture1D<int4>, thread float* Width); >+native void GetDimensions(RWTexture1D<int4>, device uint* Width); >+native void GetDimensions(RWTexture1D<int4>, device float* Width); >+native void GetDimensions(RWTexture1D<int4>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<int4>, threadgroup float* Width); >+native int4 Load(RWTexture1D<int4>, int location); >+native void Store(RWTexture1D<int4>, int4, uint location); >+ >+native void GetDimensions(RWTexture1DArray<int4>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<int4>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<int4>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<int4>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<int4>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<int4>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<int4>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<int4>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<int4>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<int4>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<int4>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<int4>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<int4>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<int4>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<int4>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<int4>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<int4>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<int4>, threadgroup float* Width, threadgroup uint* Elements); >+native int4 Load(RWTexture1DArray<int4>, int2 location); >+native void Store(RWTexture1DArray<int4>, int4, uint2 location); >+ >+native void GetDimensions(RWTexture2D<int4>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<int4>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<int4>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<int4>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<int4>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<int4>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<int4>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<int4>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<int4>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<int4>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<int4>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<int4>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<int4>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<int4>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<int4>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<int4>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<int4>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<int4>, threadgroup float* Width, threadgroup float* Height); >+native int4 Load(RWTexture2D<int4>, int2 location); >+native void Store(RWTexture2D<int4>, int4, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<int4>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<int4>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native int4 Load(RWTexture2DArray<int4>, int3 location); >+native void Store(RWTexture2DArray<int4>, int4, uint3 location); >+ >+native void GetDimensions(RWTexture3D<int4>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int4>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int4>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int4>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int4>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int4>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int4>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int4>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int4>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int4>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int4>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int4>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int4>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int4>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int4>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int4>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int4>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int4>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int4>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int4>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int4>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int4>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int4>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int4>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int4>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int4>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int4>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int4>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int4>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int4>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int4>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int4>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int4>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int4>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int4>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int4>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int4>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int4>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int4>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int4>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int4>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int4>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int4>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int4>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int4>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int4>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int4>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int4>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<int4>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<int4>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<int4>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<int4>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<int4>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<int4>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native int4 Load(RWTexture3D<int4>, int3 location); >+native void Store(RWTexture3D<int4>, int4, uint3 location); >+ >+native half Sample(Texture1D<half>, sampler, float location); >+native half Sample(Texture1D<half>, sampler, float location, int offset); >+native half Load(Texture1D<half>, int2 location); >+native half Load(Texture1D<half>, int2 location, int offset); >+native void GetDimensions(Texture1D<half>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native half Sample(Texture1DArray<half>, sampler, float2 location); >+native half Sample(Texture1DArray<half>, sampler, float2 location, int offset); >+native half Load(Texture1DArray<half>, int3 location); >+native half Load(Texture1DArray<half>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<half>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native half Sample(Texture2D<half>, sampler, float2 location); >+native half Sample(Texture2D<half>, sampler, float2 location, int2 offset); >+native half SampleBias(Texture2D<half>, sampler, float2 location, float Bias); >+native half SampleBias(Texture2D<half>, sampler, float2 location, float Bias, int2 offset); >+native half SampleGrad(Texture2D<half>, sampler, float2 location, float2 DDX, float2 DDY); >+native half SampleGrad(Texture2D<half>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native half SampleLevel(Texture2D<half>, sampler, float2 location, float LOD); >+native half SampleLevel(Texture2D<half>, sampler, float2 location, float LOD, int2 offset); >+native half4 Gather(Texture2D<half>, sampler, float2 location); >+native half4 Gather(Texture2D<half>, sampler, float2 location, int2 offset); >+native half4 GatherRed(Texture2D<half>, sampler, float2 location); >+native half4 GatherRed(Texture2D<half>, sampler, float2 location, int2 offset); >+native half Load(Texture2D<half>, int3 location); >+native half Load(Texture2D<half>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native half Sample(Texture2DArray<half>, sampler, float3 location); >+native half Sample(Texture2DArray<half>, sampler, float3 location, int2 offset); >+native half SampleBias(Texture2DArray<half>, sampler, float3 location, float Bias); >+native half SampleBias(Texture2DArray<half>, sampler, float3 location, float Bias, int2 offset); >+native half SampleGrad(Texture2DArray<half>, sampler, float3 location, float2 DDX, float2 DDY); >+native half SampleGrad(Texture2DArray<half>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native half SampleLevel(Texture2DArray<half>, sampler, float3 location, float LOD); >+native half SampleLevel(Texture2DArray<half>, sampler, float3 location, float LOD, int2 offset); >+native half4 Gather(Texture2DArray<half>, sampler, float3 location); >+native half4 Gather(Texture2DArray<half>, sampler, float3 location, int2 offset); >+native half4 GatherRed(Texture2DArray<half>, sampler, float3 location); >+native half4 GatherRed(Texture2DArray<half>, sampler, float3 location, int2 offset); >+native half Load(Texture2DArray<half>, int4 location); >+native half Load(Texture2DArray<half>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native half Sample(Texture3D<half>, sampler, float3 location); >+native half Sample(Texture3D<half>, sampler, float3 location, int3 offset); >+native half Load(Texture3D<half>, int4 location); >+native half Load(Texture3D<half>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native half Sample(TextureCube<half>, sampler, float3 location); >+native half SampleBias(TextureCube<half>, sampler, float3 location, float Bias); >+native half SampleGrad(TextureCube<half>, sampler, float3 location, float3 DDX, float3 DDY); >+native half SampleLevel(TextureCube<half>, sampler, float3 location, float LOD); >+native half4 Gather(TextureCube<half>, sampler, float3 location); >+native half4 GatherRed(TextureCube<half>, sampler, float3 location); >+native void GetDimensions(TextureCube<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<half>, thread uint* Width); >+native void GetDimensions(RWTexture1D<half>, thread float* Width); >+native void GetDimensions(RWTexture1D<half>, device uint* Width); >+native void GetDimensions(RWTexture1D<half>, device float* Width); >+native void GetDimensions(RWTexture1D<half>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<half>, threadgroup float* Width); >+native half Load(RWTexture1D<half>, int location); >+native void Store(RWTexture1D<half>, half, uint location); >+ >+native void GetDimensions(RWTexture1DArray<half>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<half>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<half>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<half>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<half>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<half>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<half>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<half>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<half>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<half>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<half>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<half>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<half>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<half>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<half>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<half>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<half>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<half>, threadgroup float* Width, threadgroup uint* Elements); >+native half Load(RWTexture1DArray<half>, int2 location); >+native void Store(RWTexture1DArray<half>, half, uint2 location); >+ >+native void GetDimensions(RWTexture2D<half>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<half>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<half>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<half>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<half>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<half>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<half>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<half>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<half>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<half>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<half>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<half>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<half>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<half>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<half>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<half>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<half>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<half>, threadgroup float* Width, threadgroup float* Height); >+native half Load(RWTexture2D<half>, int2 location); >+native void Store(RWTexture2D<half>, half, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<half>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native half Load(RWTexture2DArray<half>, int3 location); >+native void Store(RWTexture2DArray<half>, half, uint3 location); >+ >+native void GetDimensions(RWTexture3D<half>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native half Load(RWTexture3D<half>, int3 location); >+native void Store(RWTexture3D<half>, half, uint3 location); >+ >+native half2 Sample(Texture1D<half2>, sampler, float location); >+native half2 Sample(Texture1D<half2>, sampler, float location, int offset); >+native half2 Load(Texture1D<half2>, int2 location); >+native half2 Load(Texture1D<half2>, int2 location, int offset); >+native void GetDimensions(Texture1D<half2>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half2>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half2>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half2>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half2>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half2>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native half2 Sample(Texture1DArray<half2>, sampler, float2 location); >+native half2 Sample(Texture1DArray<half2>, sampler, float2 location, int offset); >+native half2 Load(Texture1DArray<half2>, int3 location); >+native half2 Load(Texture1DArray<half2>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native half2 Sample(Texture2D<half2>, sampler, float2 location); >+native half2 Sample(Texture2D<half2>, sampler, float2 location, int2 offset); >+native half2 SampleBias(Texture2D<half2>, sampler, float2 location, float Bias); >+native half2 SampleBias(Texture2D<half2>, sampler, float2 location, float Bias, int2 offset); >+native half2 SampleGrad(Texture2D<half2>, sampler, float2 location, float2 DDX, float2 DDY); >+native half2 SampleGrad(Texture2D<half2>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native half2 SampleLevel(Texture2D<half2>, sampler, float2 location, float LOD); >+native half2 SampleLevel(Texture2D<half2>, sampler, float2 location, float LOD, int2 offset); >+native half4 Gather(Texture2D<half2>, sampler, float2 location); >+native half4 Gather(Texture2D<half2>, sampler, float2 location, int2 offset); >+native half4 GatherRed(Texture2D<half2>, sampler, float2 location); >+native half4 GatherRed(Texture2D<half2>, sampler, float2 location, int2 offset); >+native half4 GatherGreen(Texture2D<half2>, sampler, float2 location); >+native half4 GatherGreen(Texture2D<half2>, sampler, float2 location, int2 offset); >+native half2 Load(Texture2D<half2>, int3 location); >+native half2 Load(Texture2D<half2>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native half2 Sample(Texture2DArray<half2>, sampler, float3 location); >+native half2 Sample(Texture2DArray<half2>, sampler, float3 location, int2 offset); >+native half2 SampleBias(Texture2DArray<half2>, sampler, float3 location, float Bias); >+native half2 SampleBias(Texture2DArray<half2>, sampler, float3 location, float Bias, int2 offset); >+native half2 SampleGrad(Texture2DArray<half2>, sampler, float3 location, float2 DDX, float2 DDY); >+native half2 SampleGrad(Texture2DArray<half2>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native half2 SampleLevel(Texture2DArray<half2>, sampler, float3 location, float LOD); >+native half2 SampleLevel(Texture2DArray<half2>, sampler, float3 location, float LOD, int2 offset); >+native half4 Gather(Texture2DArray<half2>, sampler, float3 location); >+native half4 Gather(Texture2DArray<half2>, sampler, float3 location, int2 offset); >+native half4 GatherRed(Texture2DArray<half2>, sampler, float3 location); >+native half4 GatherRed(Texture2DArray<half2>, sampler, float3 location, int2 offset); >+native half4 GatherGreen(Texture2DArray<half2>, sampler, float3 location); >+native half4 GatherGreen(Texture2DArray<half2>, sampler, float3 location, int2 offset); >+native half2 Load(Texture2DArray<half2>, int4 location); >+native half2 Load(Texture2DArray<half2>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native half2 Sample(Texture3D<half2>, sampler, float3 location); >+native half2 Sample(Texture3D<half2>, sampler, float3 location, int3 offset); >+native half2 Load(Texture3D<half2>, int4 location); >+native half2 Load(Texture3D<half2>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native half2 Sample(TextureCube<half2>, sampler, float3 location); >+native half2 SampleBias(TextureCube<half2>, sampler, float3 location, float Bias); >+native half2 SampleGrad(TextureCube<half2>, sampler, float3 location, float3 DDX, float3 DDY); >+native half2 SampleLevel(TextureCube<half2>, sampler, float3 location, float LOD); >+native half4 Gather(TextureCube<half2>, sampler, float3 location); >+native half4 GatherRed(TextureCube<half2>, sampler, float3 location); >+native half4 GatherGreen(TextureCube<half2>, sampler, float3 location); >+native void GetDimensions(TextureCube<half2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<half2>, thread uint* Width); >+native void GetDimensions(RWTexture1D<half2>, thread float* Width); >+native void GetDimensions(RWTexture1D<half2>, device uint* Width); >+native void GetDimensions(RWTexture1D<half2>, device float* Width); >+native void GetDimensions(RWTexture1D<half2>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<half2>, threadgroup float* Width); >+native half2 Load(RWTexture1D<half2>, int location); >+native void Store(RWTexture1D<half2>, half2, uint location); >+ >+native void GetDimensions(RWTexture1DArray<half2>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<half2>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<half2>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<half2>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<half2>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<half2>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<half2>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<half2>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<half2>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<half2>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<half2>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<half2>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<half2>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<half2>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<half2>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<half2>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<half2>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<half2>, threadgroup float* Width, threadgroup uint* Elements); >+native half2 Load(RWTexture1DArray<half2>, int2 location); >+native void Store(RWTexture1DArray<half2>, half2, uint2 location); >+ >+native void GetDimensions(RWTexture2D<half2>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<half2>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<half2>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<half2>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<half2>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<half2>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<half2>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<half2>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<half2>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<half2>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<half2>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<half2>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<half2>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<half2>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<half2>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<half2>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<half2>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<half2>, threadgroup float* Width, threadgroup float* Height); >+native half2 Load(RWTexture2D<half2>, int2 location); >+native void Store(RWTexture2D<half2>, half2, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<half2>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half2>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native half2 Load(RWTexture2DArray<half2>, int3 location); >+native void Store(RWTexture2DArray<half2>, half2, uint3 location); >+ >+native void GetDimensions(RWTexture3D<half2>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half2>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half2>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half2>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half2>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half2>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half2>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half2>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half2>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half2>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half2>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half2>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half2>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half2>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half2>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half2>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half2>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half2>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half2>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half2>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half2>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half2>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half2>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half2>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half2>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half2>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half2>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half2>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half2>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half2>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half2>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half2>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half2>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half2>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half2>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half2>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half2>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half2>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half2>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half2>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half2>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half2>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half2>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half2>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half2>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half2>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half2>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half2>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half2>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half2>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half2>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half2>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half2>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half2>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native half2 Load(RWTexture3D<half2>, int3 location); >+native void Store(RWTexture3D<half2>, half2, uint3 location); >+ >+native half3 Sample(Texture1D<half3>, sampler, float location); >+native half3 Sample(Texture1D<half3>, sampler, float location, int offset); >+native half3 Load(Texture1D<half3>, int2 location); >+native half3 Load(Texture1D<half3>, int2 location, int offset); >+native void GetDimensions(Texture1D<half3>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half3>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half3>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half3>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half3>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half3>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native half3 Sample(Texture1DArray<half3>, sampler, float2 location); >+native half3 Sample(Texture1DArray<half3>, sampler, float2 location, int offset); >+native half3 Load(Texture1DArray<half3>, int3 location); >+native half3 Load(Texture1DArray<half3>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native half3 Sample(Texture2D<half3>, sampler, float2 location); >+native half3 Sample(Texture2D<half3>, sampler, float2 location, int2 offset); >+native half3 SampleBias(Texture2D<half3>, sampler, float2 location, float Bias); >+native half3 SampleBias(Texture2D<half3>, sampler, float2 location, float Bias, int2 offset); >+native half3 SampleGrad(Texture2D<half3>, sampler, float2 location, float2 DDX, float2 DDY); >+native half3 SampleGrad(Texture2D<half3>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native half3 SampleLevel(Texture2D<half3>, sampler, float2 location, float LOD); >+native half3 SampleLevel(Texture2D<half3>, sampler, float2 location, float LOD, int2 offset); >+native half4 Gather(Texture2D<half3>, sampler, float2 location); >+native half4 Gather(Texture2D<half3>, sampler, float2 location, int2 offset); >+native half4 GatherRed(Texture2D<half3>, sampler, float2 location); >+native half4 GatherRed(Texture2D<half3>, sampler, float2 location, int2 offset); >+native half4 GatherGreen(Texture2D<half3>, sampler, float2 location); >+native half4 GatherGreen(Texture2D<half3>, sampler, float2 location, int2 offset); >+native half4 GatherBlue(Texture2D<half3>, sampler, float2 location); >+native half4 GatherBlue(Texture2D<half3>, sampler, float2 location, int2 offset); >+native half3 Load(Texture2D<half3>, int3 location); >+native half3 Load(Texture2D<half3>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native half3 Sample(Texture2DArray<half3>, sampler, float3 location); >+native half3 Sample(Texture2DArray<half3>, sampler, float3 location, int2 offset); >+native half3 SampleBias(Texture2DArray<half3>, sampler, float3 location, float Bias); >+native half3 SampleBias(Texture2DArray<half3>, sampler, float3 location, float Bias, int2 offset); >+native half3 SampleGrad(Texture2DArray<half3>, sampler, float3 location, float2 DDX, float2 DDY); >+native half3 SampleGrad(Texture2DArray<half3>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native half3 SampleLevel(Texture2DArray<half3>, sampler, float3 location, float LOD); >+native half3 SampleLevel(Texture2DArray<half3>, sampler, float3 location, float LOD, int2 offset); >+native half4 Gather(Texture2DArray<half3>, sampler, float3 location); >+native half4 Gather(Texture2DArray<half3>, sampler, float3 location, int2 offset); >+native half4 GatherRed(Texture2DArray<half3>, sampler, float3 location); >+native half4 GatherRed(Texture2DArray<half3>, sampler, float3 location, int2 offset); >+native half4 GatherGreen(Texture2DArray<half3>, sampler, float3 location); >+native half4 GatherGreen(Texture2DArray<half3>, sampler, float3 location, int2 offset); >+native half4 GatherBlue(Texture2DArray<half3>, sampler, float3 location); >+native half4 GatherBlue(Texture2DArray<half3>, sampler, float3 location, int2 offset); >+native half3 Load(Texture2DArray<half3>, int4 location); >+native half3 Load(Texture2DArray<half3>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native half3 Sample(Texture3D<half3>, sampler, float3 location); >+native half3 Sample(Texture3D<half3>, sampler, float3 location, int3 offset); >+native half3 Load(Texture3D<half3>, int4 location); >+native half3 Load(Texture3D<half3>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native half3 Sample(TextureCube<half3>, sampler, float3 location); >+native half3 SampleBias(TextureCube<half3>, sampler, float3 location, float Bias); >+native half3 SampleGrad(TextureCube<half3>, sampler, float3 location, float3 DDX, float3 DDY); >+native half3 SampleLevel(TextureCube<half3>, sampler, float3 location, float LOD); >+native half4 Gather(TextureCube<half3>, sampler, float3 location); >+native half4 GatherRed(TextureCube<half3>, sampler, float3 location); >+native half4 GatherGreen(TextureCube<half3>, sampler, float3 location); >+native half4 GatherBlue(TextureCube<half3>, sampler, float3 location); >+native void GetDimensions(TextureCube<half3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<half3>, thread uint* Width); >+native void GetDimensions(RWTexture1D<half3>, thread float* Width); >+native void GetDimensions(RWTexture1D<half3>, device uint* Width); >+native void GetDimensions(RWTexture1D<half3>, device float* Width); >+native void GetDimensions(RWTexture1D<half3>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<half3>, threadgroup float* Width); >+native half3 Load(RWTexture1D<half3>, int location); >+native void Store(RWTexture1D<half3>, half3, uint location); >+ >+native void GetDimensions(RWTexture1DArray<half3>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<half3>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<half3>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<half3>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<half3>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<half3>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<half3>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<half3>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<half3>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<half3>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<half3>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<half3>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<half3>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<half3>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<half3>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<half3>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<half3>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<half3>, threadgroup float* Width, threadgroup uint* Elements); >+native half3 Load(RWTexture1DArray<half3>, int2 location); >+native void Store(RWTexture1DArray<half3>, half3, uint2 location); >+ >+native void GetDimensions(RWTexture2D<half3>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<half3>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<half3>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<half3>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<half3>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<half3>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<half3>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<half3>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<half3>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<half3>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<half3>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<half3>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<half3>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<half3>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<half3>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<half3>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<half3>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<half3>, threadgroup float* Width, threadgroup float* Height); >+native half3 Load(RWTexture2D<half3>, int2 location); >+native void Store(RWTexture2D<half3>, half3, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<half3>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half3>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native half3 Load(RWTexture2DArray<half3>, int3 location); >+native void Store(RWTexture2DArray<half3>, half3, uint3 location); >+ >+native void GetDimensions(RWTexture3D<half3>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half3>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half3>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half3>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half3>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half3>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half3>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half3>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half3>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half3>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half3>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half3>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half3>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half3>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half3>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half3>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half3>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half3>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half3>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half3>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half3>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half3>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half3>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half3>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half3>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half3>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half3>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half3>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half3>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half3>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half3>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half3>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half3>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half3>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half3>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half3>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half3>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half3>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half3>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half3>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half3>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half3>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half3>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half3>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half3>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half3>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half3>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half3>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half3>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half3>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half3>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half3>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half3>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half3>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native half3 Load(RWTexture3D<half3>, int3 location); >+native void Store(RWTexture3D<half3>, half3, uint3 location); >+ >+native half4 Sample(Texture1D<half4>, sampler, float location); >+native half4 Sample(Texture1D<half4>, sampler, float location, int offset); >+native half4 Load(Texture1D<half4>, int2 location); >+native half4 Load(Texture1D<half4>, int2 location, int offset); >+native void GetDimensions(Texture1D<half4>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half4>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half4>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half4>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half4>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half4>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native half4 Sample(Texture1DArray<half4>, sampler, float2 location); >+native half4 Sample(Texture1DArray<half4>, sampler, float2 location, int offset); >+native half4 Load(Texture1DArray<half4>, int3 location); >+native half4 Load(Texture1DArray<half4>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native half4 Sample(Texture2D<half4>, sampler, float2 location); >+native half4 Sample(Texture2D<half4>, sampler, float2 location, int2 offset); >+native half4 SampleBias(Texture2D<half4>, sampler, float2 location, float Bias); >+native half4 SampleBias(Texture2D<half4>, sampler, float2 location, float Bias, int2 offset); >+native half4 SampleGrad(Texture2D<half4>, sampler, float2 location, float2 DDX, float2 DDY); >+native half4 SampleGrad(Texture2D<half4>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native half4 SampleLevel(Texture2D<half4>, sampler, float2 location, float LOD); >+native half4 SampleLevel(Texture2D<half4>, sampler, float2 location, float LOD, int2 offset); >+native half4 Gather(Texture2D<half4>, sampler, float2 location); >+native half4 Gather(Texture2D<half4>, sampler, float2 location, int2 offset); >+native half4 GatherRed(Texture2D<half4>, sampler, float2 location); >+native half4 GatherRed(Texture2D<half4>, sampler, float2 location, int2 offset); >+native half4 GatherGreen(Texture2D<half4>, sampler, float2 location); >+native half4 GatherGreen(Texture2D<half4>, sampler, float2 location, int2 offset); >+native half4 GatherBlue(Texture2D<half4>, sampler, float2 location); >+native half4 GatherBlue(Texture2D<half4>, sampler, float2 location, int2 offset); >+native half4 GatherAlpha(Texture2D<half4>, sampler, float2 location); >+native half4 GatherAlpha(Texture2D<half4>, sampler, float2 location, int2 offset); >+native half4 Load(Texture2D<half4>, int3 location); >+native half4 Load(Texture2D<half4>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native half4 Sample(Texture2DArray<half4>, sampler, float3 location); >+native half4 Sample(Texture2DArray<half4>, sampler, float3 location, int2 offset); >+native half4 SampleBias(Texture2DArray<half4>, sampler, float3 location, float Bias); >+native half4 SampleBias(Texture2DArray<half4>, sampler, float3 location, float Bias, int2 offset); >+native half4 SampleGrad(Texture2DArray<half4>, sampler, float3 location, float2 DDX, float2 DDY); >+native half4 SampleGrad(Texture2DArray<half4>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native half4 SampleLevel(Texture2DArray<half4>, sampler, float3 location, float LOD); >+native half4 SampleLevel(Texture2DArray<half4>, sampler, float3 location, float LOD, int2 offset); >+native half4 Gather(Texture2DArray<half4>, sampler, float3 location); >+native half4 Gather(Texture2DArray<half4>, sampler, float3 location, int2 offset); >+native half4 GatherRed(Texture2DArray<half4>, sampler, float3 location); >+native half4 GatherRed(Texture2DArray<half4>, sampler, float3 location, int2 offset); >+native half4 GatherGreen(Texture2DArray<half4>, sampler, float3 location); >+native half4 GatherGreen(Texture2DArray<half4>, sampler, float3 location, int2 offset); >+native half4 GatherBlue(Texture2DArray<half4>, sampler, float3 location); >+native half4 GatherBlue(Texture2DArray<half4>, sampler, float3 location, int2 offset); >+native half4 GatherAlpha(Texture2DArray<half4>, sampler, float3 location); >+native half4 GatherAlpha(Texture2DArray<half4>, sampler, float3 location, int2 offset); >+native half4 Load(Texture2DArray<half4>, int4 location); >+native half4 Load(Texture2DArray<half4>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native half4 Sample(Texture3D<half4>, sampler, float3 location); >+native half4 Sample(Texture3D<half4>, sampler, float3 location, int3 offset); >+native half4 Load(Texture3D<half4>, int4 location); >+native half4 Load(Texture3D<half4>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native half4 Sample(TextureCube<half4>, sampler, float3 location); >+native half4 SampleBias(TextureCube<half4>, sampler, float3 location, float Bias); >+native half4 SampleGrad(TextureCube<half4>, sampler, float3 location, float3 DDX, float3 DDY); >+native half4 SampleLevel(TextureCube<half4>, sampler, float3 location, float LOD); >+native half4 Gather(TextureCube<half4>, sampler, float3 location); >+native half4 GatherRed(TextureCube<half4>, sampler, float3 location); >+native half4 GatherGreen(TextureCube<half4>, sampler, float3 location); >+native half4 GatherBlue(TextureCube<half4>, sampler, float3 location); >+native half4 GatherAlpha(TextureCube<half4>, sampler, float3 location); >+native void GetDimensions(TextureCube<half4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<half4>, thread uint* Width); >+native void GetDimensions(RWTexture1D<half4>, thread float* Width); >+native void GetDimensions(RWTexture1D<half4>, device uint* Width); >+native void GetDimensions(RWTexture1D<half4>, device float* Width); >+native void GetDimensions(RWTexture1D<half4>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<half4>, threadgroup float* Width); >+native half4 Load(RWTexture1D<half4>, int location); >+native void Store(RWTexture1D<half4>, half4, uint location); >+ >+native void GetDimensions(RWTexture1DArray<half4>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<half4>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<half4>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<half4>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<half4>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<half4>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<half4>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<half4>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<half4>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<half4>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<half4>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<half4>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<half4>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<half4>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<half4>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<half4>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<half4>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<half4>, threadgroup float* Width, threadgroup uint* Elements); >+native half4 Load(RWTexture1DArray<half4>, int2 location); >+native void Store(RWTexture1DArray<half4>, half4, uint2 location); >+ >+native void GetDimensions(RWTexture2D<half4>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<half4>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<half4>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<half4>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<half4>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<half4>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<half4>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<half4>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<half4>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<half4>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<half4>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<half4>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<half4>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<half4>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<half4>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<half4>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<half4>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<half4>, threadgroup float* Width, threadgroup float* Height); >+native half4 Load(RWTexture2D<half4>, int2 location); >+native void Store(RWTexture2D<half4>, half4, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<half4>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<half4>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native half4 Load(RWTexture2DArray<half4>, int3 location); >+native void Store(RWTexture2DArray<half4>, half4, uint3 location); >+ >+native void GetDimensions(RWTexture3D<half4>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half4>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half4>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half4>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half4>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half4>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half4>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half4>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half4>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half4>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half4>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half4>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half4>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half4>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half4>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half4>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half4>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half4>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half4>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half4>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half4>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half4>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half4>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half4>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half4>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half4>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half4>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half4>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half4>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half4>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half4>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half4>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half4>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half4>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half4>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half4>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half4>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half4>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half4>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half4>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half4>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half4>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half4>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half4>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half4>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half4>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half4>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half4>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<half4>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<half4>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<half4>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<half4>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<half4>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<half4>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native half4 Load(RWTexture3D<half4>, int3 location); >+native void Store(RWTexture3D<half4>, half4, uint3 location); >+ >+native float Sample(Texture1D<float>, sampler, float location); >+native float Sample(Texture1D<float>, sampler, float location, int offset); >+native float Load(Texture1D<float>, int2 location); >+native float Load(Texture1D<float>, int2 location, int offset); >+native void GetDimensions(Texture1D<float>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native float Sample(Texture1DArray<float>, sampler, float2 location); >+native float Sample(Texture1DArray<float>, sampler, float2 location, int offset); >+native float Load(Texture1DArray<float>, int3 location); >+native float Load(Texture1DArray<float>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<float>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native float Sample(Texture2D<float>, sampler, float2 location); >+native float Sample(Texture2D<float>, sampler, float2 location, int2 offset); >+native float SampleBias(Texture2D<float>, sampler, float2 location, float Bias); >+native float SampleBias(Texture2D<float>, sampler, float2 location, float Bias, int2 offset); >+native float SampleGrad(Texture2D<float>, sampler, float2 location, float2 DDX, float2 DDY); >+native float SampleGrad(Texture2D<float>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native float SampleLevel(Texture2D<float>, sampler, float2 location, float LOD); >+native float SampleLevel(Texture2D<float>, sampler, float2 location, float LOD, int2 offset); >+native float4 Gather(Texture2D<float>, sampler, float2 location); >+native float4 Gather(Texture2D<float>, sampler, float2 location, int2 offset); >+native float4 GatherRed(Texture2D<float>, sampler, float2 location); >+native float4 GatherRed(Texture2D<float>, sampler, float2 location, int2 offset); >+native float Load(Texture2D<float>, int3 location); >+native float Load(Texture2D<float>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native float Sample(Texture2DArray<float>, sampler, float3 location); >+native float Sample(Texture2DArray<float>, sampler, float3 location, int2 offset); >+native float SampleBias(Texture2DArray<float>, sampler, float3 location, float Bias); >+native float SampleBias(Texture2DArray<float>, sampler, float3 location, float Bias, int2 offset); >+native float SampleGrad(Texture2DArray<float>, sampler, float3 location, float2 DDX, float2 DDY); >+native float SampleGrad(Texture2DArray<float>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native float SampleLevel(Texture2DArray<float>, sampler, float3 location, float LOD); >+native float SampleLevel(Texture2DArray<float>, sampler, float3 location, float LOD, int2 offset); >+native float4 Gather(Texture2DArray<float>, sampler, float3 location); >+native float4 Gather(Texture2DArray<float>, sampler, float3 location, int2 offset); >+native float4 GatherRed(Texture2DArray<float>, sampler, float3 location); >+native float4 GatherRed(Texture2DArray<float>, sampler, float3 location, int2 offset); >+native float Load(Texture2DArray<float>, int4 location); >+native float Load(Texture2DArray<float>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native float Sample(Texture3D<float>, sampler, float3 location); >+native float Sample(Texture3D<float>, sampler, float3 location, int3 offset); >+native float Load(Texture3D<float>, int4 location); >+native float Load(Texture3D<float>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native float Sample(TextureCube<float>, sampler, float3 location); >+native float SampleBias(TextureCube<float>, sampler, float3 location, float Bias); >+native float SampleGrad(TextureCube<float>, sampler, float3 location, float3 DDX, float3 DDY); >+native float SampleLevel(TextureCube<float>, sampler, float3 location, float LOD); >+native float4 Gather(TextureCube<float>, sampler, float3 location); >+native float4 GatherRed(TextureCube<float>, sampler, float3 location); >+native void GetDimensions(TextureCube<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<float>, thread uint* Width); >+native void GetDimensions(RWTexture1D<float>, thread float* Width); >+native void GetDimensions(RWTexture1D<float>, device uint* Width); >+native void GetDimensions(RWTexture1D<float>, device float* Width); >+native void GetDimensions(RWTexture1D<float>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<float>, threadgroup float* Width); >+native float Load(RWTexture1D<float>, int location); >+native void Store(RWTexture1D<float>, float, uint location); >+ >+native void GetDimensions(RWTexture1DArray<float>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<float>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<float>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<float>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<float>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<float>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<float>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<float>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<float>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<float>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<float>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<float>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<float>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<float>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<float>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<float>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<float>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<float>, threadgroup float* Width, threadgroup uint* Elements); >+native float Load(RWTexture1DArray<float>, int2 location); >+native void Store(RWTexture1DArray<float>, float, uint2 location); >+ >+native void GetDimensions(RWTexture2D<float>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<float>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<float>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<float>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<float>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<float>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<float>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<float>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<float>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<float>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<float>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<float>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<float>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<float>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<float>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<float>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<float>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<float>, threadgroup float* Width, threadgroup float* Height); >+native float Load(RWTexture2D<float>, int2 location); >+native void Store(RWTexture2D<float>, float, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<float>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native float Load(RWTexture2DArray<float>, int3 location); >+native void Store(RWTexture2DArray<float>, float, uint3 location); >+ >+native void GetDimensions(RWTexture3D<float>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native float Load(RWTexture3D<float>, int3 location); >+native void Store(RWTexture3D<float>, float, uint3 location); >+ >+native float2 Sample(Texture1D<float2>, sampler, float location); >+native float2 Sample(Texture1D<float2>, sampler, float location, int offset); >+native float2 Load(Texture1D<float2>, int2 location); >+native float2 Load(Texture1D<float2>, int2 location, int offset); >+native void GetDimensions(Texture1D<float2>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float2>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float2>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float2>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float2>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float2>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native float2 Sample(Texture1DArray<float2>, sampler, float2 location); >+native float2 Sample(Texture1DArray<float2>, sampler, float2 location, int offset); >+native float2 Load(Texture1DArray<float2>, int3 location); >+native float2 Load(Texture1DArray<float2>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native float2 Sample(Texture2D<float2>, sampler, float2 location); >+native float2 Sample(Texture2D<float2>, sampler, float2 location, int2 offset); >+native float2 SampleBias(Texture2D<float2>, sampler, float2 location, float Bias); >+native float2 SampleBias(Texture2D<float2>, sampler, float2 location, float Bias, int2 offset); >+native float2 SampleGrad(Texture2D<float2>, sampler, float2 location, float2 DDX, float2 DDY); >+native float2 SampleGrad(Texture2D<float2>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native float2 SampleLevel(Texture2D<float2>, sampler, float2 location, float LOD); >+native float2 SampleLevel(Texture2D<float2>, sampler, float2 location, float LOD, int2 offset); >+native float4 Gather(Texture2D<float2>, sampler, float2 location); >+native float4 Gather(Texture2D<float2>, sampler, float2 location, int2 offset); >+native float4 GatherRed(Texture2D<float2>, sampler, float2 location); >+native float4 GatherRed(Texture2D<float2>, sampler, float2 location, int2 offset); >+native float4 GatherGreen(Texture2D<float2>, sampler, float2 location); >+native float4 GatherGreen(Texture2D<float2>, sampler, float2 location, int2 offset); >+native float2 Load(Texture2D<float2>, int3 location); >+native float2 Load(Texture2D<float2>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native float2 Sample(Texture2DArray<float2>, sampler, float3 location); >+native float2 Sample(Texture2DArray<float2>, sampler, float3 location, int2 offset); >+native float2 SampleBias(Texture2DArray<float2>, sampler, float3 location, float Bias); >+native float2 SampleBias(Texture2DArray<float2>, sampler, float3 location, float Bias, int2 offset); >+native float2 SampleGrad(Texture2DArray<float2>, sampler, float3 location, float2 DDX, float2 DDY); >+native float2 SampleGrad(Texture2DArray<float2>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native float2 SampleLevel(Texture2DArray<float2>, sampler, float3 location, float LOD); >+native float2 SampleLevel(Texture2DArray<float2>, sampler, float3 location, float LOD, int2 offset); >+native float4 Gather(Texture2DArray<float2>, sampler, float3 location); >+native float4 Gather(Texture2DArray<float2>, sampler, float3 location, int2 offset); >+native float4 GatherRed(Texture2DArray<float2>, sampler, float3 location); >+native float4 GatherRed(Texture2DArray<float2>, sampler, float3 location, int2 offset); >+native float4 GatherGreen(Texture2DArray<float2>, sampler, float3 location); >+native float4 GatherGreen(Texture2DArray<float2>, sampler, float3 location, int2 offset); >+native float2 Load(Texture2DArray<float2>, int4 location); >+native float2 Load(Texture2DArray<float2>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native float2 Sample(Texture3D<float2>, sampler, float3 location); >+native float2 Sample(Texture3D<float2>, sampler, float3 location, int3 offset); >+native float2 Load(Texture3D<float2>, int4 location); >+native float2 Load(Texture3D<float2>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native float2 Sample(TextureCube<float2>, sampler, float3 location); >+native float2 SampleBias(TextureCube<float2>, sampler, float3 location, float Bias); >+native float2 SampleGrad(TextureCube<float2>, sampler, float3 location, float3 DDX, float3 DDY); >+native float2 SampleLevel(TextureCube<float2>, sampler, float3 location, float LOD); >+native float4 Gather(TextureCube<float2>, sampler, float3 location); >+native float4 GatherRed(TextureCube<float2>, sampler, float3 location); >+native float4 GatherGreen(TextureCube<float2>, sampler, float3 location); >+native void GetDimensions(TextureCube<float2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<float2>, thread uint* Width); >+native void GetDimensions(RWTexture1D<float2>, thread float* Width); >+native void GetDimensions(RWTexture1D<float2>, device uint* Width); >+native void GetDimensions(RWTexture1D<float2>, device float* Width); >+native void GetDimensions(RWTexture1D<float2>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<float2>, threadgroup float* Width); >+native float2 Load(RWTexture1D<float2>, int location); >+native void Store(RWTexture1D<float2>, float2, uint location); >+ >+native void GetDimensions(RWTexture1DArray<float2>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<float2>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<float2>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<float2>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<float2>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<float2>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<float2>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<float2>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<float2>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<float2>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<float2>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<float2>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<float2>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<float2>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<float2>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<float2>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<float2>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<float2>, threadgroup float* Width, threadgroup uint* Elements); >+native float2 Load(RWTexture1DArray<float2>, int2 location); >+native void Store(RWTexture1DArray<float2>, float2, uint2 location); >+ >+native void GetDimensions(RWTexture2D<float2>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<float2>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<float2>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<float2>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<float2>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<float2>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<float2>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<float2>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<float2>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<float2>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<float2>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<float2>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<float2>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<float2>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<float2>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<float2>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<float2>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<float2>, threadgroup float* Width, threadgroup float* Height); >+native float2 Load(RWTexture2D<float2>, int2 location); >+native void Store(RWTexture2D<float2>, float2, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<float2>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float2>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native float2 Load(RWTexture2DArray<float2>, int3 location); >+native void Store(RWTexture2DArray<float2>, float2, uint3 location); >+ >+native void GetDimensions(RWTexture3D<float2>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float2>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float2>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float2>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float2>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float2>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float2>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float2>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float2>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float2>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float2>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float2>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float2>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float2>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float2>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float2>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float2>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float2>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float2>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float2>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float2>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float2>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float2>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float2>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float2>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float2>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float2>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float2>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float2>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float2>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float2>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float2>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float2>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float2>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float2>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float2>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float2>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float2>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float2>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float2>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float2>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float2>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float2>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float2>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float2>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float2>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float2>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float2>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float2>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float2>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float2>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float2>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float2>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float2>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native float2 Load(RWTexture3D<float2>, int3 location); >+native void Store(RWTexture3D<float2>, float2, uint3 location); >+ >+native float3 Sample(Texture1D<float3>, sampler, float location); >+native float3 Sample(Texture1D<float3>, sampler, float location, int offset); >+native float3 Load(Texture1D<float3>, int2 location); >+native float3 Load(Texture1D<float3>, int2 location, int offset); >+native void GetDimensions(Texture1D<float3>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float3>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float3>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float3>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float3>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float3>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native float3 Sample(Texture1DArray<float3>, sampler, float2 location); >+native float3 Sample(Texture1DArray<float3>, sampler, float2 location, int offset); >+native float3 Load(Texture1DArray<float3>, int3 location); >+native float3 Load(Texture1DArray<float3>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native float3 Sample(Texture2D<float3>, sampler, float2 location); >+native float3 Sample(Texture2D<float3>, sampler, float2 location, int2 offset); >+native float3 SampleBias(Texture2D<float3>, sampler, float2 location, float Bias); >+native float3 SampleBias(Texture2D<float3>, sampler, float2 location, float Bias, int2 offset); >+native float3 SampleGrad(Texture2D<float3>, sampler, float2 location, float2 DDX, float2 DDY); >+native float3 SampleGrad(Texture2D<float3>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native float3 SampleLevel(Texture2D<float3>, sampler, float2 location, float LOD); >+native float3 SampleLevel(Texture2D<float3>, sampler, float2 location, float LOD, int2 offset); >+native float4 Gather(Texture2D<float3>, sampler, float2 location); >+native float4 Gather(Texture2D<float3>, sampler, float2 location, int2 offset); >+native float4 GatherRed(Texture2D<float3>, sampler, float2 location); >+native float4 GatherRed(Texture2D<float3>, sampler, float2 location, int2 offset); >+native float4 GatherGreen(Texture2D<float3>, sampler, float2 location); >+native float4 GatherGreen(Texture2D<float3>, sampler, float2 location, int2 offset); >+native float4 GatherBlue(Texture2D<float3>, sampler, float2 location); >+native float4 GatherBlue(Texture2D<float3>, sampler, float2 location, int2 offset); >+native float3 Load(Texture2D<float3>, int3 location); >+native float3 Load(Texture2D<float3>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native float3 Sample(Texture2DArray<float3>, sampler, float3 location); >+native float3 Sample(Texture2DArray<float3>, sampler, float3 location, int2 offset); >+native float3 SampleBias(Texture2DArray<float3>, sampler, float3 location, float Bias); >+native float3 SampleBias(Texture2DArray<float3>, sampler, float3 location, float Bias, int2 offset); >+native float3 SampleGrad(Texture2DArray<float3>, sampler, float3 location, float2 DDX, float2 DDY); >+native float3 SampleGrad(Texture2DArray<float3>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native float3 SampleLevel(Texture2DArray<float3>, sampler, float3 location, float LOD); >+native float3 SampleLevel(Texture2DArray<float3>, sampler, float3 location, float LOD, int2 offset); >+native float4 Gather(Texture2DArray<float3>, sampler, float3 location); >+native float4 Gather(Texture2DArray<float3>, sampler, float3 location, int2 offset); >+native float4 GatherRed(Texture2DArray<float3>, sampler, float3 location); >+native float4 GatherRed(Texture2DArray<float3>, sampler, float3 location, int2 offset); >+native float4 GatherGreen(Texture2DArray<float3>, sampler, float3 location); >+native float4 GatherGreen(Texture2DArray<float3>, sampler, float3 location, int2 offset); >+native float4 GatherBlue(Texture2DArray<float3>, sampler, float3 location); >+native float4 GatherBlue(Texture2DArray<float3>, sampler, float3 location, int2 offset); >+native float3 Load(Texture2DArray<float3>, int4 location); >+native float3 Load(Texture2DArray<float3>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native float3 Sample(Texture3D<float3>, sampler, float3 location); >+native float3 Sample(Texture3D<float3>, sampler, float3 location, int3 offset); >+native float3 Load(Texture3D<float3>, int4 location); >+native float3 Load(Texture3D<float3>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native float3 Sample(TextureCube<float3>, sampler, float3 location); >+native float3 SampleBias(TextureCube<float3>, sampler, float3 location, float Bias); >+native float3 SampleGrad(TextureCube<float3>, sampler, float3 location, float3 DDX, float3 DDY); >+native float3 SampleLevel(TextureCube<float3>, sampler, float3 location, float LOD); >+native float4 Gather(TextureCube<float3>, sampler, float3 location); >+native float4 GatherRed(TextureCube<float3>, sampler, float3 location); >+native float4 GatherGreen(TextureCube<float3>, sampler, float3 location); >+native float4 GatherBlue(TextureCube<float3>, sampler, float3 location); >+native void GetDimensions(TextureCube<float3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<float3>, thread uint* Width); >+native void GetDimensions(RWTexture1D<float3>, thread float* Width); >+native void GetDimensions(RWTexture1D<float3>, device uint* Width); >+native void GetDimensions(RWTexture1D<float3>, device float* Width); >+native void GetDimensions(RWTexture1D<float3>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<float3>, threadgroup float* Width); >+native float3 Load(RWTexture1D<float3>, int location); >+native void Store(RWTexture1D<float3>, float3, uint location); >+ >+native void GetDimensions(RWTexture1DArray<float3>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<float3>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<float3>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<float3>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<float3>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<float3>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<float3>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<float3>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<float3>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<float3>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<float3>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<float3>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<float3>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<float3>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<float3>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<float3>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<float3>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<float3>, threadgroup float* Width, threadgroup uint* Elements); >+native float3 Load(RWTexture1DArray<float3>, int2 location); >+native void Store(RWTexture1DArray<float3>, float3, uint2 location); >+ >+native void GetDimensions(RWTexture2D<float3>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<float3>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<float3>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<float3>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<float3>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<float3>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<float3>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<float3>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<float3>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<float3>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<float3>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<float3>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<float3>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<float3>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<float3>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<float3>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<float3>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<float3>, threadgroup float* Width, threadgroup float* Height); >+native float3 Load(RWTexture2D<float3>, int2 location); >+native void Store(RWTexture2D<float3>, float3, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<float3>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float3>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native float3 Load(RWTexture2DArray<float3>, int3 location); >+native void Store(RWTexture2DArray<float3>, float3, uint3 location); >+ >+native void GetDimensions(RWTexture3D<float3>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float3>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float3>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float3>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float3>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float3>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float3>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float3>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float3>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float3>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float3>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float3>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float3>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float3>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float3>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float3>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float3>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float3>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float3>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float3>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float3>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float3>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float3>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float3>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float3>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float3>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float3>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float3>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float3>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float3>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float3>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float3>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float3>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float3>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float3>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float3>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float3>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float3>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float3>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float3>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float3>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float3>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float3>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float3>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float3>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float3>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float3>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float3>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float3>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float3>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float3>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float3>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float3>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float3>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native float3 Load(RWTexture3D<float3>, int3 location); >+native void Store(RWTexture3D<float3>, float3, uint3 location); >+ >+native float4 Sample(Texture1D<float4>, sampler, float location); >+native float4 Sample(Texture1D<float4>, sampler, float location, int offset); >+native float4 Load(Texture1D<float4>, int2 location); >+native float4 Load(Texture1D<float4>, int2 location, int offset); >+native void GetDimensions(Texture1D<float4>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float4>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float4>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float4>, uint MipLevel, device uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float4>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float4>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels); >+native void GetDimensions(Texture1D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels); >+ >+native float4 Sample(Texture1DArray<float4>, sampler, float2 location); >+native float4 Sample(Texture1DArray<float4>, sampler, float2 location, int offset); >+native float4 Load(Texture1DArray<float4>, int3 location); >+native float4 Load(Texture1DArray<float4>, int3 location, int offset); >+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native float4 Sample(Texture2D<float4>, sampler, float2 location); >+native float4 Sample(Texture2D<float4>, sampler, float2 location, int2 offset); >+native float4 SampleBias(Texture2D<float4>, sampler, float2 location, float Bias); >+native float4 SampleBias(Texture2D<float4>, sampler, float2 location, float Bias, int2 offset); >+native float4 SampleGrad(Texture2D<float4>, sampler, float2 location, float2 DDX, float2 DDY); >+native float4 SampleGrad(Texture2D<float4>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native float4 SampleLevel(Texture2D<float4>, sampler, float2 location, float LOD); >+native float4 SampleLevel(Texture2D<float4>, sampler, float2 location, float LOD, int2 offset); >+native float4 Gather(Texture2D<float4>, sampler, float2 location); >+native float4 Gather(Texture2D<float4>, sampler, float2 location, int2 offset); >+native float4 GatherRed(Texture2D<float4>, sampler, float2 location); >+native float4 GatherRed(Texture2D<float4>, sampler, float2 location, int2 offset); >+native float4 GatherGreen(Texture2D<float4>, sampler, float2 location); >+native float4 GatherGreen(Texture2D<float4>, sampler, float2 location, int2 offset); >+native float4 GatherBlue(Texture2D<float4>, sampler, float2 location); >+native float4 GatherBlue(Texture2D<float4>, sampler, float2 location, int2 offset); >+native float4 GatherAlpha(Texture2D<float4>, sampler, float2 location); >+native float4 GatherAlpha(Texture2D<float4>, sampler, float2 location, int2 offset); >+native float4 Load(Texture2D<float4>, int3 location); >+native float4 Load(Texture2D<float4>, int3 location, int2 offset); >+native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native float4 Sample(Texture2DArray<float4>, sampler, float3 location); >+native float4 Sample(Texture2DArray<float4>, sampler, float3 location, int2 offset); >+native float4 SampleBias(Texture2DArray<float4>, sampler, float3 location, float Bias); >+native float4 SampleBias(Texture2DArray<float4>, sampler, float3 location, float Bias, int2 offset); >+native float4 SampleGrad(Texture2DArray<float4>, sampler, float3 location, float2 DDX, float2 DDY); >+native float4 SampleGrad(Texture2DArray<float4>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native float4 SampleLevel(Texture2DArray<float4>, sampler, float3 location, float LOD); >+native float4 SampleLevel(Texture2DArray<float4>, sampler, float3 location, float LOD, int2 offset); >+native float4 Gather(Texture2DArray<float4>, sampler, float3 location); >+native float4 Gather(Texture2DArray<float4>, sampler, float3 location, int2 offset); >+native float4 GatherRed(Texture2DArray<float4>, sampler, float3 location); >+native float4 GatherRed(Texture2DArray<float4>, sampler, float3 location, int2 offset); >+native float4 GatherGreen(Texture2DArray<float4>, sampler, float3 location); >+native float4 GatherGreen(Texture2DArray<float4>, sampler, float3 location, int2 offset); >+native float4 GatherBlue(Texture2DArray<float4>, sampler, float3 location); >+native float4 GatherBlue(Texture2DArray<float4>, sampler, float3 location, int2 offset); >+native float4 GatherAlpha(Texture2DArray<float4>, sampler, float3 location); >+native float4 GatherAlpha(Texture2DArray<float4>, sampler, float3 location, int2 offset); >+native float4 Load(Texture2DArray<float4>, int4 location); >+native float4 Load(Texture2DArray<float4>, int4 location, int2 offset); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native float4 Sample(Texture3D<float4>, sampler, float3 location); >+native float4 Sample(Texture3D<float4>, sampler, float3 location, int3 offset); >+native float4 Load(Texture3D<float4>, int4 location); >+native float4 Load(Texture3D<float4>, int4 location, int3 offset); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels); >+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels); >+ >+native float4 Sample(TextureCube<float4>, sampler, float3 location); >+native float4 SampleBias(TextureCube<float4>, sampler, float3 location, float Bias); >+native float4 SampleGrad(TextureCube<float4>, sampler, float3 location, float3 DDX, float3 DDY); >+native float4 SampleLevel(TextureCube<float4>, sampler, float3 location, float LOD); >+native float4 Gather(TextureCube<float4>, sampler, float3 location); >+native float4 GatherRed(TextureCube<float4>, sampler, float3 location); >+native float4 GatherGreen(TextureCube<float4>, sampler, float3 location); >+native float4 GatherBlue(TextureCube<float4>, sampler, float3 location); >+native float4 GatherAlpha(TextureCube<float4>, sampler, float3 location); >+native void GetDimensions(TextureCube<float4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureCube<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTexture1D<float4>, thread uint* Width); >+native void GetDimensions(RWTexture1D<float4>, thread float* Width); >+native void GetDimensions(RWTexture1D<float4>, device uint* Width); >+native void GetDimensions(RWTexture1D<float4>, device float* Width); >+native void GetDimensions(RWTexture1D<float4>, threadgroup uint* Width); >+native void GetDimensions(RWTexture1D<float4>, threadgroup float* Width); >+native float4 Load(RWTexture1D<float4>, int location); >+native void Store(RWTexture1D<float4>, float4, uint location); >+ >+native void GetDimensions(RWTexture1DArray<float4>, thread uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<float4>, thread float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<float4>, thread uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<float4>, thread float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<float4>, thread uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<float4>, thread float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<float4>, device uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<float4>, device float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<float4>, device uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<float4>, device float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<float4>, device uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<float4>, device float* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<float4>, threadgroup uint* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<float4>, threadgroup float* Width, thread uint* Elements); >+native void GetDimensions(RWTexture1DArray<float4>, threadgroup uint* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<float4>, threadgroup float* Width, device uint* Elements); >+native void GetDimensions(RWTexture1DArray<float4>, threadgroup uint* Width, threadgroup uint* Elements); >+native void GetDimensions(RWTexture1DArray<float4>, threadgroup float* Width, threadgroup uint* Elements); >+native float4 Load(RWTexture1DArray<float4>, int2 location); >+native void Store(RWTexture1DArray<float4>, float4, uint2 location); >+ >+native void GetDimensions(RWTexture2D<float4>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<float4>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<float4>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<float4>, thread float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<float4>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<float4>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<float4>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<float4>, device float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<float4>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<float4>, device float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<float4>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<float4>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTexture2D<float4>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTexture2D<float4>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTexture2D<float4>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTexture2D<float4>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTexture2D<float4>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTexture2D<float4>, threadgroup float* Width, threadgroup float* Height); >+native float4 Load(RWTexture2D<float4>, int2 location); >+native void Store(RWTexture2D<float4>, float4, uint2 location); >+ >+native void GetDimensions(RWTexture2DArray<float4>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTexture2DArray<float4>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native float4 Load(RWTexture2DArray<float4>, int3 location); >+native void Store(RWTexture2DArray<float4>, float4, uint3 location); >+ >+native void GetDimensions(RWTexture3D<float4>, thread uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float4>, thread float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float4>, thread uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float4>, thread float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float4>, thread uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float4>, thread float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float4>, thread uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float4>, thread float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float4>, thread uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float4>, thread float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float4>, thread uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float4>, thread float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float4>, thread uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float4>, thread float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float4>, thread uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float4>, thread float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float4>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float4>, thread float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float4>, device uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float4>, device float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float4>, device uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float4>, device float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float4>, device uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float4>, device float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float4>, device uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float4>, device float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float4>, device uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float4>, device float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float4>, device uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float4>, device float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float4>, device uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float4>, device float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float4>, device uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float4>, device float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float4>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float4>, device float* Width, threadgroup float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float4>, threadgroup uint* Width, thread uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float4>, threadgroup float* Width, thread float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float4>, threadgroup uint* Width, thread uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float4>, threadgroup float* Width, thread float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float4>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float4>, threadgroup float* Width, thread float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float4>, threadgroup uint* Width, device uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float4>, threadgroup float* Width, device float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float4>, threadgroup uint* Width, device uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float4>, threadgroup float* Width, device float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float4>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float4>, threadgroup float* Width, device float* Height, threadgroup float* Depth); >+native void GetDimensions(RWTexture3D<float4>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth); >+native void GetDimensions(RWTexture3D<float4>, threadgroup float* Width, threadgroup float* Height, thread float* Depth); >+native void GetDimensions(RWTexture3D<float4>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth); >+native void GetDimensions(RWTexture3D<float4>, threadgroup float* Width, threadgroup float* Height, device float* Depth); >+native void GetDimensions(RWTexture3D<float4>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth); >+native void GetDimensions(RWTexture3D<float4>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth); >+native float4 Load(RWTexture3D<float4>, int3 location); >+native void Store(RWTexture3D<float4>, float4, uint3 location); >+ >+native half Sample(TextureDepth2D<half>, sampler, float2 location); >+native half Sample(TextureDepth2D<half>, sampler, float2 location, int2 offset); >+native half SampleCmp(TextureDepth2D<half>, sampler, float2 location, half CompareValue); >+native half SampleCmp(TextureDepth2D<half>, sampler, float2 location, half CompareValue, int2 offset); >+native half SampleCmpLevelZero(TextureDepth2D<half>, sampler, float2 location, half CompareValue); >+native half SampleCmpLevelZero(TextureDepth2D<half>, sampler, float2 location, half CompareValue, int2 offset); >+native half SampleBias(TextureDepth2D<half>, sampler, float2 location, float Bias); >+native half SampleBias(TextureDepth2D<half>, sampler, float2 location, float Bias, int2 offset); >+native half SampleGrad(TextureDepth2D<half>, sampler, float2 location, float2 DDX, float2 DDY); >+native half SampleGrad(TextureDepth2D<half>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native half SampleLevel(TextureDepth2D<half>, sampler, float2 location, float LOD); >+native half SampleLevel(TextureDepth2D<half>, sampler, float2 location, float LOD, int2 offset); >+native half4 Gather(TextureDepth2D<half>, sampler, float2 location); >+native half4 Gather(TextureDepth2D<half>, sampler, float2 location, int2 offset); >+native half4 GatherRed(TextureDepth2D<half>, sampler, float2 location); >+native half4 GatherRed(TextureDepth2D<half>, sampler, float2 location, int2 offset); >+native half4 GatherCmp(TextureDepth2D<half>, sampler, float2 location, float compare_value); >+native half4 GatherCmp(TextureDepth2D<half>, sampler, float2 location, float compare_value, int2 offset); >+native half4 GatherCmpRed(TextureDepth2D<half>, sampler, float2 location, float compare_value); >+native half4 GatherCmpRed(TextureDepth2D<half>, sampler, float2 location, float compare_value, int2 offset); >+native half Load(TextureDepth2D<half>, int3 location); >+native half Load(TextureDepth2D<half>, int3 location, int2 offset); >+native void GetDimensions(TextureDepth2D<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native half Sample(TextureDepth2DArray<half>, sampler, float3 location); >+native half Sample(TextureDepth2DArray<half>, sampler, float3 location, int2 offset); >+native half SampleCmp(TextureDepth2DArray<half>, sampler, float3 location, half CompareValue); >+native half SampleCmp(TextureDepth2DArray<half>, sampler, float3 location, half CompareValue, int2 offset); >+native half SampleCmpLevelZero(TextureDepth2DArray<half>, sampler, float3 location, half CompareValue); >+native half SampleCmpLevelZero(TextureDepth2DArray<half>, sampler, float3 location, half CompareValue, int2 offset); >+native half SampleBias(TextureDepth2DArray<half>, sampler, float3 location, float Bias); >+native half SampleBias(TextureDepth2DArray<half>, sampler, float3 location, float Bias, int2 offset); >+native half SampleGrad(TextureDepth2DArray<half>, sampler, float3 location, float2 DDX, float2 DDY); >+native half SampleGrad(TextureDepth2DArray<half>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native half SampleLevel(TextureDepth2DArray<half>, sampler, float3 location, float LOD); >+native half SampleLevel(TextureDepth2DArray<half>, sampler, float3 location, float LOD, int2 offset); >+native half4 Gather(TextureDepth2DArray<half>, sampler, float3 location); >+native half4 Gather(TextureDepth2DArray<half>, sampler, float3 location, int2 offset); >+native half4 GatherRed(TextureDepth2DArray<half>, sampler, float3 location); >+native half4 GatherRed(TextureDepth2DArray<half>, sampler, float3 location, int2 offset); >+native half4 GatherCmp(TextureDepth2DArray<half>, sampler, float3 location, float compare_value); >+native half4 GatherCmp(TextureDepth2DArray<half>, sampler, float3 location, float compare_value, int2 offset); >+native half4 GatherCmpRed(TextureDepth2DArray<half>, sampler, float3 location, float compare_value); >+native half4 GatherCmpRed(TextureDepth2DArray<half>, sampler, float3 location, float compare_value, int2 offset); >+native half Load(TextureDepth2DArray<half>, int4 location); >+native half Load(TextureDepth2DArray<half>, int4 location, int2 offset); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native half Sample(TextureDepthCube<half>, sampler, float3 location); >+native half SampleCmp(TextureDepthCube<half>, sampler, float3 location, half CompareValue); >+native half SampleCmpLevelZero(TextureDepthCube<half>, sampler, float3 location, half CompareValue); >+native half SampleBias(TextureDepthCube<half>, sampler, float3 location, float Bias); >+native half SampleGrad(TextureDepthCube<half>, sampler, float3 location, float3 DDX, float3 DDY); >+native half SampleLevel(TextureDepthCube<half>, sampler, float3 location, float LOD); >+native half4 Gather(TextureDepthCube<half>, sampler, float3 location); >+native half4 GatherRed(TextureDepthCube<half>, sampler, float3 location); >+native half4 GatherCmp(TextureDepthCube<half>, sampler, float3 location, float compare_value); >+native half4 GatherCmpRed(TextureDepthCube<half>, sampler, float3 location, float compare_value); >+native void GetDimensions(TextureDepthCube<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTextureDepth2D<half>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTextureDepth2D<half>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTextureDepth2D<half>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTextureDepth2D<half>, thread float* Width, device float* Height); >+native void GetDimensions(RWTextureDepth2D<half>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTextureDepth2D<half>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTextureDepth2D<half>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTextureDepth2D<half>, device float* Width, thread float* Height); >+native void GetDimensions(RWTextureDepth2D<half>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTextureDepth2D<half>, device float* Width, device float* Height); >+native void GetDimensions(RWTextureDepth2D<half>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTextureDepth2D<half>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTextureDepth2D<half>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTextureDepth2D<half>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTextureDepth2D<half>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTextureDepth2D<half>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTextureDepth2D<half>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTextureDepth2D<half>, threadgroup float* Width, threadgroup float* Height); >+native half Load(RWTextureDepth2D<half>, int2 location); >+native void Store(RWTextureDepth2D<half>, half, uint2 location); >+ >+native void GetDimensions(RWTextureDepth2DArray<half>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<half>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native half Load(RWTextureDepth2DArray<half>, int3 location); >+native void Store(RWTextureDepth2DArray<half>, half, uint3 location); >+ >+native float Sample(TextureDepth2D<float>, sampler, float2 location); >+native float Sample(TextureDepth2D<float>, sampler, float2 location, int2 offset); >+native float SampleCmp(TextureDepth2D<float>, sampler, float2 location, float CompareValue); >+native float SampleCmp(TextureDepth2D<float>, sampler, float2 location, float CompareValue, int2 offset); >+native float SampleCmpLevelZero(TextureDepth2D<float>, sampler, float2 location, float CompareValue); >+native float SampleCmpLevelZero(TextureDepth2D<float>, sampler, float2 location, float CompareValue, int2 offset); >+native float SampleBias(TextureDepth2D<float>, sampler, float2 location, float Bias); >+native float SampleBias(TextureDepth2D<float>, sampler, float2 location, float Bias, int2 offset); >+native float SampleGrad(TextureDepth2D<float>, sampler, float2 location, float2 DDX, float2 DDY); >+native float SampleGrad(TextureDepth2D<float>, sampler, float2 location, float2 DDX, float2 DDY, int2 offset); >+native float SampleLevel(TextureDepth2D<float>, sampler, float2 location, float LOD); >+native float SampleLevel(TextureDepth2D<float>, sampler, float2 location, float LOD, int2 offset); >+native float4 Gather(TextureDepth2D<float>, sampler, float2 location); >+native float4 Gather(TextureDepth2D<float>, sampler, float2 location, int2 offset); >+native float4 GatherRed(TextureDepth2D<float>, sampler, float2 location); >+native float4 GatherRed(TextureDepth2D<float>, sampler, float2 location, int2 offset); >+native float4 GatherCmp(TextureDepth2D<float>, sampler, float2 location, float compare_value); >+native float4 GatherCmp(TextureDepth2D<float>, sampler, float2 location, float compare_value, int2 offset); >+native float4 GatherCmpRed(TextureDepth2D<float>, sampler, float2 location, float compare_value); >+native float4 GatherCmpRed(TextureDepth2D<float>, sampler, float2 location, float compare_value, int2 offset); >+native float Load(TextureDepth2D<float>, int3 location); >+native float Load(TextureDepth2D<float>, int3 location, int2 offset); >+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native float Sample(TextureDepth2DArray<float>, sampler, float3 location); >+native float Sample(TextureDepth2DArray<float>, sampler, float3 location, int2 offset); >+native float SampleCmp(TextureDepth2DArray<float>, sampler, float3 location, float CompareValue); >+native float SampleCmp(TextureDepth2DArray<float>, sampler, float3 location, float CompareValue, int2 offset); >+native float SampleCmpLevelZero(TextureDepth2DArray<float>, sampler, float3 location, float CompareValue); >+native float SampleCmpLevelZero(TextureDepth2DArray<float>, sampler, float3 location, float CompareValue, int2 offset); >+native float SampleBias(TextureDepth2DArray<float>, sampler, float3 location, float Bias); >+native float SampleBias(TextureDepth2DArray<float>, sampler, float3 location, float Bias, int2 offset); >+native float SampleGrad(TextureDepth2DArray<float>, sampler, float3 location, float2 DDX, float2 DDY); >+native float SampleGrad(TextureDepth2DArray<float>, sampler, float3 location, float2 DDX, float2 DDY, int2 offset); >+native float SampleLevel(TextureDepth2DArray<float>, sampler, float3 location, float LOD); >+native float SampleLevel(TextureDepth2DArray<float>, sampler, float3 location, float LOD, int2 offset); >+native float4 Gather(TextureDepth2DArray<float>, sampler, float3 location); >+native float4 Gather(TextureDepth2DArray<float>, sampler, float3 location, int2 offset); >+native float4 GatherRed(TextureDepth2DArray<float>, sampler, float3 location); >+native float4 GatherRed(TextureDepth2DArray<float>, sampler, float3 location, int2 offset); >+native float4 GatherCmp(TextureDepth2DArray<float>, sampler, float3 location, float compare_value); >+native float4 GatherCmp(TextureDepth2DArray<float>, sampler, float3 location, float compare_value, int2 offset); >+native float4 GatherCmpRed(TextureDepth2DArray<float>, sampler, float3 location, float compare_value); >+native float4 GatherCmpRed(TextureDepth2DArray<float>, sampler, float3 location, float compare_value, int2 offset); >+native float Load(TextureDepth2DArray<float>, int4 location); >+native float Load(TextureDepth2DArray<float>, int4 location, int2 offset); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels); >+ >+native float Sample(TextureDepthCube<float>, sampler, float3 location); >+native float SampleCmp(TextureDepthCube<float>, sampler, float3 location, float CompareValue); >+native float SampleCmpLevelZero(TextureDepthCube<float>, sampler, float3 location, float CompareValue); >+native float SampleBias(TextureDepthCube<float>, sampler, float3 location, float Bias); >+native float SampleGrad(TextureDepthCube<float>, sampler, float3 location, float3 DDX, float3 DDY); >+native float SampleLevel(TextureDepthCube<float>, sampler, float3 location, float LOD); >+native float4 Gather(TextureDepthCube<float>, sampler, float3 location); >+native float4 GatherRed(TextureDepthCube<float>, sampler, float3 location); >+native float4 GatherCmp(TextureDepthCube<float>, sampler, float3 location, float compare_value); >+native float4 GatherCmpRed(TextureDepthCube<float>, sampler, float3 location, float compare_value); >+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels); >+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels); >+ >+native void GetDimensions(RWTextureDepth2D<float>, thread uint* Width, thread uint* Height); >+native void GetDimensions(RWTextureDepth2D<float>, thread float* Width, thread float* Height); >+native void GetDimensions(RWTextureDepth2D<float>, thread uint* Width, device uint* Height); >+native void GetDimensions(RWTextureDepth2D<float>, thread float* Width, device float* Height); >+native void GetDimensions(RWTextureDepth2D<float>, thread uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTextureDepth2D<float>, thread float* Width, threadgroup float* Height); >+native void GetDimensions(RWTextureDepth2D<float>, device uint* Width, thread uint* Height); >+native void GetDimensions(RWTextureDepth2D<float>, device float* Width, thread float* Height); >+native void GetDimensions(RWTextureDepth2D<float>, device uint* Width, device uint* Height); >+native void GetDimensions(RWTextureDepth2D<float>, device float* Width, device float* Height); >+native void GetDimensions(RWTextureDepth2D<float>, device uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTextureDepth2D<float>, device float* Width, threadgroup float* Height); >+native void GetDimensions(RWTextureDepth2D<float>, threadgroup uint* Width, thread uint* Height); >+native void GetDimensions(RWTextureDepth2D<float>, threadgroup float* Width, thread float* Height); >+native void GetDimensions(RWTextureDepth2D<float>, threadgroup uint* Width, device uint* Height); >+native void GetDimensions(RWTextureDepth2D<float>, threadgroup float* Width, device float* Height); >+native void GetDimensions(RWTextureDepth2D<float>, threadgroup uint* Width, threadgroup uint* Height); >+native void GetDimensions(RWTextureDepth2D<float>, threadgroup float* Width, threadgroup float* Height); >+native float Load(RWTextureDepth2D<float>, int2 location); >+native void Store(RWTextureDepth2D<float>, float, uint2 location); >+ >+native void GetDimensions(RWTextureDepth2DArray<float>, thread uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, thread float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, thread uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, thread float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, thread uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, thread float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, thread uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, thread float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, thread uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, thread float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, thread uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, thread float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, thread uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, thread float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, thread uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, thread float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, thread float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, device uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, device float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, device uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, device float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, device uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, device float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, device uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, device float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, device uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, device float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, device uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, device float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, device uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, device float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, device uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, device float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, device float* Width, threadgroup float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, threadgroup uint* Width, thread uint* Height, thread uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, threadgroup float* Width, thread float* Height, thread float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, threadgroup uint* Width, thread uint* Height, device uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, threadgroup float* Width, thread float* Height, device float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, threadgroup float* Width, thread float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, threadgroup uint* Width, device uint* Height, thread uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, threadgroup float* Width, device float* Height, thread float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, threadgroup uint* Width, device uint* Height, device uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, threadgroup float* Width, device float* Height, device float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, threadgroup float* Width, device float* Height, threadgroup float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, threadgroup float* Width, threadgroup float* Height, thread float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, threadgroup float* Width, threadgroup float* Height, device float* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements); >+native void GetDimensions(RWTextureDepth2DArray<float>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements); >+native float Load(RWTextureDepth2DArray<float>, int3 location); >+native void Store(RWTextureDepth2DArray<float>, float, uint3 location); >diff --git a/Source/WebCore/Modules/webgpu/WebGPUDevice.cpp b/Source/WebCore/Modules/webgpu/WebGPUDevice.cpp >index 77ba4cbc08f..6da85e46117 100644 >--- a/Source/WebCore/Modules/webgpu/WebGPUDevice.cpp >+++ b/Source/WebCore/Modules/webgpu/WebGPUDevice.cpp >@@ -67,7 +67,7 @@ RefPtr<WebGPUBuffer> WebGPUDevice::createBuffer(WebGPUBufferDescriptor&& descrip > RefPtr<WebGPUShaderModule> WebGPUDevice::createShaderModule(WebGPUShaderModuleDescriptor&& descriptor) const > { > // FIXME: What can be validated here? >- auto module = m_device->createShaderModule(GPUShaderModuleDescriptor { descriptor.code }); >+ auto module = m_device->createShaderModule(GPUShaderModuleDescriptor { descriptor.code, descriptor.isWHLSL }); > return module ? WebGPUShaderModule::create(module.releaseNonNull()) : nullptr; > } > >diff --git a/Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h b/Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h >index af32a989ed5..b8d9817cd0a 100644 >--- a/Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h >+++ b/Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.h >@@ -33,6 +33,7 @@ namespace WebCore { > > struct WebGPUShaderModuleDescriptor { > String code; >+ bool isWHLSL; > }; > > } // namespace WebCore >diff --git a/Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.idl b/Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.idl >index 32d707ed92b..971352ab047 100644 >--- a/Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.idl >+++ b/Source/WebCore/Modules/webgpu/WebGPUShaderModuleDescriptor.idl >@@ -29,4 +29,5 @@ > EnabledAtRuntime=WebGPU > ] dictionary WebGPUShaderModuleDescriptor { > /*ArrayBuffer*/ DOMString code; // FIXME: DOMString for MTL prototyping only. >+ boolean isWHLSL = false; > }; >diff --git a/Source/WebCore/Sources.txt b/Source/WebCore/Sources.txt >index 7352f33e176..2e230f1c931 100644 >--- a/Source/WebCore/Sources.txt >+++ b/Source/WebCore/Sources.txt >@@ -301,6 +301,8 @@ Modules/websockets/WebSocketHandshake.cpp > Modules/websockets/WorkerThreadableWebSocketChannel.cpp > > Modules/webgpu/DOMWindowWebGPU.cpp >+Modules/webgpu/WHLSL/WHLSLLexer.cpp >+Modules/webgpu/WHLSL/WHLSLParser.cpp > Modules/webgpu/WebGPU.cpp > Modules/webgpu/WebGPUAdapter.cpp > Modules/webgpu/WebGPUBuffer.cpp >diff --git a/Source/WebCore/WebCore.xcodeproj/project.pbxproj b/Source/WebCore/WebCore.xcodeproj/project.pbxproj >index c924a495727..ea335ad63f4 100644 >--- a/Source/WebCore/WebCore.xcodeproj/project.pbxproj >+++ b/Source/WebCore/WebCore.xcodeproj/project.pbxproj >@@ -6404,6 +6404,30 @@ > 1C3969CF1B74211E002BCFA7 /* FontCacheCoreText.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FontCacheCoreText.cpp; sourceTree = "<group>"; }; > 1C66260E1C6E7CA600AB527C /* FontFace.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FontFace.cpp; sourceTree = "<group>"; }; > 1C66260F1C6E7CA600AB527C /* FontFace.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FontFace.h; sourceTree = "<group>"; }; >+ 1C80596B21BA164A006B0906 /* WHLSLASTNode.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTNode.h; sourceTree = "<group>"; }; >+ 1C80596F21BB02D3006B0906 /* WHLSLASTPointerType.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTPointerType.h; sourceTree = "<group>"; }; >+ 1C80597221BB02EA006B0906 /* WHLSLASTArrayReferenceType.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTArrayReferenceType.h; sourceTree = "<group>"; }; >+ 1C80597421BB02FB006B0906 /* WHLSLASTArrayType.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTArrayType.h; sourceTree = "<group>"; }; >+ 1C80597621BB0577006B0906 /* WHLSLASTReferenceType.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTReferenceType.h; sourceTree = "<group>"; }; >+ 1C80597D21BF55A7006B0906 /* WHLSLASTBaseSemantic.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTBaseSemantic.h; sourceTree = "<group>"; }; >+ 1C80598021BF55BA006B0906 /* WHLSLASTBuiltInSemantic.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTBuiltInSemantic.h; sourceTree = "<group>"; }; >+ 1C80598221BF55D1006B0906 /* WHLSLASTResourceSemantic.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTResourceSemantic.h; sourceTree = "<group>"; }; >+ 1C80598421BF55ED006B0906 /* WHLSLASTSpecializationConstantSemantic.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTSpecializationConstantSemantic.h; sourceTree = "<group>"; }; >+ 1C80598621BF5601006B0906 /* WHLSLASTStageInOutSemantic.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTStageInOutSemantic.h; sourceTree = "<group>"; }; >+ 1C80598721BF5781006B0906 /* WHLSLASTSemantic.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTSemantic.h; sourceTree = "<group>"; }; >+ 1C80598D21C1FD74006B0906 /* WHLSLASTIfStatement.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTIfStatement.h; sourceTree = "<group>"; }; >+ 1C80598F21C1FD83006B0906 /* WHLSLASTSwitchStatement.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTSwitchStatement.h; sourceTree = "<group>"; }; >+ 1C80599021C1FDAD006B0906 /* WHLSLASTSwitchCase.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTSwitchCase.h; sourceTree = "<group>"; }; >+ 1C80599121C1FDC3006B0906 /* WHLSLASTForLoop.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTForLoop.h; sourceTree = "<group>"; }; >+ 1C80599221C1FDDA006B0906 /* WHLSLASTWhileLoop.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTWhileLoop.h; sourceTree = "<group>"; }; >+ 1C80599321C1FDE8006B0906 /* WHLSLASTDoWhileLoop.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTDoWhileLoop.h; sourceTree = "<group>"; }; >+ 1C80599421C1FDFE006B0906 /* WHLSLASTBreak.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTBreak.h; sourceTree = "<group>"; }; >+ 1C80599521C1FE07006B0906 /* WHLSLASTContinue.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTContinue.h; sourceTree = "<group>"; }; >+ 1C80599621C1FE14006B0906 /* WHLSLASTFallthrough.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTFallthrough.h; sourceTree = "<group>"; }; >+ 1C80599721C1FE20006B0906 /* WHLSLASTTrap.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTTrap.h; sourceTree = "<group>"; }; >+ 1C80599821C1FE2E006B0906 /* WHLSLASTReturn.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTReturn.h; sourceTree = "<group>"; }; >+ 1C80599A21C1FEA0006B0906 /* WHLSLASTStatement.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTStatement.h; sourceTree = "<group>"; }; >+ 1C80599C21C2009D006B0906 /* WHLSLASTBlock.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTBlock.h; sourceTree = "<group>"; }; > 1C81B9560E97330800266E07 /* InspectorController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InspectorController.h; sourceTree = "<group>"; }; > 1C81B9570E97330800266E07 /* InspectorController.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = InspectorController.cpp; sourceTree = "<group>"; }; > 1C81B9580E97330800266E07 /* InspectorClient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InspectorClient.h; sourceTree = "<group>"; }; >@@ -6415,6 +6439,8 @@ > 1CAF34800A6C405200ABE06E /* WebScriptObjectPrivate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebScriptObjectPrivate.h; sourceTree = "<group>"; }; > 1CB6B4F8217B83930093B9CD /* TextDecorationThickness.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = TextDecorationThickness.h; sourceTree = "<group>"; }; > 1CB6B4FB217B83940093B9CD /* TextUnderlineOffset.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = TextUnderlineOffset.h; sourceTree = "<group>"; }; >+ 1CC46F2721B77860000998DE /* WHLSLASTTypeReference.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTTypeReference.h; sourceTree = "<group>"; }; >+ 1CC46F2921B77A32000998DE /* WHLSLASTTypeArgument.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTTypeArgument.h; sourceTree = "<group>"; }; > 1CCDF5BB1990332400BCEBAD /* SVGToOTFFontConversion.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SVGToOTFFontConversion.cpp; sourceTree = "<group>"; }; > 1CCDF5BC1990332400BCEBAD /* SVGToOTFFontConversion.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SVGToOTFFontConversion.h; sourceTree = "<group>"; }; > 1CDD45E40BA9C84600F90147 /* DebugRelease.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = DebugRelease.xcconfig; sourceTree = "<group>"; }; >@@ -13208,11 +13234,46 @@ > C11A9ED22140578B00CFB20A /* SwitchingGPUClient.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = SwitchingGPUClient.cpp; sourceTree = "<group>"; }; > C1E1D235203DF15400584665 /* ScreenProperties.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ScreenProperties.h; sourceTree = "<group>"; }; > C2015C091BE6FE2C00822389 /* FontVariantBuilder.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = FontVariantBuilder.h; sourceTree = "<group>"; }; >+ C210E91121B4BD1000B7F83D /* WHLSLLexer.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WHLSLLexer.cpp; sourceTree = "<group>"; }; >+ C210E91221B4BD1000B7F83D /* WHLSLLexer.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLLexer.h; sourceTree = "<group>"; }; > C21DF2E71D9E4E9900F5B24C /* CSSFontVariationValue.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CSSFontVariationValue.cpp; sourceTree = "<group>"; }; > C21DF2E81D9E4E9900F5B24C /* CSSFontVariationValue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSSFontVariationValue.h; sourceTree = "<group>"; }; >+ C22F76C021C0A45800C5434E /* WHLSLASTExpression.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTExpression.h; sourceTree = "<group>"; }; >+ C22F76C121C0A63E00C5434E /* WHLSLASTCommaExpression.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTCommaExpression.h; sourceTree = "<group>"; }; >+ C22F76C221C0A6DE00C5434E /* WHLSLASTTernaryExpression.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTTernaryExpression.h; sourceTree = "<group>"; }; >+ C22F76C321C0A75500C5434E /* WHLSLASTAssignmentExpression.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTAssignmentExpression.h; sourceTree = "<group>"; }; >+ C22F76C421C0A76300C5434E /* WHLSLASTReadModifyWriteExpression.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTReadModifyWriteExpression.h; sourceTree = "<group>"; }; >+ C22F76C521C0A7AE00C5434E /* WHLSLASTLogicalExpression.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTLogicalExpression.h; sourceTree = "<group>"; }; >+ C22F76C621C0A7BD00C5434E /* WHLSLASTCallExpression.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTCallExpression.h; sourceTree = "<group>"; }; >+ C22F76C721C0A8CF00C5434E /* WHLSLASTDereferenceExpression.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTDereferenceExpression.h; sourceTree = "<group>"; }; >+ C22F76C821C0A8E000C5434E /* WHLSLASTMakePointerExpression.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTMakePointerExpression.h; sourceTree = "<group>"; }; >+ C22F76C921C0A8F200C5434E /* WHLSLASTMakeArrayReferenceExpression.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTMakeArrayReferenceExpression.h; sourceTree = "<group>"; }; >+ C22F76CA21C0A90400C5434E /* WHLSLASTLogicalNotExpression.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTLogicalNotExpression.h; sourceTree = "<group>"; }; >+ C22F76CB21C0A98B00C5434E /* WHLSLASTNullLiteral.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTNullLiteral.h; sourceTree = "<group>"; }; >+ C22F76CC21C0A9A700C5434E /* WHLSLASTVariableReference.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTVariableReference.h; sourceTree = "<group>"; }; >+ C22F76CD21C0A9BA00C5434E /* WHLSLASTIntegerLiteral.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTIntegerLiteral.h; sourceTree = "<group>"; }; >+ C22F76CE21C0A9C900C5434E /* WHLSLASTUnsignedIntegerLiteral.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTUnsignedIntegerLiteral.h; sourceTree = "<group>"; }; >+ C22F76CF21C0A9F100C5434E /* WHLSLASTFloatLiteral.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTFloatLiteral.h; sourceTree = "<group>"; }; >+ C22F76D021C0AA1400C5434E /* WHLSLASTBooleanLiteral.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTBooleanLiteral.h; sourceTree = "<group>"; }; >+ C22F76D121C0AA5300C5434E /* WHLSLASTDotExpression.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTDotExpression.h; sourceTree = "<group>"; }; >+ C22F76D221C0AA6300C5434E /* WHLSLASTIndexExpression.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTIndexExpression.h; sourceTree = "<group>"; }; >+ C22F76D321C0AC5300C5434E /* WHLSLASTAnonymousVariableDeclaration.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTAnonymousVariableDeclaration.h; sourceTree = "<group>"; }; >+ C22F76D421C0AFCF00C5434E /* WHLSLASTPropertyAccessExpression.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTPropertyAccessExpression.h; sourceTree = "<group>"; }; >+ C22F76DD21C2508500C5434E /* WHLSLASTConstantExpressionEnumerationMemberReference.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTConstantExpressionEnumerationMemberReference.h; sourceTree = "<group>"; }; >+ C22F76DE21C2512800C5434E /* WHLSLASTConstantExpression.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTConstantExpression.h; sourceTree = "<group>"; }; >+ C22F76DF21C26F4700C5434E /* WHLSLASTVariableDeclarationsStatement.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTVariableDeclarationsStatement.h; sourceTree = "<group>"; }; >+ C22F76E021C26F5B00C5434E /* WHLSLASTEffectfulExpressionStatement.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTEffectfulExpressionStatement.h; sourceTree = "<group>"; }; > C2458E611FE8979E00594759 /* FontCacheCoreText.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = FontCacheCoreText.h; sourceTree = "<group>"; }; > C26017A11C72DC9900F74A16 /* CSSFontFaceSet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CSSFontFaceSet.cpp; sourceTree = "<group>"; }; > C26017A21C72DC9900F74A16 /* CSSFontFaceSet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSSFontFaceSet.h; sourceTree = "<group>"; }; >+ C274F13521C032D6003410BD /* WHLSLASTFunctionDeclaration.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTFunctionDeclaration.h; sourceTree = "<group>"; }; >+ C274F13721C03E95003410BD /* WHLSLASTBaseFunctionAttribute.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTBaseFunctionAttribute.h; sourceTree = "<group>"; }; >+ C274F13921C03EAC003410BD /* WHLSLASTNumThreadsFunctionAttribute.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTNumThreadsFunctionAttribute.h; sourceTree = "<group>"; }; >+ C274F13B21C03EBF003410BD /* WHLSLASTFunctionAttribute.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTFunctionAttribute.h; sourceTree = "<group>"; }; >+ C274F13D21C04AD5003410BD /* WHLSLASTParameter.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTParameter.h; sourceTree = "<group>"; }; >+ C274F13F21C04D57003410BD /* WHLSLASTValue.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTValue.h; sourceTree = "<group>"; }; >+ C274F14321C335FF003410BD /* WHLSLStandardLibrary.txt */ = {isa = PBXFileReference; lastKnownFileType = text; path = WHLSLStandardLibrary.txt; sourceTree = "<group>"; }; >+ C274F14521C33AC1003410BD /* WHLSLStandardLibrary.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = WHLSLStandardLibrary.h; path = DerivedSources/WebCore/WHLSLStandardLibrary.h; sourceTree = BUILT_PRODUCTS_DIR; }; > C280833C1C6DB194001451B6 /* FontFace.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = FontFace.idl; sourceTree = "<group>"; }; > C280833D1C6DC22C001451B6 /* JSFontFace.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = JSFontFace.cpp; path = DerivedSources/WebCore/JSFontFace.cpp; sourceTree = BUILT_PRODUCTS_DIR; }; > C280833E1C6DC22C001451B6 /* JSFontFace.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = JSFontFace.h; path = DerivedSources/WebCore/JSFontFace.h; sourceTree = BUILT_PRODUCTS_DIR; }; >@@ -13225,6 +13286,20 @@ > C2E38EFC1E8396FD00CA3ADF /* CSSFontStyleValue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSSFontStyleValue.h; sourceTree = "<group>"; }; > C2E38EFF1E84573500CA3ADF /* CSSFontStyleRangeValue.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CSSFontStyleRangeValue.cpp; sourceTree = "<group>"; }; > C2E38F001E84573500CA3ADF /* CSSFontStyleRangeValue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSSFontStyleRangeValue.h; sourceTree = "<group>"; }; >+ C2ECEB4C21B63CBB008F8DE9 /* WHLSLParser.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WHLSLParser.cpp; sourceTree = "<group>"; }; >+ C2ECEB4D21B63CBB008F8DE9 /* WHLSLParser.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLParser.h; sourceTree = "<group>"; }; >+ C2ECEB5021B64C72008F8DE9 /* WHLSLASTVariableDeclaration.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTVariableDeclaration.h; sourceTree = "<group>"; }; >+ C2ECEB5221B64C84008F8DE9 /* WHLSLASTTypeDefinition.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTTypeDefinition.h; sourceTree = "<group>"; }; >+ C2ECEB5421B64C97008F8DE9 /* WHLSLASTStructureDefinition.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTStructureDefinition.h; sourceTree = "<group>"; }; >+ C2ECEB5621B64CAB008F8DE9 /* WHLSLASTEnumerationDefinition.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTEnumerationDefinition.h; sourceTree = "<group>"; }; >+ C2ECEB5821B64CBE008F8DE9 /* WHLSLASTFunctionDefinition.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTFunctionDefinition.h; sourceTree = "<group>"; }; >+ C2ECEB5A21B64CD5008F8DE9 /* WHLSLASTNativeFunctionDeclaration.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTNativeFunctionDeclaration.h; sourceTree = "<group>"; }; >+ C2ECEB5C21B64CE4008F8DE9 /* WHLSLASTNativeTypeDeclaration.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTNativeTypeDeclaration.h; sourceTree = "<group>"; }; >+ C2ECEB5E21B64D6F008F8DE9 /* WHLSLProgram.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLProgram.h; sourceTree = "<group>"; }; >+ C2ECEB6021B64DC6008F8DE9 /* WHLSLASTType.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTType.h; sourceTree = "<group>"; }; >+ C2ECEB6C21BE4896008F8DE9 /* WHLSLASTStructureElement.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTStructureElement.h; sourceTree = "<group>"; }; >+ C2ECEB7421BF7F3A008F8DE9 /* WHLSLASTQualifier.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTQualifier.h; sourceTree = "<group>"; }; >+ C2ECEB7921BF8E05008F8DE9 /* WHLSLASTEnumerationMember.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLASTEnumerationMember.h; sourceTree = "<group>"; }; > C2F4E7881E45AEDF006D7105 /* ComplexTextController.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ComplexTextController.cpp; sourceTree = "<group>"; }; > C2F4E7891E45AEDF006D7105 /* ComplexTextController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ComplexTextController.h; sourceTree = "<group>"; }; > C330A22113EC196B0000B45B /* ColorChooser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ColorChooser.h; sourceTree = "<group>"; }; >@@ -19591,6 +19666,7 @@ > 656581AF09D14EE6000E61D7 /* UserAgentStyleSheetsData.cpp */, > 1A1414B313A0F0500019996C /* WebKitFontFamilyNames.cpp */, > 1A1414B413A0F0500019996C /* WebKitFontFamilyNames.h */, >+ C274F14521C33AC1003410BD /* WHLSLStandardLibrary.h */, > 51748FA21CC6EEEB00728D84 /* WorkerGlobalScopeConstructors.idl */, > 9908B0F91BCAD07D00ED0F75 /* WritableStreamBuiltins.cpp */, > 9B03D8061BB3110D00B764E8 /* WritableStreamBuiltins.h */, >@@ -25203,6 +25279,95 @@ > tabWidth = 4; > usesTabs = 0; > }; >+ C210E90D21B4BCA400B7F83D /* WHLSL */ = { >+ isa = PBXGroup; >+ children = ( >+ C22F76E221C2ED6000C5434E /* AST */, >+ C210E91121B4BD1000B7F83D /* WHLSLLexer.cpp */, >+ C210E91221B4BD1000B7F83D /* WHLSLLexer.h */, >+ C2ECEB4C21B63CBB008F8DE9 /* WHLSLParser.cpp */, >+ C2ECEB4D21B63CBB008F8DE9 /* WHLSLParser.h */, >+ C2ECEB5E21B64D6F008F8DE9 /* WHLSLProgram.h */, >+ C274F14321C335FF003410BD /* WHLSLStandardLibrary.txt */, >+ ); >+ path = WHLSL; >+ sourceTree = "<group>"; >+ }; >+ C22F76E221C2ED6000C5434E /* AST */ = { >+ isa = PBXGroup; >+ children = ( >+ C22F76D321C0AC5300C5434E /* WHLSLASTAnonymousVariableDeclaration.h */, >+ 1C80597221BB02EA006B0906 /* WHLSLASTArrayReferenceType.h */, >+ 1C80597421BB02FB006B0906 /* WHLSLASTArrayType.h */, >+ C22F76C321C0A75500C5434E /* WHLSLASTAssignmentExpression.h */, >+ C274F13721C03E95003410BD /* WHLSLASTBaseFunctionAttribute.h */, >+ 1C80597D21BF55A7006B0906 /* WHLSLASTBaseSemantic.h */, >+ 1C80599C21C2009D006B0906 /* WHLSLASTBlock.h */, >+ C22F76D021C0AA1400C5434E /* WHLSLASTBooleanLiteral.h */, >+ 1C80599421C1FDFE006B0906 /* WHLSLASTBreak.h */, >+ 1C80598021BF55BA006B0906 /* WHLSLASTBuiltInSemantic.h */, >+ C22F76C621C0A7BD00C5434E /* WHLSLASTCallExpression.h */, >+ C22F76C121C0A63E00C5434E /* WHLSLASTCommaExpression.h */, >+ C22F76DE21C2512800C5434E /* WHLSLASTConstantExpression.h */, >+ C22F76DD21C2508500C5434E /* WHLSLASTConstantExpressionEnumerationMemberReference.h */, >+ 1C80599521C1FE07006B0906 /* WHLSLASTContinue.h */, >+ C22F76C721C0A8CF00C5434E /* WHLSLASTDereferenceExpression.h */, >+ C22F76D121C0AA5300C5434E /* WHLSLASTDotExpression.h */, >+ 1C80599321C1FDE8006B0906 /* WHLSLASTDoWhileLoop.h */, >+ C22F76E021C26F5B00C5434E /* WHLSLASTEffectfulExpressionStatement.h */, >+ C2ECEB5621B64CAB008F8DE9 /* WHLSLASTEnumerationDefinition.h */, >+ C2ECEB7921BF8E05008F8DE9 /* WHLSLASTEnumerationMember.h */, >+ C22F76C021C0A45800C5434E /* WHLSLASTExpression.h */, >+ 1C80599621C1FE14006B0906 /* WHLSLASTFallthrough.h */, >+ C22F76CF21C0A9F100C5434E /* WHLSLASTFloatLiteral.h */, >+ 1C80599121C1FDC3006B0906 /* WHLSLASTForLoop.h */, >+ C274F13B21C03EBF003410BD /* WHLSLASTFunctionAttribute.h */, >+ C274F13521C032D6003410BD /* WHLSLASTFunctionDeclaration.h */, >+ C2ECEB5821B64CBE008F8DE9 /* WHLSLASTFunctionDefinition.h */, >+ 1C80598D21C1FD74006B0906 /* WHLSLASTIfStatement.h */, >+ C22F76D221C0AA6300C5434E /* WHLSLASTIndexExpression.h */, >+ C22F76CD21C0A9BA00C5434E /* WHLSLASTIntegerLiteral.h */, >+ C22F76C521C0A7AE00C5434E /* WHLSLASTLogicalExpression.h */, >+ C22F76CA21C0A90400C5434E /* WHLSLASTLogicalNotExpression.h */, >+ C22F76C921C0A8F200C5434E /* WHLSLASTMakeArrayReferenceExpression.h */, >+ C22F76C821C0A8E000C5434E /* WHLSLASTMakePointerExpression.h */, >+ C2ECEB5A21B64CD5008F8DE9 /* WHLSLASTNativeFunctionDeclaration.h */, >+ C2ECEB5C21B64CE4008F8DE9 /* WHLSLASTNativeTypeDeclaration.h */, >+ 1C80596B21BA164A006B0906 /* WHLSLASTNode.h */, >+ C22F76CB21C0A98B00C5434E /* WHLSLASTNullLiteral.h */, >+ C274F13921C03EAC003410BD /* WHLSLASTNumThreadsFunctionAttribute.h */, >+ C274F13D21C04AD5003410BD /* WHLSLASTParameter.h */, >+ 1C80596F21BB02D3006B0906 /* WHLSLASTPointerType.h */, >+ C22F76D421C0AFCF00C5434E /* WHLSLASTPropertyAccessExpression.h */, >+ C2ECEB7421BF7F3A008F8DE9 /* WHLSLASTQualifier.h */, >+ C22F76C421C0A76300C5434E /* WHLSLASTReadModifyWriteExpression.h */, >+ 1C80597621BB0577006B0906 /* WHLSLASTReferenceType.h */, >+ 1C80598221BF55D1006B0906 /* WHLSLASTResourceSemantic.h */, >+ 1C80599821C1FE2E006B0906 /* WHLSLASTReturn.h */, >+ 1C80598721BF5781006B0906 /* WHLSLASTSemantic.h */, >+ 1C80598421BF55ED006B0906 /* WHLSLASTSpecializationConstantSemantic.h */, >+ 1C80598621BF5601006B0906 /* WHLSLASTStageInOutSemantic.h */, >+ 1C80599A21C1FEA0006B0906 /* WHLSLASTStatement.h */, >+ C2ECEB5421B64C97008F8DE9 /* WHLSLASTStructureDefinition.h */, >+ C2ECEB6C21BE4896008F8DE9 /* WHLSLASTStructureElement.h */, >+ 1C80599021C1FDAD006B0906 /* WHLSLASTSwitchCase.h */, >+ 1C80598F21C1FD83006B0906 /* WHLSLASTSwitchStatement.h */, >+ C22F76C221C0A6DE00C5434E /* WHLSLASTTernaryExpression.h */, >+ 1C80599721C1FE20006B0906 /* WHLSLASTTrap.h */, >+ C2ECEB6021B64DC6008F8DE9 /* WHLSLASTType.h */, >+ 1CC46F2921B77A32000998DE /* WHLSLASTTypeArgument.h */, >+ C2ECEB5221B64C84008F8DE9 /* WHLSLASTTypeDefinition.h */, >+ 1CC46F2721B77860000998DE /* WHLSLASTTypeReference.h */, >+ C22F76CE21C0A9C900C5434E /* WHLSLASTUnsignedIntegerLiteral.h */, >+ C274F13F21C04D57003410BD /* WHLSLASTValue.h */, >+ C2ECEB5021B64C72008F8DE9 /* WHLSLASTVariableDeclaration.h */, >+ C22F76DF21C26F4700C5434E /* WHLSLASTVariableDeclarationsStatement.h */, >+ C22F76CC21C0A9A700C5434E /* WHLSLASTVariableReference.h */, >+ 1C80599221C1FDDA006B0906 /* WHLSLASTWhileLoop.h */, >+ ); >+ path = AST; >+ sourceTree = "<group>"; >+ }; > C96F5EBF1B5872260091EA9D /* mediasession */ = { > isa = PBXGroup; > children = ( >@@ -25545,6 +25710,7 @@ > D00F593E216ECC43000D71DB /* webgpu */ = { > isa = PBXGroup; > children = ( >+ C210E90D21B4BCA400B7F83D /* WHLSL */, > D00F5941216ECC7A000D71DB /* DOMWindowWebGPU.cpp */, > D00F5940216ECC7A000D71DB /* DOMWindowWebGPU.h */, > D00F5942216ECC7A000D71DB /* DOMWindowWebGPU.idl */, >diff --git a/Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h b/Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h >index 6cfe0ad5a87..5c3ecf6a7c0 100644 >--- a/Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h >+++ b/Source/WebCore/platform/graphics/gpu/GPUShaderModuleDescriptor.h >@@ -33,6 +33,7 @@ namespace WebCore { > > struct GPUShaderModuleDescriptor { > String code; >+ bool isWHLSL; > }; > > } // namespace WebCore >diff --git a/Source/WebCore/platform/graphics/gpu/cocoa/GPUShaderModuleMetal.mm b/Source/WebCore/platform/graphics/gpu/cocoa/GPUShaderModuleMetal.mm >index 4553a15df5f..ba94fcf2933 100644 >--- a/Source/WebCore/platform/graphics/gpu/cocoa/GPUShaderModuleMetal.mm >+++ b/Source/WebCore/platform/graphics/gpu/cocoa/GPUShaderModuleMetal.mm >@@ -31,6 +31,9 @@ > #import "GPUDevice.h" > #import "GPUShaderModuleDescriptor.h" > #import "Logging.h" >+#import "WHLSLParser.h" >+#import "WHLSLProgram.h" >+#import "WHLSLStandardLibrary.h" > > #import <Metal/Metal.h> > #import <wtf/BlockObjCExceptions.h> >@@ -44,12 +47,25 @@ RefPtr<GPUShaderModule> GPUShaderModule::create(const GPUDevice& device, GPUShad > return nullptr; > } > >+ String code = descriptor.code; >+ >+ if (descriptor.isWHLSL) { >+ WHLSL::Program program; >+ WHLSL::Parser parser; >+ auto standardLibrary = String::fromUTF8(WHLSLStandardLibrary, sizeof(WHLSLStandardLibrary)); >+ if (parser.parse(program, standardLibrary, WHLSL::Parser::Mode::StandardLibrary) == std::nullopt >+ && parser.parse(program, descriptor.code, WHLSL::Parser::Mode::User) == std::nullopt) >+ code = ""; >+ else >+ return nullptr; >+ } >+ > PlatformShaderModuleSmartPtr module; > > BEGIN_BLOCK_OBJC_EXCEPTIONS; > > NSError *error = [NSError errorWithDomain:@"com.apple.WebKit.GPU" code:1 userInfo:nil]; >- module = adoptNS([device.platformDevice() newLibraryWithSource:descriptor.code options:nil error:&error]); >+ module = adoptNS([device.platformDevice() newLibraryWithSource:code options:nil error:&error]); > if (!module) > LOG(WebGPU, "Shader compilation error: %s", [[error localizedDescription] UTF8String]); >
<b>You cannot view the attachment while viewing its details because your browser does not support IFRAMEs. <a href="attachment.cgi?id=357602">View the attachment on a separate page</a>.</b>
View Attachment As Diff
View Attachment As Raw
Actions:
View
|
Formatted Diff
|
Diff
Attachments on
bug 192355
:
356468
|
356569
|
356570
|
356585
|
356695
|
356778
|
356863
|
356947
|
357031
|
357035
|
357038
|
357081
|
357103
|
357199
|
357207
|
357225
|
357245
|
357268
|
357277
|
357303
|
357304
|
357361
|
357410
|
357430
|
357458
|
357520
|
357602
|
357749
|
357754
|
357765
|
357869
|
357889
|
357929
|
357932
|
357975
|
358866
|
358880
|
358902
|
359250