diff --git a/benchmark/IOL/ioling_hf/evals/results/google__gemma-3-4b-it__diverse5.scores.jsonl b/benchmark/IOL/ioling_hf/evals/results/google__gemma-3-4b-it__diverse5.scores.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..b616c2731c1223b340126d1908674b89f065a8c4 --- /dev/null +++ b/benchmark/IOL/ioling_hf/evals/results/google__gemma-3-4b-it__diverse5.scores.jsonl @@ -0,0 +1,5 @@ +{"record_id": "iol-2006-individual-p1-sub-assignment_1", "score": 0.0, "max_score": 4.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["assignment_1.1", "assignment_1.2", "assignment_1.3", "assignment_1.4"], "unit_results": [{"unit_id": "assignment_1.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 75.325, "full_output_similarity": 72.5}, {"unit_id": "assignment_1.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 81.818, "full_output_similarity": 81.818}, {"unit_id": "assignment_1.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 54.651, "full_output_similarity": 57.955}, {"unit_id": "assignment_1.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 85.714, "full_output_similarity": 85.714}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-4b-it"} +{"record_id": "iol-2011-individual-p1-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 50.676, "full_output_similarity": 54.0}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-4b-it"} +{"record_id": "iol-2015-individual-p5-sub-b", "score": 0.0, "max_score": 9.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["b.1", "b.2", "b.3", "b.4", "b.5", "b.6", "b.7", "b.8", "b.9"], "unit_results": [{"unit_id": "b.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 22.857, "full_output_similarity": 77.778}, {"unit_id": "b.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 22.222, "full_output_similarity": 82.609}, {"unit_id": "b.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 20.0, "full_output_similarity": 77.778}, {"unit_id": "b.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 25.0, "full_output_similarity": 75.0}, {"unit_id": "b.5", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 22.222, "full_output_similarity": 75.0}, {"unit_id": "b.6", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 25.0, "full_output_similarity": 75.862}, {"unit_id": "b.7", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 22.222, "full_output_similarity": 80.0}, {"unit_id": "b.8", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 24.242, "full_output_similarity": 70.0}, {"unit_id": "b.9", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 22.222, "full_output_similarity": 77.778}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-4b-it"} +{"record_id": "iol-2021-individual-p2-sub-a", "score": 0.0, "max_score": 9.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1", "a.2", "a.3", "a.4", "a.5", "a.6", "a.7", "a.8", "a.9"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 34.783, "full_output_similarity": 48.718}, {"unit_id": "a.2", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 32.727, "full_output_similarity": 66.667}, {"unit_id": "a.3", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 34.483, "full_output_similarity": 70.0}, {"unit_id": "a.4", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 27.907, "full_output_similarity": 92.857}, {"unit_id": "a.5", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 33.333, "full_output_similarity": 60.606}, {"unit_id": "a.6", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 32.0, "full_output_similarity": 73.333}, {"unit_id": "a.7", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 33.333, "full_output_similarity": 77.778}, {"unit_id": "a.8", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 32.727, "full_output_similarity": 67.742}, {"unit_id": "a.9", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 36.364, "full_output_similarity": 77.778}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-4b-it"} +{"record_id": "iol-2025-team-p1-sub-a", "score": 0.0, "max_score": 1.0, "score_fraction": 0.0, "verdict": "incorrect", "matched_units": [], "missed_units": ["a.1"], "unit_results": [{"unit_id": "a.1", "points": 1.0, "matched": false, "match_type": "none", "final_similarity": 40.909, "full_output_similarity": 32.738}], "method": "normalized_final_answer_unit_fuzzy_v3", "scoring_scope": "final_answer_only", "scorer_thresholds": {"final_partial_ratio": 92, "full_output_partial_ratio": null}, "needs_human_review": true, "model": "google/gemma-3-4b-it"} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/02/02247edece2e0f94830ea9c49eac9201 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/02/02247edece2e0f94830ea9c49eac9201 new file mode 100644 index 0000000000000000000000000000000000000000..21ca38d69ebc8e195a49d0699cc5980edc852d59 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/02/02247edece2e0f94830ea9c49eac9201 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/0445e5086c2a16c9d4d9673ccfc3ceb8 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/0445e5086c2a16c9d4d9673ccfc3ceb8 new file mode 100644 index 0000000000000000000000000000000000000000..4034c28734e4025867d59004ce02754a635e3569 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/0445e5086c2a16c9d4d9673ccfc3ceb8 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/044ac2f71a62fd4f3246dc5875a581a2 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/044ac2f71a62fd4f3246dc5875a581a2 new file mode 100644 index 0000000000000000000000000000000000000000..f9e64612474533db25edab771b7cbd00cff9ba5f Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/044ac2f71a62fd4f3246dc5875a581a2 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/046c7f3a432c18e9d626799034bc8eb0 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/046c7f3a432c18e9d626799034bc8eb0 new file mode 100644 index 0000000000000000000000000000000000000000..1463a57974b8269708edf403e670c0e2ba68c094 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/046c7f3a432c18e9d626799034bc8eb0 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/047ff758d07ae6a6723fc4ab7f57331d b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/047ff758d07ae6a6723fc4ab7f57331d new file mode 100644 index 0000000000000000000000000000000000000000..0e8286c348337739d74d4ad9fc77ec9d8692e02e Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/047ff758d07ae6a6723fc4ab7f57331d differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/04943cfb07c16ca8f6fd08dfa2210e19 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/04943cfb07c16ca8f6fd08dfa2210e19 new file mode 100644 index 0000000000000000000000000000000000000000..4e66b5fbe7f27d5bea269aaf49524dbd641a4f44 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/04943cfb07c16ca8f6fd08dfa2210e19 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/04a5ae12bf52d66ad7f74ed7e5b0be1c b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/04a5ae12bf52d66ad7f74ed7e5b0be1c new file mode 100644 index 0000000000000000000000000000000000000000..84c4a096dcc3f063470fc5f62f8f3344e7e484c0 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/04a5ae12bf52d66ad7f74ed7e5b0be1c differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/04b6ad4ab45c229badd696763e6d1d4f b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/04b6ad4ab45c229badd696763e6d1d4f new file mode 100644 index 0000000000000000000000000000000000000000..526e557852d903fb507a48b4e984c729a36becce Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/04b6ad4ab45c229badd696763e6d1d4f differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/04c5c10b2e0fd8c86bcce0a16604b5b9 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/04c5c10b2e0fd8c86bcce0a16604b5b9 new file mode 100644 index 0000000000000000000000000000000000000000..eb76f38d8bc48ef955fe7978688f3fdebc734625 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/04c5c10b2e0fd8c86bcce0a16604b5b9 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/04cdda6faeef920e536ecbfa9c916564 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/04cdda6faeef920e536ecbfa9c916564 new file mode 100644 index 0000000000000000000000000000000000000000..4e67a425dc080ed608ea269cc93df2d599c3e17b Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/04cdda6faeef920e536ecbfa9c916564 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/04fb576285645be8180c6c196b6cdc81 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/04fb576285645be8180c6c196b6cdc81 new file mode 100644 index 0000000000000000000000000000000000000000..bf4cb17941b2854aea4c4f12b4db67ea57a48ef7 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/04/04fb576285645be8180c6c196b6cdc81 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/05/0508d9e04fd4ba5cdd2b88cbc6f407f2 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/05/0508d9e04fd4ba5cdd2b88cbc6f407f2 new file mode 100644 index 0000000000000000000000000000000000000000..58324c4378e3bd9ec2d1df9363a895f372d49fd7 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/05/0508d9e04fd4ba5cdd2b88cbc6f407f2 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/05/050c3d280a2e9e35a786d0dafe32ec95 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/05/050c3d280a2e9e35a786d0dafe32ec95 new file mode 100644 index 0000000000000000000000000000000000000000..c533c142870a79ce980bdeb314bc1b9068043941 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/05/050c3d280a2e9e35a786d0dafe32ec95 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/05/05725f8b1e07a484a204fefe43f31e0f b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/05/05725f8b1e07a484a204fefe43f31e0f new file mode 100644 index 0000000000000000000000000000000000000000..59190b267959863e23e50a0b2aa0e9b9e4537e2c Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/05/05725f8b1e07a484a204fefe43f31e0f differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/05/057e78a76c3ed9644205ebf51d3b44d2 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/05/057e78a76c3ed9644205ebf51d3b44d2 new file mode 100644 index 0000000000000000000000000000000000000000..9aaca6ab6598b804265680e43e58cccfadbbccd1 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/05/057e78a76c3ed9644205ebf51d3b44d2 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/Icons/Selected/Split Bones@3x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/Icons/Selected/Split Bones@3x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..c988a0a38977e5ca952e2bead2ed2a1456466c4d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/Icons/Selected/Split Bones@3x.png.meta @@ -0,0 +1,128 @@ +fileFormatVersion: 2 +guid: 29f90cd6202745c448e74a1398b1c731 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: -1 + aniso: -1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 1 + spriteExtrude: 1 + spriteMeshType: 0 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 0 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 8 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 1 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 1 + - serializedVersion: 3 + buildTarget: iPhone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 1 + - serializedVersion: 3 + buildTarget: Windows Store Apps + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 1 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: aaa63c5d39eede94a90fb278e5431624 + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/Icons/Selected/character_Mode@4x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/Icons/Selected/character_Mode@4x.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..73f43046aaac4770f9ca8d417e38c8b8a0c28105 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/Icons/Selected/character_Mode@4x.png.meta @@ -0,0 +1,128 @@ +fileFormatVersion: 2 +guid: 0ccc508108fa6ed4fa11b4a467d7f609 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 10 + mipmaps: + mipMapMode: 0 + enableMipMap: 0 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: -1 + aniso: -1 + mipBias: -100 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 0 + lightmap: 0 + compressionQuality: 50 + spriteMode: 1 + spriteExtrude: 1 + spriteMeshType: 0 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 0 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 8 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 1 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 1 + - serializedVersion: 3 + buildTarget: iPhone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 1 + - serializedVersion: 3 + buildTarget: Windows Store Apps + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 1 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: dd303fede52875c4681a84cfdb2e4de6 + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/AssociateBonesScope.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/AssociateBonesScope.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..16d77b8c4e0245af46687e978e139fd65a36abc7 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/AssociateBonesScope.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5379fb539445eb24ea7ac709f8df31b9 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/BaseTool.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/BaseTool.cs new file mode 100644 index 0000000000000000000000000000000000000000..59286f2fe7da1b93f12a23a8dbf24a758fe4a6d2 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/BaseTool.cs @@ -0,0 +1,68 @@ +using System; +using UnityEditor.U2D.Layout; +using UnityEngine; + +namespace UnityEditor.U2D.Animation +{ + internal interface ITool {} + + internal abstract class BaseTool : SkinningObject, ITool + { + [SerializeField] + private LayoutOverlay m_LayoutOverlay; + + internal LayoutOverlay layoutOverlay + { + get + { + return m_LayoutOverlay; + } + } + + [SerializeField] + private bool m_IsActive = false; + public bool isActive + { + get { return m_IsActive; } + private set { m_IsActive = value; } + } + + public virtual int defaultControlID { get { return 0; } } + + public virtual IMeshPreviewBehaviour previewBehaviour + { + get { return null; } + } + + internal override void OnDestroy() + { + Deactivate(); + } + + public void Activate() + { + isActive = true; + OnActivate(); + } + + public void Deactivate() + { + isActive = false; + OnDeactivate(); + } + + public void DoGUI() + { + if (isActive) + OnGUI(); + } + + public virtual void Initialize(LayoutOverlay layout) + { + m_LayoutOverlay = layout; + } + protected virtual void OnActivate() {} + protected virtual void OnDeactivate() {} + protected virtual void OnGUI() {} + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/BaseTool.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/BaseTool.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..503664f105d8d457892d9a024738d67538779cc8 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/BaseTool.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: cc0c24ed6655ecc449dcbe4a8f3bd744 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/BoneDrawingUtility.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/BoneDrawingUtility.cs new file mode 100644 index 0000000000000000000000000000000000000000..f3ae2fc72ecffe60047b890d02c8e69aa753150c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/BoneDrawingUtility.cs @@ -0,0 +1,84 @@ +using UnityEngine; + +namespace UnityEditor.U2D.Animation +{ + internal static class BoneDrawingUtility + { + public static float GetBoneRadius(Vector3 position, float scale = 1.0f) + { + if (Camera.current != null) + { + return 0.15f * scale * HandleUtility.GetHandleSize(position); + } + + return 10f * scale / Handles.matrix.GetColumn(0).magnitude; + } + + public static void DrawBoneNode(Vector3 position, Vector3 forward, Color color, float scale = 1.0f) + { + Color c = Handles.color; + Handles.color = color; + + Handles.DrawSolidDisc(position, -forward, GetBoneRadius(position, scale) * 0.3f); + + Handles.color = c; + } + + public static void DrawBone(Vector3 position, Vector3 endPosition, Vector3 forward, Color color, float scale = 1.0f) + { + Color c = Handles.color; + Handles.color = color; + + var right = Vector3.right; + var v = endPosition - position; + + if (v.sqrMagnitude != 0) + right = v.normalized; + + var up = Vector3.Cross(right, forward).normalized; + var radius = GetBoneRadius(position, scale) * 0.5f; + var numSamples = 12; + + if (v.sqrMagnitude <= radius * radius) + DrawingUtility.DrawSolidArc(position, -forward, up, 360f, radius, numSamples * 2); + else + { + DrawingUtility.DrawSolidArc(position, -forward, up, 180f, radius, numSamples); + DrawingUtility.DrawLine(position, endPosition, forward, radius * 2f, 0f); + } + + Handles.color = c; + } + + public static void DrawBoneOutline(Vector3 position, Vector3 endPosition, Vector3 forward, Color color, float outlineScale = 1.35f, float scale = 1.0f) + { + outlineScale = Mathf.Max(1f, outlineScale); + + Color c = Handles.color; + Handles.color = color; + + var right = Vector3.right; + var v = endPosition - position; + + if (v.sqrMagnitude != 0) + right = v.normalized; + + var up = Vector3.Cross(right, forward).normalized; + var radius = GetBoneRadius(position, scale) * 0.5f; + var outlineWidth = radius * (outlineScale - 1f); + var numSamples = 12; + + if (v.sqrMagnitude <= radius * radius) + DrawingUtility.DrawSolidArc(position, -forward, up, 360f, radius, outlineScale, numSamples * 2); + else + { + DrawingUtility.DrawSolidArc(position, -forward, up, 180f, radius, outlineScale, numSamples); + DrawingUtility.DrawSolidArc(endPosition, -forward, -up, 180f, outlineWidth, 0f, numSamples); + DrawingUtility.DrawLine(position + up * (radius + outlineWidth * 0.5f), endPosition + up * outlineWidth * 0.5f, forward, outlineWidth, outlineWidth); + DrawingUtility.DrawLine(position - up * (radius + outlineWidth * 0.5f), endPosition - up * outlineWidth * 0.5f, forward, outlineWidth, outlineWidth); + } + + Handles.color = c; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Cache/BaseObject.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Cache/BaseObject.cs new file mode 100644 index 0000000000000000000000000000000000000000..9cf75cfa920afa1ec45a77e259232985aec770b3 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Cache/BaseObject.cs @@ -0,0 +1,106 @@ +using System; +using UnityEngine; + +namespace UnityEditor.U2D.Animation +{ +#if CODE_COVERAGE + internal class BaseObject + { + public static T CreateInstance() + { + return Activator.CreateInstance(); + } + + public static void DestroyImmediate(object o) + { + if (o is BaseObject) + { + var obj = o as BaseObject; + obj.OnDestroy(); + s_Objects.Remove(obj.GetInstanceID()); + } + else if (o is UnityEngine.Object) + { + var obj = o as UnityEngine.Object; + Undo.ClearUndo(obj); + UnityEngine.Object.DestroyImmediate(obj); + } + } + + public static BaseObject InstanceIDToObject(int instanceID) + { + var obj = default(BaseObject); + s_Objects.TryGetValue(instanceID, out obj); + return obj; + } + + private static Dictionary s_Objects = new Dictionary(); + private static int s_InstanceID = 0; + private int m_InstanceID; + + public string name { get; set; } + public HideFlags hideFlags = HideFlags.None; + + public BaseObject() + { + m_InstanceID = ++s_InstanceID; + s_Objects.Add(m_InstanceID, this); + } + + internal virtual void OnEnable() {} + internal virtual void OnDestroy() {} + + public int GetInstanceID() + { + return m_InstanceID; + } + + public override bool Equals(object other) + { + if ((other == null)) + return false; + + return object.ReferenceEquals(this, other); + } + + public override int GetHashCode() + { + return m_InstanceID.GetHashCode(); + } + + public static bool operator==(BaseObject t1, BaseObject t2) + { + if (object.ReferenceEquals(t1, null)) + return object.ReferenceEquals(t2, null); + + return object.ReferenceEquals(t1, t2); + } + + public static bool operator!=(BaseObject t1, BaseObject t2) + { + return !(t1 == t2); + } + } +#else + internal class BaseObject : ScriptableObject + { + public static void DestroyImmediate(object o) + { + if (o is UnityEngine.Object) + { + var obj = o as UnityEngine.Object; + Undo.ClearUndo(obj); + UnityEngine.Object.DestroyImmediate(obj); + } + } + + public static BaseObject InstanceIDToObject(int instanceID) + { + return EditorUtility.InstanceIDToObject(instanceID) as BaseObject; + } + + internal virtual void OnEnable() {} + internal virtual void OnDestroy() {} + } +#endif +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Selection/ITransformSelection.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Selection/ITransformSelection.cs new file mode 100644 index 0000000000000000000000000000000000000000..b9c822163ed728742d61b393c311f461983b9a5d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Selection/ITransformSelection.cs @@ -0,0 +1,11 @@ +using System; +using UnityEngine; + +namespace UnityEditor.U2D.Animation +{ + internal interface ITransformSelection : ISelection where T : TransformCache + { + T root { get; } + T[] roots { get; } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Selection/ITransformSelection.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Selection/ITransformSelection.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..7e91fdd0aadbc553e694cc82477eaf9ea39ac771 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Selection/ITransformSelection.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 08c104e7d99d71c4eb0702b4e3e4b7d5 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Selection/SerializableSelection.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Selection/SerializableSelection.cs new file mode 100644 index 0000000000000000000000000000000000000000..2b3378f0d2e5666e03f835298def88d5822e08ad --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Selection/SerializableSelection.cs @@ -0,0 +1,138 @@ +using System; +using System.Collections.Generic; +using UnityEngine; + +namespace UnityEditor.U2D.Animation +{ + [Serializable] + internal abstract class SerializableSelection : ISelection, ISerializationCallbackReceiver + { + internal readonly static int kInvalidID = -1; + + [SerializeField] + private T[] m_Keys = new T[0]; + + private HashSet m_Selection = new HashSet(); + private HashSet m_TemporalSelection = new HashSet(); + private bool m_SelectionInProgress = false; + + public int Count + { + get { return m_Selection.Count + m_TemporalSelection.Count; } + } + + public T activeElement + { + get { return First(); } + set + { + Clear(); + Select(value, true); + } + } + + public T[] elements + { + get + { + var set = m_Selection; + + if (m_SelectionInProgress) + { + var union = new HashSet(m_Selection); + union.UnionWith(m_TemporalSelection); + set = union; + } + + return new List(set).ToArray(); + } + set + { + Clear(); + foreach(var element in value) + Select(element, true); + } + } + + protected abstract T GetInvalidElement(); + + public void Clear() + { + GetSelection().Clear(); + } + + public void BeginSelection() + { + m_SelectionInProgress = true; + Clear(); + } + + public void EndSelection(bool select) + { + m_SelectionInProgress = false; + + if (select) + m_Selection.UnionWith(m_TemporalSelection); + else + m_Selection.ExceptWith(m_TemporalSelection); + + m_TemporalSelection.Clear(); + } + + public void Select(T element, bool select) + { + if(EqualityComparer.Default.Equals(element, GetInvalidElement())) + return; + + if (select) + GetSelection().Add(element); + else if (Contains(element)) + GetSelection().Remove(element); + } + + public bool Contains(T element) + { + return m_Selection.Contains(element) || m_TemporalSelection.Contains(element); + } + + private HashSet GetSelection() + { + if (m_SelectionInProgress) + return m_TemporalSelection; + + return m_Selection; + } + + private T First() + { + T element = First(m_Selection); + + if(EqualityComparer.Default.Equals(element, GetInvalidElement())) + element = First(m_TemporalSelection); + + return element; + } + + private T First(HashSet set) + { + if(set.Count == 0) + return GetInvalidElement(); + + using (var enumerator = set.GetEnumerator()) + { + Debug.Assert(enumerator.MoveNext()); + return enumerator.Current; + } + } + + void ISerializationCallbackReceiver.OnBeforeSerialize() + { + m_Keys = new List(m_Selection).ToArray(); + } + + void ISerializationCallbackReceiver.OnAfterDeserialize() + { + elements = m_Keys; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Selection/SerializableSelection.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Selection/SerializableSelection.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..29e6726691ea07747edcd6bd71ad477c4af2dba3 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Selection/SerializableSelection.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 3fe89a573a78649d2856fde6fc441e38 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/Meshing/Iterators/EdgeIterator.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/Meshing/Iterators/EdgeIterator.cs new file mode 100644 index 0000000000000000000000000000000000000000..e713d92014f951377542a3bdcdcd634ce3a0f18a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/Meshing/Iterators/EdgeIterator.cs @@ -0,0 +1,102 @@ +// ----------------------------------------------------------------------- +// +// Triangle.NET code by Christian Woltering, http://triangle.codeplex.com/ +// +// ----------------------------------------------------------------------- + +namespace UnityEngine.U2D.Animation.TriangleNet + .Meshing.Iterators +{ + using System.Collections.Generic; + using Animation.TriangleNet.Topology; + using Animation.TriangleNet.Geometry; + + /// + /// Enumerates the edges of a triangulation. + /// + internal class EdgeIterator : IEnumerator + { + IEnumerator triangles; + Otri tri = default(Otri); + Otri neighbor = default(Otri); + Osub sub = default(Osub); + Edge current; + Vertex p1, p2; + + /// + /// Initializes a new instance of the class. + /// + public EdgeIterator(Mesh mesh) + { + triangles = mesh.triangles.GetEnumerator(); + triangles.MoveNext(); + + tri.tri = triangles.Current; + tri.orient = 0; + } + + public Edge Current + { + get { return current; } + } + + public void Dispose() + { + this.triangles.Dispose(); + } + + object System.Collections.IEnumerator.Current + { + get { return current; } + } + + public bool MoveNext() + { + if (tri.tri == null) + { + return false; + } + + current = null; + + while (current == null) + { + if (tri.orient == 3) + { + if (triangles.MoveNext()) + { + tri.tri = triangles.Current; + tri.orient = 0; + } + else + { + // Finally no more triangles + return false; + } + } + + tri.Sym(ref neighbor); + + if ((tri.tri.id < neighbor.tri.id) || (neighbor.tri.id == Mesh.DUMMY)) + { + p1 = tri.Org(); + p2 = tri.Dest(); + + tri.Pivot(ref sub); + + // Boundary mark of dummysub is 0, so we don't need to worry about that. + current = new Edge(p1.id, p2.id, sub.seg.boundary); + } + + tri.orient++; + } + + return true; + } + + public void Reset() + { + this.triangles.Reset(); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/Meshing/Iterators/EdgeIterator.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/Meshing/Iterators/EdgeIterator.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..389eff8938bafee1d819e5e8ecee4215e9fa56f1 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/Meshing/Iterators/EdgeIterator.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 43e16ced10076476cafe049a9a276377 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/Meshing/Iterators/RegionIterator.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/Meshing/Iterators/RegionIterator.cs new file mode 100644 index 0000000000000000000000000000000000000000..e4cfb622fd3ecfffa29561d6d6ccfb36cae482b0 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/Meshing/Iterators/RegionIterator.cs @@ -0,0 +1,123 @@ +// ----------------------------------------------------------------------- +// +// Original Matlab code by John Burkardt, Florida State University +// Triangle.NET code by Christian Woltering, http://triangle.codeplex.com/ +// +// ----------------------------------------------------------------------- +namespace UnityEngine.U2D.Animation.TriangleNet + .Meshing.Iterators +{ + using System; + using System.Collections.Generic; + using Animation.TriangleNet.Topology; + /// + /// Iterates the region a given triangle belongs to and applies an action + /// to each connected trianlge in that region. + /// + /// + /// The default action is to set the region id and area constraint. + /// + internal class RegionIterator + { + List region; + public RegionIterator(Mesh mesh) + { + this.region = new List(); + } + + /// + /// Set the region attribute of all trianlges connected to given triangle. + /// + /// The triangle seed. + /// If non-zero, process all triangles of the + /// region that is enclosed by segments with given boundary label. + public void Process(Triangle triangle, int boundary = 0) + { + this.Process(triangle, (tri) => + { + // Set the region id and area constraint. + tri.label = triangle.label; + tri.area = triangle.area; + }, boundary); + } + + /// + /// Process all trianlges connected to given triangle and apply given action. + /// + /// The seeding triangle. + /// The action to apply to each triangle. + /// If non-zero, process all triangles of the + /// region that is enclosed by segments with given boundary label. + public void Process(Triangle triangle, Action action, int boundary = 0) + { + // Make sure the triangle under consideration still exists. + // It may have been eaten by the virus. + if (triangle.id == Mesh.DUMMY || Otri.IsDead(triangle)) + { + return; + } + // Add the seeding triangle to the region. + region.Add(triangle); + triangle.infected = true; + if (boundary == 0) + { + // Stop at any subsegment. + ProcessRegion(action, seg => seg.hash == Mesh.DUMMY); + } + else + { + // Stop at segments that have the given boundary label. + ProcessRegion(action, seg => seg.boundary != boundary); + } + // Free up memory (virus pool should be empty anyway). + region.Clear(); + } + + /// + /// Apply given action to each triangle of selected region. + /// + /// + /// + void ProcessRegion(Action action, Func protector) + { + Otri testtri = default(Otri); + Otri neighbor = default(Otri); + Osub neighborsubseg = default(Osub); + // Loop through all the infected triangles, spreading the attribute + // and/or area constraint to their neighbors, then to their neighbors' + // neighbors. + for (int i = 0; i < region.Count; i++) + { + // WARNING: Don't use foreach, viri list gets modified. + testtri.tri = region[i]; + // Apply function. + action(testtri.tri); + // Check each of the triangle's three neighbors. + for (testtri.orient = 0; testtri.orient < 3; testtri.orient++) + { + // Find the neighbor. + testtri.Sym(ref neighbor); + // Check for a subsegment between the triangle and its neighbor. + testtri.Pivot(ref neighborsubseg); + // Make sure the neighbor exists, is not already infected, and + // isn't protected by a subsegment. + if ((neighbor.tri.id != Mesh.DUMMY) && !neighbor.IsInfected() + && protector(neighborsubseg.seg)) + { + // Infect the neighbor. + neighbor.Infect(); + // Ensure that the neighbor's neighbors will be infected. + region.Add(neighbor.tri); + } + } + } + // Uninfect all triangles. + foreach (var virus in region) + { + virus.infected = false; + } + // Empty the virus pool. + region.Clear(); + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise.meta new file mode 100644 index 0000000000000000000000000000000000000000..ed256113852f9f2f02a0026f3f82a68fed826280 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: abc6c021d7cd541b3956a3969c8c3ccb +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/PropertyAttributes.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/PropertyAttributes.cs new file mode 100644 index 0000000000000000000000000000000000000000..195be0e2b542f41fcb2932e550bfe2591e1b3ff2 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/PropertyAttributes.cs @@ -0,0 +1,6 @@ +namespace Unity.Mathematics +{ + public class PostNormalizeAttribute : UnityEngine.PropertyAttribute {} + + public class DoNotNormalizeAttribute : UnityEngine.PropertyAttribute {} +} \ No newline at end of file diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/PropertyAttributes.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/PropertyAttributes.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..934c05706bcc4ac1662e27f4a5df398c4f66054c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/PropertyAttributes.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 61cbbdd02bb00406b94029228cb3b73b +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float2x2.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float2x2.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..d0a42b290eb7ba647034975ff2371c38b3b4641f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float2x2.gen.cs @@ -0,0 +1,468 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [System.Serializable] + public partial struct float2x2 : System.IEquatable, IFormattable + { + public float2 c0; + public float2 c1; + + /// float2x2 identity transform. + public static readonly float2x2 identity = new float2x2(1.0f, 0.0f, 0.0f, 1.0f); + + /// float2x2 zero value. + public static readonly float2x2 zero; + + /// Constructs a float2x2 matrix from two float2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x2(float2 c0, float2 c1) + { + this.c0 = c0; + this.c1 = c1; + } + + /// Constructs a float2x2 matrix from 4 float values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x2(float m00, float m01, + float m10, float m11) + { + this.c0 = new float2(m00, m10); + this.c1 = new float2(m01, m11); + } + + /// Constructs a float2x2 matrix from a single float value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x2(float v) + { + this.c0 = v; + this.c1 = v; + } + + /// Constructs a float2x2 matrix from a single bool value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x2(bool v) + { + this.c0 = math.select(new float2(0.0f), new float2(1.0f), v); + this.c1 = math.select(new float2(0.0f), new float2(1.0f), v); + } + + /// Constructs a float2x2 matrix from a bool2x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x2(bool2x2 v) + { + this.c0 = math.select(new float2(0.0f), new float2(1.0f), v.c0); + this.c1 = math.select(new float2(0.0f), new float2(1.0f), v.c1); + } + + /// Constructs a float2x2 matrix from a single int value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x2(int v) + { + this.c0 = v; + this.c1 = v; + } + + /// Constructs a float2x2 matrix from a int2x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x2(int2x2 v) + { + this.c0 = v.c0; + this.c1 = v.c1; + } + + /// Constructs a float2x2 matrix from a single uint value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x2(uint v) + { + this.c0 = v; + this.c1 = v; + } + + /// Constructs a float2x2 matrix from a uint2x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x2(uint2x2 v) + { + this.c0 = v.c0; + this.c1 = v.c1; + } + + /// Constructs a float2x2 matrix from a single double value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x2(double v) + { + this.c0 = (float2)v; + this.c1 = (float2)v; + } + + /// Constructs a float2x2 matrix from a double2x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x2(double2x2 v) + { + this.c0 = (float2)v.c0; + this.c1 = (float2)v.c1; + } + + + /// Implicitly converts a single float value to a float2x2 matrix by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float2x2(float v) { return new float2x2(v); } + + /// Explicitly converts a single bool value to a float2x2 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float2x2(bool v) { return new float2x2(v); } + + /// Explicitly converts a bool2x2 matrix to a float2x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float2x2(bool2x2 v) { return new float2x2(v); } + + /// Implicitly converts a single int value to a float2x2 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float2x2(int v) { return new float2x2(v); } + + /// Implicitly converts a int2x2 matrix to a float2x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float2x2(int2x2 v) { return new float2x2(v); } + + /// Implicitly converts a single uint value to a float2x2 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float2x2(uint v) { return new float2x2(v); } + + /// Implicitly converts a uint2x2 matrix to a float2x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float2x2(uint2x2 v) { return new float2x2(v); } + + /// Explicitly converts a single double value to a float2x2 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float2x2(double v) { return new float2x2(v); } + + /// Explicitly converts a double2x2 matrix to a float2x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float2x2(double2x2 v) { return new float2x2(v); } + + + /// Returns the result of a componentwise multiplication operation on two float2x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 operator * (float2x2 lhs, float2x2 rhs) { return new float2x2 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1); } + + /// Returns the result of a componentwise multiplication operation on a float2x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 operator * (float2x2 lhs, float rhs) { return new float2x2 (lhs.c0 * rhs, lhs.c1 * rhs); } + + /// Returns the result of a componentwise multiplication operation on a float value and a float2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 operator * (float lhs, float2x2 rhs) { return new float2x2 (lhs * rhs.c0, lhs * rhs.c1); } + + + /// Returns the result of a componentwise addition operation on two float2x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 operator + (float2x2 lhs, float2x2 rhs) { return new float2x2 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1); } + + /// Returns the result of a componentwise addition operation on a float2x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 operator + (float2x2 lhs, float rhs) { return new float2x2 (lhs.c0 + rhs, lhs.c1 + rhs); } + + /// Returns the result of a componentwise addition operation on a float value and a float2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 operator + (float lhs, float2x2 rhs) { return new float2x2 (lhs + rhs.c0, lhs + rhs.c1); } + + + /// Returns the result of a componentwise subtraction operation on two float2x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 operator - (float2x2 lhs, float2x2 rhs) { return new float2x2 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1); } + + /// Returns the result of a componentwise subtraction operation on a float2x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 operator - (float2x2 lhs, float rhs) { return new float2x2 (lhs.c0 - rhs, lhs.c1 - rhs); } + + /// Returns the result of a componentwise subtraction operation on a float value and a float2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 operator - (float lhs, float2x2 rhs) { return new float2x2 (lhs - rhs.c0, lhs - rhs.c1); } + + + /// Returns the result of a componentwise division operation on two float2x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 operator / (float2x2 lhs, float2x2 rhs) { return new float2x2 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1); } + + /// Returns the result of a componentwise division operation on a float2x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 operator / (float2x2 lhs, float rhs) { return new float2x2 (lhs.c0 / rhs, lhs.c1 / rhs); } + + /// Returns the result of a componentwise division operation on a float value and a float2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 operator / (float lhs, float2x2 rhs) { return new float2x2 (lhs / rhs.c0, lhs / rhs.c1); } + + + /// Returns the result of a componentwise modulus operation on two float2x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 operator % (float2x2 lhs, float2x2 rhs) { return new float2x2 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1); } + + /// Returns the result of a componentwise modulus operation on a float2x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 operator % (float2x2 lhs, float rhs) { return new float2x2 (lhs.c0 % rhs, lhs.c1 % rhs); } + + /// Returns the result of a componentwise modulus operation on a float value and a float2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 operator % (float lhs, float2x2 rhs) { return new float2x2 (lhs % rhs.c0, lhs % rhs.c1); } + + + /// Returns the result of a componentwise increment operation on a float2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 operator ++ (float2x2 val) { return new float2x2 (++val.c0, ++val.c1); } + + + /// Returns the result of a componentwise decrement operation on a float2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 operator -- (float2x2 val) { return new float2x2 (--val.c0, --val.c1); } + + + /// Returns the result of a componentwise less than operation on two float2x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator < (float2x2 lhs, float2x2 rhs) { return new bool2x2 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1); } + + /// Returns the result of a componentwise less than operation on a float2x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator < (float2x2 lhs, float rhs) { return new bool2x2 (lhs.c0 < rhs, lhs.c1 < rhs); } + + /// Returns the result of a componentwise less than operation on a float value and a float2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator < (float lhs, float2x2 rhs) { return new bool2x2 (lhs < rhs.c0, lhs < rhs.c1); } + + + /// Returns the result of a componentwise less or equal operation on two float2x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator <= (float2x2 lhs, float2x2 rhs) { return new bool2x2 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1); } + + /// Returns the result of a componentwise less or equal operation on a float2x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator <= (float2x2 lhs, float rhs) { return new bool2x2 (lhs.c0 <= rhs, lhs.c1 <= rhs); } + + /// Returns the result of a componentwise less or equal operation on a float value and a float2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator <= (float lhs, float2x2 rhs) { return new bool2x2 (lhs <= rhs.c0, lhs <= rhs.c1); } + + + /// Returns the result of a componentwise greater than operation on two float2x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator > (float2x2 lhs, float2x2 rhs) { return new bool2x2 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1); } + + /// Returns the result of a componentwise greater than operation on a float2x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator > (float2x2 lhs, float rhs) { return new bool2x2 (lhs.c0 > rhs, lhs.c1 > rhs); } + + /// Returns the result of a componentwise greater than operation on a float value and a float2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator > (float lhs, float2x2 rhs) { return new bool2x2 (lhs > rhs.c0, lhs > rhs.c1); } + + + /// Returns the result of a componentwise greater or equal operation on two float2x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator >= (float2x2 lhs, float2x2 rhs) { return new bool2x2 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1); } + + /// Returns the result of a componentwise greater or equal operation on a float2x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator >= (float2x2 lhs, float rhs) { return new bool2x2 (lhs.c0 >= rhs, lhs.c1 >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on a float value and a float2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator >= (float lhs, float2x2 rhs) { return new bool2x2 (lhs >= rhs.c0, lhs >= rhs.c1); } + + + /// Returns the result of a componentwise unary minus operation on a float2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 operator - (float2x2 val) { return new float2x2 (-val.c0, -val.c1); } + + + /// Returns the result of a componentwise unary plus operation on a float2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 operator + (float2x2 val) { return new float2x2 (+val.c0, +val.c1); } + + + /// Returns the result of a componentwise equality operation on two float2x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator == (float2x2 lhs, float2x2 rhs) { return new bool2x2 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1); } + + /// Returns the result of a componentwise equality operation on a float2x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator == (float2x2 lhs, float rhs) { return new bool2x2 (lhs.c0 == rhs, lhs.c1 == rhs); } + + /// Returns the result of a componentwise equality operation on a float value and a float2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator == (float lhs, float2x2 rhs) { return new bool2x2 (lhs == rhs.c0, lhs == rhs.c1); } + + + /// Returns the result of a componentwise not equal operation on two float2x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator != (float2x2 lhs, float2x2 rhs) { return new bool2x2 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1); } + + /// Returns the result of a componentwise not equal operation on a float2x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator != (float2x2 lhs, float rhs) { return new bool2x2 (lhs.c0 != rhs, lhs.c1 != rhs); } + + /// Returns the result of a componentwise not equal operation on a float value and a float2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator != (float lhs, float2x2 rhs) { return new bool2x2 (lhs != rhs.c0, lhs != rhs.c1); } + + + + /// Returns the float2 element at a specified index. + unsafe public ref float2 this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 2) + throw new System.ArgumentException("index must be between[0...1]"); +#endif + fixed (float2x2* array = &this) { return ref ((float2*)array)[index]; } + } + } + + /// Returns true if the float2x2 is equal to a given float2x2, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(float2x2 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1); } + + /// Returns true if the float2x2 is equal to a given float2x2, false otherwise. + public override bool Equals(object o) { return Equals((float2x2)o); } + + + /// Returns a hash code for the float2x2. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the float2x2. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("float2x2({0}f, {1}f, {2}f, {3}f)", c0.x, c1.x, c0.y, c1.y); + } + + /// Returns a string representation of the float2x2 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("float2x2({0}f, {1}f, {2}f, {3}f)", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider)); + } + + } + + public static partial class math + { + /// Returns a float2x2 matrix constructed from two float2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 float2x2(float2 c0, float2 c1) { return new float2x2(c0, c1); } + + /// Returns a float2x2 matrix constructed from from 4 float values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 float2x2(float m00, float m01, + float m10, float m11) + { + return new float2x2(m00, m01, + m10, m11); + } + + /// Returns a float2x2 matrix constructed from a single float value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 float2x2(float v) { return new float2x2(v); } + + /// Returns a float2x2 matrix constructed from a single bool value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 float2x2(bool v) { return new float2x2(v); } + + /// Return a float2x2 matrix constructed from a bool2x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 float2x2(bool2x2 v) { return new float2x2(v); } + + /// Returns a float2x2 matrix constructed from a single int value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 float2x2(int v) { return new float2x2(v); } + + /// Return a float2x2 matrix constructed from a int2x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 float2x2(int2x2 v) { return new float2x2(v); } + + /// Returns a float2x2 matrix constructed from a single uint value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 float2x2(uint v) { return new float2x2(v); } + + /// Return a float2x2 matrix constructed from a uint2x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 float2x2(uint2x2 v) { return new float2x2(v); } + + /// Returns a float2x2 matrix constructed from a single double value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 float2x2(double v) { return new float2x2(v); } + + /// Return a float2x2 matrix constructed from a double2x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 float2x2(double2x2 v) { return new float2x2(v); } + + /// Return the float2x2 transpose of a float2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 transpose(float2x2 v) + { + return float2x2( + v.c0.x, v.c0.y, + v.c1.x, v.c1.y); + } + + /// Returns the float2x2 full inverse of a float2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 inverse(float2x2 m) + { + float a = m.c0.x; + float b = m.c1.x; + float c = m.c0.y; + float d = m.c1.y; + + float det = a * d - b * c; + + return float2x2(d, -b, -c, a) * (1.0f / det); + } + + /// Returns the determinant of a float2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float determinant(float2x2 m) + { + float a = m.c0.x; + float b = m.c1.x; + float c = m.c0.y; + float d = m.c1.y; + + return a * d - b * c; + } + + /// Returns a uint hash code of a float2x2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(float2x2 v) + { + return csum(asuint(v.c0) * uint2(0x9C9F0823u, 0x5A9CA13Bu) + + asuint(v.c1) * uint2(0xAFCDD5EFu, 0xA88D187Du)) + 0xCF6EBA1Du; + } + + /// + /// Returns a uint2 vector hash code of a float2x2 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2 hashwide(float2x2 v) + { + return (asuint(v.c0) * uint2(0x9D88E5A1u, 0xEADF0775u) + + asuint(v.c1) * uint2(0x747A9D7Bu, 0x4111F799u)) + 0xB5F05AF1u; + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float2x2.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float2x2.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..f0671d4abd0acf41c64d3cab6a5c5c403ea0787d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float2x2.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 93080f7a13fd743e3aaaac6fee9f12b6 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float2x3.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float2x3.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..54d4bc98ab86510b277cc8a74436a76af02bceb6 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float2x3.gen.cs @@ -0,0 +1,454 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [System.Serializable] + public partial struct float2x3 : System.IEquatable, IFormattable + { + public float2 c0; + public float2 c1; + public float2 c2; + + /// float2x3 zero value. + public static readonly float2x3 zero; + + /// Constructs a float2x3 matrix from three float2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x3(float2 c0, float2 c1, float2 c2) + { + this.c0 = c0; + this.c1 = c1; + this.c2 = c2; + } + + /// Constructs a float2x3 matrix from 6 float values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x3(float m00, float m01, float m02, + float m10, float m11, float m12) + { + this.c0 = new float2(m00, m10); + this.c1 = new float2(m01, m11); + this.c2 = new float2(m02, m12); + } + + /// Constructs a float2x3 matrix from a single float value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x3(float v) + { + this.c0 = v; + this.c1 = v; + this.c2 = v; + } + + /// Constructs a float2x3 matrix from a single bool value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x3(bool v) + { + this.c0 = math.select(new float2(0.0f), new float2(1.0f), v); + this.c1 = math.select(new float2(0.0f), new float2(1.0f), v); + this.c2 = math.select(new float2(0.0f), new float2(1.0f), v); + } + + /// Constructs a float2x3 matrix from a bool2x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x3(bool2x3 v) + { + this.c0 = math.select(new float2(0.0f), new float2(1.0f), v.c0); + this.c1 = math.select(new float2(0.0f), new float2(1.0f), v.c1); + this.c2 = math.select(new float2(0.0f), new float2(1.0f), v.c2); + } + + /// Constructs a float2x3 matrix from a single int value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x3(int v) + { + this.c0 = v; + this.c1 = v; + this.c2 = v; + } + + /// Constructs a float2x3 matrix from a int2x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x3(int2x3 v) + { + this.c0 = v.c0; + this.c1 = v.c1; + this.c2 = v.c2; + } + + /// Constructs a float2x3 matrix from a single uint value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x3(uint v) + { + this.c0 = v; + this.c1 = v; + this.c2 = v; + } + + /// Constructs a float2x3 matrix from a uint2x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x3(uint2x3 v) + { + this.c0 = v.c0; + this.c1 = v.c1; + this.c2 = v.c2; + } + + /// Constructs a float2x3 matrix from a single double value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x3(double v) + { + this.c0 = (float2)v; + this.c1 = (float2)v; + this.c2 = (float2)v; + } + + /// Constructs a float2x3 matrix from a double2x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x3(double2x3 v) + { + this.c0 = (float2)v.c0; + this.c1 = (float2)v.c1; + this.c2 = (float2)v.c2; + } + + + /// Implicitly converts a single float value to a float2x3 matrix by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float2x3(float v) { return new float2x3(v); } + + /// Explicitly converts a single bool value to a float2x3 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float2x3(bool v) { return new float2x3(v); } + + /// Explicitly converts a bool2x3 matrix to a float2x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float2x3(bool2x3 v) { return new float2x3(v); } + + /// Implicitly converts a single int value to a float2x3 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float2x3(int v) { return new float2x3(v); } + + /// Implicitly converts a int2x3 matrix to a float2x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float2x3(int2x3 v) { return new float2x3(v); } + + /// Implicitly converts a single uint value to a float2x3 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float2x3(uint v) { return new float2x3(v); } + + /// Implicitly converts a uint2x3 matrix to a float2x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float2x3(uint2x3 v) { return new float2x3(v); } + + /// Explicitly converts a single double value to a float2x3 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float2x3(double v) { return new float2x3(v); } + + /// Explicitly converts a double2x3 matrix to a float2x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float2x3(double2x3 v) { return new float2x3(v); } + + + /// Returns the result of a componentwise multiplication operation on two float2x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 operator * (float2x3 lhs, float2x3 rhs) { return new float2x3 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2); } + + /// Returns the result of a componentwise multiplication operation on a float2x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 operator * (float2x3 lhs, float rhs) { return new float2x3 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs); } + + /// Returns the result of a componentwise multiplication operation on a float value and a float2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 operator * (float lhs, float2x3 rhs) { return new float2x3 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2); } + + + /// Returns the result of a componentwise addition operation on two float2x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 operator + (float2x3 lhs, float2x3 rhs) { return new float2x3 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2); } + + /// Returns the result of a componentwise addition operation on a float2x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 operator + (float2x3 lhs, float rhs) { return new float2x3 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs); } + + /// Returns the result of a componentwise addition operation on a float value and a float2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 operator + (float lhs, float2x3 rhs) { return new float2x3 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2); } + + + /// Returns the result of a componentwise subtraction operation on two float2x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 operator - (float2x3 lhs, float2x3 rhs) { return new float2x3 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2); } + + /// Returns the result of a componentwise subtraction operation on a float2x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 operator - (float2x3 lhs, float rhs) { return new float2x3 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs); } + + /// Returns the result of a componentwise subtraction operation on a float value and a float2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 operator - (float lhs, float2x3 rhs) { return new float2x3 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2); } + + + /// Returns the result of a componentwise division operation on two float2x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 operator / (float2x3 lhs, float2x3 rhs) { return new float2x3 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2); } + + /// Returns the result of a componentwise division operation on a float2x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 operator / (float2x3 lhs, float rhs) { return new float2x3 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs); } + + /// Returns the result of a componentwise division operation on a float value and a float2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 operator / (float lhs, float2x3 rhs) { return new float2x3 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2); } + + + /// Returns the result of a componentwise modulus operation on two float2x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 operator % (float2x3 lhs, float2x3 rhs) { return new float2x3 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2); } + + /// Returns the result of a componentwise modulus operation on a float2x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 operator % (float2x3 lhs, float rhs) { return new float2x3 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs); } + + /// Returns the result of a componentwise modulus operation on a float value and a float2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 operator % (float lhs, float2x3 rhs) { return new float2x3 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2); } + + + /// Returns the result of a componentwise increment operation on a float2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 operator ++ (float2x3 val) { return new float2x3 (++val.c0, ++val.c1, ++val.c2); } + + + /// Returns the result of a componentwise decrement operation on a float2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 operator -- (float2x3 val) { return new float2x3 (--val.c0, --val.c1, --val.c2); } + + + /// Returns the result of a componentwise less than operation on two float2x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator < (float2x3 lhs, float2x3 rhs) { return new bool2x3 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2); } + + /// Returns the result of a componentwise less than operation on a float2x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator < (float2x3 lhs, float rhs) { return new bool2x3 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs); } + + /// Returns the result of a componentwise less than operation on a float value and a float2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator < (float lhs, float2x3 rhs) { return new bool2x3 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2); } + + + /// Returns the result of a componentwise less or equal operation on two float2x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator <= (float2x3 lhs, float2x3 rhs) { return new bool2x3 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2); } + + /// Returns the result of a componentwise less or equal operation on a float2x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator <= (float2x3 lhs, float rhs) { return new bool2x3 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs); } + + /// Returns the result of a componentwise less or equal operation on a float value and a float2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator <= (float lhs, float2x3 rhs) { return new bool2x3 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2); } + + + /// Returns the result of a componentwise greater than operation on two float2x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator > (float2x3 lhs, float2x3 rhs) { return new bool2x3 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2); } + + /// Returns the result of a componentwise greater than operation on a float2x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator > (float2x3 lhs, float rhs) { return new bool2x3 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs); } + + /// Returns the result of a componentwise greater than operation on a float value and a float2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator > (float lhs, float2x3 rhs) { return new bool2x3 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2); } + + + /// Returns the result of a componentwise greater or equal operation on two float2x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator >= (float2x3 lhs, float2x3 rhs) { return new bool2x3 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2); } + + /// Returns the result of a componentwise greater or equal operation on a float2x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator >= (float2x3 lhs, float rhs) { return new bool2x3 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on a float value and a float2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator >= (float lhs, float2x3 rhs) { return new bool2x3 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2); } + + + /// Returns the result of a componentwise unary minus operation on a float2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 operator - (float2x3 val) { return new float2x3 (-val.c0, -val.c1, -val.c2); } + + + /// Returns the result of a componentwise unary plus operation on a float2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 operator + (float2x3 val) { return new float2x3 (+val.c0, +val.c1, +val.c2); } + + + /// Returns the result of a componentwise equality operation on two float2x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator == (float2x3 lhs, float2x3 rhs) { return new bool2x3 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2); } + + /// Returns the result of a componentwise equality operation on a float2x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator == (float2x3 lhs, float rhs) { return new bool2x3 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs); } + + /// Returns the result of a componentwise equality operation on a float value and a float2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator == (float lhs, float2x3 rhs) { return new bool2x3 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2); } + + + /// Returns the result of a componentwise not equal operation on two float2x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator != (float2x3 lhs, float2x3 rhs) { return new bool2x3 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2); } + + /// Returns the result of a componentwise not equal operation on a float2x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator != (float2x3 lhs, float rhs) { return new bool2x3 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs); } + + /// Returns the result of a componentwise not equal operation on a float value and a float2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator != (float lhs, float2x3 rhs) { return new bool2x3 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2); } + + + + /// Returns the float2 element at a specified index. + unsafe public ref float2 this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 3) + throw new System.ArgumentException("index must be between[0...2]"); +#endif + fixed (float2x3* array = &this) { return ref ((float2*)array)[index]; } + } + } + + /// Returns true if the float2x3 is equal to a given float2x3, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(float2x3 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2); } + + /// Returns true if the float2x3 is equal to a given float2x3, false otherwise. + public override bool Equals(object o) { return Equals((float2x3)o); } + + + /// Returns a hash code for the float2x3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the float2x3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("float2x3({0}f, {1}f, {2}f, {3}f, {4}f, {5}f)", c0.x, c1.x, c2.x, c0.y, c1.y, c2.y); + } + + /// Returns a string representation of the float2x3 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("float2x3({0}f, {1}f, {2}f, {3}f, {4}f, {5}f)", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider)); + } + + } + + public static partial class math + { + /// Returns a float2x3 matrix constructed from three float2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 float2x3(float2 c0, float2 c1, float2 c2) { return new float2x3(c0, c1, c2); } + + /// Returns a float2x3 matrix constructed from from 6 float values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 float2x3(float m00, float m01, float m02, + float m10, float m11, float m12) + { + return new float2x3(m00, m01, m02, + m10, m11, m12); + } + + /// Returns a float2x3 matrix constructed from a single float value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 float2x3(float v) { return new float2x3(v); } + + /// Returns a float2x3 matrix constructed from a single bool value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 float2x3(bool v) { return new float2x3(v); } + + /// Return a float2x3 matrix constructed from a bool2x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 float2x3(bool2x3 v) { return new float2x3(v); } + + /// Returns a float2x3 matrix constructed from a single int value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 float2x3(int v) { return new float2x3(v); } + + /// Return a float2x3 matrix constructed from a int2x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 float2x3(int2x3 v) { return new float2x3(v); } + + /// Returns a float2x3 matrix constructed from a single uint value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 float2x3(uint v) { return new float2x3(v); } + + /// Return a float2x3 matrix constructed from a uint2x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 float2x3(uint2x3 v) { return new float2x3(v); } + + /// Returns a float2x3 matrix constructed from a single double value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 float2x3(double v) { return new float2x3(v); } + + /// Return a float2x3 matrix constructed from a double2x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 float2x3(double2x3 v) { return new float2x3(v); } + + /// Return the float3x2 transpose of a float2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 transpose(float2x3 v) + { + return float3x2( + v.c0.x, v.c0.y, + v.c1.x, v.c1.y, + v.c2.x, v.c2.y); + } + + /// Returns a uint hash code of a float2x3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(float2x3 v) + { + return csum(asuint(v.c0) * uint2(0xE857DCE1u, 0xF62213C5u) + + asuint(v.c1) * uint2(0x9CDAA959u, 0xAA269ABFu) + + asuint(v.c2) * uint2(0xD54BA36Fu, 0xFD0847B9u)) + 0x8189A683u; + } + + /// + /// Returns a uint2 vector hash code of a float2x3 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2 hashwide(float2x3 v) + { + return (asuint(v.c0) * uint2(0xB139D651u, 0xE7579997u) + + asuint(v.c1) * uint2(0xEF7D56C7u, 0x66F38F0Bu) + + asuint(v.c2) * uint2(0x624256A3u, 0x5292ADE1u)) + 0xD2E590E5u; + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float2x3.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float2x3.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..509bdb81ab4e06879a0a3b2fcf04dce2cdb18a53 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float2x3.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f6047b8d8f85d4465b798320ea146853 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float2x4.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float2x4.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..5e668893e9f1d6e86da909728e87e598dbd238bd --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float2x4.gen.cs @@ -0,0 +1,469 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [System.Serializable] + public partial struct float2x4 : System.IEquatable, IFormattable + { + public float2 c0; + public float2 c1; + public float2 c2; + public float2 c3; + + /// float2x4 zero value. + public static readonly float2x4 zero; + + /// Constructs a float2x4 matrix from four float2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x4(float2 c0, float2 c1, float2 c2, float2 c3) + { + this.c0 = c0; + this.c1 = c1; + this.c2 = c2; + this.c3 = c3; + } + + /// Constructs a float2x4 matrix from 8 float values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x4(float m00, float m01, float m02, float m03, + float m10, float m11, float m12, float m13) + { + this.c0 = new float2(m00, m10); + this.c1 = new float2(m01, m11); + this.c2 = new float2(m02, m12); + this.c3 = new float2(m03, m13); + } + + /// Constructs a float2x4 matrix from a single float value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x4(float v) + { + this.c0 = v; + this.c1 = v; + this.c2 = v; + this.c3 = v; + } + + /// Constructs a float2x4 matrix from a single bool value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x4(bool v) + { + this.c0 = math.select(new float2(0.0f), new float2(1.0f), v); + this.c1 = math.select(new float2(0.0f), new float2(1.0f), v); + this.c2 = math.select(new float2(0.0f), new float2(1.0f), v); + this.c3 = math.select(new float2(0.0f), new float2(1.0f), v); + } + + /// Constructs a float2x4 matrix from a bool2x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x4(bool2x4 v) + { + this.c0 = math.select(new float2(0.0f), new float2(1.0f), v.c0); + this.c1 = math.select(new float2(0.0f), new float2(1.0f), v.c1); + this.c2 = math.select(new float2(0.0f), new float2(1.0f), v.c2); + this.c3 = math.select(new float2(0.0f), new float2(1.0f), v.c3); + } + + /// Constructs a float2x4 matrix from a single int value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x4(int v) + { + this.c0 = v; + this.c1 = v; + this.c2 = v; + this.c3 = v; + } + + /// Constructs a float2x4 matrix from a int2x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x4(int2x4 v) + { + this.c0 = v.c0; + this.c1 = v.c1; + this.c2 = v.c2; + this.c3 = v.c3; + } + + /// Constructs a float2x4 matrix from a single uint value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x4(uint v) + { + this.c0 = v; + this.c1 = v; + this.c2 = v; + this.c3 = v; + } + + /// Constructs a float2x4 matrix from a uint2x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x4(uint2x4 v) + { + this.c0 = v.c0; + this.c1 = v.c1; + this.c2 = v.c2; + this.c3 = v.c3; + } + + /// Constructs a float2x4 matrix from a single double value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x4(double v) + { + this.c0 = (float2)v; + this.c1 = (float2)v; + this.c2 = (float2)v; + this.c3 = (float2)v; + } + + /// Constructs a float2x4 matrix from a double2x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2x4(double2x4 v) + { + this.c0 = (float2)v.c0; + this.c1 = (float2)v.c1; + this.c2 = (float2)v.c2; + this.c3 = (float2)v.c3; + } + + + /// Implicitly converts a single float value to a float2x4 matrix by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float2x4(float v) { return new float2x4(v); } + + /// Explicitly converts a single bool value to a float2x4 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float2x4(bool v) { return new float2x4(v); } + + /// Explicitly converts a bool2x4 matrix to a float2x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float2x4(bool2x4 v) { return new float2x4(v); } + + /// Implicitly converts a single int value to a float2x4 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float2x4(int v) { return new float2x4(v); } + + /// Implicitly converts a int2x4 matrix to a float2x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float2x4(int2x4 v) { return new float2x4(v); } + + /// Implicitly converts a single uint value to a float2x4 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float2x4(uint v) { return new float2x4(v); } + + /// Implicitly converts a uint2x4 matrix to a float2x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float2x4(uint2x4 v) { return new float2x4(v); } + + /// Explicitly converts a single double value to a float2x4 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float2x4(double v) { return new float2x4(v); } + + /// Explicitly converts a double2x4 matrix to a float2x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float2x4(double2x4 v) { return new float2x4(v); } + + + /// Returns the result of a componentwise multiplication operation on two float2x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 operator * (float2x4 lhs, float2x4 rhs) { return new float2x4 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2, lhs.c3 * rhs.c3); } + + /// Returns the result of a componentwise multiplication operation on a float2x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 operator * (float2x4 lhs, float rhs) { return new float2x4 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs, lhs.c3 * rhs); } + + /// Returns the result of a componentwise multiplication operation on a float value and a float2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 operator * (float lhs, float2x4 rhs) { return new float2x4 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2, lhs * rhs.c3); } + + + /// Returns the result of a componentwise addition operation on two float2x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 operator + (float2x4 lhs, float2x4 rhs) { return new float2x4 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2, lhs.c3 + rhs.c3); } + + /// Returns the result of a componentwise addition operation on a float2x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 operator + (float2x4 lhs, float rhs) { return new float2x4 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs, lhs.c3 + rhs); } + + /// Returns the result of a componentwise addition operation on a float value and a float2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 operator + (float lhs, float2x4 rhs) { return new float2x4 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2, lhs + rhs.c3); } + + + /// Returns the result of a componentwise subtraction operation on two float2x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 operator - (float2x4 lhs, float2x4 rhs) { return new float2x4 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2, lhs.c3 - rhs.c3); } + + /// Returns the result of a componentwise subtraction operation on a float2x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 operator - (float2x4 lhs, float rhs) { return new float2x4 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs, lhs.c3 - rhs); } + + /// Returns the result of a componentwise subtraction operation on a float value and a float2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 operator - (float lhs, float2x4 rhs) { return new float2x4 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2, lhs - rhs.c3); } + + + /// Returns the result of a componentwise division operation on two float2x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 operator / (float2x4 lhs, float2x4 rhs) { return new float2x4 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2, lhs.c3 / rhs.c3); } + + /// Returns the result of a componentwise division operation on a float2x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 operator / (float2x4 lhs, float rhs) { return new float2x4 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs, lhs.c3 / rhs); } + + /// Returns the result of a componentwise division operation on a float value and a float2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 operator / (float lhs, float2x4 rhs) { return new float2x4 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2, lhs / rhs.c3); } + + + /// Returns the result of a componentwise modulus operation on two float2x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 operator % (float2x4 lhs, float2x4 rhs) { return new float2x4 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2, lhs.c3 % rhs.c3); } + + /// Returns the result of a componentwise modulus operation on a float2x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 operator % (float2x4 lhs, float rhs) { return new float2x4 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs, lhs.c3 % rhs); } + + /// Returns the result of a componentwise modulus operation on a float value and a float2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 operator % (float lhs, float2x4 rhs) { return new float2x4 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2, lhs % rhs.c3); } + + + /// Returns the result of a componentwise increment operation on a float2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 operator ++ (float2x4 val) { return new float2x4 (++val.c0, ++val.c1, ++val.c2, ++val.c3); } + + + /// Returns the result of a componentwise decrement operation on a float2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 operator -- (float2x4 val) { return new float2x4 (--val.c0, --val.c1, --val.c2, --val.c3); } + + + /// Returns the result of a componentwise less than operation on two float2x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator < (float2x4 lhs, float2x4 rhs) { return new bool2x4 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2, lhs.c3 < rhs.c3); } + + /// Returns the result of a componentwise less than operation on a float2x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator < (float2x4 lhs, float rhs) { return new bool2x4 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs, lhs.c3 < rhs); } + + /// Returns the result of a componentwise less than operation on a float value and a float2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator < (float lhs, float2x4 rhs) { return new bool2x4 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2, lhs < rhs.c3); } + + + /// Returns the result of a componentwise less or equal operation on two float2x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator <= (float2x4 lhs, float2x4 rhs) { return new bool2x4 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2, lhs.c3 <= rhs.c3); } + + /// Returns the result of a componentwise less or equal operation on a float2x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator <= (float2x4 lhs, float rhs) { return new bool2x4 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs, lhs.c3 <= rhs); } + + /// Returns the result of a componentwise less or equal operation on a float value and a float2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator <= (float lhs, float2x4 rhs) { return new bool2x4 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2, lhs <= rhs.c3); } + + + /// Returns the result of a componentwise greater than operation on two float2x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator > (float2x4 lhs, float2x4 rhs) { return new bool2x4 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2, lhs.c3 > rhs.c3); } + + /// Returns the result of a componentwise greater than operation on a float2x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator > (float2x4 lhs, float rhs) { return new bool2x4 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs, lhs.c3 > rhs); } + + /// Returns the result of a componentwise greater than operation on a float value and a float2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator > (float lhs, float2x4 rhs) { return new bool2x4 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2, lhs > rhs.c3); } + + + /// Returns the result of a componentwise greater or equal operation on two float2x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator >= (float2x4 lhs, float2x4 rhs) { return new bool2x4 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2, lhs.c3 >= rhs.c3); } + + /// Returns the result of a componentwise greater or equal operation on a float2x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator >= (float2x4 lhs, float rhs) { return new bool2x4 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs, lhs.c3 >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on a float value and a float2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator >= (float lhs, float2x4 rhs) { return new bool2x4 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2, lhs >= rhs.c3); } + + + /// Returns the result of a componentwise unary minus operation on a float2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 operator - (float2x4 val) { return new float2x4 (-val.c0, -val.c1, -val.c2, -val.c3); } + + + /// Returns the result of a componentwise unary plus operation on a float2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 operator + (float2x4 val) { return new float2x4 (+val.c0, +val.c1, +val.c2, +val.c3); } + + + /// Returns the result of a componentwise equality operation on two float2x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator == (float2x4 lhs, float2x4 rhs) { return new bool2x4 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2, lhs.c3 == rhs.c3); } + + /// Returns the result of a componentwise equality operation on a float2x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator == (float2x4 lhs, float rhs) { return new bool2x4 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs, lhs.c3 == rhs); } + + /// Returns the result of a componentwise equality operation on a float value and a float2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator == (float lhs, float2x4 rhs) { return new bool2x4 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2, lhs == rhs.c3); } + + + /// Returns the result of a componentwise not equal operation on two float2x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator != (float2x4 lhs, float2x4 rhs) { return new bool2x4 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2, lhs.c3 != rhs.c3); } + + /// Returns the result of a componentwise not equal operation on a float2x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator != (float2x4 lhs, float rhs) { return new bool2x4 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs, lhs.c3 != rhs); } + + /// Returns the result of a componentwise not equal operation on a float value and a float2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator != (float lhs, float2x4 rhs) { return new bool2x4 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2, lhs != rhs.c3); } + + + + /// Returns the float2 element at a specified index. + unsafe public ref float2 this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 4) + throw new System.ArgumentException("index must be between[0...3]"); +#endif + fixed (float2x4* array = &this) { return ref ((float2*)array)[index]; } + } + } + + /// Returns true if the float2x4 is equal to a given float2x4, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(float2x4 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2) && c3.Equals(rhs.c3); } + + /// Returns true if the float2x4 is equal to a given float2x4, false otherwise. + public override bool Equals(object o) { return Equals((float2x4)o); } + + + /// Returns a hash code for the float2x4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the float2x4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("float2x4({0}f, {1}f, {2}f, {3}f, {4}f, {5}f, {6}f, {7}f)", c0.x, c1.x, c2.x, c3.x, c0.y, c1.y, c2.y, c3.y); + } + + /// Returns a string representation of the float2x4 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("float2x4({0}f, {1}f, {2}f, {3}f, {4}f, {5}f, {6}f, {7}f)", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c3.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider), c3.y.ToString(format, formatProvider)); + } + + } + + public static partial class math + { + /// Returns a float2x4 matrix constructed from four float2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 float2x4(float2 c0, float2 c1, float2 c2, float2 c3) { return new float2x4(c0, c1, c2, c3); } + + /// Returns a float2x4 matrix constructed from from 8 float values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 float2x4(float m00, float m01, float m02, float m03, + float m10, float m11, float m12, float m13) + { + return new float2x4(m00, m01, m02, m03, + m10, m11, m12, m13); + } + + /// Returns a float2x4 matrix constructed from a single float value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 float2x4(float v) { return new float2x4(v); } + + /// Returns a float2x4 matrix constructed from a single bool value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 float2x4(bool v) { return new float2x4(v); } + + /// Return a float2x4 matrix constructed from a bool2x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 float2x4(bool2x4 v) { return new float2x4(v); } + + /// Returns a float2x4 matrix constructed from a single int value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 float2x4(int v) { return new float2x4(v); } + + /// Return a float2x4 matrix constructed from a int2x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 float2x4(int2x4 v) { return new float2x4(v); } + + /// Returns a float2x4 matrix constructed from a single uint value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 float2x4(uint v) { return new float2x4(v); } + + /// Return a float2x4 matrix constructed from a uint2x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 float2x4(uint2x4 v) { return new float2x4(v); } + + /// Returns a float2x4 matrix constructed from a single double value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 float2x4(double v) { return new float2x4(v); } + + /// Return a float2x4 matrix constructed from a double2x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 float2x4(double2x4 v) { return new float2x4(v); } + + /// Return the float4x2 transpose of a float2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 transpose(float2x4 v) + { + return float4x2( + v.c0.x, v.c0.y, + v.c1.x, v.c1.y, + v.c2.x, v.c2.y, + v.c3.x, v.c3.y); + } + + /// Returns a uint hash code of a float2x4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(float2x4 v) + { + return csum(asuint(v.c0) * uint2(0xD35C9B2Du, 0xA10D9E27u) + + asuint(v.c1) * uint2(0x568DAAA9u, 0x7530254Fu) + + asuint(v.c2) * uint2(0x9F090439u, 0x5E9F85C9u) + + asuint(v.c3) * uint2(0x8C4CA03Fu, 0xB8D969EDu)) + 0xAC5DB57Bu; + } + + /// + /// Returns a uint2 vector hash code of a float2x4 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2 hashwide(float2x4 v) + { + return (asuint(v.c0) * uint2(0xA91A02EDu, 0xB3C49313u) + + asuint(v.c1) * uint2(0xF43A9ABBu, 0x84E7E01Bu) + + asuint(v.c2) * uint2(0x8E055BE5u, 0x6E624EB7u) + + asuint(v.c3) * uint2(0x7383ED49u, 0xDD49C23Bu)) + 0xEBD0D005u; + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float2x4.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float2x4.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..4579c6911427c8ef8f352dea696af7005e0aafa0 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float2x4.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 70c2d51ac2a824bdb88b239c4fa6122c +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..b03206b34468fbe4e2225142dda46ca6c7fde6bf --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3.gen.cs @@ -0,0 +1,1538 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; +using System.Diagnostics; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [DebuggerTypeProxy(typeof(float3.DebuggerProxy))] + [System.Serializable] + public partial struct float3 : System.IEquatable, IFormattable + { + public float x; + public float y; + public float z; + + /// float3 zero value. + public static readonly float3 zero; + + /// Constructs a float3 vector from three float values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3(float x, float y, float z) + { + this.x = x; + this.y = y; + this.z = z; + } + + /// Constructs a float3 vector from a float value and a float2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3(float x, float2 yz) + { + this.x = x; + this.y = yz.x; + this.z = yz.y; + } + + /// Constructs a float3 vector from a float2 vector and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3(float2 xy, float z) + { + this.x = xy.x; + this.y = xy.y; + this.z = z; + } + + /// Constructs a float3 vector from a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3(float3 xyz) + { + this.x = xyz.x; + this.y = xyz.y; + this.z = xyz.z; + } + + /// Constructs a float3 vector from a single float value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3(float v) + { + this.x = v; + this.y = v; + this.z = v; + } + + /// Constructs a float3 vector from a single bool value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3(bool v) + { + this.x = v ? 1.0f : 0.0f; + this.y = v ? 1.0f : 0.0f; + this.z = v ? 1.0f : 0.0f; + } + + /// Constructs a float3 vector from a bool3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3(bool3 v) + { + this.x = v.x ? 1.0f : 0.0f; + this.y = v.y ? 1.0f : 0.0f; + this.z = v.z ? 1.0f : 0.0f; + } + + /// Constructs a float3 vector from a single int value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3(int v) + { + this.x = v; + this.y = v; + this.z = v; + } + + /// Constructs a float3 vector from a int3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3(int3 v) + { + this.x = v.x; + this.y = v.y; + this.z = v.z; + } + + /// Constructs a float3 vector from a single uint value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3(uint v) + { + this.x = v; + this.y = v; + this.z = v; + } + + /// Constructs a float3 vector from a uint3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3(uint3 v) + { + this.x = v.x; + this.y = v.y; + this.z = v.z; + } + + /// Constructs a float3 vector from a single half value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3(half v) + { + this.x = v; + this.y = v; + this.z = v; + } + + /// Constructs a float3 vector from a half3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3(half3 v) + { + this.x = v.x; + this.y = v.y; + this.z = v.z; + } + + /// Constructs a float3 vector from a single double value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3(double v) + { + this.x = (float)v; + this.y = (float)v; + this.z = (float)v; + } + + /// Constructs a float3 vector from a double3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3(double3 v) + { + this.x = (float)v.x; + this.y = (float)v.y; + this.z = (float)v.z; + } + + + /// Implicitly converts a single float value to a float3 vector by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float3(float v) { return new float3(v); } + + /// Explicitly converts a single bool value to a float3 vector by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float3(bool v) { return new float3(v); } + + /// Explicitly converts a bool3 vector to a float3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float3(bool3 v) { return new float3(v); } + + /// Implicitly converts a single int value to a float3 vector by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float3(int v) { return new float3(v); } + + /// Implicitly converts a int3 vector to a float3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float3(int3 v) { return new float3(v); } + + /// Implicitly converts a single uint value to a float3 vector by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float3(uint v) { return new float3(v); } + + /// Implicitly converts a uint3 vector to a float3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float3(uint3 v) { return new float3(v); } + + /// Implicitly converts a single half value to a float3 vector by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float3(half v) { return new float3(v); } + + /// Implicitly converts a half3 vector to a float3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float3(half3 v) { return new float3(v); } + + /// Explicitly converts a single double value to a float3 vector by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float3(double v) { return new float3(v); } + + /// Explicitly converts a double3 vector to a float3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float3(double3 v) { return new float3(v); } + + + /// Returns the result of a componentwise multiplication operation on two float3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 operator * (float3 lhs, float3 rhs) { return new float3 (lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z); } + + /// Returns the result of a componentwise multiplication operation on a float3 vector and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 operator * (float3 lhs, float rhs) { return new float3 (lhs.x * rhs, lhs.y * rhs, lhs.z * rhs); } + + /// Returns the result of a componentwise multiplication operation on a float value and a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 operator * (float lhs, float3 rhs) { return new float3 (lhs * rhs.x, lhs * rhs.y, lhs * rhs.z); } + + + /// Returns the result of a componentwise addition operation on two float3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 operator + (float3 lhs, float3 rhs) { return new float3 (lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z); } + + /// Returns the result of a componentwise addition operation on a float3 vector and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 operator + (float3 lhs, float rhs) { return new float3 (lhs.x + rhs, lhs.y + rhs, lhs.z + rhs); } + + /// Returns the result of a componentwise addition operation on a float value and a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 operator + (float lhs, float3 rhs) { return new float3 (lhs + rhs.x, lhs + rhs.y, lhs + rhs.z); } + + + /// Returns the result of a componentwise subtraction operation on two float3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 operator - (float3 lhs, float3 rhs) { return new float3 (lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z); } + + /// Returns the result of a componentwise subtraction operation on a float3 vector and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 operator - (float3 lhs, float rhs) { return new float3 (lhs.x - rhs, lhs.y - rhs, lhs.z - rhs); } + + /// Returns the result of a componentwise subtraction operation on a float value and a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 operator - (float lhs, float3 rhs) { return new float3 (lhs - rhs.x, lhs - rhs.y, lhs - rhs.z); } + + + /// Returns the result of a componentwise division operation on two float3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 operator / (float3 lhs, float3 rhs) { return new float3 (lhs.x / rhs.x, lhs.y / rhs.y, lhs.z / rhs.z); } + + /// Returns the result of a componentwise division operation on a float3 vector and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 operator / (float3 lhs, float rhs) { return new float3 (lhs.x / rhs, lhs.y / rhs, lhs.z / rhs); } + + /// Returns the result of a componentwise division operation on a float value and a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 operator / (float lhs, float3 rhs) { return new float3 (lhs / rhs.x, lhs / rhs.y, lhs / rhs.z); } + + + /// Returns the result of a componentwise modulus operation on two float3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 operator % (float3 lhs, float3 rhs) { return new float3 (lhs.x % rhs.x, lhs.y % rhs.y, lhs.z % rhs.z); } + + /// Returns the result of a componentwise modulus operation on a float3 vector and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 operator % (float3 lhs, float rhs) { return new float3 (lhs.x % rhs, lhs.y % rhs, lhs.z % rhs); } + + /// Returns the result of a componentwise modulus operation on a float value and a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 operator % (float lhs, float3 rhs) { return new float3 (lhs % rhs.x, lhs % rhs.y, lhs % rhs.z); } + + + /// Returns the result of a componentwise increment operation on a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 operator ++ (float3 val) { return new float3 (++val.x, ++val.y, ++val.z); } + + + /// Returns the result of a componentwise decrement operation on a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 operator -- (float3 val) { return new float3 (--val.x, --val.y, --val.z); } + + + /// Returns the result of a componentwise less than operation on two float3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator < (float3 lhs, float3 rhs) { return new bool3 (lhs.x < rhs.x, lhs.y < rhs.y, lhs.z < rhs.z); } + + /// Returns the result of a componentwise less than operation on a float3 vector and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator < (float3 lhs, float rhs) { return new bool3 (lhs.x < rhs, lhs.y < rhs, lhs.z < rhs); } + + /// Returns the result of a componentwise less than operation on a float value and a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator < (float lhs, float3 rhs) { return new bool3 (lhs < rhs.x, lhs < rhs.y, lhs < rhs.z); } + + + /// Returns the result of a componentwise less or equal operation on two float3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator <= (float3 lhs, float3 rhs) { return new bool3 (lhs.x <= rhs.x, lhs.y <= rhs.y, lhs.z <= rhs.z); } + + /// Returns the result of a componentwise less or equal operation on a float3 vector and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator <= (float3 lhs, float rhs) { return new bool3 (lhs.x <= rhs, lhs.y <= rhs, lhs.z <= rhs); } + + /// Returns the result of a componentwise less or equal operation on a float value and a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator <= (float lhs, float3 rhs) { return new bool3 (lhs <= rhs.x, lhs <= rhs.y, lhs <= rhs.z); } + + + /// Returns the result of a componentwise greater than operation on two float3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator > (float3 lhs, float3 rhs) { return new bool3 (lhs.x > rhs.x, lhs.y > rhs.y, lhs.z > rhs.z); } + + /// Returns the result of a componentwise greater than operation on a float3 vector and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator > (float3 lhs, float rhs) { return new bool3 (lhs.x > rhs, lhs.y > rhs, lhs.z > rhs); } + + /// Returns the result of a componentwise greater than operation on a float value and a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator > (float lhs, float3 rhs) { return new bool3 (lhs > rhs.x, lhs > rhs.y, lhs > rhs.z); } + + + /// Returns the result of a componentwise greater or equal operation on two float3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator >= (float3 lhs, float3 rhs) { return new bool3 (lhs.x >= rhs.x, lhs.y >= rhs.y, lhs.z >= rhs.z); } + + /// Returns the result of a componentwise greater or equal operation on a float3 vector and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator >= (float3 lhs, float rhs) { return new bool3 (lhs.x >= rhs, lhs.y >= rhs, lhs.z >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on a float value and a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator >= (float lhs, float3 rhs) { return new bool3 (lhs >= rhs.x, lhs >= rhs.y, lhs >= rhs.z); } + + + /// Returns the result of a componentwise unary minus operation on a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 operator - (float3 val) { return new float3 (-val.x, -val.y, -val.z); } + + + /// Returns the result of a componentwise unary plus operation on a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 operator + (float3 val) { return new float3 (+val.x, +val.y, +val.z); } + + + /// Returns the result of a componentwise equality operation on two float3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator == (float3 lhs, float3 rhs) { return new bool3 (lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z); } + + /// Returns the result of a componentwise equality operation on a float3 vector and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator == (float3 lhs, float rhs) { return new bool3 (lhs.x == rhs, lhs.y == rhs, lhs.z == rhs); } + + /// Returns the result of a componentwise equality operation on a float value and a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator == (float lhs, float3 rhs) { return new bool3 (lhs == rhs.x, lhs == rhs.y, lhs == rhs.z); } + + + /// Returns the result of a componentwise not equal operation on two float3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator != (float3 lhs, float3 rhs) { return new bool3 (lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z); } + + /// Returns the result of a componentwise not equal operation on a float3 vector and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator != (float3 lhs, float rhs) { return new bool3 (lhs.x != rhs, lhs.y != rhs, lhs.z != rhs); } + + /// Returns the result of a componentwise not equal operation on a float value and a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator != (float lhs, float3 rhs) { return new bool3 (lhs != rhs.x, lhs != rhs.y, lhs != rhs.z); } + + + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xxxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xxyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, x, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xxzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xxzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, x, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xxzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xyxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, y, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xyyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xyzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, y, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xyzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xyzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xzxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xzxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, z, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xzxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xzyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, z, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xzyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xzyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xzzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xzzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xzzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yxxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yxyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, x, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yxzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yxzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, x, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yxzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yyxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, y, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yyyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yyzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, y, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yyzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yyzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yzxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yzxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, z, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yzxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yzyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, z, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yzyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yzyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yzzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yzzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yzzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zxxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zxyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, x, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zxzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zxzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, x, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zxzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zyxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, y, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zyyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zyzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, y, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zyzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zyzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zzxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zzxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, z, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zzxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zzyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, z, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zzyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zzyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zzzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zzzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zzzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 xxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 xxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 xxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 xyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 xyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 xyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(x, y, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; y = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 xzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 xzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(x, z, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; z = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 xzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 yxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 yxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 yxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(y, x, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; x = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 yyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 yyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 yyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 yzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(y, z, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; z = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 yzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 yzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 zxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 zxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(z, x, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; x = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 zxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 zyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(z, y, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; y = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 zyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 zyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 zzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 zzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 zzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float2 xx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float2(x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float2 xy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float2(x, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; y = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float2 xz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float2(x, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; z = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float2 yx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float2(y, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; x = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float2 yy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float2(y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float2 yz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float2(y, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; z = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float2 zx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float2(z, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; x = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float2 zy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float2(z, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; y = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float2 zz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float2(z, z); } + } + + + + /// Returns the float element at a specified index. + unsafe public float this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 3) + throw new System.ArgumentException("index must be between[0...2]"); +#endif + fixed (float3* array = &this) { return ((float*)array)[index]; } + } + set + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 3) + throw new System.ArgumentException("index must be between[0...2]"); +#endif + fixed (float* array = &x) { array[index] = value; } + } + } + + /// Returns true if the float3 is equal to a given float3, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(float3 rhs) { return x == rhs.x && y == rhs.y && z == rhs.z; } + + /// Returns true if the float3 is equal to a given float3, false otherwise. + public override bool Equals(object o) { return Equals((float3)o); } + + + /// Returns a hash code for the float3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the float3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("float3({0}f, {1}f, {2}f)", x, y, z); + } + + /// Returns a string representation of the float3 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("float3({0}f, {1}f, {2}f)", x.ToString(format, formatProvider), y.ToString(format, formatProvider), z.ToString(format, formatProvider)); + } + + internal sealed class DebuggerProxy + { + public float x; + public float y; + public float z; + public DebuggerProxy(float3 v) + { + x = v.x; + y = v.y; + z = v.z; + } + } + + } + + public static partial class math + { + /// Returns a float3 vector constructed from three float values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 float3(float x, float y, float z) { return new float3(x, y, z); } + + /// Returns a float3 vector constructed from a float value and a float2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 float3(float x, float2 yz) { return new float3(x, yz); } + + /// Returns a float3 vector constructed from a float2 vector and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 float3(float2 xy, float z) { return new float3(xy, z); } + + /// Returns a float3 vector constructed from a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 float3(float3 xyz) { return new float3(xyz); } + + /// Returns a float3 vector constructed from a single float value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 float3(float v) { return new float3(v); } + + /// Returns a float3 vector constructed from a single bool value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 float3(bool v) { return new float3(v); } + + /// Return a float3 vector constructed from a bool3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 float3(bool3 v) { return new float3(v); } + + /// Returns a float3 vector constructed from a single int value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 float3(int v) { return new float3(v); } + + /// Return a float3 vector constructed from a int3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 float3(int3 v) { return new float3(v); } + + /// Returns a float3 vector constructed from a single uint value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 float3(uint v) { return new float3(v); } + + /// Return a float3 vector constructed from a uint3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 float3(uint3 v) { return new float3(v); } + + /// Returns a float3 vector constructed from a single half value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 float3(half v) { return new float3(v); } + + /// Return a float3 vector constructed from a half3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 float3(half3 v) { return new float3(v); } + + /// Returns a float3 vector constructed from a single double value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 float3(double v) { return new float3(v); } + + /// Return a float3 vector constructed from a double3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 float3(double3 v) { return new float3(v); } + + /// Returns a uint hash code of a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(float3 v) + { + return csum(asuint(v) * uint3(0x9B13B92Du, 0x4ABF0813u, 0x86068063u)) + 0xD75513F9u; + } + + /// + /// Returns a uint3 vector hash code of a float3 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 hashwide(float3 v) + { + return (asuint(v) * uint3(0x5AB3E8CDu, 0x676E8407u, 0xB36DE767u)) + 0x6FCA387Du; + } + + /// Returns the result of specified shuffling of the components from two float3 vectors into a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float shuffle(float3 a, float3 b, ShuffleComponent x) + { + return select_shuffle_component(a, b, x); + } + + /// Returns the result of specified shuffling of the components from two float3 vectors into a float2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 shuffle(float3 a, float3 b, ShuffleComponent x, ShuffleComponent y) + { + return float2( + select_shuffle_component(a, b, x), + select_shuffle_component(a, b, y)); + } + + /// Returns the result of specified shuffling of the components from two float3 vectors into a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 shuffle(float3 a, float3 b, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z) + { + return float3( + select_shuffle_component(a, b, x), + select_shuffle_component(a, b, y), + select_shuffle_component(a, b, z)); + } + + /// Returns the result of specified shuffling of the components from two float3 vectors into a float4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 shuffle(float3 a, float3 b, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w) + { + return float4( + select_shuffle_component(a, b, x), + select_shuffle_component(a, b, y), + select_shuffle_component(a, b, z), + select_shuffle_component(a, b, w)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static float select_shuffle_component(float3 a, float3 b, ShuffleComponent component) + { + switch(component) + { + case ShuffleComponent.LeftX: + return a.x; + case ShuffleComponent.LeftY: + return a.y; + case ShuffleComponent.LeftZ: + return a.z; + case ShuffleComponent.RightX: + return b.x; + case ShuffleComponent.RightY: + return b.y; + case ShuffleComponent.RightZ: + return b.z; + default: + throw new System.ArgumentException("Invalid shuffle component: " + component); + } + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..40c6c755d07e35ff35a7ab89f042e4bc84157c31 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 6e8e5da9e769595428f8f1f51e642dd3 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3x2.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3x2.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..793efb936f0d4c711711cf977a9ca076e121d194 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3x2.gen.cs @@ -0,0 +1,442 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [System.Serializable] + public partial struct float3x2 : System.IEquatable, IFormattable + { + public float3 c0; + public float3 c1; + + /// float3x2 zero value. + public static readonly float3x2 zero; + + /// Constructs a float3x2 matrix from two float3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x2(float3 c0, float3 c1) + { + this.c0 = c0; + this.c1 = c1; + } + + /// Constructs a float3x2 matrix from 6 float values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x2(float m00, float m01, + float m10, float m11, + float m20, float m21) + { + this.c0 = new float3(m00, m10, m20); + this.c1 = new float3(m01, m11, m21); + } + + /// Constructs a float3x2 matrix from a single float value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x2(float v) + { + this.c0 = v; + this.c1 = v; + } + + /// Constructs a float3x2 matrix from a single bool value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x2(bool v) + { + this.c0 = math.select(new float3(0.0f), new float3(1.0f), v); + this.c1 = math.select(new float3(0.0f), new float3(1.0f), v); + } + + /// Constructs a float3x2 matrix from a bool3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x2(bool3x2 v) + { + this.c0 = math.select(new float3(0.0f), new float3(1.0f), v.c0); + this.c1 = math.select(new float3(0.0f), new float3(1.0f), v.c1); + } + + /// Constructs a float3x2 matrix from a single int value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x2(int v) + { + this.c0 = v; + this.c1 = v; + } + + /// Constructs a float3x2 matrix from a int3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x2(int3x2 v) + { + this.c0 = v.c0; + this.c1 = v.c1; + } + + /// Constructs a float3x2 matrix from a single uint value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x2(uint v) + { + this.c0 = v; + this.c1 = v; + } + + /// Constructs a float3x2 matrix from a uint3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x2(uint3x2 v) + { + this.c0 = v.c0; + this.c1 = v.c1; + } + + /// Constructs a float3x2 matrix from a single double value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x2(double v) + { + this.c0 = (float3)v; + this.c1 = (float3)v; + } + + /// Constructs a float3x2 matrix from a double3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x2(double3x2 v) + { + this.c0 = (float3)v.c0; + this.c1 = (float3)v.c1; + } + + + /// Implicitly converts a single float value to a float3x2 matrix by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float3x2(float v) { return new float3x2(v); } + + /// Explicitly converts a single bool value to a float3x2 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float3x2(bool v) { return new float3x2(v); } + + /// Explicitly converts a bool3x2 matrix to a float3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float3x2(bool3x2 v) { return new float3x2(v); } + + /// Implicitly converts a single int value to a float3x2 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float3x2(int v) { return new float3x2(v); } + + /// Implicitly converts a int3x2 matrix to a float3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float3x2(int3x2 v) { return new float3x2(v); } + + /// Implicitly converts a single uint value to a float3x2 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float3x2(uint v) { return new float3x2(v); } + + /// Implicitly converts a uint3x2 matrix to a float3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float3x2(uint3x2 v) { return new float3x2(v); } + + /// Explicitly converts a single double value to a float3x2 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float3x2(double v) { return new float3x2(v); } + + /// Explicitly converts a double3x2 matrix to a float3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float3x2(double3x2 v) { return new float3x2(v); } + + + /// Returns the result of a componentwise multiplication operation on two float3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 operator * (float3x2 lhs, float3x2 rhs) { return new float3x2 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1); } + + /// Returns the result of a componentwise multiplication operation on a float3x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 operator * (float3x2 lhs, float rhs) { return new float3x2 (lhs.c0 * rhs, lhs.c1 * rhs); } + + /// Returns the result of a componentwise multiplication operation on a float value and a float3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 operator * (float lhs, float3x2 rhs) { return new float3x2 (lhs * rhs.c0, lhs * rhs.c1); } + + + /// Returns the result of a componentwise addition operation on two float3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 operator + (float3x2 lhs, float3x2 rhs) { return new float3x2 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1); } + + /// Returns the result of a componentwise addition operation on a float3x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 operator + (float3x2 lhs, float rhs) { return new float3x2 (lhs.c0 + rhs, lhs.c1 + rhs); } + + /// Returns the result of a componentwise addition operation on a float value and a float3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 operator + (float lhs, float3x2 rhs) { return new float3x2 (lhs + rhs.c0, lhs + rhs.c1); } + + + /// Returns the result of a componentwise subtraction operation on two float3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 operator - (float3x2 lhs, float3x2 rhs) { return new float3x2 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1); } + + /// Returns the result of a componentwise subtraction operation on a float3x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 operator - (float3x2 lhs, float rhs) { return new float3x2 (lhs.c0 - rhs, lhs.c1 - rhs); } + + /// Returns the result of a componentwise subtraction operation on a float value and a float3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 operator - (float lhs, float3x2 rhs) { return new float3x2 (lhs - rhs.c0, lhs - rhs.c1); } + + + /// Returns the result of a componentwise division operation on two float3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 operator / (float3x2 lhs, float3x2 rhs) { return new float3x2 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1); } + + /// Returns the result of a componentwise division operation on a float3x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 operator / (float3x2 lhs, float rhs) { return new float3x2 (lhs.c0 / rhs, lhs.c1 / rhs); } + + /// Returns the result of a componentwise division operation on a float value and a float3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 operator / (float lhs, float3x2 rhs) { return new float3x2 (lhs / rhs.c0, lhs / rhs.c1); } + + + /// Returns the result of a componentwise modulus operation on two float3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 operator % (float3x2 lhs, float3x2 rhs) { return new float3x2 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1); } + + /// Returns the result of a componentwise modulus operation on a float3x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 operator % (float3x2 lhs, float rhs) { return new float3x2 (lhs.c0 % rhs, lhs.c1 % rhs); } + + /// Returns the result of a componentwise modulus operation on a float value and a float3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 operator % (float lhs, float3x2 rhs) { return new float3x2 (lhs % rhs.c0, lhs % rhs.c1); } + + + /// Returns the result of a componentwise increment operation on a float3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 operator ++ (float3x2 val) { return new float3x2 (++val.c0, ++val.c1); } + + + /// Returns the result of a componentwise decrement operation on a float3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 operator -- (float3x2 val) { return new float3x2 (--val.c0, --val.c1); } + + + /// Returns the result of a componentwise less than operation on two float3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator < (float3x2 lhs, float3x2 rhs) { return new bool3x2 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1); } + + /// Returns the result of a componentwise less than operation on a float3x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator < (float3x2 lhs, float rhs) { return new bool3x2 (lhs.c0 < rhs, lhs.c1 < rhs); } + + /// Returns the result of a componentwise less than operation on a float value and a float3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator < (float lhs, float3x2 rhs) { return new bool3x2 (lhs < rhs.c0, lhs < rhs.c1); } + + + /// Returns the result of a componentwise less or equal operation on two float3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator <= (float3x2 lhs, float3x2 rhs) { return new bool3x2 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1); } + + /// Returns the result of a componentwise less or equal operation on a float3x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator <= (float3x2 lhs, float rhs) { return new bool3x2 (lhs.c0 <= rhs, lhs.c1 <= rhs); } + + /// Returns the result of a componentwise less or equal operation on a float value and a float3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator <= (float lhs, float3x2 rhs) { return new bool3x2 (lhs <= rhs.c0, lhs <= rhs.c1); } + + + /// Returns the result of a componentwise greater than operation on two float3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator > (float3x2 lhs, float3x2 rhs) { return new bool3x2 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1); } + + /// Returns the result of a componentwise greater than operation on a float3x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator > (float3x2 lhs, float rhs) { return new bool3x2 (lhs.c0 > rhs, lhs.c1 > rhs); } + + /// Returns the result of a componentwise greater than operation on a float value and a float3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator > (float lhs, float3x2 rhs) { return new bool3x2 (lhs > rhs.c0, lhs > rhs.c1); } + + + /// Returns the result of a componentwise greater or equal operation on two float3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator >= (float3x2 lhs, float3x2 rhs) { return new bool3x2 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1); } + + /// Returns the result of a componentwise greater or equal operation on a float3x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator >= (float3x2 lhs, float rhs) { return new bool3x2 (lhs.c0 >= rhs, lhs.c1 >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on a float value and a float3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator >= (float lhs, float3x2 rhs) { return new bool3x2 (lhs >= rhs.c0, lhs >= rhs.c1); } + + + /// Returns the result of a componentwise unary minus operation on a float3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 operator - (float3x2 val) { return new float3x2 (-val.c0, -val.c1); } + + + /// Returns the result of a componentwise unary plus operation on a float3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 operator + (float3x2 val) { return new float3x2 (+val.c0, +val.c1); } + + + /// Returns the result of a componentwise equality operation on two float3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator == (float3x2 lhs, float3x2 rhs) { return new bool3x2 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1); } + + /// Returns the result of a componentwise equality operation on a float3x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator == (float3x2 lhs, float rhs) { return new bool3x2 (lhs.c0 == rhs, lhs.c1 == rhs); } + + /// Returns the result of a componentwise equality operation on a float value and a float3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator == (float lhs, float3x2 rhs) { return new bool3x2 (lhs == rhs.c0, lhs == rhs.c1); } + + + /// Returns the result of a componentwise not equal operation on two float3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator != (float3x2 lhs, float3x2 rhs) { return new bool3x2 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1); } + + /// Returns the result of a componentwise not equal operation on a float3x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator != (float3x2 lhs, float rhs) { return new bool3x2 (lhs.c0 != rhs, lhs.c1 != rhs); } + + /// Returns the result of a componentwise not equal operation on a float value and a float3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator != (float lhs, float3x2 rhs) { return new bool3x2 (lhs != rhs.c0, lhs != rhs.c1); } + + + + /// Returns the float3 element at a specified index. + unsafe public ref float3 this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 2) + throw new System.ArgumentException("index must be between[0...1]"); +#endif + fixed (float3x2* array = &this) { return ref ((float3*)array)[index]; } + } + } + + /// Returns true if the float3x2 is equal to a given float3x2, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(float3x2 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1); } + + /// Returns true if the float3x2 is equal to a given float3x2, false otherwise. + public override bool Equals(object o) { return Equals((float3x2)o); } + + + /// Returns a hash code for the float3x2. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the float3x2. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("float3x2({0}f, {1}f, {2}f, {3}f, {4}f, {5}f)", c0.x, c1.x, c0.y, c1.y, c0.z, c1.z); + } + + /// Returns a string representation of the float3x2 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("float3x2({0}f, {1}f, {2}f, {3}f, {4}f, {5}f)", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider)); + } + + } + + public static partial class math + { + /// Returns a float3x2 matrix constructed from two float3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 float3x2(float3 c0, float3 c1) { return new float3x2(c0, c1); } + + /// Returns a float3x2 matrix constructed from from 6 float values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 float3x2(float m00, float m01, + float m10, float m11, + float m20, float m21) + { + return new float3x2(m00, m01, + m10, m11, + m20, m21); + } + + /// Returns a float3x2 matrix constructed from a single float value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 float3x2(float v) { return new float3x2(v); } + + /// Returns a float3x2 matrix constructed from a single bool value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 float3x2(bool v) { return new float3x2(v); } + + /// Return a float3x2 matrix constructed from a bool3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 float3x2(bool3x2 v) { return new float3x2(v); } + + /// Returns a float3x2 matrix constructed from a single int value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 float3x2(int v) { return new float3x2(v); } + + /// Return a float3x2 matrix constructed from a int3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 float3x2(int3x2 v) { return new float3x2(v); } + + /// Returns a float3x2 matrix constructed from a single uint value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 float3x2(uint v) { return new float3x2(v); } + + /// Return a float3x2 matrix constructed from a uint3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 float3x2(uint3x2 v) { return new float3x2(v); } + + /// Returns a float3x2 matrix constructed from a single double value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 float3x2(double v) { return new float3x2(v); } + + /// Return a float3x2 matrix constructed from a double3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 float3x2(double3x2 v) { return new float3x2(v); } + + /// Return the float2x3 transpose of a float3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 transpose(float3x2 v) + { + return float2x3( + v.c0.x, v.c0.y, v.c0.z, + v.c1.x, v.c1.y, v.c1.z); + } + + /// Returns a uint hash code of a float3x2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(float3x2 v) + { + return csum(asuint(v.c0) * uint3(0xE121E6ADu, 0xC9CA1249u, 0x69B60C81u) + + asuint(v.c1) * uint3(0xE0EB6C25u, 0xF648BEABu, 0x6BDB2B07u)) + 0xEF63C699u; + } + + /// + /// Returns a uint3 vector hash code of a float3x2 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 hashwide(float3x2 v) + { + return (asuint(v.c0) * uint3(0x9001903Fu, 0xA895B9CDu, 0x9D23B201u) + + asuint(v.c1) * uint3(0x4B01D3E1u, 0x7461CA0Du, 0x79725379u)) + 0xD6258E5Bu; + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3x2.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3x2.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..84208ff879b95976ebd1e6a961183e52e2b61010 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3x2.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: d20ff0b41ab5f4071b3d6ec3442fb2f7 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3x3.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3x3.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..ba247e09e206e5d4ec3e2dbc74095893e392c9e6 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3x3.gen.cs @@ -0,0 +1,494 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [System.Serializable] + public partial struct float3x3 : System.IEquatable, IFormattable + { + public float3 c0; + public float3 c1; + public float3 c2; + + /// float3x3 identity transform. + public static readonly float3x3 identity = new float3x3(1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f); + + /// float3x3 zero value. + public static readonly float3x3 zero; + + /// Constructs a float3x3 matrix from three float3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x3(float3 c0, float3 c1, float3 c2) + { + this.c0 = c0; + this.c1 = c1; + this.c2 = c2; + } + + /// Constructs a float3x3 matrix from 9 float values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x3(float m00, float m01, float m02, + float m10, float m11, float m12, + float m20, float m21, float m22) + { + this.c0 = new float3(m00, m10, m20); + this.c1 = new float3(m01, m11, m21); + this.c2 = new float3(m02, m12, m22); + } + + /// Constructs a float3x3 matrix from a single float value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x3(float v) + { + this.c0 = v; + this.c1 = v; + this.c2 = v; + } + + /// Constructs a float3x3 matrix from a single bool value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x3(bool v) + { + this.c0 = math.select(new float3(0.0f), new float3(1.0f), v); + this.c1 = math.select(new float3(0.0f), new float3(1.0f), v); + this.c2 = math.select(new float3(0.0f), new float3(1.0f), v); + } + + /// Constructs a float3x3 matrix from a bool3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x3(bool3x3 v) + { + this.c0 = math.select(new float3(0.0f), new float3(1.0f), v.c0); + this.c1 = math.select(new float3(0.0f), new float3(1.0f), v.c1); + this.c2 = math.select(new float3(0.0f), new float3(1.0f), v.c2); + } + + /// Constructs a float3x3 matrix from a single int value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x3(int v) + { + this.c0 = v; + this.c1 = v; + this.c2 = v; + } + + /// Constructs a float3x3 matrix from a int3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x3(int3x3 v) + { + this.c0 = v.c0; + this.c1 = v.c1; + this.c2 = v.c2; + } + + /// Constructs a float3x3 matrix from a single uint value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x3(uint v) + { + this.c0 = v; + this.c1 = v; + this.c2 = v; + } + + /// Constructs a float3x3 matrix from a uint3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x3(uint3x3 v) + { + this.c0 = v.c0; + this.c1 = v.c1; + this.c2 = v.c2; + } + + /// Constructs a float3x3 matrix from a single double value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x3(double v) + { + this.c0 = (float3)v; + this.c1 = (float3)v; + this.c2 = (float3)v; + } + + /// Constructs a float3x3 matrix from a double3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x3(double3x3 v) + { + this.c0 = (float3)v.c0; + this.c1 = (float3)v.c1; + this.c2 = (float3)v.c2; + } + + + /// Implicitly converts a single float value to a float3x3 matrix by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float3x3(float v) { return new float3x3(v); } + + /// Explicitly converts a single bool value to a float3x3 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float3x3(bool v) { return new float3x3(v); } + + /// Explicitly converts a bool3x3 matrix to a float3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float3x3(bool3x3 v) { return new float3x3(v); } + + /// Implicitly converts a single int value to a float3x3 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float3x3(int v) { return new float3x3(v); } + + /// Implicitly converts a int3x3 matrix to a float3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float3x3(int3x3 v) { return new float3x3(v); } + + /// Implicitly converts a single uint value to a float3x3 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float3x3(uint v) { return new float3x3(v); } + + /// Implicitly converts a uint3x3 matrix to a float3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float3x3(uint3x3 v) { return new float3x3(v); } + + /// Explicitly converts a single double value to a float3x3 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float3x3(double v) { return new float3x3(v); } + + /// Explicitly converts a double3x3 matrix to a float3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float3x3(double3x3 v) { return new float3x3(v); } + + + /// Returns the result of a componentwise multiplication operation on two float3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 operator * (float3x3 lhs, float3x3 rhs) { return new float3x3 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2); } + + /// Returns the result of a componentwise multiplication operation on a float3x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 operator * (float3x3 lhs, float rhs) { return new float3x3 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs); } + + /// Returns the result of a componentwise multiplication operation on a float value and a float3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 operator * (float lhs, float3x3 rhs) { return new float3x3 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2); } + + + /// Returns the result of a componentwise addition operation on two float3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 operator + (float3x3 lhs, float3x3 rhs) { return new float3x3 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2); } + + /// Returns the result of a componentwise addition operation on a float3x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 operator + (float3x3 lhs, float rhs) { return new float3x3 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs); } + + /// Returns the result of a componentwise addition operation on a float value and a float3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 operator + (float lhs, float3x3 rhs) { return new float3x3 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2); } + + + /// Returns the result of a componentwise subtraction operation on two float3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 operator - (float3x3 lhs, float3x3 rhs) { return new float3x3 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2); } + + /// Returns the result of a componentwise subtraction operation on a float3x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 operator - (float3x3 lhs, float rhs) { return new float3x3 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs); } + + /// Returns the result of a componentwise subtraction operation on a float value and a float3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 operator - (float lhs, float3x3 rhs) { return new float3x3 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2); } + + + /// Returns the result of a componentwise division operation on two float3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 operator / (float3x3 lhs, float3x3 rhs) { return new float3x3 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2); } + + /// Returns the result of a componentwise division operation on a float3x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 operator / (float3x3 lhs, float rhs) { return new float3x3 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs); } + + /// Returns the result of a componentwise division operation on a float value and a float3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 operator / (float lhs, float3x3 rhs) { return new float3x3 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2); } + + + /// Returns the result of a componentwise modulus operation on two float3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 operator % (float3x3 lhs, float3x3 rhs) { return new float3x3 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2); } + + /// Returns the result of a componentwise modulus operation on a float3x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 operator % (float3x3 lhs, float rhs) { return new float3x3 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs); } + + /// Returns the result of a componentwise modulus operation on a float value and a float3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 operator % (float lhs, float3x3 rhs) { return new float3x3 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2); } + + + /// Returns the result of a componentwise increment operation on a float3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 operator ++ (float3x3 val) { return new float3x3 (++val.c0, ++val.c1, ++val.c2); } + + + /// Returns the result of a componentwise decrement operation on a float3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 operator -- (float3x3 val) { return new float3x3 (--val.c0, --val.c1, --val.c2); } + + + /// Returns the result of a componentwise less than operation on two float3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator < (float3x3 lhs, float3x3 rhs) { return new bool3x3 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2); } + + /// Returns the result of a componentwise less than operation on a float3x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator < (float3x3 lhs, float rhs) { return new bool3x3 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs); } + + /// Returns the result of a componentwise less than operation on a float value and a float3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator < (float lhs, float3x3 rhs) { return new bool3x3 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2); } + + + /// Returns the result of a componentwise less or equal operation on two float3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator <= (float3x3 lhs, float3x3 rhs) { return new bool3x3 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2); } + + /// Returns the result of a componentwise less or equal operation on a float3x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator <= (float3x3 lhs, float rhs) { return new bool3x3 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs); } + + /// Returns the result of a componentwise less or equal operation on a float value and a float3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator <= (float lhs, float3x3 rhs) { return new bool3x3 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2); } + + + /// Returns the result of a componentwise greater than operation on two float3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator > (float3x3 lhs, float3x3 rhs) { return new bool3x3 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2); } + + /// Returns the result of a componentwise greater than operation on a float3x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator > (float3x3 lhs, float rhs) { return new bool3x3 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs); } + + /// Returns the result of a componentwise greater than operation on a float value and a float3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator > (float lhs, float3x3 rhs) { return new bool3x3 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2); } + + + /// Returns the result of a componentwise greater or equal operation on two float3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator >= (float3x3 lhs, float3x3 rhs) { return new bool3x3 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2); } + + /// Returns the result of a componentwise greater or equal operation on a float3x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator >= (float3x3 lhs, float rhs) { return new bool3x3 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on a float value and a float3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator >= (float lhs, float3x3 rhs) { return new bool3x3 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2); } + + + /// Returns the result of a componentwise unary minus operation on a float3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 operator - (float3x3 val) { return new float3x3 (-val.c0, -val.c1, -val.c2); } + + + /// Returns the result of a componentwise unary plus operation on a float3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 operator + (float3x3 val) { return new float3x3 (+val.c0, +val.c1, +val.c2); } + + + /// Returns the result of a componentwise equality operation on two float3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator == (float3x3 lhs, float3x3 rhs) { return new bool3x3 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2); } + + /// Returns the result of a componentwise equality operation on a float3x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator == (float3x3 lhs, float rhs) { return new bool3x3 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs); } + + /// Returns the result of a componentwise equality operation on a float value and a float3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator == (float lhs, float3x3 rhs) { return new bool3x3 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2); } + + + /// Returns the result of a componentwise not equal operation on two float3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator != (float3x3 lhs, float3x3 rhs) { return new bool3x3 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2); } + + /// Returns the result of a componentwise not equal operation on a float3x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator != (float3x3 lhs, float rhs) { return new bool3x3 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs); } + + /// Returns the result of a componentwise not equal operation on a float value and a float3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator != (float lhs, float3x3 rhs) { return new bool3x3 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2); } + + + + /// Returns the float3 element at a specified index. + unsafe public ref float3 this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 3) + throw new System.ArgumentException("index must be between[0...2]"); +#endif + fixed (float3x3* array = &this) { return ref ((float3*)array)[index]; } + } + } + + /// Returns true if the float3x3 is equal to a given float3x3, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(float3x3 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2); } + + /// Returns true if the float3x3 is equal to a given float3x3, false otherwise. + public override bool Equals(object o) { return Equals((float3x3)o); } + + + /// Returns a hash code for the float3x3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the float3x3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("float3x3({0}f, {1}f, {2}f, {3}f, {4}f, {5}f, {6}f, {7}f, {8}f)", c0.x, c1.x, c2.x, c0.y, c1.y, c2.y, c0.z, c1.z, c2.z); + } + + /// Returns a string representation of the float3x3 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("float3x3({0}f, {1}f, {2}f, {3}f, {4}f, {5}f, {6}f, {7}f, {8}f)", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider), c2.z.ToString(format, formatProvider)); + } + + } + + public static partial class math + { + /// Returns a float3x3 matrix constructed from three float3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 float3x3(float3 c0, float3 c1, float3 c2) { return new float3x3(c0, c1, c2); } + + /// Returns a float3x3 matrix constructed from from 9 float values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 float3x3(float m00, float m01, float m02, + float m10, float m11, float m12, + float m20, float m21, float m22) + { + return new float3x3(m00, m01, m02, + m10, m11, m12, + m20, m21, m22); + } + + /// Returns a float3x3 matrix constructed from a single float value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 float3x3(float v) { return new float3x3(v); } + + /// Returns a float3x3 matrix constructed from a single bool value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 float3x3(bool v) { return new float3x3(v); } + + /// Return a float3x3 matrix constructed from a bool3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 float3x3(bool3x3 v) { return new float3x3(v); } + + /// Returns a float3x3 matrix constructed from a single int value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 float3x3(int v) { return new float3x3(v); } + + /// Return a float3x3 matrix constructed from a int3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 float3x3(int3x3 v) { return new float3x3(v); } + + /// Returns a float3x3 matrix constructed from a single uint value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 float3x3(uint v) { return new float3x3(v); } + + /// Return a float3x3 matrix constructed from a uint3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 float3x3(uint3x3 v) { return new float3x3(v); } + + /// Returns a float3x3 matrix constructed from a single double value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 float3x3(double v) { return new float3x3(v); } + + /// Return a float3x3 matrix constructed from a double3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 float3x3(double3x3 v) { return new float3x3(v); } + + /// Return the float3x3 transpose of a float3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 transpose(float3x3 v) + { + return float3x3( + v.c0.x, v.c0.y, v.c0.z, + v.c1.x, v.c1.y, v.c1.z, + v.c2.x, v.c2.y, v.c2.z); + } + + /// Returns the float3x3 full inverse of a float3x3 matrix. + public static float3x3 inverse(float3x3 m) + { + float3 c0 = m.c0; + float3 c1 = m.c1; + float3 c2 = m.c2; + + float3 t0 = float3(c1.x, c2.x, c0.x); + float3 t1 = float3(c1.y, c2.y, c0.y); + float3 t2 = float3(c1.z, c2.z, c0.z); + + float3 m0 = t1 * t2.yzx - t1.yzx * t2; + float3 m1 = t0.yzx * t2 - t0 * t2.yzx; + float3 m2 = t0 * t1.yzx - t0.yzx * t1; + + float rcpDet = 1.0f / csum(t0.zxy * m0); + return float3x3(m0, m1, m2) * rcpDet; + } + + /// Returns the determinant of a float3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float determinant(float3x3 m) + { + float3 c0 = m.c0; + float3 c1 = m.c1; + float3 c2 = m.c2; + + float m00 = c1.y * c2.z - c1.z * c2.y; + float m01 = c0.y * c2.z - c0.z * c2.y; + float m02 = c0.y * c1.z - c0.z * c1.y; + + return c0.x * m00 - c1.x * m01 + c2.x * m02; + } + + /// Returns a uint hash code of a float3x3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(float3x3 v) + { + return csum(asuint(v.c0) * uint3(0x713BD06Fu, 0x753AD6ADu, 0xD19764C7u) + + asuint(v.c1) * uint3(0xB5D0BF63u, 0xF9102C5Fu, 0x9881FB9Fu) + + asuint(v.c2) * uint3(0x56A1530Du, 0x804B722Du, 0x738E50E5u)) + 0x4FC93C25u; + } + + /// + /// Returns a uint3 vector hash code of a float3x3 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 hashwide(float3x3 v) + { + return (asuint(v.c0) * uint3(0xCD0445A5u, 0xD2B90D9Bu, 0xD35C9B2Du) + + asuint(v.c1) * uint3(0xA10D9E27u, 0x568DAAA9u, 0x7530254Fu) + + asuint(v.c2) * uint3(0x9F090439u, 0x5E9F85C9u, 0x8C4CA03Fu)) + 0xB8D969EDu; + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3x3.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3x3.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..2f2483241594dea9aaf39bb6d3e69cf3a76e14d6 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3x3.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 3ad77e7310a1e44499f09a51a558bb01 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3x4.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3x4.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..607126362e593b90175b28ea729a68cdb46e85fe --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3x4.gen.cs @@ -0,0 +1,489 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [System.Serializable] + public partial struct float3x4 : System.IEquatable, IFormattable + { + public float3 c0; + public float3 c1; + public float3 c2; + public float3 c3; + + /// float3x4 zero value. + public static readonly float3x4 zero; + + /// Constructs a float3x4 matrix from four float3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x4(float3 c0, float3 c1, float3 c2, float3 c3) + { + this.c0 = c0; + this.c1 = c1; + this.c2 = c2; + this.c3 = c3; + } + + /// Constructs a float3x4 matrix from 12 float values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x4(float m00, float m01, float m02, float m03, + float m10, float m11, float m12, float m13, + float m20, float m21, float m22, float m23) + { + this.c0 = new float3(m00, m10, m20); + this.c1 = new float3(m01, m11, m21); + this.c2 = new float3(m02, m12, m22); + this.c3 = new float3(m03, m13, m23); + } + + /// Constructs a float3x4 matrix from a single float value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x4(float v) + { + this.c0 = v; + this.c1 = v; + this.c2 = v; + this.c3 = v; + } + + /// Constructs a float3x4 matrix from a single bool value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x4(bool v) + { + this.c0 = math.select(new float3(0.0f), new float3(1.0f), v); + this.c1 = math.select(new float3(0.0f), new float3(1.0f), v); + this.c2 = math.select(new float3(0.0f), new float3(1.0f), v); + this.c3 = math.select(new float3(0.0f), new float3(1.0f), v); + } + + /// Constructs a float3x4 matrix from a bool3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x4(bool3x4 v) + { + this.c0 = math.select(new float3(0.0f), new float3(1.0f), v.c0); + this.c1 = math.select(new float3(0.0f), new float3(1.0f), v.c1); + this.c2 = math.select(new float3(0.0f), new float3(1.0f), v.c2); + this.c3 = math.select(new float3(0.0f), new float3(1.0f), v.c3); + } + + /// Constructs a float3x4 matrix from a single int value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x4(int v) + { + this.c0 = v; + this.c1 = v; + this.c2 = v; + this.c3 = v; + } + + /// Constructs a float3x4 matrix from a int3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x4(int3x4 v) + { + this.c0 = v.c0; + this.c1 = v.c1; + this.c2 = v.c2; + this.c3 = v.c3; + } + + /// Constructs a float3x4 matrix from a single uint value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x4(uint v) + { + this.c0 = v; + this.c1 = v; + this.c2 = v; + this.c3 = v; + } + + /// Constructs a float3x4 matrix from a uint3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x4(uint3x4 v) + { + this.c0 = v.c0; + this.c1 = v.c1; + this.c2 = v.c2; + this.c3 = v.c3; + } + + /// Constructs a float3x4 matrix from a single double value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x4(double v) + { + this.c0 = (float3)v; + this.c1 = (float3)v; + this.c2 = (float3)v; + this.c3 = (float3)v; + } + + /// Constructs a float3x4 matrix from a double3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3x4(double3x4 v) + { + this.c0 = (float3)v.c0; + this.c1 = (float3)v.c1; + this.c2 = (float3)v.c2; + this.c3 = (float3)v.c3; + } + + + /// Implicitly converts a single float value to a float3x4 matrix by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float3x4(float v) { return new float3x4(v); } + + /// Explicitly converts a single bool value to a float3x4 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float3x4(bool v) { return new float3x4(v); } + + /// Explicitly converts a bool3x4 matrix to a float3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float3x4(bool3x4 v) { return new float3x4(v); } + + /// Implicitly converts a single int value to a float3x4 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float3x4(int v) { return new float3x4(v); } + + /// Implicitly converts a int3x4 matrix to a float3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float3x4(int3x4 v) { return new float3x4(v); } + + /// Implicitly converts a single uint value to a float3x4 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float3x4(uint v) { return new float3x4(v); } + + /// Implicitly converts a uint3x4 matrix to a float3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float3x4(uint3x4 v) { return new float3x4(v); } + + /// Explicitly converts a single double value to a float3x4 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float3x4(double v) { return new float3x4(v); } + + /// Explicitly converts a double3x4 matrix to a float3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float3x4(double3x4 v) { return new float3x4(v); } + + + /// Returns the result of a componentwise multiplication operation on two float3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 operator * (float3x4 lhs, float3x4 rhs) { return new float3x4 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2, lhs.c3 * rhs.c3); } + + /// Returns the result of a componentwise multiplication operation on a float3x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 operator * (float3x4 lhs, float rhs) { return new float3x4 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs, lhs.c3 * rhs); } + + /// Returns the result of a componentwise multiplication operation on a float value and a float3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 operator * (float lhs, float3x4 rhs) { return new float3x4 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2, lhs * rhs.c3); } + + + /// Returns the result of a componentwise addition operation on two float3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 operator + (float3x4 lhs, float3x4 rhs) { return new float3x4 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2, lhs.c3 + rhs.c3); } + + /// Returns the result of a componentwise addition operation on a float3x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 operator + (float3x4 lhs, float rhs) { return new float3x4 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs, lhs.c3 + rhs); } + + /// Returns the result of a componentwise addition operation on a float value and a float3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 operator + (float lhs, float3x4 rhs) { return new float3x4 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2, lhs + rhs.c3); } + + + /// Returns the result of a componentwise subtraction operation on two float3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 operator - (float3x4 lhs, float3x4 rhs) { return new float3x4 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2, lhs.c3 - rhs.c3); } + + /// Returns the result of a componentwise subtraction operation on a float3x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 operator - (float3x4 lhs, float rhs) { return new float3x4 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs, lhs.c3 - rhs); } + + /// Returns the result of a componentwise subtraction operation on a float value and a float3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 operator - (float lhs, float3x4 rhs) { return new float3x4 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2, lhs - rhs.c3); } + + + /// Returns the result of a componentwise division operation on two float3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 operator / (float3x4 lhs, float3x4 rhs) { return new float3x4 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2, lhs.c3 / rhs.c3); } + + /// Returns the result of a componentwise division operation on a float3x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 operator / (float3x4 lhs, float rhs) { return new float3x4 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs, lhs.c3 / rhs); } + + /// Returns the result of a componentwise division operation on a float value and a float3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 operator / (float lhs, float3x4 rhs) { return new float3x4 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2, lhs / rhs.c3); } + + + /// Returns the result of a componentwise modulus operation on two float3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 operator % (float3x4 lhs, float3x4 rhs) { return new float3x4 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2, lhs.c3 % rhs.c3); } + + /// Returns the result of a componentwise modulus operation on a float3x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 operator % (float3x4 lhs, float rhs) { return new float3x4 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs, lhs.c3 % rhs); } + + /// Returns the result of a componentwise modulus operation on a float value and a float3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 operator % (float lhs, float3x4 rhs) { return new float3x4 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2, lhs % rhs.c3); } + + + /// Returns the result of a componentwise increment operation on a float3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 operator ++ (float3x4 val) { return new float3x4 (++val.c0, ++val.c1, ++val.c2, ++val.c3); } + + + /// Returns the result of a componentwise decrement operation on a float3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 operator -- (float3x4 val) { return new float3x4 (--val.c0, --val.c1, --val.c2, --val.c3); } + + + /// Returns the result of a componentwise less than operation on two float3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator < (float3x4 lhs, float3x4 rhs) { return new bool3x4 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2, lhs.c3 < rhs.c3); } + + /// Returns the result of a componentwise less than operation on a float3x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator < (float3x4 lhs, float rhs) { return new bool3x4 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs, lhs.c3 < rhs); } + + /// Returns the result of a componentwise less than operation on a float value and a float3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator < (float lhs, float3x4 rhs) { return new bool3x4 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2, lhs < rhs.c3); } + + + /// Returns the result of a componentwise less or equal operation on two float3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator <= (float3x4 lhs, float3x4 rhs) { return new bool3x4 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2, lhs.c3 <= rhs.c3); } + + /// Returns the result of a componentwise less or equal operation on a float3x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator <= (float3x4 lhs, float rhs) { return new bool3x4 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs, lhs.c3 <= rhs); } + + /// Returns the result of a componentwise less or equal operation on a float value and a float3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator <= (float lhs, float3x4 rhs) { return new bool3x4 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2, lhs <= rhs.c3); } + + + /// Returns the result of a componentwise greater than operation on two float3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator > (float3x4 lhs, float3x4 rhs) { return new bool3x4 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2, lhs.c3 > rhs.c3); } + + /// Returns the result of a componentwise greater than operation on a float3x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator > (float3x4 lhs, float rhs) { return new bool3x4 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs, lhs.c3 > rhs); } + + /// Returns the result of a componentwise greater than operation on a float value and a float3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator > (float lhs, float3x4 rhs) { return new bool3x4 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2, lhs > rhs.c3); } + + + /// Returns the result of a componentwise greater or equal operation on two float3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator >= (float3x4 lhs, float3x4 rhs) { return new bool3x4 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2, lhs.c3 >= rhs.c3); } + + /// Returns the result of a componentwise greater or equal operation on a float3x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator >= (float3x4 lhs, float rhs) { return new bool3x4 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs, lhs.c3 >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on a float value and a float3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator >= (float lhs, float3x4 rhs) { return new bool3x4 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2, lhs >= rhs.c3); } + + + /// Returns the result of a componentwise unary minus operation on a float3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 operator - (float3x4 val) { return new float3x4 (-val.c0, -val.c1, -val.c2, -val.c3); } + + + /// Returns the result of a componentwise unary plus operation on a float3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 operator + (float3x4 val) { return new float3x4 (+val.c0, +val.c1, +val.c2, +val.c3); } + + + /// Returns the result of a componentwise equality operation on two float3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator == (float3x4 lhs, float3x4 rhs) { return new bool3x4 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2, lhs.c3 == rhs.c3); } + + /// Returns the result of a componentwise equality operation on a float3x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator == (float3x4 lhs, float rhs) { return new bool3x4 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs, lhs.c3 == rhs); } + + /// Returns the result of a componentwise equality operation on a float value and a float3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator == (float lhs, float3x4 rhs) { return new bool3x4 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2, lhs == rhs.c3); } + + + /// Returns the result of a componentwise not equal operation on two float3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator != (float3x4 lhs, float3x4 rhs) { return new bool3x4 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2, lhs.c3 != rhs.c3); } + + /// Returns the result of a componentwise not equal operation on a float3x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator != (float3x4 lhs, float rhs) { return new bool3x4 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs, lhs.c3 != rhs); } + + /// Returns the result of a componentwise not equal operation on a float value and a float3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator != (float lhs, float3x4 rhs) { return new bool3x4 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2, lhs != rhs.c3); } + + + + /// Returns the float3 element at a specified index. + unsafe public ref float3 this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 4) + throw new System.ArgumentException("index must be between[0...3]"); +#endif + fixed (float3x4* array = &this) { return ref ((float3*)array)[index]; } + } + } + + /// Returns true if the float3x4 is equal to a given float3x4, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(float3x4 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2) && c3.Equals(rhs.c3); } + + /// Returns true if the float3x4 is equal to a given float3x4, false otherwise. + public override bool Equals(object o) { return Equals((float3x4)o); } + + + /// Returns a hash code for the float3x4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the float3x4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("float3x4({0}f, {1}f, {2}f, {3}f, {4}f, {5}f, {6}f, {7}f, {8}f, {9}f, {10}f, {11}f)", c0.x, c1.x, c2.x, c3.x, c0.y, c1.y, c2.y, c3.y, c0.z, c1.z, c2.z, c3.z); + } + + /// Returns a string representation of the float3x4 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("float3x4({0}f, {1}f, {2}f, {3}f, {4}f, {5}f, {6}f, {7}f, {8}f, {9}f, {10}f, {11}f)", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c3.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider), c3.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider), c2.z.ToString(format, formatProvider), c3.z.ToString(format, formatProvider)); + } + + } + + public static partial class math + { + /// Returns a float3x4 matrix constructed from four float3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 float3x4(float3 c0, float3 c1, float3 c2, float3 c3) { return new float3x4(c0, c1, c2, c3); } + + /// Returns a float3x4 matrix constructed from from 12 float values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 float3x4(float m00, float m01, float m02, float m03, + float m10, float m11, float m12, float m13, + float m20, float m21, float m22, float m23) + { + return new float3x4(m00, m01, m02, m03, + m10, m11, m12, m13, + m20, m21, m22, m23); + } + + /// Returns a float3x4 matrix constructed from a single float value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 float3x4(float v) { return new float3x4(v); } + + /// Returns a float3x4 matrix constructed from a single bool value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 float3x4(bool v) { return new float3x4(v); } + + /// Return a float3x4 matrix constructed from a bool3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 float3x4(bool3x4 v) { return new float3x4(v); } + + /// Returns a float3x4 matrix constructed from a single int value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 float3x4(int v) { return new float3x4(v); } + + /// Return a float3x4 matrix constructed from a int3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 float3x4(int3x4 v) { return new float3x4(v); } + + /// Returns a float3x4 matrix constructed from a single uint value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 float3x4(uint v) { return new float3x4(v); } + + /// Return a float3x4 matrix constructed from a uint3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 float3x4(uint3x4 v) { return new float3x4(v); } + + /// Returns a float3x4 matrix constructed from a single double value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 float3x4(double v) { return new float3x4(v); } + + /// Return a float3x4 matrix constructed from a double3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 float3x4(double3x4 v) { return new float3x4(v); } + + /// Return the float4x3 transpose of a float3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 transpose(float3x4 v) + { + return float4x3( + v.c0.x, v.c0.y, v.c0.z, + v.c1.x, v.c1.y, v.c1.z, + v.c2.x, v.c2.y, v.c2.z, + v.c3.x, v.c3.y, v.c3.z); + } + + // Fast matrix inverse for rigid transforms (Orthonormal basis and translation) + public static float3x4 fastinverse(float3x4 m) + { + float3 c0 = m.c0; + float3 c1 = m.c1; + float3 c2 = m.c2; + float3 pos = m.c3; + + float3 r0 = float3(c0.x, c1.x, c2.x); + float3 r1 = float3(c0.y, c1.y, c2.y); + float3 r2 = float3(c0.z, c1.z, c2.z); + + pos = -(r0 * pos.x + r1 * pos.y + r2 * pos.z); + + return float3x4(r0, r1, r2, pos); + } + + /// Returns a uint hash code of a float3x4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(float3x4 v) + { + return csum(asuint(v.c0) * uint3(0xF9EA92D5u, 0xC2FAFCB9u, 0x616E9CA1u) + + asuint(v.c1) * uint3(0xC5C5394Bu, 0xCAE78587u, 0x7A1541C9u) + + asuint(v.c2) * uint3(0xF83BD927u, 0x6A243BCBu, 0x509B84C9u) + + asuint(v.c3) * uint3(0x91D13847u, 0x52F7230Fu, 0xCF286E83u)) + 0xE121E6ADu; + } + + /// + /// Returns a uint3 vector hash code of a float3x4 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 hashwide(float3x4 v) + { + return (asuint(v.c0) * uint3(0xC9CA1249u, 0x69B60C81u, 0xE0EB6C25u) + + asuint(v.c1) * uint3(0xF648BEABu, 0x6BDB2B07u, 0xEF63C699u) + + asuint(v.c2) * uint3(0x9001903Fu, 0xA895B9CDu, 0x9D23B201u) + + asuint(v.c3) * uint3(0x4B01D3E1u, 0x7461CA0Du, 0x79725379u)) + 0xD6258E5Bu; + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3x4.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3x4.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..2d90f40961902143bee1b29daf51e8b5c2b83766 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3x4.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 8e85ad7d883b9468da066c1ad9de70d0 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float4.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float4.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..e69190870fff7f3d2d69b2d815513f13b79f5fbe --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float4.gen.cs @@ -0,0 +1,3464 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; +using System.Diagnostics; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [DebuggerTypeProxy(typeof(float4.DebuggerProxy))] + [System.Serializable] + public partial struct float4 : System.IEquatable, IFormattable + { + public float x; + public float y; + public float z; + public float w; + + /// float4 zero value. + public static readonly float4 zero; + + /// Constructs a float4 vector from four float values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4(float x, float y, float z, float w) + { + this.x = x; + this.y = y; + this.z = z; + this.w = w; + } + + /// Constructs a float4 vector from two float values and a float2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4(float x, float y, float2 zw) + { + this.x = x; + this.y = y; + this.z = zw.x; + this.w = zw.y; + } + + /// Constructs a float4 vector from a float value, a float2 vector and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4(float x, float2 yz, float w) + { + this.x = x; + this.y = yz.x; + this.z = yz.y; + this.w = w; + } + + /// Constructs a float4 vector from a float value and a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4(float x, float3 yzw) + { + this.x = x; + this.y = yzw.x; + this.z = yzw.y; + this.w = yzw.z; + } + + /// Constructs a float4 vector from a float2 vector and two float values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4(float2 xy, float z, float w) + { + this.x = xy.x; + this.y = xy.y; + this.z = z; + this.w = w; + } + + /// Constructs a float4 vector from two float2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4(float2 xy, float2 zw) + { + this.x = xy.x; + this.y = xy.y; + this.z = zw.x; + this.w = zw.y; + } + + /// Constructs a float4 vector from a float3 vector and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4(float3 xyz, float w) + { + this.x = xyz.x; + this.y = xyz.y; + this.z = xyz.z; + this.w = w; + } + + /// Constructs a float4 vector from a float4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4(float4 xyzw) + { + this.x = xyzw.x; + this.y = xyzw.y; + this.z = xyzw.z; + this.w = xyzw.w; + } + + /// Constructs a float4 vector from a single float value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4(float v) + { + this.x = v; + this.y = v; + this.z = v; + this.w = v; + } + + /// Constructs a float4 vector from a single bool value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4(bool v) + { + this.x = v ? 1.0f : 0.0f; + this.y = v ? 1.0f : 0.0f; + this.z = v ? 1.0f : 0.0f; + this.w = v ? 1.0f : 0.0f; + } + + /// Constructs a float4 vector from a bool4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4(bool4 v) + { + this.x = v.x ? 1.0f : 0.0f; + this.y = v.y ? 1.0f : 0.0f; + this.z = v.z ? 1.0f : 0.0f; + this.w = v.w ? 1.0f : 0.0f; + } + + /// Constructs a float4 vector from a single int value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4(int v) + { + this.x = v; + this.y = v; + this.z = v; + this.w = v; + } + + /// Constructs a float4 vector from a int4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4(int4 v) + { + this.x = v.x; + this.y = v.y; + this.z = v.z; + this.w = v.w; + } + + /// Constructs a float4 vector from a single uint value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4(uint v) + { + this.x = v; + this.y = v; + this.z = v; + this.w = v; + } + + /// Constructs a float4 vector from a uint4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4(uint4 v) + { + this.x = v.x; + this.y = v.y; + this.z = v.z; + this.w = v.w; + } + + /// Constructs a float4 vector from a single half value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4(half v) + { + this.x = v; + this.y = v; + this.z = v; + this.w = v; + } + + /// Constructs a float4 vector from a half4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4(half4 v) + { + this.x = v.x; + this.y = v.y; + this.z = v.z; + this.w = v.w; + } + + /// Constructs a float4 vector from a single double value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4(double v) + { + this.x = (float)v; + this.y = (float)v; + this.z = (float)v; + this.w = (float)v; + } + + /// Constructs a float4 vector from a double4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4(double4 v) + { + this.x = (float)v.x; + this.y = (float)v.y; + this.z = (float)v.z; + this.w = (float)v.w; + } + + + /// Implicitly converts a single float value to a float4 vector by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float4(float v) { return new float4(v); } + + /// Explicitly converts a single bool value to a float4 vector by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float4(bool v) { return new float4(v); } + + /// Explicitly converts a bool4 vector to a float4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float4(bool4 v) { return new float4(v); } + + /// Implicitly converts a single int value to a float4 vector by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float4(int v) { return new float4(v); } + + /// Implicitly converts a int4 vector to a float4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float4(int4 v) { return new float4(v); } + + /// Implicitly converts a single uint value to a float4 vector by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float4(uint v) { return new float4(v); } + + /// Implicitly converts a uint4 vector to a float4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float4(uint4 v) { return new float4(v); } + + /// Implicitly converts a single half value to a float4 vector by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float4(half v) { return new float4(v); } + + /// Implicitly converts a half4 vector to a float4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float4(half4 v) { return new float4(v); } + + /// Explicitly converts a single double value to a float4 vector by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float4(double v) { return new float4(v); } + + /// Explicitly converts a double4 vector to a float4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float4(double4 v) { return new float4(v); } + + + /// Returns the result of a componentwise multiplication operation on two float4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 operator * (float4 lhs, float4 rhs) { return new float4 (lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z, lhs.w * rhs.w); } + + /// Returns the result of a componentwise multiplication operation on a float4 vector and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 operator * (float4 lhs, float rhs) { return new float4 (lhs.x * rhs, lhs.y * rhs, lhs.z * rhs, lhs.w * rhs); } + + /// Returns the result of a componentwise multiplication operation on a float value and a float4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 operator * (float lhs, float4 rhs) { return new float4 (lhs * rhs.x, lhs * rhs.y, lhs * rhs.z, lhs * rhs.w); } + + + /// Returns the result of a componentwise addition operation on two float4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 operator + (float4 lhs, float4 rhs) { return new float4 (lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z, lhs.w + rhs.w); } + + /// Returns the result of a componentwise addition operation on a float4 vector and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 operator + (float4 lhs, float rhs) { return new float4 (lhs.x + rhs, lhs.y + rhs, lhs.z + rhs, lhs.w + rhs); } + + /// Returns the result of a componentwise addition operation on a float value and a float4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 operator + (float lhs, float4 rhs) { return new float4 (lhs + rhs.x, lhs + rhs.y, lhs + rhs.z, lhs + rhs.w); } + + + /// Returns the result of a componentwise subtraction operation on two float4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 operator - (float4 lhs, float4 rhs) { return new float4 (lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z, lhs.w - rhs.w); } + + /// Returns the result of a componentwise subtraction operation on a float4 vector and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 operator - (float4 lhs, float rhs) { return new float4 (lhs.x - rhs, lhs.y - rhs, lhs.z - rhs, lhs.w - rhs); } + + /// Returns the result of a componentwise subtraction operation on a float value and a float4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 operator - (float lhs, float4 rhs) { return new float4 (lhs - rhs.x, lhs - rhs.y, lhs - rhs.z, lhs - rhs.w); } + + + /// Returns the result of a componentwise division operation on two float4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 operator / (float4 lhs, float4 rhs) { return new float4 (lhs.x / rhs.x, lhs.y / rhs.y, lhs.z / rhs.z, lhs.w / rhs.w); } + + /// Returns the result of a componentwise division operation on a float4 vector and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 operator / (float4 lhs, float rhs) { return new float4 (lhs.x / rhs, lhs.y / rhs, lhs.z / rhs, lhs.w / rhs); } + + /// Returns the result of a componentwise division operation on a float value and a float4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 operator / (float lhs, float4 rhs) { return new float4 (lhs / rhs.x, lhs / rhs.y, lhs / rhs.z, lhs / rhs.w); } + + + /// Returns the result of a componentwise modulus operation on two float4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 operator % (float4 lhs, float4 rhs) { return new float4 (lhs.x % rhs.x, lhs.y % rhs.y, lhs.z % rhs.z, lhs.w % rhs.w); } + + /// Returns the result of a componentwise modulus operation on a float4 vector and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 operator % (float4 lhs, float rhs) { return new float4 (lhs.x % rhs, lhs.y % rhs, lhs.z % rhs, lhs.w % rhs); } + + /// Returns the result of a componentwise modulus operation on a float value and a float4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 operator % (float lhs, float4 rhs) { return new float4 (lhs % rhs.x, lhs % rhs.y, lhs % rhs.z, lhs % rhs.w); } + + + /// Returns the result of a componentwise increment operation on a float4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 operator ++ (float4 val) { return new float4 (++val.x, ++val.y, ++val.z, ++val.w); } + + + /// Returns the result of a componentwise decrement operation on a float4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 operator -- (float4 val) { return new float4 (--val.x, --val.y, --val.z, --val.w); } + + + /// Returns the result of a componentwise less than operation on two float4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator < (float4 lhs, float4 rhs) { return new bool4 (lhs.x < rhs.x, lhs.y < rhs.y, lhs.z < rhs.z, lhs.w < rhs.w); } + + /// Returns the result of a componentwise less than operation on a float4 vector and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator < (float4 lhs, float rhs) { return new bool4 (lhs.x < rhs, lhs.y < rhs, lhs.z < rhs, lhs.w < rhs); } + + /// Returns the result of a componentwise less than operation on a float value and a float4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator < (float lhs, float4 rhs) { return new bool4 (lhs < rhs.x, lhs < rhs.y, lhs < rhs.z, lhs < rhs.w); } + + + /// Returns the result of a componentwise less or equal operation on two float4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator <= (float4 lhs, float4 rhs) { return new bool4 (lhs.x <= rhs.x, lhs.y <= rhs.y, lhs.z <= rhs.z, lhs.w <= rhs.w); } + + /// Returns the result of a componentwise less or equal operation on a float4 vector and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator <= (float4 lhs, float rhs) { return new bool4 (lhs.x <= rhs, lhs.y <= rhs, lhs.z <= rhs, lhs.w <= rhs); } + + /// Returns the result of a componentwise less or equal operation on a float value and a float4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator <= (float lhs, float4 rhs) { return new bool4 (lhs <= rhs.x, lhs <= rhs.y, lhs <= rhs.z, lhs <= rhs.w); } + + + /// Returns the result of a componentwise greater than operation on two float4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator > (float4 lhs, float4 rhs) { return new bool4 (lhs.x > rhs.x, lhs.y > rhs.y, lhs.z > rhs.z, lhs.w > rhs.w); } + + /// Returns the result of a componentwise greater than operation on a float4 vector and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator > (float4 lhs, float rhs) { return new bool4 (lhs.x > rhs, lhs.y > rhs, lhs.z > rhs, lhs.w > rhs); } + + /// Returns the result of a componentwise greater than operation on a float value and a float4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator > (float lhs, float4 rhs) { return new bool4 (lhs > rhs.x, lhs > rhs.y, lhs > rhs.z, lhs > rhs.w); } + + + /// Returns the result of a componentwise greater or equal operation on two float4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator >= (float4 lhs, float4 rhs) { return new bool4 (lhs.x >= rhs.x, lhs.y >= rhs.y, lhs.z >= rhs.z, lhs.w >= rhs.w); } + + /// Returns the result of a componentwise greater or equal operation on a float4 vector and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator >= (float4 lhs, float rhs) { return new bool4 (lhs.x >= rhs, lhs.y >= rhs, lhs.z >= rhs, lhs.w >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on a float value and a float4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator >= (float lhs, float4 rhs) { return new bool4 (lhs >= rhs.x, lhs >= rhs.y, lhs >= rhs.z, lhs >= rhs.w); } + + + /// Returns the result of a componentwise unary minus operation on a float4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 operator - (float4 val) { return new float4 (-val.x, -val.y, -val.z, -val.w); } + + + /// Returns the result of a componentwise unary plus operation on a float4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 operator + (float4 val) { return new float4 (+val.x, +val.y, +val.z, +val.w); } + + + /// Returns the result of a componentwise equality operation on two float4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator == (float4 lhs, float4 rhs) { return new bool4 (lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z, lhs.w == rhs.w); } + + /// Returns the result of a componentwise equality operation on a float4 vector and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator == (float4 lhs, float rhs) { return new bool4 (lhs.x == rhs, lhs.y == rhs, lhs.z == rhs, lhs.w == rhs); } + + /// Returns the result of a componentwise equality operation on a float value and a float4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator == (float lhs, float4 rhs) { return new bool4 (lhs == rhs.x, lhs == rhs.y, lhs == rhs.z, lhs == rhs.w); } + + + /// Returns the result of a componentwise not equal operation on two float4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator != (float4 lhs, float4 rhs) { return new bool4 (lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z, lhs.w != rhs.w); } + + /// Returns the result of a componentwise not equal operation on a float4 vector and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator != (float4 lhs, float rhs) { return new bool4 (lhs.x != rhs, lhs.y != rhs, lhs.z != rhs, lhs.w != rhs); } + + /// Returns the result of a componentwise not equal operation on a float value and a float4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator != (float lhs, float4 rhs) { return new bool4 (lhs != rhs.x, lhs != rhs.y, lhs != rhs.z, lhs != rhs.w); } + + + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xxxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xxxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, x, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xxyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, x, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xxyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, x, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xxzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xxzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, x, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xxzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xxzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, x, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xxwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, x, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xxwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, x, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xxwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, x, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xxww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, x, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xyxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, y, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xyxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, y, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xyyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xyyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, y, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xyzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, y, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xyzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xyzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xyzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, y, z, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; y = value.y; z = value.z; w = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xywx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, y, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xywy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, y, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xywz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, y, w, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; y = value.y; w = value.z; z = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xyww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, y, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xzxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xzxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, z, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xzxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xzxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, z, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xzyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, z, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xzyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xzyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xzyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, z, y, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; z = value.y; y = value.z; w = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xzzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xzzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xzzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xzzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, z, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xzwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, z, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xzwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, z, w, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; z = value.y; w = value.z; y = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xzwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, z, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xzww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, z, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xwxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, w, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xwxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, w, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xwxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, w, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xwxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, w, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xwyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, w, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xwyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, w, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xwyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, w, y, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; w = value.y; y = value.z; z = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xwyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, w, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xwzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, w, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xwzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, w, z, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; w = value.y; z = value.z; y = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xwzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, w, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xwzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, w, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xwwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, w, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xwwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, w, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xwwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, w, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 xwww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(x, w, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yxxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yxxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, x, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yxyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, x, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yxyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, x, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yxzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yxzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, x, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yxzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yxzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, x, z, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; x = value.y; z = value.z; w = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yxwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, x, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yxwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, x, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yxwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, x, w, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; x = value.y; w = value.z; z = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yxww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, x, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yyxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, y, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yyxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, y, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yyyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yyyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, y, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yyzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, y, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yyzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yyzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yyzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, y, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yywx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, y, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yywy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, y, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yywz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, y, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yyww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, y, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yzxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yzxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, z, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yzxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yzxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, z, x, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; z = value.y; x = value.z; w = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yzyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, z, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yzyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yzyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yzyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, z, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yzzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yzzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yzzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yzzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, z, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yzwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, z, w, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; z = value.y; w = value.z; x = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yzwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, z, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yzwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, z, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 yzww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, z, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 ywxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, w, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 ywxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, w, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 ywxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, w, x, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; w = value.y; x = value.z; z = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 ywxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, w, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 ywyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, w, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 ywyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, w, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 ywyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, w, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 ywyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, w, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 ywzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, w, z, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; w = value.y; z = value.z; x = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 ywzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, w, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 ywzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, w, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 ywzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, w, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 ywwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, w, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 ywwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, w, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 ywwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, w, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 ywww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(y, w, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zxxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zxxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, x, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zxyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, x, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zxyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, x, y, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; x = value.y; y = value.z; w = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zxzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zxzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, x, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zxzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zxzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, x, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zxwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, x, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zxwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, x, w, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; x = value.y; w = value.z; y = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zxwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, x, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zxww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, x, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zyxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, y, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zyxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, y, x, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; y = value.y; x = value.z; w = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zyyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zyyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, y, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zyzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, y, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zyzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zyzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zyzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, y, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zywx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, y, w, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; y = value.y; w = value.z; x = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zywy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, y, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zywz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, y, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zyww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, y, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zzxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zzxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, z, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zzxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zzxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, z, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zzyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, z, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zzyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zzyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zzyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, z, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zzzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zzzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zzzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zzzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, z, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zzwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, z, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zzwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, z, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zzwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, z, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zzww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, z, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zwxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, w, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zwxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, w, x, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; w = value.y; x = value.z; y = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zwxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, w, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zwxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, w, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zwyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, w, y, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; w = value.y; y = value.z; x = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zwyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, w, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zwyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, w, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zwyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, w, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zwzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, w, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zwzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, w, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zwzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, w, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zwzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, w, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zwwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, w, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zwwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, w, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zwwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, w, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 zwww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(z, w, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wxxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wxxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, x, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wxyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, x, y, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; x = value.y; y = value.z; z = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wxyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, x, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wxzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wxzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, x, z, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; x = value.y; z = value.z; y = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wxzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wxzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, x, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wxwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, x, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wxwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, x, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wxwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, x, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wxww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, x, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wyxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, y, x, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; y = value.y; x = value.z; z = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wyxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, y, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wyyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wyyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, y, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wyzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, y, z, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; y = value.y; z = value.z; x = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wyzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wyzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wyzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, y, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wywx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, y, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wywy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, y, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wywz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, y, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wyww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, y, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wzxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wzxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, z, x, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; z = value.y; x = value.z; y = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wzxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wzxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, z, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wzyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, z, y, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; z = value.y; y = value.z; x = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wzyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wzyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wzyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, z, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wzzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wzzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wzzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wzzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, z, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wzwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, z, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wzwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, z, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wzwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, z, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wzww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, z, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wwxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, w, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wwxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, w, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wwxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, w, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wwxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, w, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wwyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, w, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wwyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, w, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wwyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, w, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wwyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, w, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wwzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, w, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wwzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, w, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wwzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, w, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wwzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, w, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wwwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, w, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wwwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, w, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wwwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, w, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float4 wwww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float4(w, w, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 xxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 xxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 xxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 xxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(x, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 xyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 xyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 xyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(x, y, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; y = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 xyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(x, y, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; y = value.y; w = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 xzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 xzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(x, z, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; z = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 xzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 xzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(x, z, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; z = value.y; w = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 xwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(x, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 xwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(x, w, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; w = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 xwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(x, w, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; w = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 xww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(x, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 yxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 yxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 yxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(y, x, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; x = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 yxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(y, x, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; x = value.y; w = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 yyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 yyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 yyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 yyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(y, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 yzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(y, z, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; z = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 yzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 yzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 yzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(y, z, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; z = value.y; w = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 ywx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(y, w, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; w = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 ywy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(y, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 ywz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(y, w, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; w = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 yww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(y, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 zxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 zxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(z, x, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; x = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 zxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 zxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(z, x, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; x = value.y; w = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 zyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(z, y, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; y = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 zyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 zyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 zyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(z, y, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; y = value.y; w = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 zzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 zzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 zzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 zzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(z, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 zwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(z, w, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; w = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 zwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(z, w, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; w = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 zwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(z, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 zww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(z, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 wxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(w, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 wxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(w, x, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; x = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 wxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(w, x, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; x = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 wxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(w, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 wyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(w, y, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; y = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 wyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(w, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 wyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(w, y, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; y = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 wyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(w, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 wzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(w, z, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; z = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 wzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(w, z, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; z = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 wzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(w, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 wzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(w, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 wwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(w, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 wwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(w, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 wwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(w, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float3 www + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float3(w, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float2 xx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float2(x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float2 xy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float2(x, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; y = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float2 xz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float2(x, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; z = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float2 xw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float2(x, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; w = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float2 yx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float2(y, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; x = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float2 yy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float2(y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float2 yz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float2(y, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; z = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float2 yw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float2(y, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; w = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float2 zx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float2(z, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; x = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float2 zy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float2(z, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; y = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float2 zz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float2(z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float2 zw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float2(z, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; w = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float2 wx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float2(w, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; x = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float2 wy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float2(w, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; y = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float2 wz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float2(w, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; z = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public float2 ww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new float2(w, w); } + } + + + + /// Returns the float element at a specified index. + unsafe public float this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 4) + throw new System.ArgumentException("index must be between[0...3]"); +#endif + fixed (float4* array = &this) { return ((float*)array)[index]; } + } + set + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 4) + throw new System.ArgumentException("index must be between[0...3]"); +#endif + fixed (float* array = &x) { array[index] = value; } + } + } + + /// Returns true if the float4 is equal to a given float4, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(float4 rhs) { return x == rhs.x && y == rhs.y && z == rhs.z && w == rhs.w; } + + /// Returns true if the float4 is equal to a given float4, false otherwise. + public override bool Equals(object o) { return Equals((float4)o); } + + + /// Returns a hash code for the float4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the float4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("float4({0}f, {1}f, {2}f, {3}f)", x, y, z, w); + } + + /// Returns a string representation of the float4 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("float4({0}f, {1}f, {2}f, {3}f)", x.ToString(format, formatProvider), y.ToString(format, formatProvider), z.ToString(format, formatProvider), w.ToString(format, formatProvider)); + } + + internal sealed class DebuggerProxy + { + public float x; + public float y; + public float z; + public float w; + public DebuggerProxy(float4 v) + { + x = v.x; + y = v.y; + z = v.z; + w = v.w; + } + } + + } + + public static partial class math + { + /// Returns a float4 vector constructed from four float values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 float4(float x, float y, float z, float w) { return new float4(x, y, z, w); } + + /// Returns a float4 vector constructed from two float values and a float2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 float4(float x, float y, float2 zw) { return new float4(x, y, zw); } + + /// Returns a float4 vector constructed from a float value, a float2 vector and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 float4(float x, float2 yz, float w) { return new float4(x, yz, w); } + + /// Returns a float4 vector constructed from a float value and a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 float4(float x, float3 yzw) { return new float4(x, yzw); } + + /// Returns a float4 vector constructed from a float2 vector and two float values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 float4(float2 xy, float z, float w) { return new float4(xy, z, w); } + + /// Returns a float4 vector constructed from two float2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 float4(float2 xy, float2 zw) { return new float4(xy, zw); } + + /// Returns a float4 vector constructed from a float3 vector and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 float4(float3 xyz, float w) { return new float4(xyz, w); } + + /// Returns a float4 vector constructed from a float4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 float4(float4 xyzw) { return new float4(xyzw); } + + /// Returns a float4 vector constructed from a single float value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 float4(float v) { return new float4(v); } + + /// Returns a float4 vector constructed from a single bool value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 float4(bool v) { return new float4(v); } + + /// Return a float4 vector constructed from a bool4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 float4(bool4 v) { return new float4(v); } + + /// Returns a float4 vector constructed from a single int value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 float4(int v) { return new float4(v); } + + /// Return a float4 vector constructed from a int4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 float4(int4 v) { return new float4(v); } + + /// Returns a float4 vector constructed from a single uint value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 float4(uint v) { return new float4(v); } + + /// Return a float4 vector constructed from a uint4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 float4(uint4 v) { return new float4(v); } + + /// Returns a float4 vector constructed from a single half value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 float4(half v) { return new float4(v); } + + /// Return a float4 vector constructed from a half4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 float4(half4 v) { return new float4(v); } + + /// Returns a float4 vector constructed from a single double value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 float4(double v) { return new float4(v); } + + /// Return a float4 vector constructed from a double4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 float4(double4 v) { return new float4(v); } + + /// Returns a uint hash code of a float4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(float4 v) + { + return csum(asuint(v) * uint4(0xE69626FFu, 0xBD010EEBu, 0x9CEDE1D1u, 0x43BE0B51u)) + 0xAF836EE1u; + } + + /// + /// Returns a uint4 vector hash code of a float4 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 hashwide(float4 v) + { + return (asuint(v) * uint4(0xB130C137u, 0x54834775u, 0x7C022221u, 0xA2D00EDFu)) + 0xA8977779u; + } + + /// Returns the result of specified shuffling of the components from two float4 vectors into a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float shuffle(float4 a, float4 b, ShuffleComponent x) + { + return select_shuffle_component(a, b, x); + } + + /// Returns the result of specified shuffling of the components from two float4 vectors into a float2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 shuffle(float4 a, float4 b, ShuffleComponent x, ShuffleComponent y) + { + return float2( + select_shuffle_component(a, b, x), + select_shuffle_component(a, b, y)); + } + + /// Returns the result of specified shuffling of the components from two float4 vectors into a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 shuffle(float4 a, float4 b, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z) + { + return float3( + select_shuffle_component(a, b, x), + select_shuffle_component(a, b, y), + select_shuffle_component(a, b, z)); + } + + /// Returns the result of specified shuffling of the components from two float4 vectors into a float4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 shuffle(float4 a, float4 b, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w) + { + return float4( + select_shuffle_component(a, b, x), + select_shuffle_component(a, b, y), + select_shuffle_component(a, b, z), + select_shuffle_component(a, b, w)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static float select_shuffle_component(float4 a, float4 b, ShuffleComponent component) + { + switch(component) + { + case ShuffleComponent.LeftX: + return a.x; + case ShuffleComponent.LeftY: + return a.y; + case ShuffleComponent.LeftZ: + return a.z; + case ShuffleComponent.LeftW: + return a.w; + case ShuffleComponent.RightX: + return b.x; + case ShuffleComponent.RightY: + return b.y; + case ShuffleComponent.RightZ: + return b.z; + case ShuffleComponent.RightW: + return b.w; + default: + throw new System.ArgumentException("Invalid shuffle component: " + component); + } + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float4.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float4.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..acec4112c4ab76da1530b7a832a09447bceb9ebc --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float4.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 9c9ea498ec5f4a443830f78ebf231f3e +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float4x2.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float4x2.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..9ffa5048407b35b14decb9ab9f256b56b3399497 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float4x2.gen.cs @@ -0,0 +1,445 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [System.Serializable] + public partial struct float4x2 : System.IEquatable, IFormattable + { + public float4 c0; + public float4 c1; + + /// float4x2 zero value. + public static readonly float4x2 zero; + + /// Constructs a float4x2 matrix from two float4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x2(float4 c0, float4 c1) + { + this.c0 = c0; + this.c1 = c1; + } + + /// Constructs a float4x2 matrix from 8 float values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x2(float m00, float m01, + float m10, float m11, + float m20, float m21, + float m30, float m31) + { + this.c0 = new float4(m00, m10, m20, m30); + this.c1 = new float4(m01, m11, m21, m31); + } + + /// Constructs a float4x2 matrix from a single float value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x2(float v) + { + this.c0 = v; + this.c1 = v; + } + + /// Constructs a float4x2 matrix from a single bool value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x2(bool v) + { + this.c0 = math.select(new float4(0.0f), new float4(1.0f), v); + this.c1 = math.select(new float4(0.0f), new float4(1.0f), v); + } + + /// Constructs a float4x2 matrix from a bool4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x2(bool4x2 v) + { + this.c0 = math.select(new float4(0.0f), new float4(1.0f), v.c0); + this.c1 = math.select(new float4(0.0f), new float4(1.0f), v.c1); + } + + /// Constructs a float4x2 matrix from a single int value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x2(int v) + { + this.c0 = v; + this.c1 = v; + } + + /// Constructs a float4x2 matrix from a int4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x2(int4x2 v) + { + this.c0 = v.c0; + this.c1 = v.c1; + } + + /// Constructs a float4x2 matrix from a single uint value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x2(uint v) + { + this.c0 = v; + this.c1 = v; + } + + /// Constructs a float4x2 matrix from a uint4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x2(uint4x2 v) + { + this.c0 = v.c0; + this.c1 = v.c1; + } + + /// Constructs a float4x2 matrix from a single double value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x2(double v) + { + this.c0 = (float4)v; + this.c1 = (float4)v; + } + + /// Constructs a float4x2 matrix from a double4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x2(double4x2 v) + { + this.c0 = (float4)v.c0; + this.c1 = (float4)v.c1; + } + + + /// Implicitly converts a single float value to a float4x2 matrix by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float4x2(float v) { return new float4x2(v); } + + /// Explicitly converts a single bool value to a float4x2 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float4x2(bool v) { return new float4x2(v); } + + /// Explicitly converts a bool4x2 matrix to a float4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float4x2(bool4x2 v) { return new float4x2(v); } + + /// Implicitly converts a single int value to a float4x2 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float4x2(int v) { return new float4x2(v); } + + /// Implicitly converts a int4x2 matrix to a float4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float4x2(int4x2 v) { return new float4x2(v); } + + /// Implicitly converts a single uint value to a float4x2 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float4x2(uint v) { return new float4x2(v); } + + /// Implicitly converts a uint4x2 matrix to a float4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float4x2(uint4x2 v) { return new float4x2(v); } + + /// Explicitly converts a single double value to a float4x2 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float4x2(double v) { return new float4x2(v); } + + /// Explicitly converts a double4x2 matrix to a float4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float4x2(double4x2 v) { return new float4x2(v); } + + + /// Returns the result of a componentwise multiplication operation on two float4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 operator * (float4x2 lhs, float4x2 rhs) { return new float4x2 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1); } + + /// Returns the result of a componentwise multiplication operation on a float4x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 operator * (float4x2 lhs, float rhs) { return new float4x2 (lhs.c0 * rhs, lhs.c1 * rhs); } + + /// Returns the result of a componentwise multiplication operation on a float value and a float4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 operator * (float lhs, float4x2 rhs) { return new float4x2 (lhs * rhs.c0, lhs * rhs.c1); } + + + /// Returns the result of a componentwise addition operation on two float4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 operator + (float4x2 lhs, float4x2 rhs) { return new float4x2 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1); } + + /// Returns the result of a componentwise addition operation on a float4x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 operator + (float4x2 lhs, float rhs) { return new float4x2 (lhs.c0 + rhs, lhs.c1 + rhs); } + + /// Returns the result of a componentwise addition operation on a float value and a float4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 operator + (float lhs, float4x2 rhs) { return new float4x2 (lhs + rhs.c0, lhs + rhs.c1); } + + + /// Returns the result of a componentwise subtraction operation on two float4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 operator - (float4x2 lhs, float4x2 rhs) { return new float4x2 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1); } + + /// Returns the result of a componentwise subtraction operation on a float4x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 operator - (float4x2 lhs, float rhs) { return new float4x2 (lhs.c0 - rhs, lhs.c1 - rhs); } + + /// Returns the result of a componentwise subtraction operation on a float value and a float4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 operator - (float lhs, float4x2 rhs) { return new float4x2 (lhs - rhs.c0, lhs - rhs.c1); } + + + /// Returns the result of a componentwise division operation on two float4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 operator / (float4x2 lhs, float4x2 rhs) { return new float4x2 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1); } + + /// Returns the result of a componentwise division operation on a float4x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 operator / (float4x2 lhs, float rhs) { return new float4x2 (lhs.c0 / rhs, lhs.c1 / rhs); } + + /// Returns the result of a componentwise division operation on a float value and a float4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 operator / (float lhs, float4x2 rhs) { return new float4x2 (lhs / rhs.c0, lhs / rhs.c1); } + + + /// Returns the result of a componentwise modulus operation on two float4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 operator % (float4x2 lhs, float4x2 rhs) { return new float4x2 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1); } + + /// Returns the result of a componentwise modulus operation on a float4x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 operator % (float4x2 lhs, float rhs) { return new float4x2 (lhs.c0 % rhs, lhs.c1 % rhs); } + + /// Returns the result of a componentwise modulus operation on a float value and a float4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 operator % (float lhs, float4x2 rhs) { return new float4x2 (lhs % rhs.c0, lhs % rhs.c1); } + + + /// Returns the result of a componentwise increment operation on a float4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 operator ++ (float4x2 val) { return new float4x2 (++val.c0, ++val.c1); } + + + /// Returns the result of a componentwise decrement operation on a float4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 operator -- (float4x2 val) { return new float4x2 (--val.c0, --val.c1); } + + + /// Returns the result of a componentwise less than operation on two float4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator < (float4x2 lhs, float4x2 rhs) { return new bool4x2 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1); } + + /// Returns the result of a componentwise less than operation on a float4x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator < (float4x2 lhs, float rhs) { return new bool4x2 (lhs.c0 < rhs, lhs.c1 < rhs); } + + /// Returns the result of a componentwise less than operation on a float value and a float4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator < (float lhs, float4x2 rhs) { return new bool4x2 (lhs < rhs.c0, lhs < rhs.c1); } + + + /// Returns the result of a componentwise less or equal operation on two float4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator <= (float4x2 lhs, float4x2 rhs) { return new bool4x2 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1); } + + /// Returns the result of a componentwise less or equal operation on a float4x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator <= (float4x2 lhs, float rhs) { return new bool4x2 (lhs.c0 <= rhs, lhs.c1 <= rhs); } + + /// Returns the result of a componentwise less or equal operation on a float value and a float4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator <= (float lhs, float4x2 rhs) { return new bool4x2 (lhs <= rhs.c0, lhs <= rhs.c1); } + + + /// Returns the result of a componentwise greater than operation on two float4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator > (float4x2 lhs, float4x2 rhs) { return new bool4x2 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1); } + + /// Returns the result of a componentwise greater than operation on a float4x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator > (float4x2 lhs, float rhs) { return new bool4x2 (lhs.c0 > rhs, lhs.c1 > rhs); } + + /// Returns the result of a componentwise greater than operation on a float value and a float4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator > (float lhs, float4x2 rhs) { return new bool4x2 (lhs > rhs.c0, lhs > rhs.c1); } + + + /// Returns the result of a componentwise greater or equal operation on two float4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator >= (float4x2 lhs, float4x2 rhs) { return new bool4x2 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1); } + + /// Returns the result of a componentwise greater or equal operation on a float4x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator >= (float4x2 lhs, float rhs) { return new bool4x2 (lhs.c0 >= rhs, lhs.c1 >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on a float value and a float4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator >= (float lhs, float4x2 rhs) { return new bool4x2 (lhs >= rhs.c0, lhs >= rhs.c1); } + + + /// Returns the result of a componentwise unary minus operation on a float4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 operator - (float4x2 val) { return new float4x2 (-val.c0, -val.c1); } + + + /// Returns the result of a componentwise unary plus operation on a float4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 operator + (float4x2 val) { return new float4x2 (+val.c0, +val.c1); } + + + /// Returns the result of a componentwise equality operation on two float4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator == (float4x2 lhs, float4x2 rhs) { return new bool4x2 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1); } + + /// Returns the result of a componentwise equality operation on a float4x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator == (float4x2 lhs, float rhs) { return new bool4x2 (lhs.c0 == rhs, lhs.c1 == rhs); } + + /// Returns the result of a componentwise equality operation on a float value and a float4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator == (float lhs, float4x2 rhs) { return new bool4x2 (lhs == rhs.c0, lhs == rhs.c1); } + + + /// Returns the result of a componentwise not equal operation on two float4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator != (float4x2 lhs, float4x2 rhs) { return new bool4x2 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1); } + + /// Returns the result of a componentwise not equal operation on a float4x2 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator != (float4x2 lhs, float rhs) { return new bool4x2 (lhs.c0 != rhs, lhs.c1 != rhs); } + + /// Returns the result of a componentwise not equal operation on a float value and a float4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator != (float lhs, float4x2 rhs) { return new bool4x2 (lhs != rhs.c0, lhs != rhs.c1); } + + + + /// Returns the float4 element at a specified index. + unsafe public ref float4 this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 2) + throw new System.ArgumentException("index must be between[0...1]"); +#endif + fixed (float4x2* array = &this) { return ref ((float4*)array)[index]; } + } + } + + /// Returns true if the float4x2 is equal to a given float4x2, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(float4x2 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1); } + + /// Returns true if the float4x2 is equal to a given float4x2, false otherwise. + public override bool Equals(object o) { return Equals((float4x2)o); } + + + /// Returns a hash code for the float4x2. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the float4x2. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("float4x2({0}f, {1}f, {2}f, {3}f, {4}f, {5}f, {6}f, {7}f)", c0.x, c1.x, c0.y, c1.y, c0.z, c1.z, c0.w, c1.w); + } + + /// Returns a string representation of the float4x2 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("float4x2({0}f, {1}f, {2}f, {3}f, {4}f, {5}f, {6}f, {7}f)", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider), c0.w.ToString(format, formatProvider), c1.w.ToString(format, formatProvider)); + } + + } + + public static partial class math + { + /// Returns a float4x2 matrix constructed from two float4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 float4x2(float4 c0, float4 c1) { return new float4x2(c0, c1); } + + /// Returns a float4x2 matrix constructed from from 8 float values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 float4x2(float m00, float m01, + float m10, float m11, + float m20, float m21, + float m30, float m31) + { + return new float4x2(m00, m01, + m10, m11, + m20, m21, + m30, m31); + } + + /// Returns a float4x2 matrix constructed from a single float value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 float4x2(float v) { return new float4x2(v); } + + /// Returns a float4x2 matrix constructed from a single bool value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 float4x2(bool v) { return new float4x2(v); } + + /// Return a float4x2 matrix constructed from a bool4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 float4x2(bool4x2 v) { return new float4x2(v); } + + /// Returns a float4x2 matrix constructed from a single int value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 float4x2(int v) { return new float4x2(v); } + + /// Return a float4x2 matrix constructed from a int4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 float4x2(int4x2 v) { return new float4x2(v); } + + /// Returns a float4x2 matrix constructed from a single uint value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 float4x2(uint v) { return new float4x2(v); } + + /// Return a float4x2 matrix constructed from a uint4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 float4x2(uint4x2 v) { return new float4x2(v); } + + /// Returns a float4x2 matrix constructed from a single double value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 float4x2(double v) { return new float4x2(v); } + + /// Return a float4x2 matrix constructed from a double4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 float4x2(double4x2 v) { return new float4x2(v); } + + /// Return the float2x4 transpose of a float4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 transpose(float4x2 v) + { + return float2x4( + v.c0.x, v.c0.y, v.c0.z, v.c0.w, + v.c1.x, v.c1.y, v.c1.z, v.c1.w); + } + + /// Returns a uint hash code of a float4x2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(float4x2 v) + { + return csum(asuint(v.c0) * uint4(0xAAC3C25Du, 0xD21D0945u, 0x88FCAB2Du, 0x614DA60Du) + + asuint(v.c1) * uint4(0x5BA2C50Bu, 0x8C455ACBu, 0xCD266C89u, 0xF1852A33u)) + 0x77E35E77u; + } + + /// + /// Returns a uint4 vector hash code of a float4x2 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 hashwide(float4x2 v) + { + return (asuint(v.c0) * uint4(0x863E3729u, 0xE191B035u, 0x68586FAFu, 0xD4DFF6D3u) + + asuint(v.c1) * uint4(0xCB634F4Du, 0x9B13B92Du, 0x4ABF0813u, 0x86068063u)) + 0xD75513F9u; + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float4x2.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float4x2.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..c65dacf1f83b4401a28b345ef20f4c8f613c1b8d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float4x2.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 2a2cb705f8c4d45e8ba95502e037109b +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float4x3.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float4x3.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..b938c9318a65a87965b18bd7c1e23e83127651f7 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float4x3.gen.cs @@ -0,0 +1,460 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [System.Serializable] + public partial struct float4x3 : System.IEquatable, IFormattable + { + public float4 c0; + public float4 c1; + public float4 c2; + + /// float4x3 zero value. + public static readonly float4x3 zero; + + /// Constructs a float4x3 matrix from three float4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x3(float4 c0, float4 c1, float4 c2) + { + this.c0 = c0; + this.c1 = c1; + this.c2 = c2; + } + + /// Constructs a float4x3 matrix from 12 float values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x3(float m00, float m01, float m02, + float m10, float m11, float m12, + float m20, float m21, float m22, + float m30, float m31, float m32) + { + this.c0 = new float4(m00, m10, m20, m30); + this.c1 = new float4(m01, m11, m21, m31); + this.c2 = new float4(m02, m12, m22, m32); + } + + /// Constructs a float4x3 matrix from a single float value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x3(float v) + { + this.c0 = v; + this.c1 = v; + this.c2 = v; + } + + /// Constructs a float4x3 matrix from a single bool value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x3(bool v) + { + this.c0 = math.select(new float4(0.0f), new float4(1.0f), v); + this.c1 = math.select(new float4(0.0f), new float4(1.0f), v); + this.c2 = math.select(new float4(0.0f), new float4(1.0f), v); + } + + /// Constructs a float4x3 matrix from a bool4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x3(bool4x3 v) + { + this.c0 = math.select(new float4(0.0f), new float4(1.0f), v.c0); + this.c1 = math.select(new float4(0.0f), new float4(1.0f), v.c1); + this.c2 = math.select(new float4(0.0f), new float4(1.0f), v.c2); + } + + /// Constructs a float4x3 matrix from a single int value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x3(int v) + { + this.c0 = v; + this.c1 = v; + this.c2 = v; + } + + /// Constructs a float4x3 matrix from a int4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x3(int4x3 v) + { + this.c0 = v.c0; + this.c1 = v.c1; + this.c2 = v.c2; + } + + /// Constructs a float4x3 matrix from a single uint value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x3(uint v) + { + this.c0 = v; + this.c1 = v; + this.c2 = v; + } + + /// Constructs a float4x3 matrix from a uint4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x3(uint4x3 v) + { + this.c0 = v.c0; + this.c1 = v.c1; + this.c2 = v.c2; + } + + /// Constructs a float4x3 matrix from a single double value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x3(double v) + { + this.c0 = (float4)v; + this.c1 = (float4)v; + this.c2 = (float4)v; + } + + /// Constructs a float4x3 matrix from a double4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x3(double4x3 v) + { + this.c0 = (float4)v.c0; + this.c1 = (float4)v.c1; + this.c2 = (float4)v.c2; + } + + + /// Implicitly converts a single float value to a float4x3 matrix by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float4x3(float v) { return new float4x3(v); } + + /// Explicitly converts a single bool value to a float4x3 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float4x3(bool v) { return new float4x3(v); } + + /// Explicitly converts a bool4x3 matrix to a float4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float4x3(bool4x3 v) { return new float4x3(v); } + + /// Implicitly converts a single int value to a float4x3 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float4x3(int v) { return new float4x3(v); } + + /// Implicitly converts a int4x3 matrix to a float4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float4x3(int4x3 v) { return new float4x3(v); } + + /// Implicitly converts a single uint value to a float4x3 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float4x3(uint v) { return new float4x3(v); } + + /// Implicitly converts a uint4x3 matrix to a float4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float4x3(uint4x3 v) { return new float4x3(v); } + + /// Explicitly converts a single double value to a float4x3 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float4x3(double v) { return new float4x3(v); } + + /// Explicitly converts a double4x3 matrix to a float4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float4x3(double4x3 v) { return new float4x3(v); } + + + /// Returns the result of a componentwise multiplication operation on two float4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 operator * (float4x3 lhs, float4x3 rhs) { return new float4x3 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2); } + + /// Returns the result of a componentwise multiplication operation on a float4x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 operator * (float4x3 lhs, float rhs) { return new float4x3 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs); } + + /// Returns the result of a componentwise multiplication operation on a float value and a float4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 operator * (float lhs, float4x3 rhs) { return new float4x3 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2); } + + + /// Returns the result of a componentwise addition operation on two float4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 operator + (float4x3 lhs, float4x3 rhs) { return new float4x3 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2); } + + /// Returns the result of a componentwise addition operation on a float4x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 operator + (float4x3 lhs, float rhs) { return new float4x3 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs); } + + /// Returns the result of a componentwise addition operation on a float value and a float4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 operator + (float lhs, float4x3 rhs) { return new float4x3 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2); } + + + /// Returns the result of a componentwise subtraction operation on two float4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 operator - (float4x3 lhs, float4x3 rhs) { return new float4x3 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2); } + + /// Returns the result of a componentwise subtraction operation on a float4x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 operator - (float4x3 lhs, float rhs) { return new float4x3 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs); } + + /// Returns the result of a componentwise subtraction operation on a float value and a float4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 operator - (float lhs, float4x3 rhs) { return new float4x3 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2); } + + + /// Returns the result of a componentwise division operation on two float4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 operator / (float4x3 lhs, float4x3 rhs) { return new float4x3 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2); } + + /// Returns the result of a componentwise division operation on a float4x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 operator / (float4x3 lhs, float rhs) { return new float4x3 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs); } + + /// Returns the result of a componentwise division operation on a float value and a float4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 operator / (float lhs, float4x3 rhs) { return new float4x3 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2); } + + + /// Returns the result of a componentwise modulus operation on two float4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 operator % (float4x3 lhs, float4x3 rhs) { return new float4x3 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2); } + + /// Returns the result of a componentwise modulus operation on a float4x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 operator % (float4x3 lhs, float rhs) { return new float4x3 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs); } + + /// Returns the result of a componentwise modulus operation on a float value and a float4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 operator % (float lhs, float4x3 rhs) { return new float4x3 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2); } + + + /// Returns the result of a componentwise increment operation on a float4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 operator ++ (float4x3 val) { return new float4x3 (++val.c0, ++val.c1, ++val.c2); } + + + /// Returns the result of a componentwise decrement operation on a float4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 operator -- (float4x3 val) { return new float4x3 (--val.c0, --val.c1, --val.c2); } + + + /// Returns the result of a componentwise less than operation on two float4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator < (float4x3 lhs, float4x3 rhs) { return new bool4x3 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2); } + + /// Returns the result of a componentwise less than operation on a float4x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator < (float4x3 lhs, float rhs) { return new bool4x3 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs); } + + /// Returns the result of a componentwise less than operation on a float value and a float4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator < (float lhs, float4x3 rhs) { return new bool4x3 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2); } + + + /// Returns the result of a componentwise less or equal operation on two float4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator <= (float4x3 lhs, float4x3 rhs) { return new bool4x3 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2); } + + /// Returns the result of a componentwise less or equal operation on a float4x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator <= (float4x3 lhs, float rhs) { return new bool4x3 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs); } + + /// Returns the result of a componentwise less or equal operation on a float value and a float4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator <= (float lhs, float4x3 rhs) { return new bool4x3 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2); } + + + /// Returns the result of a componentwise greater than operation on two float4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator > (float4x3 lhs, float4x3 rhs) { return new bool4x3 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2); } + + /// Returns the result of a componentwise greater than operation on a float4x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator > (float4x3 lhs, float rhs) { return new bool4x3 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs); } + + /// Returns the result of a componentwise greater than operation on a float value and a float4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator > (float lhs, float4x3 rhs) { return new bool4x3 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2); } + + + /// Returns the result of a componentwise greater or equal operation on two float4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator >= (float4x3 lhs, float4x3 rhs) { return new bool4x3 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2); } + + /// Returns the result of a componentwise greater or equal operation on a float4x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator >= (float4x3 lhs, float rhs) { return new bool4x3 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on a float value and a float4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator >= (float lhs, float4x3 rhs) { return new bool4x3 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2); } + + + /// Returns the result of a componentwise unary minus operation on a float4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 operator - (float4x3 val) { return new float4x3 (-val.c0, -val.c1, -val.c2); } + + + /// Returns the result of a componentwise unary plus operation on a float4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 operator + (float4x3 val) { return new float4x3 (+val.c0, +val.c1, +val.c2); } + + + /// Returns the result of a componentwise equality operation on two float4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator == (float4x3 lhs, float4x3 rhs) { return new bool4x3 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2); } + + /// Returns the result of a componentwise equality operation on a float4x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator == (float4x3 lhs, float rhs) { return new bool4x3 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs); } + + /// Returns the result of a componentwise equality operation on a float value and a float4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator == (float lhs, float4x3 rhs) { return new bool4x3 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2); } + + + /// Returns the result of a componentwise not equal operation on two float4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator != (float4x3 lhs, float4x3 rhs) { return new bool4x3 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2); } + + /// Returns the result of a componentwise not equal operation on a float4x3 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator != (float4x3 lhs, float rhs) { return new bool4x3 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs); } + + /// Returns the result of a componentwise not equal operation on a float value and a float4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator != (float lhs, float4x3 rhs) { return new bool4x3 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2); } + + + + /// Returns the float4 element at a specified index. + unsafe public ref float4 this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 3) + throw new System.ArgumentException("index must be between[0...2]"); +#endif + fixed (float4x3* array = &this) { return ref ((float4*)array)[index]; } + } + } + + /// Returns true if the float4x3 is equal to a given float4x3, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(float4x3 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2); } + + /// Returns true if the float4x3 is equal to a given float4x3, false otherwise. + public override bool Equals(object o) { return Equals((float4x3)o); } + + + /// Returns a hash code for the float4x3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the float4x3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("float4x3({0}f, {1}f, {2}f, {3}f, {4}f, {5}f, {6}f, {7}f, {8}f, {9}f, {10}f, {11}f)", c0.x, c1.x, c2.x, c0.y, c1.y, c2.y, c0.z, c1.z, c2.z, c0.w, c1.w, c2.w); + } + + /// Returns a string representation of the float4x3 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("float4x3({0}f, {1}f, {2}f, {3}f, {4}f, {5}f, {6}f, {7}f, {8}f, {9}f, {10}f, {11}f)", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider), c2.z.ToString(format, formatProvider), c0.w.ToString(format, formatProvider), c1.w.ToString(format, formatProvider), c2.w.ToString(format, formatProvider)); + } + + } + + public static partial class math + { + /// Returns a float4x3 matrix constructed from three float4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 float4x3(float4 c0, float4 c1, float4 c2) { return new float4x3(c0, c1, c2); } + + /// Returns a float4x3 matrix constructed from from 12 float values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 float4x3(float m00, float m01, float m02, + float m10, float m11, float m12, + float m20, float m21, float m22, + float m30, float m31, float m32) + { + return new float4x3(m00, m01, m02, + m10, m11, m12, + m20, m21, m22, + m30, m31, m32); + } + + /// Returns a float4x3 matrix constructed from a single float value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 float4x3(float v) { return new float4x3(v); } + + /// Returns a float4x3 matrix constructed from a single bool value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 float4x3(bool v) { return new float4x3(v); } + + /// Return a float4x3 matrix constructed from a bool4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 float4x3(bool4x3 v) { return new float4x3(v); } + + /// Returns a float4x3 matrix constructed from a single int value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 float4x3(int v) { return new float4x3(v); } + + /// Return a float4x3 matrix constructed from a int4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 float4x3(int4x3 v) { return new float4x3(v); } + + /// Returns a float4x3 matrix constructed from a single uint value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 float4x3(uint v) { return new float4x3(v); } + + /// Return a float4x3 matrix constructed from a uint4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 float4x3(uint4x3 v) { return new float4x3(v); } + + /// Returns a float4x3 matrix constructed from a single double value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 float4x3(double v) { return new float4x3(v); } + + /// Return a float4x3 matrix constructed from a double4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 float4x3(double4x3 v) { return new float4x3(v); } + + /// Return the float3x4 transpose of a float4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 transpose(float4x3 v) + { + return float3x4( + v.c0.x, v.c0.y, v.c0.z, v.c0.w, + v.c1.x, v.c1.y, v.c1.z, v.c1.w, + v.c2.x, v.c2.y, v.c2.z, v.c2.w); + } + + /// Returns a uint hash code of a float4x3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(float4x3 v) + { + return csum(asuint(v.c0) * uint4(0xC53F4755u, 0x6985C229u, 0xE133B0B3u, 0xC3E0A3B9u) + + asuint(v.c1) * uint4(0xFE31134Fu, 0x712A34D7u, 0x9D77A59Bu, 0x4942CA39u) + + asuint(v.c2) * uint4(0xB40EC62Du, 0x565ED63Fu, 0x93C30C2Bu, 0xDCAF0351u)) + 0x6E050B01u; + } + + /// + /// Returns a uint4 vector hash code of a float4x3 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 hashwide(float4x3 v) + { + return (asuint(v.c0) * uint4(0x750FDBF5u, 0x7F3DD499u, 0x52EAAEBBu, 0x4599C793u) + + asuint(v.c1) * uint4(0x83B5E729u, 0xC267163Fu, 0x67BC9149u, 0xAD7C5EC1u) + + asuint(v.c2) * uint4(0x822A7D6Du, 0xB492BF15u, 0xD37220E3u, 0x7AA2C2BDu)) + 0xE16BC89Du; + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float4x3.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float4x3.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..5e79be871ad2ec9daf7f9470e5483fb4bfc1cc1f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float4x3.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b8e17e5c41b0344afa5389019db2eb9f +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float4x4.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float4x4.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..3cf507e11634762dc4226fe33ee746a71aca91a8 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float4x4.gen.cs @@ -0,0 +1,596 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [System.Serializable] + public partial struct float4x4 : System.IEquatable, IFormattable + { + public float4 c0; + public float4 c1; + public float4 c2; + public float4 c3; + + /// float4x4 identity transform. + public static readonly float4x4 identity = new float4x4(1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f); + + /// float4x4 zero value. + public static readonly float4x4 zero; + + /// Constructs a float4x4 matrix from four float4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x4(float4 c0, float4 c1, float4 c2, float4 c3) + { + this.c0 = c0; + this.c1 = c1; + this.c2 = c2; + this.c3 = c3; + } + + /// Constructs a float4x4 matrix from 16 float values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x4(float m00, float m01, float m02, float m03, + float m10, float m11, float m12, float m13, + float m20, float m21, float m22, float m23, + float m30, float m31, float m32, float m33) + { + this.c0 = new float4(m00, m10, m20, m30); + this.c1 = new float4(m01, m11, m21, m31); + this.c2 = new float4(m02, m12, m22, m32); + this.c3 = new float4(m03, m13, m23, m33); + } + + /// Constructs a float4x4 matrix from a single float value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x4(float v) + { + this.c0 = v; + this.c1 = v; + this.c2 = v; + this.c3 = v; + } + + /// Constructs a float4x4 matrix from a single bool value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x4(bool v) + { + this.c0 = math.select(new float4(0.0f), new float4(1.0f), v); + this.c1 = math.select(new float4(0.0f), new float4(1.0f), v); + this.c2 = math.select(new float4(0.0f), new float4(1.0f), v); + this.c3 = math.select(new float4(0.0f), new float4(1.0f), v); + } + + /// Constructs a float4x4 matrix from a bool4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x4(bool4x4 v) + { + this.c0 = math.select(new float4(0.0f), new float4(1.0f), v.c0); + this.c1 = math.select(new float4(0.0f), new float4(1.0f), v.c1); + this.c2 = math.select(new float4(0.0f), new float4(1.0f), v.c2); + this.c3 = math.select(new float4(0.0f), new float4(1.0f), v.c3); + } + + /// Constructs a float4x4 matrix from a single int value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x4(int v) + { + this.c0 = v; + this.c1 = v; + this.c2 = v; + this.c3 = v; + } + + /// Constructs a float4x4 matrix from a int4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x4(int4x4 v) + { + this.c0 = v.c0; + this.c1 = v.c1; + this.c2 = v.c2; + this.c3 = v.c3; + } + + /// Constructs a float4x4 matrix from a single uint value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x4(uint v) + { + this.c0 = v; + this.c1 = v; + this.c2 = v; + this.c3 = v; + } + + /// Constructs a float4x4 matrix from a uint4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x4(uint4x4 v) + { + this.c0 = v.c0; + this.c1 = v.c1; + this.c2 = v.c2; + this.c3 = v.c3; + } + + /// Constructs a float4x4 matrix from a single double value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x4(double v) + { + this.c0 = (float4)v; + this.c1 = (float4)v; + this.c2 = (float4)v; + this.c3 = (float4)v; + } + + /// Constructs a float4x4 matrix from a double4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4x4(double4x4 v) + { + this.c0 = (float4)v.c0; + this.c1 = (float4)v.c1; + this.c2 = (float4)v.c2; + this.c3 = (float4)v.c3; + } + + + /// Implicitly converts a single float value to a float4x4 matrix by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float4x4(float v) { return new float4x4(v); } + + /// Explicitly converts a single bool value to a float4x4 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float4x4(bool v) { return new float4x4(v); } + + /// Explicitly converts a bool4x4 matrix to a float4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float4x4(bool4x4 v) { return new float4x4(v); } + + /// Implicitly converts a single int value to a float4x4 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float4x4(int v) { return new float4x4(v); } + + /// Implicitly converts a int4x4 matrix to a float4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float4x4(int4x4 v) { return new float4x4(v); } + + /// Implicitly converts a single uint value to a float4x4 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float4x4(uint v) { return new float4x4(v); } + + /// Implicitly converts a uint4x4 matrix to a float4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float4x4(uint4x4 v) { return new float4x4(v); } + + /// Explicitly converts a single double value to a float4x4 matrix by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float4x4(double v) { return new float4x4(v); } + + /// Explicitly converts a double4x4 matrix to a float4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator float4x4(double4x4 v) { return new float4x4(v); } + + + /// Returns the result of a componentwise multiplication operation on two float4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 operator * (float4x4 lhs, float4x4 rhs) { return new float4x4 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2, lhs.c3 * rhs.c3); } + + /// Returns the result of a componentwise multiplication operation on a float4x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 operator * (float4x4 lhs, float rhs) { return new float4x4 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs, lhs.c3 * rhs); } + + /// Returns the result of a componentwise multiplication operation on a float value and a float4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 operator * (float lhs, float4x4 rhs) { return new float4x4 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2, lhs * rhs.c3); } + + + /// Returns the result of a componentwise addition operation on two float4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 operator + (float4x4 lhs, float4x4 rhs) { return new float4x4 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2, lhs.c3 + rhs.c3); } + + /// Returns the result of a componentwise addition operation on a float4x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 operator + (float4x4 lhs, float rhs) { return new float4x4 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs, lhs.c3 + rhs); } + + /// Returns the result of a componentwise addition operation on a float value and a float4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 operator + (float lhs, float4x4 rhs) { return new float4x4 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2, lhs + rhs.c3); } + + + /// Returns the result of a componentwise subtraction operation on two float4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 operator - (float4x4 lhs, float4x4 rhs) { return new float4x4 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2, lhs.c3 - rhs.c3); } + + /// Returns the result of a componentwise subtraction operation on a float4x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 operator - (float4x4 lhs, float rhs) { return new float4x4 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs, lhs.c3 - rhs); } + + /// Returns the result of a componentwise subtraction operation on a float value and a float4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 operator - (float lhs, float4x4 rhs) { return new float4x4 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2, lhs - rhs.c3); } + + + /// Returns the result of a componentwise division operation on two float4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 operator / (float4x4 lhs, float4x4 rhs) { return new float4x4 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2, lhs.c3 / rhs.c3); } + + /// Returns the result of a componentwise division operation on a float4x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 operator / (float4x4 lhs, float rhs) { return new float4x4 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs, lhs.c3 / rhs); } + + /// Returns the result of a componentwise division operation on a float value and a float4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 operator / (float lhs, float4x4 rhs) { return new float4x4 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2, lhs / rhs.c3); } + + + /// Returns the result of a componentwise modulus operation on two float4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 operator % (float4x4 lhs, float4x4 rhs) { return new float4x4 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2, lhs.c3 % rhs.c3); } + + /// Returns the result of a componentwise modulus operation on a float4x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 operator % (float4x4 lhs, float rhs) { return new float4x4 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs, lhs.c3 % rhs); } + + /// Returns the result of a componentwise modulus operation on a float value and a float4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 operator % (float lhs, float4x4 rhs) { return new float4x4 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2, lhs % rhs.c3); } + + + /// Returns the result of a componentwise increment operation on a float4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 operator ++ (float4x4 val) { return new float4x4 (++val.c0, ++val.c1, ++val.c2, ++val.c3); } + + + /// Returns the result of a componentwise decrement operation on a float4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 operator -- (float4x4 val) { return new float4x4 (--val.c0, --val.c1, --val.c2, --val.c3); } + + + /// Returns the result of a componentwise less than operation on two float4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator < (float4x4 lhs, float4x4 rhs) { return new bool4x4 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2, lhs.c3 < rhs.c3); } + + /// Returns the result of a componentwise less than operation on a float4x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator < (float4x4 lhs, float rhs) { return new bool4x4 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs, lhs.c3 < rhs); } + + /// Returns the result of a componentwise less than operation on a float value and a float4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator < (float lhs, float4x4 rhs) { return new bool4x4 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2, lhs < rhs.c3); } + + + /// Returns the result of a componentwise less or equal operation on two float4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator <= (float4x4 lhs, float4x4 rhs) { return new bool4x4 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2, lhs.c3 <= rhs.c3); } + + /// Returns the result of a componentwise less or equal operation on a float4x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator <= (float4x4 lhs, float rhs) { return new bool4x4 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs, lhs.c3 <= rhs); } + + /// Returns the result of a componentwise less or equal operation on a float value and a float4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator <= (float lhs, float4x4 rhs) { return new bool4x4 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2, lhs <= rhs.c3); } + + + /// Returns the result of a componentwise greater than operation on two float4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator > (float4x4 lhs, float4x4 rhs) { return new bool4x4 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2, lhs.c3 > rhs.c3); } + + /// Returns the result of a componentwise greater than operation on a float4x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator > (float4x4 lhs, float rhs) { return new bool4x4 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs, lhs.c3 > rhs); } + + /// Returns the result of a componentwise greater than operation on a float value and a float4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator > (float lhs, float4x4 rhs) { return new bool4x4 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2, lhs > rhs.c3); } + + + /// Returns the result of a componentwise greater or equal operation on two float4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator >= (float4x4 lhs, float4x4 rhs) { return new bool4x4 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2, lhs.c3 >= rhs.c3); } + + /// Returns the result of a componentwise greater or equal operation on a float4x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator >= (float4x4 lhs, float rhs) { return new bool4x4 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs, lhs.c3 >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on a float value and a float4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator >= (float lhs, float4x4 rhs) { return new bool4x4 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2, lhs >= rhs.c3); } + + + /// Returns the result of a componentwise unary minus operation on a float4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 operator - (float4x4 val) { return new float4x4 (-val.c0, -val.c1, -val.c2, -val.c3); } + + + /// Returns the result of a componentwise unary plus operation on a float4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 operator + (float4x4 val) { return new float4x4 (+val.c0, +val.c1, +val.c2, +val.c3); } + + + /// Returns the result of a componentwise equality operation on two float4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator == (float4x4 lhs, float4x4 rhs) { return new bool4x4 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2, lhs.c3 == rhs.c3); } + + /// Returns the result of a componentwise equality operation on a float4x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator == (float4x4 lhs, float rhs) { return new bool4x4 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs, lhs.c3 == rhs); } + + /// Returns the result of a componentwise equality operation on a float value and a float4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator == (float lhs, float4x4 rhs) { return new bool4x4 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2, lhs == rhs.c3); } + + + /// Returns the result of a componentwise not equal operation on two float4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator != (float4x4 lhs, float4x4 rhs) { return new bool4x4 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2, lhs.c3 != rhs.c3); } + + /// Returns the result of a componentwise not equal operation on a float4x4 matrix and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator != (float4x4 lhs, float rhs) { return new bool4x4 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs, lhs.c3 != rhs); } + + /// Returns the result of a componentwise not equal operation on a float value and a float4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator != (float lhs, float4x4 rhs) { return new bool4x4 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2, lhs != rhs.c3); } + + + + /// Returns the float4 element at a specified index. + unsafe public ref float4 this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 4) + throw new System.ArgumentException("index must be between[0...3]"); +#endif + fixed (float4x4* array = &this) { return ref ((float4*)array)[index]; } + } + } + + /// Returns true if the float4x4 is equal to a given float4x4, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(float4x4 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2) && c3.Equals(rhs.c3); } + + /// Returns true if the float4x4 is equal to a given float4x4, false otherwise. + public override bool Equals(object o) { return Equals((float4x4)o); } + + + /// Returns a hash code for the float4x4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the float4x4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("float4x4({0}f, {1}f, {2}f, {3}f, {4}f, {5}f, {6}f, {7}f, {8}f, {9}f, {10}f, {11}f, {12}f, {13}f, {14}f, {15}f)", c0.x, c1.x, c2.x, c3.x, c0.y, c1.y, c2.y, c3.y, c0.z, c1.z, c2.z, c3.z, c0.w, c1.w, c2.w, c3.w); + } + + /// Returns a string representation of the float4x4 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("float4x4({0}f, {1}f, {2}f, {3}f, {4}f, {5}f, {6}f, {7}f, {8}f, {9}f, {10}f, {11}f, {12}f, {13}f, {14}f, {15}f)", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c3.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider), c3.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider), c2.z.ToString(format, formatProvider), c3.z.ToString(format, formatProvider), c0.w.ToString(format, formatProvider), c1.w.ToString(format, formatProvider), c2.w.ToString(format, formatProvider), c3.w.ToString(format, formatProvider)); + } + + } + + public static partial class math + { + /// Returns a float4x4 matrix constructed from four float4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 float4x4(float4 c0, float4 c1, float4 c2, float4 c3) { return new float4x4(c0, c1, c2, c3); } + + /// Returns a float4x4 matrix constructed from from 16 float values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 float4x4(float m00, float m01, float m02, float m03, + float m10, float m11, float m12, float m13, + float m20, float m21, float m22, float m23, + float m30, float m31, float m32, float m33) + { + return new float4x4(m00, m01, m02, m03, + m10, m11, m12, m13, + m20, m21, m22, m23, + m30, m31, m32, m33); + } + + /// Returns a float4x4 matrix constructed from a single float value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 float4x4(float v) { return new float4x4(v); } + + /// Returns a float4x4 matrix constructed from a single bool value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 float4x4(bool v) { return new float4x4(v); } + + /// Return a float4x4 matrix constructed from a bool4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 float4x4(bool4x4 v) { return new float4x4(v); } + + /// Returns a float4x4 matrix constructed from a single int value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 float4x4(int v) { return new float4x4(v); } + + /// Return a float4x4 matrix constructed from a int4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 float4x4(int4x4 v) { return new float4x4(v); } + + /// Returns a float4x4 matrix constructed from a single uint value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 float4x4(uint v) { return new float4x4(v); } + + /// Return a float4x4 matrix constructed from a uint4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 float4x4(uint4x4 v) { return new float4x4(v); } + + /// Returns a float4x4 matrix constructed from a single double value by converting it to float and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 float4x4(double v) { return new float4x4(v); } + + /// Return a float4x4 matrix constructed from a double4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 float4x4(double4x4 v) { return new float4x4(v); } + + /// Return the result of rotating a float3 vector by a float4x4 matrix + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 rotate(float4x4 a, float3 b) + { + return (a.c0 * b.x + a.c1 * b.y + a.c2 * b.z).xyz; + } + + /// Return the result of transforming a float3 point by a float4x4 matrix + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 transform(float4x4 a, float3 b) + { + return (a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3).xyz; + } + + /// Return the float4x4 transpose of a float4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 transpose(float4x4 v) + { + return float4x4( + v.c0.x, v.c0.y, v.c0.z, v.c0.w, + v.c1.x, v.c1.y, v.c1.z, v.c1.w, + v.c2.x, v.c2.y, v.c2.z, v.c2.w, + v.c3.x, v.c3.y, v.c3.z, v.c3.w); + } + + /// Returns the float4x4 full inverse of a float4x4 matrix. + public static float4x4 inverse(float4x4 m) + { + float4 c0 = m.c0; + float4 c1 = m.c1; + float4 c2 = m.c2; + float4 c3 = m.c3; + + float4 r0y_r1y_r0x_r1x = movelh(c1, c0); + float4 r0z_r1z_r0w_r1w = movelh(c2, c3); + float4 r2y_r3y_r2x_r3x = movehl(c0, c1); + float4 r2z_r3z_r2w_r3w = movehl(c3, c2); + + float4 r1y_r2y_r1x_r2x = shuffle(c1, c0, ShuffleComponent.LeftY, ShuffleComponent.LeftZ, ShuffleComponent.RightY, ShuffleComponent.RightZ); + float4 r1z_r2z_r1w_r2w = shuffle(c2, c3, ShuffleComponent.LeftY, ShuffleComponent.LeftZ, ShuffleComponent.RightY, ShuffleComponent.RightZ); + float4 r3y_r0y_r3x_r0x = shuffle(c1, c0, ShuffleComponent.LeftW, ShuffleComponent.LeftX, ShuffleComponent.RightW, ShuffleComponent.RightX); + float4 r3z_r0z_r3w_r0w = shuffle(c2, c3, ShuffleComponent.LeftW, ShuffleComponent.LeftX, ShuffleComponent.RightW, ShuffleComponent.RightX); + + float4 r0_wzyx = shuffle(r0z_r1z_r0w_r1w, r0y_r1y_r0x_r1x, ShuffleComponent.LeftZ, ShuffleComponent.LeftX, ShuffleComponent.RightX, ShuffleComponent.RightZ); + float4 r1_wzyx = shuffle(r0z_r1z_r0w_r1w, r0y_r1y_r0x_r1x, ShuffleComponent.LeftW, ShuffleComponent.LeftY, ShuffleComponent.RightY, ShuffleComponent.RightW); + float4 r2_wzyx = shuffle(r2z_r3z_r2w_r3w, r2y_r3y_r2x_r3x, ShuffleComponent.LeftZ, ShuffleComponent.LeftX, ShuffleComponent.RightX, ShuffleComponent.RightZ); + float4 r3_wzyx = shuffle(r2z_r3z_r2w_r3w, r2y_r3y_r2x_r3x, ShuffleComponent.LeftW, ShuffleComponent.LeftY, ShuffleComponent.RightY, ShuffleComponent.RightW); + float4 r0_xyzw = shuffle(r0y_r1y_r0x_r1x, r0z_r1z_r0w_r1w, ShuffleComponent.LeftZ, ShuffleComponent.LeftX, ShuffleComponent.RightX, ShuffleComponent.RightZ); + + // Calculate remaining inner term pairs. inner terms have zw=-xy, so we only have to calculate xy and can pack two pairs per vector. + float4 inner12_23 = r1y_r2y_r1x_r2x * r2z_r3z_r2w_r3w - r1z_r2z_r1w_r2w * r2y_r3y_r2x_r3x; + float4 inner02_13 = r0y_r1y_r0x_r1x * r2z_r3z_r2w_r3w - r0z_r1z_r0w_r1w * r2y_r3y_r2x_r3x; + float4 inner30_01 = r3z_r0z_r3w_r0w * r0y_r1y_r0x_r1x - r3y_r0y_r3x_r0x * r0z_r1z_r0w_r1w; + + // Expand inner terms back to 4 components. zw signs still need to be flipped + float4 inner12 = shuffle(inner12_23, inner12_23, ShuffleComponent.LeftX, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.RightX); + float4 inner23 = shuffle(inner12_23, inner12_23, ShuffleComponent.LeftY, ShuffleComponent.LeftW, ShuffleComponent.RightW, ShuffleComponent.RightY); + + float4 inner02 = shuffle(inner02_13, inner02_13, ShuffleComponent.LeftX, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.RightX); + float4 inner13 = shuffle(inner02_13, inner02_13, ShuffleComponent.LeftY, ShuffleComponent.LeftW, ShuffleComponent.RightW, ShuffleComponent.RightY); + + // Calculate minors + float4 minors0 = r3_wzyx * inner12 - r2_wzyx * inner13 + r1_wzyx * inner23; + + float4 denom = r0_xyzw * minors0; + + // Horizontal sum of denominator. Free sign flip of z and w compensates for missing flip in inner terms. + denom = denom + shuffle(denom, denom, ShuffleComponent.LeftY, ShuffleComponent.LeftX, ShuffleComponent.RightW, ShuffleComponent.RightZ); // x+y x+y z+w z+w + denom = denom - shuffle(denom, denom, ShuffleComponent.LeftZ, ShuffleComponent.LeftZ, ShuffleComponent.RightX, ShuffleComponent.RightX); // x+y-z-w x+y-z-w z+w-x-y z+w-x-y + + float4 rcp_denom_ppnn = float4(1.0f) / denom; + float4x4 res; + res.c0 = minors0 * rcp_denom_ppnn; + + float4 inner30 = shuffle(inner30_01, inner30_01, ShuffleComponent.LeftX, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.RightX); + float4 inner01 = shuffle(inner30_01, inner30_01, ShuffleComponent.LeftY, ShuffleComponent.LeftW, ShuffleComponent.RightW, ShuffleComponent.RightY); + + float4 minors1 = r2_wzyx * inner30 - r0_wzyx * inner23 - r3_wzyx * inner02; + res.c1 = minors1 * rcp_denom_ppnn; + + float4 minors2 = r0_wzyx * inner13 - r1_wzyx * inner30 - r3_wzyx * inner01; + res.c2 = minors2 * rcp_denom_ppnn; + + float4 minors3 = r1_wzyx * inner02 - r0_wzyx * inner12 + r2_wzyx * inner01; + res.c3 = minors3 * rcp_denom_ppnn; + return res; + } + + // Fast matrix inverse for rigid transforms (Orthonormal basis and translation) + public static float4x4 fastinverse(float4x4 m) + { + float4 c0 = m.c0; + float4 c1 = m.c1; + float4 c2 = m.c2; + float4 pos = m.c3; + + float4 zero = float4(0); + + float4 t0 = unpacklo(c0, c2); + float4 t1 = unpacklo(c1, zero); + float4 t2 = unpackhi(c0, c2); + float4 t3 = unpackhi(c1, zero); + + float4 r0 = unpacklo(t0, t1); + float4 r1 = unpackhi(t0, t1); + float4 r2 = unpacklo(t2, t3); + + pos = -(r0 * pos.x + r1 * pos.y + r2 * pos.z); + pos.w = 1.0f; + + return float4x4(r0, r1, r2, pos); + } + + /// Returns the determinant of a float4x4 matrix. + public static float determinant(float4x4 m) + { + float4 c0 = m.c0; + float4 c1 = m.c1; + float4 c2 = m.c2; + float4 c3 = m.c3; + + float m00 = c1.y * (c2.z * c3.w - c2.w * c3.z) - c2.y * (c1.z * c3.w - c1.w * c3.z) + c3.y * (c1.z * c2.w - c1.w * c2.z); + float m01 = c0.y * (c2.z * c3.w - c2.w * c3.z) - c2.y * (c0.z * c3.w - c0.w * c3.z) + c3.y * (c0.z * c2.w - c0.w * c2.z); + float m02 = c0.y * (c1.z * c3.w - c1.w * c3.z) - c1.y * (c0.z * c3.w - c0.w * c3.z) + c3.y * (c0.z * c1.w - c0.w * c1.z); + float m03 = c0.y * (c1.z * c2.w - c1.w * c2.z) - c1.y * (c0.z * c2.w - c0.w * c2.z) + c2.y * (c0.z * c1.w - c0.w * c1.z); + + return c0.x * m00 - c1.x * m01 + c2.x * m02 - c3.x * m03; + } + + /// Returns a uint hash code of a float4x4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(float4x4 v) + { + return csum(asuint(v.c0) * uint4(0xC4B1493Fu, 0xBA0966D3u, 0xAFBEE253u, 0x5B419C01u) + + asuint(v.c1) * uint4(0x515D90F5u, 0xEC9F68F3u, 0xF9EA92D5u, 0xC2FAFCB9u) + + asuint(v.c2) * uint4(0x616E9CA1u, 0xC5C5394Bu, 0xCAE78587u, 0x7A1541C9u) + + asuint(v.c3) * uint4(0xF83BD927u, 0x6A243BCBu, 0x509B84C9u, 0x91D13847u)) + 0x52F7230Fu; + } + + /// + /// Returns a uint4 vector hash code of a float4x4 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 hashwide(float4x4 v) + { + return (asuint(v.c0) * uint4(0xCF286E83u, 0xE121E6ADu, 0xC9CA1249u, 0x69B60C81u) + + asuint(v.c1) * uint4(0xE0EB6C25u, 0xF648BEABu, 0x6BDB2B07u, 0xEF63C699u) + + asuint(v.c2) * uint4(0x9001903Fu, 0xA895B9CDu, 0x9D23B201u, 0x4B01D3E1u) + + asuint(v.c3) * uint4(0x7461CA0Du, 0x79725379u, 0xD6258E5Bu, 0xEE390C97u)) + 0x9C8A2F05u; + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float4x4.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float4x4.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..0b3cfdc86054e53119f764c7ed75bd264a9cff58 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float4x4.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 53454a4b51c974a438994628ac5767e2 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/half.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/half.cs new file mode 100644 index 0000000000000000000000000000000000000000..7f28b00ca8f8a3bb74ea1a3f0d3c4d1b197728fd --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/half.cs @@ -0,0 +1,110 @@ +using System; +using System.Runtime.CompilerServices; + +namespace Unity.Mathematics +{ + public struct half : System.IEquatable, IFormattable + { + public ushort value; + + /// half zero value. + public static readonly half zero = new half(); + + public static float MaxValue { get { return 65504.0f; } } + public static float MinValue { get { return -65504.0f; } } + + /// Constructs a half value from a half value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half(half x) + { + value = x.value; + } + + /// Constructs a half value from a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half(float v) + { + value = (ushort)math.f32tof16(v); + } + + /// Constructs a half value from a double value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half(double v) + { + value = (ushort)math.f32tof16((float)v); + } + + /// Explicitly converts a float value to a half value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator half(float v) { return new half(v); } + + /// Explicitly converts a double value to a half value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator half(double v) { return new half(v); } + + /// Implicitly converts a half value to a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator float(half d) { return math.f16tof32(d.value); } + + /// Implicitly converts a half value to a double value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator double(half d) { return math.f16tof32(d.value); } + + + /// Returns whether two half values are equal. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool operator ==(half lhs, half rhs) { return lhs.value == rhs.value; } + + /// Returns whether two half values are different. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool operator !=(half lhs, half rhs) { return lhs.value != rhs.value; } + + + /// Returns true if the half is equal to a given half, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(half rhs) { return value == rhs.value; } + + /// Returns true if the half is equal to a given half, false otherwise. + public override bool Equals(object o) { return Equals((half)o); } + + /// Returns a hash code for the half. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)value; } + + /// Returns a string representation of the half. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return math.f16tof32(value).ToString(); + } + + /// Returns a string representation of the half using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return math.f16tof32(value).ToString(format, formatProvider); + } + } + + public static partial class math + { + /// Returns a half value constructed from a half values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half half(half x) { return new half(x); } + + /// Returns a half value constructed from a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half half(float v) { return new half(v); } + + /// Returns a half value constructed from a double value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half half(double v) { return new half(v); } + + /// Returns a uint hash code of a half value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(half v) + { + return v.value * 0x745ED837u + 0x816EFB5Du; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/half.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/half.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..ab9dc0d8d29aeec0289d67a5e1ed1d653483f9be --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/half.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a513f9316035e1649a644c2e9f69c12a +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/half2.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/half2.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..6976df5ac6fb07162c6f5cbdcfd069ad1a268681 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/half2.gen.cs @@ -0,0 +1,471 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; +using System.Diagnostics; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [DebuggerTypeProxy(typeof(half2.DebuggerProxy))] + public partial struct half2 : System.IEquatable, IFormattable + { + public half x; + public half y; + + /// half2 zero value. + public static readonly half2 zero; + + /// Constructs a half2 vector from two half values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half2(half x, half y) + { + this.x = x; + this.y = y; + } + + /// Constructs a half2 vector from a half2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half2(half2 xy) + { + this.x = xy.x; + this.y = xy.y; + } + + /// Constructs a half2 vector from a single half value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half2(half v) + { + this.x = v; + this.y = v; + } + + /// Constructs a half2 vector from a single float value by converting it to half and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half2(float v) + { + this.x = (half)v; + this.y = (half)v; + } + + /// Constructs a half2 vector from a float2 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half2(float2 v) + { + this.x = (half)v.x; + this.y = (half)v.y; + } + + /// Constructs a half2 vector from a single double value by converting it to half and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half2(double v) + { + this.x = (half)v; + this.y = (half)v; + } + + /// Constructs a half2 vector from a double2 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half2(double2 v) + { + this.x = (half)v.x; + this.y = (half)v.y; + } + + + /// Implicitly converts a single half value to a half2 vector by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator half2(half v) { return new half2(v); } + + /// Explicitly converts a single float value to a half2 vector by converting it to half and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator half2(float v) { return new half2(v); } + + /// Explicitly converts a float2 vector to a half2 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator half2(float2 v) { return new half2(v); } + + /// Explicitly converts a single double value to a half2 vector by converting it to half and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator half2(double v) { return new half2(v); } + + /// Explicitly converts a double2 vector to a half2 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator half2(double2 v) { return new half2(v); } + + + /// Returns the result of a componentwise equality operation on two half2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 operator == (half2 lhs, half2 rhs) { return new bool2 (lhs.x == rhs.x, lhs.y == rhs.y); } + + /// Returns the result of a componentwise equality operation on a half2 vector and a half value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 operator == (half2 lhs, half rhs) { return new bool2 (lhs.x == rhs, lhs.y == rhs); } + + /// Returns the result of a componentwise equality operation on a half value and a half2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 operator == (half lhs, half2 rhs) { return new bool2 (lhs == rhs.x, lhs == rhs.y); } + + + /// Returns the result of a componentwise not equal operation on two half2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 operator != (half2 lhs, half2 rhs) { return new bool2 (lhs.x != rhs.x, lhs.y != rhs.y); } + + /// Returns the result of a componentwise not equal operation on a half2 vector and a half value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 operator != (half2 lhs, half rhs) { return new bool2 (lhs.x != rhs, lhs.y != rhs); } + + /// Returns the result of a componentwise not equal operation on a half value and a half2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 operator != (half lhs, half2 rhs) { return new bool2 (lhs != rhs.x, lhs != rhs.y); } + + + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 yxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 yxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 yyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 yyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 xx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 xy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(x, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; y = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 yx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(y, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; x = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 yy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(y, y); } + } + + + + /// Returns the half element at a specified index. + unsafe public half this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 2) + throw new System.ArgumentException("index must be between[0...1]"); +#endif + fixed (half2* array = &this) { return ((half*)array)[index]; } + } + set + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 2) + throw new System.ArgumentException("index must be between[0...1]"); +#endif + fixed (half* array = &x) { array[index] = value; } + } + } + + /// Returns true if the half2 is equal to a given half2, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(half2 rhs) { return x == rhs.x && y == rhs.y; } + + /// Returns true if the half2 is equal to a given half2, false otherwise. + public override bool Equals(object o) { return Equals((half2)o); } + + + /// Returns a hash code for the half2. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the half2. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("half2({0}, {1})", x, y); + } + + /// Returns a string representation of the half2 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("half2({0}, {1})", x.ToString(format, formatProvider), y.ToString(format, formatProvider)); + } + + internal sealed class DebuggerProxy + { + public half x; + public half y; + public DebuggerProxy(half2 v) + { + x = v.x; + y = v.y; + } + } + + } + + public static partial class math + { + /// Returns a half2 vector constructed from two half values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half2 half2(half x, half y) { return new half2(x, y); } + + /// Returns a half2 vector constructed from a half2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half2 half2(half2 xy) { return new half2(xy); } + + /// Returns a half2 vector constructed from a single half value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half2 half2(half v) { return new half2(v); } + + /// Returns a half2 vector constructed from a single float value by converting it to half and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half2 half2(float v) { return new half2(v); } + + /// Return a half2 vector constructed from a float2 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half2 half2(float2 v) { return new half2(v); } + + /// Returns a half2 vector constructed from a single double value by converting it to half and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half2 half2(double v) { return new half2(v); } + + /// Return a half2 vector constructed from a double2 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half2 half2(double2 v) { return new half2(v); } + + /// Returns a uint hash code of a half2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(half2 v) + { + return csum(uint2(v.x.value, v.y.value) * uint2(0x6E624EB7u, 0x7383ED49u)) + 0xDD49C23Bu; + } + + /// + /// Returns a uint2 vector hash code of a half2 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2 hashwide(half2 v) + { + return (uint2(v.x.value, v.y.value) * uint2(0xEBD0D005u, 0x91475DF7u)) + 0x55E84827u; + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/half2.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/half2.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..e9af8ddc2fbf7e83617e1c5bf1ba38e539cf5738 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/half2.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 79785f1f327add947b5448161b8ddc4f +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/half3.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/half3.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..4cbba35cbce5a1f1718825f1ebdd775a37101ce1 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/half3.gen.cs @@ -0,0 +1,1239 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; +using System.Diagnostics; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [DebuggerTypeProxy(typeof(half3.DebuggerProxy))] + public partial struct half3 : System.IEquatable, IFormattable + { + public half x; + public half y; + public half z; + + /// half3 zero value. + public static readonly half3 zero; + + /// Constructs a half3 vector from three half values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half3(half x, half y, half z) + { + this.x = x; + this.y = y; + this.z = z; + } + + /// Constructs a half3 vector from a half value and a half2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half3(half x, half2 yz) + { + this.x = x; + this.y = yz.x; + this.z = yz.y; + } + + /// Constructs a half3 vector from a half2 vector and a half value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half3(half2 xy, half z) + { + this.x = xy.x; + this.y = xy.y; + this.z = z; + } + + /// Constructs a half3 vector from a half3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half3(half3 xyz) + { + this.x = xyz.x; + this.y = xyz.y; + this.z = xyz.z; + } + + /// Constructs a half3 vector from a single half value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half3(half v) + { + this.x = v; + this.y = v; + this.z = v; + } + + /// Constructs a half3 vector from a single float value by converting it to half and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half3(float v) + { + this.x = (half)v; + this.y = (half)v; + this.z = (half)v; + } + + /// Constructs a half3 vector from a float3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half3(float3 v) + { + this.x = (half)v.x; + this.y = (half)v.y; + this.z = (half)v.z; + } + + /// Constructs a half3 vector from a single double value by converting it to half and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half3(double v) + { + this.x = (half)v; + this.y = (half)v; + this.z = (half)v; + } + + /// Constructs a half3 vector from a double3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half3(double3 v) + { + this.x = (half)v.x; + this.y = (half)v.y; + this.z = (half)v.z; + } + + + /// Implicitly converts a single half value to a half3 vector by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator half3(half v) { return new half3(v); } + + /// Explicitly converts a single float value to a half3 vector by converting it to half and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator half3(float v) { return new half3(v); } + + /// Explicitly converts a float3 vector to a half3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator half3(float3 v) { return new half3(v); } + + /// Explicitly converts a single double value to a half3 vector by converting it to half and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator half3(double v) { return new half3(v); } + + /// Explicitly converts a double3 vector to a half3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator half3(double3 v) { return new half3(v); } + + + /// Returns the result of a componentwise equality operation on two half3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator == (half3 lhs, half3 rhs) { return new bool3 (lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z); } + + /// Returns the result of a componentwise equality operation on a half3 vector and a half value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator == (half3 lhs, half rhs) { return new bool3 (lhs.x == rhs, lhs.y == rhs, lhs.z == rhs); } + + /// Returns the result of a componentwise equality operation on a half value and a half3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator == (half lhs, half3 rhs) { return new bool3 (lhs == rhs.x, lhs == rhs.y, lhs == rhs.z); } + + + /// Returns the result of a componentwise not equal operation on two half3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator != (half3 lhs, half3 rhs) { return new bool3 (lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z); } + + /// Returns the result of a componentwise not equal operation on a half3 vector and a half value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator != (half3 lhs, half rhs) { return new bool3 (lhs.x != rhs, lhs.y != rhs, lhs.z != rhs); } + + /// Returns the result of a componentwise not equal operation on a half value and a half3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator != (half lhs, half3 rhs) { return new bool3 (lhs != rhs.x, lhs != rhs.y, lhs != rhs.z); } + + + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xyxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xyyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xyzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xyzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xyzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xzxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xzxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, z, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xzxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xzyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, z, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xzyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xzyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xzzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xzzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xzzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yyxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yyyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yyzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yyzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yyzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yzxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yzxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, z, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yzxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yzyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, z, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yzyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yzyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yzzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yzzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yzzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zxxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zxyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, x, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zxzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zxzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, x, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zxzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zyxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, y, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zyyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zyzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, y, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zyzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zyzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zzxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zzxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, z, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zzxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zzyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, z, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zzyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zzyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zzzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zzzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zzzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, y, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; y = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, z, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; z = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 yxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 yxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 yxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, x, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; x = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 yyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 yyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 yyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 yzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, z, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; z = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 yzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 yzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 zxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 zxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(z, x, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; x = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 zxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 zyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(z, y, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; y = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 zyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 zyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 zzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 zzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 zzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 xx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 xy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(x, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; y = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 xz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(x, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; z = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 yx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(y, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; x = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 yy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 yz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(y, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; z = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 zx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(z, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; x = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 zy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(z, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; y = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 zz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(z, z); } + } + + + + /// Returns the half element at a specified index. + unsafe public half this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 3) + throw new System.ArgumentException("index must be between[0...2]"); +#endif + fixed (half3* array = &this) { return ((half*)array)[index]; } + } + set + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 3) + throw new System.ArgumentException("index must be between[0...2]"); +#endif + fixed (half* array = &x) { array[index] = value; } + } + } + + /// Returns true if the half3 is equal to a given half3, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(half3 rhs) { return x == rhs.x && y == rhs.y && z == rhs.z; } + + /// Returns true if the half3 is equal to a given half3, false otherwise. + public override bool Equals(object o) { return Equals((half3)o); } + + + /// Returns a hash code for the half3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the half3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("half3({0}, {1}, {2})", x, y, z); + } + + /// Returns a string representation of the half3 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("half3({0}, {1}, {2})", x.ToString(format, formatProvider), y.ToString(format, formatProvider), z.ToString(format, formatProvider)); + } + + internal sealed class DebuggerProxy + { + public half x; + public half y; + public half z; + public DebuggerProxy(half3 v) + { + x = v.x; + y = v.y; + z = v.z; + } + } + + } + + public static partial class math + { + /// Returns a half3 vector constructed from three half values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half3 half3(half x, half y, half z) { return new half3(x, y, z); } + + /// Returns a half3 vector constructed from a half value and a half2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half3 half3(half x, half2 yz) { return new half3(x, yz); } + + /// Returns a half3 vector constructed from a half2 vector and a half value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half3 half3(half2 xy, half z) { return new half3(xy, z); } + + /// Returns a half3 vector constructed from a half3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half3 half3(half3 xyz) { return new half3(xyz); } + + /// Returns a half3 vector constructed from a single half value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half3 half3(half v) { return new half3(v); } + + /// Returns a half3 vector constructed from a single float value by converting it to half and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half3 half3(float v) { return new half3(v); } + + /// Return a half3 vector constructed from a float3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half3 half3(float3 v) { return new half3(v); } + + /// Returns a half3 vector constructed from a single double value by converting it to half and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half3 half3(double v) { return new half3(v); } + + /// Return a half3 vector constructed from a double3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half3 half3(double3 v) { return new half3(v); } + + /// Returns a uint hash code of a half3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(half3 v) + { + return csum(uint3(v.x.value, v.y.value, v.z.value) * uint3(0x685835CFu, 0xC3D32AE1u, 0xB966942Fu)) + 0xFE9856B3u; + } + + /// + /// Returns a uint3 vector hash code of a half3 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 hashwide(half3 v) + { + return (uint3(v.x.value, v.y.value, v.z.value) * uint3(0xFA3A3285u, 0xAD55999Du, 0xDCDD5341u)) + 0x94DDD769u; + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/half3.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/half3.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..22fa764696f0a96969c902724ed7db1c269fd7f5 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/half3.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: d271113f4074d29479af6b04f032a53e +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/half4.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/half4.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..69a0d4dcb6989f9551ba465ab92bc47d76335462 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/half4.gen.cs @@ -0,0 +1,3155 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; +using System.Diagnostics; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [DebuggerTypeProxy(typeof(half4.DebuggerProxy))] + public partial struct half4 : System.IEquatable, IFormattable + { + public half x; + public half y; + public half z; + public half w; + + /// half4 zero value. + public static readonly half4 zero; + + /// Constructs a half4 vector from four half values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half4(half x, half y, half z, half w) + { + this.x = x; + this.y = y; + this.z = z; + this.w = w; + } + + /// Constructs a half4 vector from two half values and a half2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half4(half x, half y, half2 zw) + { + this.x = x; + this.y = y; + this.z = zw.x; + this.w = zw.y; + } + + /// Constructs a half4 vector from a half value, a half2 vector and a half value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half4(half x, half2 yz, half w) + { + this.x = x; + this.y = yz.x; + this.z = yz.y; + this.w = w; + } + + /// Constructs a half4 vector from a half value and a half3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half4(half x, half3 yzw) + { + this.x = x; + this.y = yzw.x; + this.z = yzw.y; + this.w = yzw.z; + } + + /// Constructs a half4 vector from a half2 vector and two half values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half4(half2 xy, half z, half w) + { + this.x = xy.x; + this.y = xy.y; + this.z = z; + this.w = w; + } + + /// Constructs a half4 vector from two half2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half4(half2 xy, half2 zw) + { + this.x = xy.x; + this.y = xy.y; + this.z = zw.x; + this.w = zw.y; + } + + /// Constructs a half4 vector from a half3 vector and a half value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half4(half3 xyz, half w) + { + this.x = xyz.x; + this.y = xyz.y; + this.z = xyz.z; + this.w = w; + } + + /// Constructs a half4 vector from a half4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half4(half4 xyzw) + { + this.x = xyzw.x; + this.y = xyzw.y; + this.z = xyzw.z; + this.w = xyzw.w; + } + + /// Constructs a half4 vector from a single half value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half4(half v) + { + this.x = v; + this.y = v; + this.z = v; + this.w = v; + } + + /// Constructs a half4 vector from a single float value by converting it to half and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half4(float v) + { + this.x = (half)v; + this.y = (half)v; + this.z = (half)v; + this.w = (half)v; + } + + /// Constructs a half4 vector from a float4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half4(float4 v) + { + this.x = (half)v.x; + this.y = (half)v.y; + this.z = (half)v.z; + this.w = (half)v.w; + } + + /// Constructs a half4 vector from a single double value by converting it to half and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half4(double v) + { + this.x = (half)v; + this.y = (half)v; + this.z = (half)v; + this.w = (half)v; + } + + /// Constructs a half4 vector from a double4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public half4(double4 v) + { + this.x = (half)v.x; + this.y = (half)v.y; + this.z = (half)v.z; + this.w = (half)v.w; + } + + + /// Implicitly converts a single half value to a half4 vector by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator half4(half v) { return new half4(v); } + + /// Explicitly converts a single float value to a half4 vector by converting it to half and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator half4(float v) { return new half4(v); } + + /// Explicitly converts a float4 vector to a half4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator half4(float4 v) { return new half4(v); } + + /// Explicitly converts a single double value to a half4 vector by converting it to half and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator half4(double v) { return new half4(v); } + + /// Explicitly converts a double4 vector to a half4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator half4(double4 v) { return new half4(v); } + + + /// Returns the result of a componentwise equality operation on two half4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator == (half4 lhs, half4 rhs) { return new bool4 (lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z, lhs.w == rhs.w); } + + /// Returns the result of a componentwise equality operation on a half4 vector and a half value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator == (half4 lhs, half rhs) { return new bool4 (lhs.x == rhs, lhs.y == rhs, lhs.z == rhs, lhs.w == rhs); } + + /// Returns the result of a componentwise equality operation on a half value and a half4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator == (half lhs, half4 rhs) { return new bool4 (lhs == rhs.x, lhs == rhs.y, lhs == rhs.z, lhs == rhs.w); } + + + /// Returns the result of a componentwise not equal operation on two half4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator != (half4 lhs, half4 rhs) { return new bool4 (lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z, lhs.w != rhs.w); } + + /// Returns the result of a componentwise not equal operation on a half4 vector and a half value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator != (half4 lhs, half rhs) { return new bool4 (lhs.x != rhs, lhs.y != rhs, lhs.z != rhs, lhs.w != rhs); } + + /// Returns the result of a componentwise not equal operation on a half value and a half4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator != (half lhs, half4 rhs) { return new bool4 (lhs != rhs.x, lhs != rhs.y, lhs != rhs.z, lhs != rhs.w); } + + + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xxww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, x, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xyxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xyxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xyyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xyyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xyzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xyzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xyzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xyzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, z, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; y = value.y; z = value.z; w = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xywx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xywy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xywz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, w, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; y = value.y; w = value.z; z = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xyww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, y, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xzxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xzxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, z, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xzxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xzxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, z, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xzyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, z, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xzyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xzyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xzyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, z, y, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; z = value.y; y = value.z; w = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xzzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xzzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xzzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xzzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, z, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xzwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, z, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xzwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, z, w, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; z = value.y; w = value.z; y = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xzwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, z, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xzww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, z, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xwxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, w, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xwxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, w, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xwxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, w, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xwxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, w, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xwyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, w, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xwyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, w, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xwyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, w, y, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; w = value.y; y = value.z; z = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xwyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, w, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xwzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, w, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xwzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, w, z, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; w = value.y; z = value.z; y = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xwzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, w, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xwzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, w, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xwwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, w, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xwwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, w, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xwwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, w, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 xwww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(x, w, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, z, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; x = value.y; z = value.z; w = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, w, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; x = value.y; w = value.z; z = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yxww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, x, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yyxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yyxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yyyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yyyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yyzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yyzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yyzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yyzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yywx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yywy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yywz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yyww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, y, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yzxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yzxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, z, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yzxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yzxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, z, x, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; z = value.y; x = value.z; w = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yzyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, z, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yzyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yzyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yzyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, z, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yzzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yzzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yzzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yzzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, z, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yzwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, z, w, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; z = value.y; w = value.z; x = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yzwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, z, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yzwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, z, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 yzww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, z, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 ywxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, w, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 ywxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, w, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 ywxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, w, x, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; w = value.y; x = value.z; z = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 ywxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, w, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 ywyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, w, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 ywyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, w, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 ywyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, w, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 ywyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, w, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 ywzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, w, z, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; w = value.y; z = value.z; x = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 ywzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, w, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 ywzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, w, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 ywzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, w, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 ywwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, w, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 ywwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, w, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 ywwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, w, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 ywww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(y, w, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zxxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zxxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, x, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zxyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, x, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zxyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, x, y, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; x = value.y; y = value.z; w = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zxzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zxzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, x, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zxzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zxzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, x, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zxwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, x, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zxwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, x, w, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; x = value.y; w = value.z; y = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zxwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, x, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zxww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, x, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zyxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, y, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zyxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, y, x, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; y = value.y; x = value.z; w = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zyyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zyyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, y, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zyzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, y, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zyzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zyzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zyzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, y, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zywx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, y, w, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; y = value.y; w = value.z; x = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zywy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, y, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zywz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, y, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zyww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, y, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zzxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zzxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, z, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zzxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zzxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, z, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zzyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, z, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zzyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zzyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zzyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, z, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zzzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zzzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zzzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zzzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, z, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zzwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, z, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zzwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, z, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zzwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, z, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zzww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, z, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zwxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, w, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zwxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, w, x, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; w = value.y; x = value.z; y = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zwxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, w, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zwxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, w, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zwyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, w, y, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; w = value.y; y = value.z; x = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zwyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, w, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zwyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, w, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zwyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, w, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zwzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, w, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zwzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, w, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zwzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, w, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zwzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, w, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zwwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, w, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zwwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, w, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zwwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, w, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 zwww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(z, w, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wxxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wxxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, x, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wxyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, x, y, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; x = value.y; y = value.z; z = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wxyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, x, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wxzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wxzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, x, z, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; x = value.y; z = value.z; y = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wxzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wxzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, x, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wxwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, x, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wxwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, x, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wxwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, x, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wxww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, x, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wyxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, y, x, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; y = value.y; x = value.z; z = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wyxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, y, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wyyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wyyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, y, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wyzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, y, z, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; y = value.y; z = value.z; x = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wyzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wyzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wyzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, y, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wywx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, y, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wywy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, y, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wywz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, y, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wyww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, y, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wzxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wzxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, z, x, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; z = value.y; x = value.z; y = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wzxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wzxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, z, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wzyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, z, y, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; z = value.y; y = value.z; x = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wzyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wzyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wzyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, z, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wzzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wzzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wzzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wzzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, z, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wzwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, z, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wzwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, z, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wzwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, z, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wzww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, z, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wwxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, w, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wwxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, w, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wwxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, w, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wwxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, w, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wwyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, w, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wwyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, w, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wwyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, w, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wwyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, w, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wwzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, w, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wwzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, w, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wwzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, w, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wwzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, w, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wwwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, w, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wwwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, w, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wwwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, w, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half4 wwww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half4(w, w, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, y, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; y = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, y, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; y = value.y; w = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, z, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; z = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, z, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; z = value.y; w = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, w, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; w = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, w, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; w = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 xww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(x, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 yxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 yxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 yxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, x, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; x = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 yxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, x, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; x = value.y; w = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 yyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 yyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 yyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 yyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 yzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, z, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; z = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 yzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 yzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 yzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, z, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; z = value.y; w = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 ywx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, w, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; w = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 ywy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 ywz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, w, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; w = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 yww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(y, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 zxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 zxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(z, x, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; x = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 zxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 zxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(z, x, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; x = value.y; w = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 zyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(z, y, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; y = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 zyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 zyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 zyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(z, y, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; y = value.y; w = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 zzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 zzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 zzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 zzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(z, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 zwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(z, w, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; w = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 zwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(z, w, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; w = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 zwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(z, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 zww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(z, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 wxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(w, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 wxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(w, x, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; x = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 wxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(w, x, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; x = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 wxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(w, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 wyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(w, y, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; y = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 wyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(w, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 wyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(w, y, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; y = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 wyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(w, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 wzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(w, z, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; z = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 wzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(w, z, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; z = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 wzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(w, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 wzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(w, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 wwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(w, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 wwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(w, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 wwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(w, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half3 www + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half3(w, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 xx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 xy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(x, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; y = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 xz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(x, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; z = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 xw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(x, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; w = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 yx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(y, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; x = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 yy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 yz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(y, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; z = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 yw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(y, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; w = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 zx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(z, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; x = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 zy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(z, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; y = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 zz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 zw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(z, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; w = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 wx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(w, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; x = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 wy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(w, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; y = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 wz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(w, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; z = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public half2 ww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new half2(w, w); } + } + + + + /// Returns the half element at a specified index. + unsafe public half this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 4) + throw new System.ArgumentException("index must be between[0...3]"); +#endif + fixed (half4* array = &this) { return ((half*)array)[index]; } + } + set + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 4) + throw new System.ArgumentException("index must be between[0...3]"); +#endif + fixed (half* array = &x) { array[index] = value; } + } + } + + /// Returns true if the half4 is equal to a given half4, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(half4 rhs) { return x == rhs.x && y == rhs.y && z == rhs.z && w == rhs.w; } + + /// Returns true if the half4 is equal to a given half4, false otherwise. + public override bool Equals(object o) { return Equals((half4)o); } + + + /// Returns a hash code for the half4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the half4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("half4({0}, {1}, {2}, {3})", x, y, z, w); + } + + /// Returns a string representation of the half4 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("half4({0}, {1}, {2}, {3})", x.ToString(format, formatProvider), y.ToString(format, formatProvider), z.ToString(format, formatProvider), w.ToString(format, formatProvider)); + } + + internal sealed class DebuggerProxy + { + public half x; + public half y; + public half z; + public half w; + public DebuggerProxy(half4 v) + { + x = v.x; + y = v.y; + z = v.z; + w = v.w; + } + } + + } + + public static partial class math + { + /// Returns a half4 vector constructed from four half values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half4 half4(half x, half y, half z, half w) { return new half4(x, y, z, w); } + + /// Returns a half4 vector constructed from two half values and a half2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half4 half4(half x, half y, half2 zw) { return new half4(x, y, zw); } + + /// Returns a half4 vector constructed from a half value, a half2 vector and a half value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half4 half4(half x, half2 yz, half w) { return new half4(x, yz, w); } + + /// Returns a half4 vector constructed from a half value and a half3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half4 half4(half x, half3 yzw) { return new half4(x, yzw); } + + /// Returns a half4 vector constructed from a half2 vector and two half values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half4 half4(half2 xy, half z, half w) { return new half4(xy, z, w); } + + /// Returns a half4 vector constructed from two half2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half4 half4(half2 xy, half2 zw) { return new half4(xy, zw); } + + /// Returns a half4 vector constructed from a half3 vector and a half value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half4 half4(half3 xyz, half w) { return new half4(xyz, w); } + + /// Returns a half4 vector constructed from a half4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half4 half4(half4 xyzw) { return new half4(xyzw); } + + /// Returns a half4 vector constructed from a single half value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half4 half4(half v) { return new half4(v); } + + /// Returns a half4 vector constructed from a single float value by converting it to half and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half4 half4(float v) { return new half4(v); } + + /// Return a half4 vector constructed from a float4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half4 half4(float4 v) { return new half4(v); } + + /// Returns a half4 vector constructed from a single double value by converting it to half and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half4 half4(double v) { return new half4(v); } + + /// Return a half4 vector constructed from a double4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static half4 half4(double4 v) { return new half4(v); } + + /// Returns a uint hash code of a half4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(half4 v) + { + return csum(uint4(v.x.value, v.y.value, v.z.value, v.w.value) * uint4(0x745ED837u, 0x9CDC88F5u, 0xFA62D721u, 0x7E4DB1CFu)) + 0x68EEE0F5u; + } + + /// + /// Returns a uint4 vector hash code of a half4 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 hashwide(half4 v) + { + return (uint4(v.x.value, v.y.value, v.z.value, v.w.value) * uint4(0xBC3B0A59u, 0x816EFB5Du, 0xA24E82B7u, 0x45A22087u)) + 0xFC104C3Bu; + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/half4.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/half4.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..81168fb9818ac41a09c6ecc13ea899063d8fd007 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/half4.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a48ec2283f8d80e4b8d21c071400d3da +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int2.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int2.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..6757c2e5bfead644e9d8bec9e805dc2a6dcd1908 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int2.gen.cs @@ -0,0 +1,780 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; +using System.Diagnostics; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [DebuggerTypeProxy(typeof(int2.DebuggerProxy))] + [System.Serializable] + public partial struct int2 : System.IEquatable, IFormattable + { + public int x; + public int y; + + /// int2 zero value. + public static readonly int2 zero; + + /// Constructs a int2 vector from two int values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2(int x, int y) + { + this.x = x; + this.y = y; + } + + /// Constructs a int2 vector from an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2(int2 xy) + { + this.x = xy.x; + this.y = xy.y; + } + + /// Constructs a int2 vector from a single int value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2(int v) + { + this.x = v; + this.y = v; + } + + /// Constructs a int2 vector from a single bool value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2(bool v) + { + this.x = v ? 1 : 0; + this.y = v ? 1 : 0; + } + + /// Constructs a int2 vector from a bool2 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2(bool2 v) + { + this.x = v.x ? 1 : 0; + this.y = v.y ? 1 : 0; + } + + /// Constructs a int2 vector from a single uint value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2(uint v) + { + this.x = (int)v; + this.y = (int)v; + } + + /// Constructs a int2 vector from a uint2 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2(uint2 v) + { + this.x = (int)v.x; + this.y = (int)v.y; + } + + /// Constructs a int2 vector from a single float value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2(float v) + { + this.x = (int)v; + this.y = (int)v; + } + + /// Constructs a int2 vector from a float2 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2(float2 v) + { + this.x = (int)v.x; + this.y = (int)v.y; + } + + /// Constructs a int2 vector from a single double value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2(double v) + { + this.x = (int)v; + this.y = (int)v; + } + + /// Constructs a int2 vector from a double2 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2(double2 v) + { + this.x = (int)v.x; + this.y = (int)v.y; + } + + + /// Implicitly converts a single int value to a int2 vector by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator int2(int v) { return new int2(v); } + + /// Explicitly converts a single bool value to a int2 vector by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2(bool v) { return new int2(v); } + + /// Explicitly converts a bool2 vector to a int2 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2(bool2 v) { return new int2(v); } + + /// Explicitly converts a single uint value to a int2 vector by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2(uint v) { return new int2(v); } + + /// Explicitly converts a uint2 vector to a int2 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2(uint2 v) { return new int2(v); } + + /// Explicitly converts a single float value to a int2 vector by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2(float v) { return new int2(v); } + + /// Explicitly converts a float2 vector to a int2 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2(float2 v) { return new int2(v); } + + /// Explicitly converts a single double value to a int2 vector by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2(double v) { return new int2(v); } + + /// Explicitly converts a double2 vector to a int2 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2(double2 v) { return new int2(v); } + + + /// Returns the result of a componentwise multiplication operation on two int2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator * (int2 lhs, int2 rhs) { return new int2 (lhs.x * rhs.x, lhs.y * rhs.y); } + + /// Returns the result of a componentwise multiplication operation on an int2 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator * (int2 lhs, int rhs) { return new int2 (lhs.x * rhs, lhs.y * rhs); } + + /// Returns the result of a componentwise multiplication operation on an int value and an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator * (int lhs, int2 rhs) { return new int2 (lhs * rhs.x, lhs * rhs.y); } + + + /// Returns the result of a componentwise addition operation on two int2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator + (int2 lhs, int2 rhs) { return new int2 (lhs.x + rhs.x, lhs.y + rhs.y); } + + /// Returns the result of a componentwise addition operation on an int2 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator + (int2 lhs, int rhs) { return new int2 (lhs.x + rhs, lhs.y + rhs); } + + /// Returns the result of a componentwise addition operation on an int value and an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator + (int lhs, int2 rhs) { return new int2 (lhs + rhs.x, lhs + rhs.y); } + + + /// Returns the result of a componentwise subtraction operation on two int2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator - (int2 lhs, int2 rhs) { return new int2 (lhs.x - rhs.x, lhs.y - rhs.y); } + + /// Returns the result of a componentwise subtraction operation on an int2 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator - (int2 lhs, int rhs) { return new int2 (lhs.x - rhs, lhs.y - rhs); } + + /// Returns the result of a componentwise subtraction operation on an int value and an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator - (int lhs, int2 rhs) { return new int2 (lhs - rhs.x, lhs - rhs.y); } + + + /// Returns the result of a componentwise division operation on two int2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator / (int2 lhs, int2 rhs) { return new int2 (lhs.x / rhs.x, lhs.y / rhs.y); } + + /// Returns the result of a componentwise division operation on an int2 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator / (int2 lhs, int rhs) { return new int2 (lhs.x / rhs, lhs.y / rhs); } + + /// Returns the result of a componentwise division operation on an int value and an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator / (int lhs, int2 rhs) { return new int2 (lhs / rhs.x, lhs / rhs.y); } + + + /// Returns the result of a componentwise modulus operation on two int2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator % (int2 lhs, int2 rhs) { return new int2 (lhs.x % rhs.x, lhs.y % rhs.y); } + + /// Returns the result of a componentwise modulus operation on an int2 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator % (int2 lhs, int rhs) { return new int2 (lhs.x % rhs, lhs.y % rhs); } + + /// Returns the result of a componentwise modulus operation on an int value and an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator % (int lhs, int2 rhs) { return new int2 (lhs % rhs.x, lhs % rhs.y); } + + + /// Returns the result of a componentwise increment operation on an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator ++ (int2 val) { return new int2 (++val.x, ++val.y); } + + + /// Returns the result of a componentwise decrement operation on an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator -- (int2 val) { return new int2 (--val.x, --val.y); } + + + /// Returns the result of a componentwise less than operation on two int2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 operator < (int2 lhs, int2 rhs) { return new bool2 (lhs.x < rhs.x, lhs.y < rhs.y); } + + /// Returns the result of a componentwise less than operation on an int2 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 operator < (int2 lhs, int rhs) { return new bool2 (lhs.x < rhs, lhs.y < rhs); } + + /// Returns the result of a componentwise less than operation on an int value and an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 operator < (int lhs, int2 rhs) { return new bool2 (lhs < rhs.x, lhs < rhs.y); } + + + /// Returns the result of a componentwise less or equal operation on two int2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 operator <= (int2 lhs, int2 rhs) { return new bool2 (lhs.x <= rhs.x, lhs.y <= rhs.y); } + + /// Returns the result of a componentwise less or equal operation on an int2 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 operator <= (int2 lhs, int rhs) { return new bool2 (lhs.x <= rhs, lhs.y <= rhs); } + + /// Returns the result of a componentwise less or equal operation on an int value and an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 operator <= (int lhs, int2 rhs) { return new bool2 (lhs <= rhs.x, lhs <= rhs.y); } + + + /// Returns the result of a componentwise greater than operation on two int2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 operator > (int2 lhs, int2 rhs) { return new bool2 (lhs.x > rhs.x, lhs.y > rhs.y); } + + /// Returns the result of a componentwise greater than operation on an int2 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 operator > (int2 lhs, int rhs) { return new bool2 (lhs.x > rhs, lhs.y > rhs); } + + /// Returns the result of a componentwise greater than operation on an int value and an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 operator > (int lhs, int2 rhs) { return new bool2 (lhs > rhs.x, lhs > rhs.y); } + + + /// Returns the result of a componentwise greater or equal operation on two int2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 operator >= (int2 lhs, int2 rhs) { return new bool2 (lhs.x >= rhs.x, lhs.y >= rhs.y); } + + /// Returns the result of a componentwise greater or equal operation on an int2 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 operator >= (int2 lhs, int rhs) { return new bool2 (lhs.x >= rhs, lhs.y >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on an int value and an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 operator >= (int lhs, int2 rhs) { return new bool2 (lhs >= rhs.x, lhs >= rhs.y); } + + + /// Returns the result of a componentwise unary minus operation on an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator - (int2 val) { return new int2 (-val.x, -val.y); } + + + /// Returns the result of a componentwise unary plus operation on an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator + (int2 val) { return new int2 (+val.x, +val.y); } + + + /// Returns the result of a componentwise left shift operation on an int2 vector by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator << (int2 x, int n) { return new int2 (x.x << n, x.y << n); } + + /// Returns the result of a componentwise right shift operation on an int2 vector by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator >> (int2 x, int n) { return new int2 (x.x >> n, x.y >> n); } + + /// Returns the result of a componentwise equality operation on two int2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 operator == (int2 lhs, int2 rhs) { return new bool2 (lhs.x == rhs.x, lhs.y == rhs.y); } + + /// Returns the result of a componentwise equality operation on an int2 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 operator == (int2 lhs, int rhs) { return new bool2 (lhs.x == rhs, lhs.y == rhs); } + + /// Returns the result of a componentwise equality operation on an int value and an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 operator == (int lhs, int2 rhs) { return new bool2 (lhs == rhs.x, lhs == rhs.y); } + + + /// Returns the result of a componentwise not equal operation on two int2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 operator != (int2 lhs, int2 rhs) { return new bool2 (lhs.x != rhs.x, lhs.y != rhs.y); } + + /// Returns the result of a componentwise not equal operation on an int2 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 operator != (int2 lhs, int rhs) { return new bool2 (lhs.x != rhs, lhs.y != rhs); } + + /// Returns the result of a componentwise not equal operation on an int value and an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 operator != (int lhs, int2 rhs) { return new bool2 (lhs != rhs.x, lhs != rhs.y); } + + + /// Returns the result of a componentwise bitwise not operation on an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator ~ (int2 val) { return new int2 (~val.x, ~val.y); } + + + /// Returns the result of a componentwise bitwise and operation on two int2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator & (int2 lhs, int2 rhs) { return new int2 (lhs.x & rhs.x, lhs.y & rhs.y); } + + /// Returns the result of a componentwise bitwise and operation on an int2 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator & (int2 lhs, int rhs) { return new int2 (lhs.x & rhs, lhs.y & rhs); } + + /// Returns the result of a componentwise bitwise and operation on an int value and an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator & (int lhs, int2 rhs) { return new int2 (lhs & rhs.x, lhs & rhs.y); } + + + /// Returns the result of a componentwise bitwise or operation on two int2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator | (int2 lhs, int2 rhs) { return new int2 (lhs.x | rhs.x, lhs.y | rhs.y); } + + /// Returns the result of a componentwise bitwise or operation on an int2 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator | (int2 lhs, int rhs) { return new int2 (lhs.x | rhs, lhs.y | rhs); } + + /// Returns the result of a componentwise bitwise or operation on an int value and an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator | (int lhs, int2 rhs) { return new int2 (lhs | rhs.x, lhs | rhs.y); } + + + /// Returns the result of a componentwise bitwise exclusive or operation on two int2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator ^ (int2 lhs, int2 rhs) { return new int2 (lhs.x ^ rhs.x, lhs.y ^ rhs.y); } + + /// Returns the result of a componentwise bitwise exclusive or operation on an int2 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator ^ (int2 lhs, int rhs) { return new int2 (lhs.x ^ rhs, lhs.y ^ rhs); } + + /// Returns the result of a componentwise bitwise exclusive or operation on an int value and an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 operator ^ (int lhs, int2 rhs) { return new int2 (lhs ^ rhs.x, lhs ^ rhs.y); } + + + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 yxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 yxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 yyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 yyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 xx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 xy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(x, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; y = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 yx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(y, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; x = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 yy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(y, y); } + } + + + + /// Returns the int element at a specified index. + unsafe public int this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 2) + throw new System.ArgumentException("index must be between[0...1]"); +#endif + fixed (int2* array = &this) { return ((int*)array)[index]; } + } + set + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 2) + throw new System.ArgumentException("index must be between[0...1]"); +#endif + fixed (int* array = &x) { array[index] = value; } + } + } + + /// Returns true if the int2 is equal to a given int2, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(int2 rhs) { return x == rhs.x && y == rhs.y; } + + /// Returns true if the int2 is equal to a given int2, false otherwise. + public override bool Equals(object o) { return Equals((int2)o); } + + + /// Returns a hash code for the int2. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the int2. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("int2({0}, {1})", x, y); + } + + /// Returns a string representation of the int2 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("int2({0}, {1})", x.ToString(format, formatProvider), y.ToString(format, formatProvider)); + } + + internal sealed class DebuggerProxy + { + public int x; + public int y; + public DebuggerProxy(int2 v) + { + x = v.x; + y = v.y; + } + } + + } + + public static partial class math + { + /// Returns a int2 vector constructed from two int values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 int2(int x, int y) { return new int2(x, y); } + + /// Returns a int2 vector constructed from an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 int2(int2 xy) { return new int2(xy); } + + /// Returns a int2 vector constructed from a single int value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 int2(int v) { return new int2(v); } + + /// Returns a int2 vector constructed from a single bool value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 int2(bool v) { return new int2(v); } + + /// Return a int2 vector constructed from a bool2 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 int2(bool2 v) { return new int2(v); } + + /// Returns a int2 vector constructed from a single uint value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 int2(uint v) { return new int2(v); } + + /// Return a int2 vector constructed from a uint2 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 int2(uint2 v) { return new int2(v); } + + /// Returns a int2 vector constructed from a single float value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 int2(float v) { return new int2(v); } + + /// Return a int2 vector constructed from a float2 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 int2(float2 v) { return new int2(v); } + + /// Returns a int2 vector constructed from a single double value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 int2(double v) { return new int2(v); } + + /// Return a int2 vector constructed from a double2 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 int2(double2 v) { return new int2(v); } + + /// Returns a uint hash code of a int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(int2 v) + { + return csum(asuint(v) * uint2(0x83B58237u, 0x833E3E29u)) + 0xA9D919BFu; + } + + /// + /// Returns a uint2 vector hash code of a int2 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2 hashwide(int2 v) + { + return (asuint(v) * uint2(0xC3EC1D97u, 0xB8B208C7u)) + 0x5D3ED947u; + } + + /// Returns the result of specified shuffling of the components from two int2 vectors into an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int shuffle(int2 a, int2 b, ShuffleComponent x) + { + return select_shuffle_component(a, b, x); + } + + /// Returns the result of specified shuffling of the components from two int2 vectors into an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 shuffle(int2 a, int2 b, ShuffleComponent x, ShuffleComponent y) + { + return int2( + select_shuffle_component(a, b, x), + select_shuffle_component(a, b, y)); + } + + /// Returns the result of specified shuffling of the components from two int2 vectors into an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 shuffle(int2 a, int2 b, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z) + { + return int3( + select_shuffle_component(a, b, x), + select_shuffle_component(a, b, y), + select_shuffle_component(a, b, z)); + } + + /// Returns the result of specified shuffling of the components from two int2 vectors into an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 shuffle(int2 a, int2 b, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w) + { + return int4( + select_shuffle_component(a, b, x), + select_shuffle_component(a, b, y), + select_shuffle_component(a, b, z), + select_shuffle_component(a, b, w)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static int select_shuffle_component(int2 a, int2 b, ShuffleComponent component) + { + switch(component) + { + case ShuffleComponent.LeftX: + return a.x; + case ShuffleComponent.LeftY: + return a.y; + case ShuffleComponent.RightX: + return b.x; + case ShuffleComponent.RightY: + return b.y; + default: + throw new System.ArgumentException("Invalid shuffle component: " + component); + } + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int2.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int2.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..304b19c1561bc4451da7bcb4ef3d87b588e589a1 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int2.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 29938ef4dca90ce47ae640695d8b1c9f +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int2x2.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int2x2.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..8eb2671bc90136e8df29002ab17a85f0149f48d9 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int2x2.gen.cs @@ -0,0 +1,506 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [System.Serializable] + public partial struct int2x2 : System.IEquatable, IFormattable + { + public int2 c0; + public int2 c1; + + /// int2x2 identity transform. + public static readonly int2x2 identity = new int2x2(1, 0, 0, 1); + + /// int2x2 zero value. + public static readonly int2x2 zero; + + /// Constructs a int2x2 matrix from two int2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x2(int2 c0, int2 c1) + { + this.c0 = c0; + this.c1 = c1; + } + + /// Constructs a int2x2 matrix from 4 int values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x2(int m00, int m01, + int m10, int m11) + { + this.c0 = new int2(m00, m10); + this.c1 = new int2(m01, m11); + } + + /// Constructs a int2x2 matrix from a single int value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x2(int v) + { + this.c0 = v; + this.c1 = v; + } + + /// Constructs a int2x2 matrix from a single bool value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x2(bool v) + { + this.c0 = math.select(new int2(0), new int2(1), v); + this.c1 = math.select(new int2(0), new int2(1), v); + } + + /// Constructs a int2x2 matrix from a bool2x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x2(bool2x2 v) + { + this.c0 = math.select(new int2(0), new int2(1), v.c0); + this.c1 = math.select(new int2(0), new int2(1), v.c1); + } + + /// Constructs a int2x2 matrix from a single uint value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x2(uint v) + { + this.c0 = (int2)v; + this.c1 = (int2)v; + } + + /// Constructs a int2x2 matrix from a uint2x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x2(uint2x2 v) + { + this.c0 = (int2)v.c0; + this.c1 = (int2)v.c1; + } + + /// Constructs a int2x2 matrix from a single float value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x2(float v) + { + this.c0 = (int2)v; + this.c1 = (int2)v; + } + + /// Constructs a int2x2 matrix from a float2x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x2(float2x2 v) + { + this.c0 = (int2)v.c0; + this.c1 = (int2)v.c1; + } + + /// Constructs a int2x2 matrix from a single double value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x2(double v) + { + this.c0 = (int2)v; + this.c1 = (int2)v; + } + + /// Constructs a int2x2 matrix from a double2x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x2(double2x2 v) + { + this.c0 = (int2)v.c0; + this.c1 = (int2)v.c1; + } + + + /// Implicitly converts a single int value to a int2x2 matrix by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator int2x2(int v) { return new int2x2(v); } + + /// Explicitly converts a single bool value to a int2x2 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2x2(bool v) { return new int2x2(v); } + + /// Explicitly converts a bool2x2 matrix to a int2x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2x2(bool2x2 v) { return new int2x2(v); } + + /// Explicitly converts a single uint value to a int2x2 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2x2(uint v) { return new int2x2(v); } + + /// Explicitly converts a uint2x2 matrix to a int2x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2x2(uint2x2 v) { return new int2x2(v); } + + /// Explicitly converts a single float value to a int2x2 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2x2(float v) { return new int2x2(v); } + + /// Explicitly converts a float2x2 matrix to a int2x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2x2(float2x2 v) { return new int2x2(v); } + + /// Explicitly converts a single double value to a int2x2 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2x2(double v) { return new int2x2(v); } + + /// Explicitly converts a double2x2 matrix to a int2x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2x2(double2x2 v) { return new int2x2(v); } + + + /// Returns the result of a componentwise multiplication operation on two int2x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator * (int2x2 lhs, int2x2 rhs) { return new int2x2 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1); } + + /// Returns the result of a componentwise multiplication operation on an int2x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator * (int2x2 lhs, int rhs) { return new int2x2 (lhs.c0 * rhs, lhs.c1 * rhs); } + + /// Returns the result of a componentwise multiplication operation on an int value and an int2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator * (int lhs, int2x2 rhs) { return new int2x2 (lhs * rhs.c0, lhs * rhs.c1); } + + + /// Returns the result of a componentwise addition operation on two int2x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator + (int2x2 lhs, int2x2 rhs) { return new int2x2 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1); } + + /// Returns the result of a componentwise addition operation on an int2x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator + (int2x2 lhs, int rhs) { return new int2x2 (lhs.c0 + rhs, lhs.c1 + rhs); } + + /// Returns the result of a componentwise addition operation on an int value and an int2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator + (int lhs, int2x2 rhs) { return new int2x2 (lhs + rhs.c0, lhs + rhs.c1); } + + + /// Returns the result of a componentwise subtraction operation on two int2x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator - (int2x2 lhs, int2x2 rhs) { return new int2x2 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1); } + + /// Returns the result of a componentwise subtraction operation on an int2x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator - (int2x2 lhs, int rhs) { return new int2x2 (lhs.c0 - rhs, lhs.c1 - rhs); } + + /// Returns the result of a componentwise subtraction operation on an int value and an int2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator - (int lhs, int2x2 rhs) { return new int2x2 (lhs - rhs.c0, lhs - rhs.c1); } + + + /// Returns the result of a componentwise division operation on two int2x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator / (int2x2 lhs, int2x2 rhs) { return new int2x2 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1); } + + /// Returns the result of a componentwise division operation on an int2x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator / (int2x2 lhs, int rhs) { return new int2x2 (lhs.c0 / rhs, lhs.c1 / rhs); } + + /// Returns the result of a componentwise division operation on an int value and an int2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator / (int lhs, int2x2 rhs) { return new int2x2 (lhs / rhs.c0, lhs / rhs.c1); } + + + /// Returns the result of a componentwise modulus operation on two int2x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator % (int2x2 lhs, int2x2 rhs) { return new int2x2 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1); } + + /// Returns the result of a componentwise modulus operation on an int2x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator % (int2x2 lhs, int rhs) { return new int2x2 (lhs.c0 % rhs, lhs.c1 % rhs); } + + /// Returns the result of a componentwise modulus operation on an int value and an int2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator % (int lhs, int2x2 rhs) { return new int2x2 (lhs % rhs.c0, lhs % rhs.c1); } + + + /// Returns the result of a componentwise increment operation on an int2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator ++ (int2x2 val) { return new int2x2 (++val.c0, ++val.c1); } + + + /// Returns the result of a componentwise decrement operation on an int2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator -- (int2x2 val) { return new int2x2 (--val.c0, --val.c1); } + + + /// Returns the result of a componentwise less than operation on two int2x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator < (int2x2 lhs, int2x2 rhs) { return new bool2x2 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1); } + + /// Returns the result of a componentwise less than operation on an int2x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator < (int2x2 lhs, int rhs) { return new bool2x2 (lhs.c0 < rhs, lhs.c1 < rhs); } + + /// Returns the result of a componentwise less than operation on an int value and an int2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator < (int lhs, int2x2 rhs) { return new bool2x2 (lhs < rhs.c0, lhs < rhs.c1); } + + + /// Returns the result of a componentwise less or equal operation on two int2x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator <= (int2x2 lhs, int2x2 rhs) { return new bool2x2 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1); } + + /// Returns the result of a componentwise less or equal operation on an int2x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator <= (int2x2 lhs, int rhs) { return new bool2x2 (lhs.c0 <= rhs, lhs.c1 <= rhs); } + + /// Returns the result of a componentwise less or equal operation on an int value and an int2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator <= (int lhs, int2x2 rhs) { return new bool2x2 (lhs <= rhs.c0, lhs <= rhs.c1); } + + + /// Returns the result of a componentwise greater than operation on two int2x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator > (int2x2 lhs, int2x2 rhs) { return new bool2x2 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1); } + + /// Returns the result of a componentwise greater than operation on an int2x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator > (int2x2 lhs, int rhs) { return new bool2x2 (lhs.c0 > rhs, lhs.c1 > rhs); } + + /// Returns the result of a componentwise greater than operation on an int value and an int2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator > (int lhs, int2x2 rhs) { return new bool2x2 (lhs > rhs.c0, lhs > rhs.c1); } + + + /// Returns the result of a componentwise greater or equal operation on two int2x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator >= (int2x2 lhs, int2x2 rhs) { return new bool2x2 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1); } + + /// Returns the result of a componentwise greater or equal operation on an int2x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator >= (int2x2 lhs, int rhs) { return new bool2x2 (lhs.c0 >= rhs, lhs.c1 >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on an int value and an int2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator >= (int lhs, int2x2 rhs) { return new bool2x2 (lhs >= rhs.c0, lhs >= rhs.c1); } + + + /// Returns the result of a componentwise unary minus operation on an int2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator - (int2x2 val) { return new int2x2 (-val.c0, -val.c1); } + + + /// Returns the result of a componentwise unary plus operation on an int2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator + (int2x2 val) { return new int2x2 (+val.c0, +val.c1); } + + + /// Returns the result of a componentwise left shift operation on an int2x2 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator << (int2x2 x, int n) { return new int2x2 (x.c0 << n, x.c1 << n); } + + /// Returns the result of a componentwise right shift operation on an int2x2 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator >> (int2x2 x, int n) { return new int2x2 (x.c0 >> n, x.c1 >> n); } + + /// Returns the result of a componentwise equality operation on two int2x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator == (int2x2 lhs, int2x2 rhs) { return new bool2x2 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1); } + + /// Returns the result of a componentwise equality operation on an int2x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator == (int2x2 lhs, int rhs) { return new bool2x2 (lhs.c0 == rhs, lhs.c1 == rhs); } + + /// Returns the result of a componentwise equality operation on an int value and an int2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator == (int lhs, int2x2 rhs) { return new bool2x2 (lhs == rhs.c0, lhs == rhs.c1); } + + + /// Returns the result of a componentwise not equal operation on two int2x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator != (int2x2 lhs, int2x2 rhs) { return new bool2x2 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1); } + + /// Returns the result of a componentwise not equal operation on an int2x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator != (int2x2 lhs, int rhs) { return new bool2x2 (lhs.c0 != rhs, lhs.c1 != rhs); } + + /// Returns the result of a componentwise not equal operation on an int value and an int2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x2 operator != (int lhs, int2x2 rhs) { return new bool2x2 (lhs != rhs.c0, lhs != rhs.c1); } + + + /// Returns the result of a componentwise bitwise not operation on an int2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator ~ (int2x2 val) { return new int2x2 (~val.c0, ~val.c1); } + + + /// Returns the result of a componentwise bitwise and operation on two int2x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator & (int2x2 lhs, int2x2 rhs) { return new int2x2 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1); } + + /// Returns the result of a componentwise bitwise and operation on an int2x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator & (int2x2 lhs, int rhs) { return new int2x2 (lhs.c0 & rhs, lhs.c1 & rhs); } + + /// Returns the result of a componentwise bitwise and operation on an int value and an int2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator & (int lhs, int2x2 rhs) { return new int2x2 (lhs & rhs.c0, lhs & rhs.c1); } + + + /// Returns the result of a componentwise bitwise or operation on two int2x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator | (int2x2 lhs, int2x2 rhs) { return new int2x2 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1); } + + /// Returns the result of a componentwise bitwise or operation on an int2x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator | (int2x2 lhs, int rhs) { return new int2x2 (lhs.c0 | rhs, lhs.c1 | rhs); } + + /// Returns the result of a componentwise bitwise or operation on an int value and an int2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator | (int lhs, int2x2 rhs) { return new int2x2 (lhs | rhs.c0, lhs | rhs.c1); } + + + /// Returns the result of a componentwise bitwise exclusive or operation on two int2x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator ^ (int2x2 lhs, int2x2 rhs) { return new int2x2 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1); } + + /// Returns the result of a componentwise bitwise exclusive or operation on an int2x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator ^ (int2x2 lhs, int rhs) { return new int2x2 (lhs.c0 ^ rhs, lhs.c1 ^ rhs); } + + /// Returns the result of a componentwise bitwise exclusive or operation on an int value and an int2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 operator ^ (int lhs, int2x2 rhs) { return new int2x2 (lhs ^ rhs.c0, lhs ^ rhs.c1); } + + + + /// Returns the int2 element at a specified index. + unsafe public ref int2 this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 2) + throw new System.ArgumentException("index must be between[0...1]"); +#endif + fixed (int2x2* array = &this) { return ref ((int2*)array)[index]; } + } + } + + /// Returns true if the int2x2 is equal to a given int2x2, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(int2x2 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1); } + + /// Returns true if the int2x2 is equal to a given int2x2, false otherwise. + public override bool Equals(object o) { return Equals((int2x2)o); } + + + /// Returns a hash code for the int2x2. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the int2x2. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("int2x2({0}, {1}, {2}, {3})", c0.x, c1.x, c0.y, c1.y); + } + + /// Returns a string representation of the int2x2 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("int2x2({0}, {1}, {2}, {3})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider)); + } + + } + + public static partial class math + { + /// Returns a int2x2 matrix constructed from two int2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 int2x2(int2 c0, int2 c1) { return new int2x2(c0, c1); } + + /// Returns a int2x2 matrix constructed from from 4 int values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 int2x2(int m00, int m01, + int m10, int m11) + { + return new int2x2(m00, m01, + m10, m11); + } + + /// Returns a int2x2 matrix constructed from a single int value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 int2x2(int v) { return new int2x2(v); } + + /// Returns a int2x2 matrix constructed from a single bool value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 int2x2(bool v) { return new int2x2(v); } + + /// Return a int2x2 matrix constructed from a bool2x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 int2x2(bool2x2 v) { return new int2x2(v); } + + /// Returns a int2x2 matrix constructed from a single uint value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 int2x2(uint v) { return new int2x2(v); } + + /// Return a int2x2 matrix constructed from a uint2x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 int2x2(uint2x2 v) { return new int2x2(v); } + + /// Returns a int2x2 matrix constructed from a single float value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 int2x2(float v) { return new int2x2(v); } + + /// Return a int2x2 matrix constructed from a float2x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 int2x2(float2x2 v) { return new int2x2(v); } + + /// Returns a int2x2 matrix constructed from a single double value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 int2x2(double v) { return new int2x2(v); } + + /// Return a int2x2 matrix constructed from a double2x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 int2x2(double2x2 v) { return new int2x2(v); } + + /// Return the int2x2 transpose of a int2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 transpose(int2x2 v) + { + return int2x2( + v.c0.x, v.c0.y, + v.c1.x, v.c1.y); + } + + /// Returns the determinant of a int2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int determinant(int2x2 m) + { + int a = m.c0.x; + int b = m.c1.x; + int c = m.c0.y; + int d = m.c1.y; + + return a * d - b * c; + } + + /// Returns a uint hash code of a int2x2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(int2x2 v) + { + return csum(asuint(v.c0) * uint2(0xE191B035u, 0x68586FAFu) + + asuint(v.c1) * uint2(0xD4DFF6D3u, 0xCB634F4Du)) + 0x9B13B92Du; + } + + /// + /// Returns a uint2 vector hash code of a int2x2 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2 hashwide(int2x2 v) + { + return (asuint(v.c0) * uint2(0x4ABF0813u, 0x86068063u) + + asuint(v.c1) * uint2(0xD75513F9u, 0x5AB3E8CDu)) + 0x676E8407u; + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int2x2.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int2x2.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..a9650df15ecda2c5d16a793c2c7e5cba4ee1e26f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int2x2.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 9ee90f66ec9324008b40d056f2a6fd46 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int2x3.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int2x3.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..500a949ccbe8cce6883ad465448b59eaebbaf67b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int2x3.gen.cs @@ -0,0 +1,506 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [System.Serializable] + public partial struct int2x3 : System.IEquatable, IFormattable + { + public int2 c0; + public int2 c1; + public int2 c2; + + /// int2x3 zero value. + public static readonly int2x3 zero; + + /// Constructs a int2x3 matrix from three int2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x3(int2 c0, int2 c1, int2 c2) + { + this.c0 = c0; + this.c1 = c1; + this.c2 = c2; + } + + /// Constructs a int2x3 matrix from 6 int values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x3(int m00, int m01, int m02, + int m10, int m11, int m12) + { + this.c0 = new int2(m00, m10); + this.c1 = new int2(m01, m11); + this.c2 = new int2(m02, m12); + } + + /// Constructs a int2x3 matrix from a single int value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x3(int v) + { + this.c0 = v; + this.c1 = v; + this.c2 = v; + } + + /// Constructs a int2x3 matrix from a single bool value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x3(bool v) + { + this.c0 = math.select(new int2(0), new int2(1), v); + this.c1 = math.select(new int2(0), new int2(1), v); + this.c2 = math.select(new int2(0), new int2(1), v); + } + + /// Constructs a int2x3 matrix from a bool2x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x3(bool2x3 v) + { + this.c0 = math.select(new int2(0), new int2(1), v.c0); + this.c1 = math.select(new int2(0), new int2(1), v.c1); + this.c2 = math.select(new int2(0), new int2(1), v.c2); + } + + /// Constructs a int2x3 matrix from a single uint value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x3(uint v) + { + this.c0 = (int2)v; + this.c1 = (int2)v; + this.c2 = (int2)v; + } + + /// Constructs a int2x3 matrix from a uint2x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x3(uint2x3 v) + { + this.c0 = (int2)v.c0; + this.c1 = (int2)v.c1; + this.c2 = (int2)v.c2; + } + + /// Constructs a int2x3 matrix from a single float value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x3(float v) + { + this.c0 = (int2)v; + this.c1 = (int2)v; + this.c2 = (int2)v; + } + + /// Constructs a int2x3 matrix from a float2x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x3(float2x3 v) + { + this.c0 = (int2)v.c0; + this.c1 = (int2)v.c1; + this.c2 = (int2)v.c2; + } + + /// Constructs a int2x3 matrix from a single double value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x3(double v) + { + this.c0 = (int2)v; + this.c1 = (int2)v; + this.c2 = (int2)v; + } + + /// Constructs a int2x3 matrix from a double2x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x3(double2x3 v) + { + this.c0 = (int2)v.c0; + this.c1 = (int2)v.c1; + this.c2 = (int2)v.c2; + } + + + /// Implicitly converts a single int value to a int2x3 matrix by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator int2x3(int v) { return new int2x3(v); } + + /// Explicitly converts a single bool value to a int2x3 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2x3(bool v) { return new int2x3(v); } + + /// Explicitly converts a bool2x3 matrix to a int2x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2x3(bool2x3 v) { return new int2x3(v); } + + /// Explicitly converts a single uint value to a int2x3 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2x3(uint v) { return new int2x3(v); } + + /// Explicitly converts a uint2x3 matrix to a int2x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2x3(uint2x3 v) { return new int2x3(v); } + + /// Explicitly converts a single float value to a int2x3 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2x3(float v) { return new int2x3(v); } + + /// Explicitly converts a float2x3 matrix to a int2x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2x3(float2x3 v) { return new int2x3(v); } + + /// Explicitly converts a single double value to a int2x3 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2x3(double v) { return new int2x3(v); } + + /// Explicitly converts a double2x3 matrix to a int2x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2x3(double2x3 v) { return new int2x3(v); } + + + /// Returns the result of a componentwise multiplication operation on two int2x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator * (int2x3 lhs, int2x3 rhs) { return new int2x3 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2); } + + /// Returns the result of a componentwise multiplication operation on an int2x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator * (int2x3 lhs, int rhs) { return new int2x3 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs); } + + /// Returns the result of a componentwise multiplication operation on an int value and an int2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator * (int lhs, int2x3 rhs) { return new int2x3 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2); } + + + /// Returns the result of a componentwise addition operation on two int2x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator + (int2x3 lhs, int2x3 rhs) { return new int2x3 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2); } + + /// Returns the result of a componentwise addition operation on an int2x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator + (int2x3 lhs, int rhs) { return new int2x3 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs); } + + /// Returns the result of a componentwise addition operation on an int value and an int2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator + (int lhs, int2x3 rhs) { return new int2x3 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2); } + + + /// Returns the result of a componentwise subtraction operation on two int2x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator - (int2x3 lhs, int2x3 rhs) { return new int2x3 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2); } + + /// Returns the result of a componentwise subtraction operation on an int2x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator - (int2x3 lhs, int rhs) { return new int2x3 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs); } + + /// Returns the result of a componentwise subtraction operation on an int value and an int2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator - (int lhs, int2x3 rhs) { return new int2x3 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2); } + + + /// Returns the result of a componentwise division operation on two int2x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator / (int2x3 lhs, int2x3 rhs) { return new int2x3 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2); } + + /// Returns the result of a componentwise division operation on an int2x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator / (int2x3 lhs, int rhs) { return new int2x3 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs); } + + /// Returns the result of a componentwise division operation on an int value and an int2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator / (int lhs, int2x3 rhs) { return new int2x3 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2); } + + + /// Returns the result of a componentwise modulus operation on two int2x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator % (int2x3 lhs, int2x3 rhs) { return new int2x3 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2); } + + /// Returns the result of a componentwise modulus operation on an int2x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator % (int2x3 lhs, int rhs) { return new int2x3 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs); } + + /// Returns the result of a componentwise modulus operation on an int value and an int2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator % (int lhs, int2x3 rhs) { return new int2x3 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2); } + + + /// Returns the result of a componentwise increment operation on an int2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator ++ (int2x3 val) { return new int2x3 (++val.c0, ++val.c1, ++val.c2); } + + + /// Returns the result of a componentwise decrement operation on an int2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator -- (int2x3 val) { return new int2x3 (--val.c0, --val.c1, --val.c2); } + + + /// Returns the result of a componentwise less than operation on two int2x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator < (int2x3 lhs, int2x3 rhs) { return new bool2x3 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2); } + + /// Returns the result of a componentwise less than operation on an int2x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator < (int2x3 lhs, int rhs) { return new bool2x3 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs); } + + /// Returns the result of a componentwise less than operation on an int value and an int2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator < (int lhs, int2x3 rhs) { return new bool2x3 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2); } + + + /// Returns the result of a componentwise less or equal operation on two int2x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator <= (int2x3 lhs, int2x3 rhs) { return new bool2x3 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2); } + + /// Returns the result of a componentwise less or equal operation on an int2x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator <= (int2x3 lhs, int rhs) { return new bool2x3 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs); } + + /// Returns the result of a componentwise less or equal operation on an int value and an int2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator <= (int lhs, int2x3 rhs) { return new bool2x3 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2); } + + + /// Returns the result of a componentwise greater than operation on two int2x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator > (int2x3 lhs, int2x3 rhs) { return new bool2x3 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2); } + + /// Returns the result of a componentwise greater than operation on an int2x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator > (int2x3 lhs, int rhs) { return new bool2x3 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs); } + + /// Returns the result of a componentwise greater than operation on an int value and an int2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator > (int lhs, int2x3 rhs) { return new bool2x3 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2); } + + + /// Returns the result of a componentwise greater or equal operation on two int2x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator >= (int2x3 lhs, int2x3 rhs) { return new bool2x3 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2); } + + /// Returns the result of a componentwise greater or equal operation on an int2x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator >= (int2x3 lhs, int rhs) { return new bool2x3 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on an int value and an int2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator >= (int lhs, int2x3 rhs) { return new bool2x3 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2); } + + + /// Returns the result of a componentwise unary minus operation on an int2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator - (int2x3 val) { return new int2x3 (-val.c0, -val.c1, -val.c2); } + + + /// Returns the result of a componentwise unary plus operation on an int2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator + (int2x3 val) { return new int2x3 (+val.c0, +val.c1, +val.c2); } + + + /// Returns the result of a componentwise left shift operation on an int2x3 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator << (int2x3 x, int n) { return new int2x3 (x.c0 << n, x.c1 << n, x.c2 << n); } + + /// Returns the result of a componentwise right shift operation on an int2x3 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator >> (int2x3 x, int n) { return new int2x3 (x.c0 >> n, x.c1 >> n, x.c2 >> n); } + + /// Returns the result of a componentwise equality operation on two int2x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator == (int2x3 lhs, int2x3 rhs) { return new bool2x3 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2); } + + /// Returns the result of a componentwise equality operation on an int2x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator == (int2x3 lhs, int rhs) { return new bool2x3 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs); } + + /// Returns the result of a componentwise equality operation on an int value and an int2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator == (int lhs, int2x3 rhs) { return new bool2x3 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2); } + + + /// Returns the result of a componentwise not equal operation on two int2x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator != (int2x3 lhs, int2x3 rhs) { return new bool2x3 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2); } + + /// Returns the result of a componentwise not equal operation on an int2x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator != (int2x3 lhs, int rhs) { return new bool2x3 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs); } + + /// Returns the result of a componentwise not equal operation on an int value and an int2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x3 operator != (int lhs, int2x3 rhs) { return new bool2x3 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2); } + + + /// Returns the result of a componentwise bitwise not operation on an int2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator ~ (int2x3 val) { return new int2x3 (~val.c0, ~val.c1, ~val.c2); } + + + /// Returns the result of a componentwise bitwise and operation on two int2x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator & (int2x3 lhs, int2x3 rhs) { return new int2x3 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1, lhs.c2 & rhs.c2); } + + /// Returns the result of a componentwise bitwise and operation on an int2x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator & (int2x3 lhs, int rhs) { return new int2x3 (lhs.c0 & rhs, lhs.c1 & rhs, lhs.c2 & rhs); } + + /// Returns the result of a componentwise bitwise and operation on an int value and an int2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator & (int lhs, int2x3 rhs) { return new int2x3 (lhs & rhs.c0, lhs & rhs.c1, lhs & rhs.c2); } + + + /// Returns the result of a componentwise bitwise or operation on two int2x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator | (int2x3 lhs, int2x3 rhs) { return new int2x3 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1, lhs.c2 | rhs.c2); } + + /// Returns the result of a componentwise bitwise or operation on an int2x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator | (int2x3 lhs, int rhs) { return new int2x3 (lhs.c0 | rhs, lhs.c1 | rhs, lhs.c2 | rhs); } + + /// Returns the result of a componentwise bitwise or operation on an int value and an int2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator | (int lhs, int2x3 rhs) { return new int2x3 (lhs | rhs.c0, lhs | rhs.c1, lhs | rhs.c2); } + + + /// Returns the result of a componentwise bitwise exclusive or operation on two int2x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator ^ (int2x3 lhs, int2x3 rhs) { return new int2x3 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1, lhs.c2 ^ rhs.c2); } + + /// Returns the result of a componentwise bitwise exclusive or operation on an int2x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator ^ (int2x3 lhs, int rhs) { return new int2x3 (lhs.c0 ^ rhs, lhs.c1 ^ rhs, lhs.c2 ^ rhs); } + + /// Returns the result of a componentwise bitwise exclusive or operation on an int value and an int2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 operator ^ (int lhs, int2x3 rhs) { return new int2x3 (lhs ^ rhs.c0, lhs ^ rhs.c1, lhs ^ rhs.c2); } + + + + /// Returns the int2 element at a specified index. + unsafe public ref int2 this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 3) + throw new System.ArgumentException("index must be between[0...2]"); +#endif + fixed (int2x3* array = &this) { return ref ((int2*)array)[index]; } + } + } + + /// Returns true if the int2x3 is equal to a given int2x3, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(int2x3 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2); } + + /// Returns true if the int2x3 is equal to a given int2x3, false otherwise. + public override bool Equals(object o) { return Equals((int2x3)o); } + + + /// Returns a hash code for the int2x3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the int2x3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("int2x3({0}, {1}, {2}, {3}, {4}, {5})", c0.x, c1.x, c2.x, c0.y, c1.y, c2.y); + } + + /// Returns a string representation of the int2x3 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("int2x3({0}, {1}, {2}, {3}, {4}, {5})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider)); + } + + } + + public static partial class math + { + /// Returns a int2x3 matrix constructed from three int2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 int2x3(int2 c0, int2 c1, int2 c2) { return new int2x3(c0, c1, c2); } + + /// Returns a int2x3 matrix constructed from from 6 int values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 int2x3(int m00, int m01, int m02, + int m10, int m11, int m12) + { + return new int2x3(m00, m01, m02, + m10, m11, m12); + } + + /// Returns a int2x3 matrix constructed from a single int value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 int2x3(int v) { return new int2x3(v); } + + /// Returns a int2x3 matrix constructed from a single bool value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 int2x3(bool v) { return new int2x3(v); } + + /// Return a int2x3 matrix constructed from a bool2x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 int2x3(bool2x3 v) { return new int2x3(v); } + + /// Returns a int2x3 matrix constructed from a single uint value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 int2x3(uint v) { return new int2x3(v); } + + /// Return a int2x3 matrix constructed from a uint2x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 int2x3(uint2x3 v) { return new int2x3(v); } + + /// Returns a int2x3 matrix constructed from a single float value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 int2x3(float v) { return new int2x3(v); } + + /// Return a int2x3 matrix constructed from a float2x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 int2x3(float2x3 v) { return new int2x3(v); } + + /// Returns a int2x3 matrix constructed from a single double value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 int2x3(double v) { return new int2x3(v); } + + /// Return a int2x3 matrix constructed from a double2x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 int2x3(double2x3 v) { return new int2x3(v); } + + /// Return the int3x2 transpose of a int2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 transpose(int2x3 v) + { + return int3x2( + v.c0.x, v.c0.y, + v.c1.x, v.c1.y, + v.c2.x, v.c2.y); + } + + /// Returns a uint hash code of a int2x3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(int2x3 v) + { + return csum(asuint(v.c0) * uint2(0xCAE78587u, 0x7A1541C9u) + + asuint(v.c1) * uint2(0xF83BD927u, 0x6A243BCBu) + + asuint(v.c2) * uint2(0x509B84C9u, 0x91D13847u)) + 0x52F7230Fu; + } + + /// + /// Returns a uint2 vector hash code of a int2x3 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2 hashwide(int2x3 v) + { + return (asuint(v.c0) * uint2(0xCF286E83u, 0xE121E6ADu) + + asuint(v.c1) * uint2(0xC9CA1249u, 0x69B60C81u) + + asuint(v.c2) * uint2(0xE0EB6C25u, 0xF648BEABu)) + 0x6BDB2B07u; + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int2x3.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int2x3.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..e1ae9c21f645fe85ba8fd06ccf266c0b0524787f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int2x3.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 34b460e6ab4e94f68b249b11a8f71131 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int2x4.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int2x4.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..3bab0cdf568eb8daa42682c8aa37359de9b17d65 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int2x4.gen.cs @@ -0,0 +1,521 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [System.Serializable] + public partial struct int2x4 : System.IEquatable, IFormattable + { + public int2 c0; + public int2 c1; + public int2 c2; + public int2 c3; + + /// int2x4 zero value. + public static readonly int2x4 zero; + + /// Constructs a int2x4 matrix from four int2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x4(int2 c0, int2 c1, int2 c2, int2 c3) + { + this.c0 = c0; + this.c1 = c1; + this.c2 = c2; + this.c3 = c3; + } + + /// Constructs a int2x4 matrix from 8 int values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x4(int m00, int m01, int m02, int m03, + int m10, int m11, int m12, int m13) + { + this.c0 = new int2(m00, m10); + this.c1 = new int2(m01, m11); + this.c2 = new int2(m02, m12); + this.c3 = new int2(m03, m13); + } + + /// Constructs a int2x4 matrix from a single int value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x4(int v) + { + this.c0 = v; + this.c1 = v; + this.c2 = v; + this.c3 = v; + } + + /// Constructs a int2x4 matrix from a single bool value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x4(bool v) + { + this.c0 = math.select(new int2(0), new int2(1), v); + this.c1 = math.select(new int2(0), new int2(1), v); + this.c2 = math.select(new int2(0), new int2(1), v); + this.c3 = math.select(new int2(0), new int2(1), v); + } + + /// Constructs a int2x4 matrix from a bool2x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x4(bool2x4 v) + { + this.c0 = math.select(new int2(0), new int2(1), v.c0); + this.c1 = math.select(new int2(0), new int2(1), v.c1); + this.c2 = math.select(new int2(0), new int2(1), v.c2); + this.c3 = math.select(new int2(0), new int2(1), v.c3); + } + + /// Constructs a int2x4 matrix from a single uint value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x4(uint v) + { + this.c0 = (int2)v; + this.c1 = (int2)v; + this.c2 = (int2)v; + this.c3 = (int2)v; + } + + /// Constructs a int2x4 matrix from a uint2x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x4(uint2x4 v) + { + this.c0 = (int2)v.c0; + this.c1 = (int2)v.c1; + this.c2 = (int2)v.c2; + this.c3 = (int2)v.c3; + } + + /// Constructs a int2x4 matrix from a single float value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x4(float v) + { + this.c0 = (int2)v; + this.c1 = (int2)v; + this.c2 = (int2)v; + this.c3 = (int2)v; + } + + /// Constructs a int2x4 matrix from a float2x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x4(float2x4 v) + { + this.c0 = (int2)v.c0; + this.c1 = (int2)v.c1; + this.c2 = (int2)v.c2; + this.c3 = (int2)v.c3; + } + + /// Constructs a int2x4 matrix from a single double value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x4(double v) + { + this.c0 = (int2)v; + this.c1 = (int2)v; + this.c2 = (int2)v; + this.c3 = (int2)v; + } + + /// Constructs a int2x4 matrix from a double2x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2x4(double2x4 v) + { + this.c0 = (int2)v.c0; + this.c1 = (int2)v.c1; + this.c2 = (int2)v.c2; + this.c3 = (int2)v.c3; + } + + + /// Implicitly converts a single int value to a int2x4 matrix by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator int2x4(int v) { return new int2x4(v); } + + /// Explicitly converts a single bool value to a int2x4 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2x4(bool v) { return new int2x4(v); } + + /// Explicitly converts a bool2x4 matrix to a int2x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2x4(bool2x4 v) { return new int2x4(v); } + + /// Explicitly converts a single uint value to a int2x4 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2x4(uint v) { return new int2x4(v); } + + /// Explicitly converts a uint2x4 matrix to a int2x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2x4(uint2x4 v) { return new int2x4(v); } + + /// Explicitly converts a single float value to a int2x4 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2x4(float v) { return new int2x4(v); } + + /// Explicitly converts a float2x4 matrix to a int2x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2x4(float2x4 v) { return new int2x4(v); } + + /// Explicitly converts a single double value to a int2x4 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2x4(double v) { return new int2x4(v); } + + /// Explicitly converts a double2x4 matrix to a int2x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int2x4(double2x4 v) { return new int2x4(v); } + + + /// Returns the result of a componentwise multiplication operation on two int2x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator * (int2x4 lhs, int2x4 rhs) { return new int2x4 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2, lhs.c3 * rhs.c3); } + + /// Returns the result of a componentwise multiplication operation on an int2x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator * (int2x4 lhs, int rhs) { return new int2x4 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs, lhs.c3 * rhs); } + + /// Returns the result of a componentwise multiplication operation on an int value and an int2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator * (int lhs, int2x4 rhs) { return new int2x4 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2, lhs * rhs.c3); } + + + /// Returns the result of a componentwise addition operation on two int2x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator + (int2x4 lhs, int2x4 rhs) { return new int2x4 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2, lhs.c3 + rhs.c3); } + + /// Returns the result of a componentwise addition operation on an int2x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator + (int2x4 lhs, int rhs) { return new int2x4 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs, lhs.c3 + rhs); } + + /// Returns the result of a componentwise addition operation on an int value and an int2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator + (int lhs, int2x4 rhs) { return new int2x4 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2, lhs + rhs.c3); } + + + /// Returns the result of a componentwise subtraction operation on two int2x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator - (int2x4 lhs, int2x4 rhs) { return new int2x4 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2, lhs.c3 - rhs.c3); } + + /// Returns the result of a componentwise subtraction operation on an int2x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator - (int2x4 lhs, int rhs) { return new int2x4 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs, lhs.c3 - rhs); } + + /// Returns the result of a componentwise subtraction operation on an int value and an int2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator - (int lhs, int2x4 rhs) { return new int2x4 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2, lhs - rhs.c3); } + + + /// Returns the result of a componentwise division operation on two int2x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator / (int2x4 lhs, int2x4 rhs) { return new int2x4 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2, lhs.c3 / rhs.c3); } + + /// Returns the result of a componentwise division operation on an int2x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator / (int2x4 lhs, int rhs) { return new int2x4 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs, lhs.c3 / rhs); } + + /// Returns the result of a componentwise division operation on an int value and an int2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator / (int lhs, int2x4 rhs) { return new int2x4 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2, lhs / rhs.c3); } + + + /// Returns the result of a componentwise modulus operation on two int2x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator % (int2x4 lhs, int2x4 rhs) { return new int2x4 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2, lhs.c3 % rhs.c3); } + + /// Returns the result of a componentwise modulus operation on an int2x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator % (int2x4 lhs, int rhs) { return new int2x4 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs, lhs.c3 % rhs); } + + /// Returns the result of a componentwise modulus operation on an int value and an int2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator % (int lhs, int2x4 rhs) { return new int2x4 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2, lhs % rhs.c3); } + + + /// Returns the result of a componentwise increment operation on an int2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator ++ (int2x4 val) { return new int2x4 (++val.c0, ++val.c1, ++val.c2, ++val.c3); } + + + /// Returns the result of a componentwise decrement operation on an int2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator -- (int2x4 val) { return new int2x4 (--val.c0, --val.c1, --val.c2, --val.c3); } + + + /// Returns the result of a componentwise less than operation on two int2x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator < (int2x4 lhs, int2x4 rhs) { return new bool2x4 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2, lhs.c3 < rhs.c3); } + + /// Returns the result of a componentwise less than operation on an int2x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator < (int2x4 lhs, int rhs) { return new bool2x4 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs, lhs.c3 < rhs); } + + /// Returns the result of a componentwise less than operation on an int value and an int2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator < (int lhs, int2x4 rhs) { return new bool2x4 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2, lhs < rhs.c3); } + + + /// Returns the result of a componentwise less or equal operation on two int2x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator <= (int2x4 lhs, int2x4 rhs) { return new bool2x4 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2, lhs.c3 <= rhs.c3); } + + /// Returns the result of a componentwise less or equal operation on an int2x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator <= (int2x4 lhs, int rhs) { return new bool2x4 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs, lhs.c3 <= rhs); } + + /// Returns the result of a componentwise less or equal operation on an int value and an int2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator <= (int lhs, int2x4 rhs) { return new bool2x4 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2, lhs <= rhs.c3); } + + + /// Returns the result of a componentwise greater than operation on two int2x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator > (int2x4 lhs, int2x4 rhs) { return new bool2x4 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2, lhs.c3 > rhs.c3); } + + /// Returns the result of a componentwise greater than operation on an int2x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator > (int2x4 lhs, int rhs) { return new bool2x4 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs, lhs.c3 > rhs); } + + /// Returns the result of a componentwise greater than operation on an int value and an int2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator > (int lhs, int2x4 rhs) { return new bool2x4 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2, lhs > rhs.c3); } + + + /// Returns the result of a componentwise greater or equal operation on two int2x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator >= (int2x4 lhs, int2x4 rhs) { return new bool2x4 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2, lhs.c3 >= rhs.c3); } + + /// Returns the result of a componentwise greater or equal operation on an int2x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator >= (int2x4 lhs, int rhs) { return new bool2x4 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs, lhs.c3 >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on an int value and an int2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator >= (int lhs, int2x4 rhs) { return new bool2x4 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2, lhs >= rhs.c3); } + + + /// Returns the result of a componentwise unary minus operation on an int2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator - (int2x4 val) { return new int2x4 (-val.c0, -val.c1, -val.c2, -val.c3); } + + + /// Returns the result of a componentwise unary plus operation on an int2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator + (int2x4 val) { return new int2x4 (+val.c0, +val.c1, +val.c2, +val.c3); } + + + /// Returns the result of a componentwise left shift operation on an int2x4 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator << (int2x4 x, int n) { return new int2x4 (x.c0 << n, x.c1 << n, x.c2 << n, x.c3 << n); } + + /// Returns the result of a componentwise right shift operation on an int2x4 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator >> (int2x4 x, int n) { return new int2x4 (x.c0 >> n, x.c1 >> n, x.c2 >> n, x.c3 >> n); } + + /// Returns the result of a componentwise equality operation on two int2x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator == (int2x4 lhs, int2x4 rhs) { return new bool2x4 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2, lhs.c3 == rhs.c3); } + + /// Returns the result of a componentwise equality operation on an int2x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator == (int2x4 lhs, int rhs) { return new bool2x4 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs, lhs.c3 == rhs); } + + /// Returns the result of a componentwise equality operation on an int value and an int2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator == (int lhs, int2x4 rhs) { return new bool2x4 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2, lhs == rhs.c3); } + + + /// Returns the result of a componentwise not equal operation on two int2x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator != (int2x4 lhs, int2x4 rhs) { return new bool2x4 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2, lhs.c3 != rhs.c3); } + + /// Returns the result of a componentwise not equal operation on an int2x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator != (int2x4 lhs, int rhs) { return new bool2x4 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs, lhs.c3 != rhs); } + + /// Returns the result of a componentwise not equal operation on an int value and an int2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2x4 operator != (int lhs, int2x4 rhs) { return new bool2x4 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2, lhs != rhs.c3); } + + + /// Returns the result of a componentwise bitwise not operation on an int2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator ~ (int2x4 val) { return new int2x4 (~val.c0, ~val.c1, ~val.c2, ~val.c3); } + + + /// Returns the result of a componentwise bitwise and operation on two int2x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator & (int2x4 lhs, int2x4 rhs) { return new int2x4 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1, lhs.c2 & rhs.c2, lhs.c3 & rhs.c3); } + + /// Returns the result of a componentwise bitwise and operation on an int2x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator & (int2x4 lhs, int rhs) { return new int2x4 (lhs.c0 & rhs, lhs.c1 & rhs, lhs.c2 & rhs, lhs.c3 & rhs); } + + /// Returns the result of a componentwise bitwise and operation on an int value and an int2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator & (int lhs, int2x4 rhs) { return new int2x4 (lhs & rhs.c0, lhs & rhs.c1, lhs & rhs.c2, lhs & rhs.c3); } + + + /// Returns the result of a componentwise bitwise or operation on two int2x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator | (int2x4 lhs, int2x4 rhs) { return new int2x4 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1, lhs.c2 | rhs.c2, lhs.c3 | rhs.c3); } + + /// Returns the result of a componentwise bitwise or operation on an int2x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator | (int2x4 lhs, int rhs) { return new int2x4 (lhs.c0 | rhs, lhs.c1 | rhs, lhs.c2 | rhs, lhs.c3 | rhs); } + + /// Returns the result of a componentwise bitwise or operation on an int value and an int2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator | (int lhs, int2x4 rhs) { return new int2x4 (lhs | rhs.c0, lhs | rhs.c1, lhs | rhs.c2, lhs | rhs.c3); } + + + /// Returns the result of a componentwise bitwise exclusive or operation on two int2x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator ^ (int2x4 lhs, int2x4 rhs) { return new int2x4 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1, lhs.c2 ^ rhs.c2, lhs.c3 ^ rhs.c3); } + + /// Returns the result of a componentwise bitwise exclusive or operation on an int2x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator ^ (int2x4 lhs, int rhs) { return new int2x4 (lhs.c0 ^ rhs, lhs.c1 ^ rhs, lhs.c2 ^ rhs, lhs.c3 ^ rhs); } + + /// Returns the result of a componentwise bitwise exclusive or operation on an int value and an int2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 operator ^ (int lhs, int2x4 rhs) { return new int2x4 (lhs ^ rhs.c0, lhs ^ rhs.c1, lhs ^ rhs.c2, lhs ^ rhs.c3); } + + + + /// Returns the int2 element at a specified index. + unsafe public ref int2 this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 4) + throw new System.ArgumentException("index must be between[0...3]"); +#endif + fixed (int2x4* array = &this) { return ref ((int2*)array)[index]; } + } + } + + /// Returns true if the int2x4 is equal to a given int2x4, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(int2x4 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2) && c3.Equals(rhs.c3); } + + /// Returns true if the int2x4 is equal to a given int2x4, false otherwise. + public override bool Equals(object o) { return Equals((int2x4)o); } + + + /// Returns a hash code for the int2x4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the int2x4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("int2x4({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7})", c0.x, c1.x, c2.x, c3.x, c0.y, c1.y, c2.y, c3.y); + } + + /// Returns a string representation of the int2x4 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("int2x4({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c3.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider), c3.y.ToString(format, formatProvider)); + } + + } + + public static partial class math + { + /// Returns a int2x4 matrix constructed from four int2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 int2x4(int2 c0, int2 c1, int2 c2, int2 c3) { return new int2x4(c0, c1, c2, c3); } + + /// Returns a int2x4 matrix constructed from from 8 int values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 int2x4(int m00, int m01, int m02, int m03, + int m10, int m11, int m12, int m13) + { + return new int2x4(m00, m01, m02, m03, + m10, m11, m12, m13); + } + + /// Returns a int2x4 matrix constructed from a single int value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 int2x4(int v) { return new int2x4(v); } + + /// Returns a int2x4 matrix constructed from a single bool value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 int2x4(bool v) { return new int2x4(v); } + + /// Return a int2x4 matrix constructed from a bool2x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 int2x4(bool2x4 v) { return new int2x4(v); } + + /// Returns a int2x4 matrix constructed from a single uint value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 int2x4(uint v) { return new int2x4(v); } + + /// Return a int2x4 matrix constructed from a uint2x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 int2x4(uint2x4 v) { return new int2x4(v); } + + /// Returns a int2x4 matrix constructed from a single float value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 int2x4(float v) { return new int2x4(v); } + + /// Return a int2x4 matrix constructed from a float2x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 int2x4(float2x4 v) { return new int2x4(v); } + + /// Returns a int2x4 matrix constructed from a single double value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 int2x4(double v) { return new int2x4(v); } + + /// Return a int2x4 matrix constructed from a double2x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 int2x4(double2x4 v) { return new int2x4(v); } + + /// Return the int4x2 transpose of a int2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 transpose(int2x4 v) + { + return int4x2( + v.c0.x, v.c0.y, + v.c1.x, v.c1.y, + v.c2.x, v.c2.y, + v.c3.x, v.c3.y); + } + + /// Returns a uint hash code of a int2x4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(int2x4 v) + { + return csum(asuint(v.c0) * uint2(0x7AA07CD3u, 0xAF642BA9u) + + asuint(v.c1) * uint2(0xA8F2213Bu, 0x9F3FDC37u) + + asuint(v.c2) * uint2(0xAC60D0C3u, 0x9263662Fu) + + asuint(v.c3) * uint2(0xE69626FFu, 0xBD010EEBu)) + 0x9CEDE1D1u; + } + + /// + /// Returns a uint2 vector hash code of a int2x4 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2 hashwide(int2x4 v) + { + return (asuint(v.c0) * uint2(0x43BE0B51u, 0xAF836EE1u) + + asuint(v.c1) * uint2(0xB130C137u, 0x54834775u) + + asuint(v.c2) * uint2(0x7C022221u, 0xA2D00EDFu) + + asuint(v.c3) * uint2(0xA8977779u, 0x9F1C739Bu)) + 0x4B1BD187u; + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int2x4.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int2x4.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..786086529f615e00daf36dcd14ca73aac7a0cb8d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int2x4.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 827909947b5c9455fa16a57c0b8c55f7 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int3.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int3.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..897ff5db34c802391a9246b07b690b1597bef2ab --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int3.gen.cs @@ -0,0 +1,1556 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; +using System.Diagnostics; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [DebuggerTypeProxy(typeof(int3.DebuggerProxy))] + [System.Serializable] + public partial struct int3 : System.IEquatable, IFormattable + { + public int x; + public int y; + public int z; + + /// int3 zero value. + public static readonly int3 zero; + + /// Constructs a int3 vector from three int values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3(int x, int y, int z) + { + this.x = x; + this.y = y; + this.z = z; + } + + /// Constructs a int3 vector from an int value and an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3(int x, int2 yz) + { + this.x = x; + this.y = yz.x; + this.z = yz.y; + } + + /// Constructs a int3 vector from an int2 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3(int2 xy, int z) + { + this.x = xy.x; + this.y = xy.y; + this.z = z; + } + + /// Constructs a int3 vector from an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3(int3 xyz) + { + this.x = xyz.x; + this.y = xyz.y; + this.z = xyz.z; + } + + /// Constructs a int3 vector from a single int value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3(int v) + { + this.x = v; + this.y = v; + this.z = v; + } + + /// Constructs a int3 vector from a single bool value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3(bool v) + { + this.x = v ? 1 : 0; + this.y = v ? 1 : 0; + this.z = v ? 1 : 0; + } + + /// Constructs a int3 vector from a bool3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3(bool3 v) + { + this.x = v.x ? 1 : 0; + this.y = v.y ? 1 : 0; + this.z = v.z ? 1 : 0; + } + + /// Constructs a int3 vector from a single uint value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3(uint v) + { + this.x = (int)v; + this.y = (int)v; + this.z = (int)v; + } + + /// Constructs a int3 vector from a uint3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3(uint3 v) + { + this.x = (int)v.x; + this.y = (int)v.y; + this.z = (int)v.z; + } + + /// Constructs a int3 vector from a single float value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3(float v) + { + this.x = (int)v; + this.y = (int)v; + this.z = (int)v; + } + + /// Constructs a int3 vector from a float3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3(float3 v) + { + this.x = (int)v.x; + this.y = (int)v.y; + this.z = (int)v.z; + } + + /// Constructs a int3 vector from a single double value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3(double v) + { + this.x = (int)v; + this.y = (int)v; + this.z = (int)v; + } + + /// Constructs a int3 vector from a double3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3(double3 v) + { + this.x = (int)v.x; + this.y = (int)v.y; + this.z = (int)v.z; + } + + + /// Implicitly converts a single int value to a int3 vector by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator int3(int v) { return new int3(v); } + + /// Explicitly converts a single bool value to a int3 vector by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3(bool v) { return new int3(v); } + + /// Explicitly converts a bool3 vector to a int3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3(bool3 v) { return new int3(v); } + + /// Explicitly converts a single uint value to a int3 vector by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3(uint v) { return new int3(v); } + + /// Explicitly converts a uint3 vector to a int3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3(uint3 v) { return new int3(v); } + + /// Explicitly converts a single float value to a int3 vector by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3(float v) { return new int3(v); } + + /// Explicitly converts a float3 vector to a int3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3(float3 v) { return new int3(v); } + + /// Explicitly converts a single double value to a int3 vector by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3(double v) { return new int3(v); } + + /// Explicitly converts a double3 vector to a int3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3(double3 v) { return new int3(v); } + + + /// Returns the result of a componentwise multiplication operation on two int3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator * (int3 lhs, int3 rhs) { return new int3 (lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z); } + + /// Returns the result of a componentwise multiplication operation on an int3 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator * (int3 lhs, int rhs) { return new int3 (lhs.x * rhs, lhs.y * rhs, lhs.z * rhs); } + + /// Returns the result of a componentwise multiplication operation on an int value and an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator * (int lhs, int3 rhs) { return new int3 (lhs * rhs.x, lhs * rhs.y, lhs * rhs.z); } + + + /// Returns the result of a componentwise addition operation on two int3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator + (int3 lhs, int3 rhs) { return new int3 (lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z); } + + /// Returns the result of a componentwise addition operation on an int3 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator + (int3 lhs, int rhs) { return new int3 (lhs.x + rhs, lhs.y + rhs, lhs.z + rhs); } + + /// Returns the result of a componentwise addition operation on an int value and an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator + (int lhs, int3 rhs) { return new int3 (lhs + rhs.x, lhs + rhs.y, lhs + rhs.z); } + + + /// Returns the result of a componentwise subtraction operation on two int3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator - (int3 lhs, int3 rhs) { return new int3 (lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z); } + + /// Returns the result of a componentwise subtraction operation on an int3 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator - (int3 lhs, int rhs) { return new int3 (lhs.x - rhs, lhs.y - rhs, lhs.z - rhs); } + + /// Returns the result of a componentwise subtraction operation on an int value and an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator - (int lhs, int3 rhs) { return new int3 (lhs - rhs.x, lhs - rhs.y, lhs - rhs.z); } + + + /// Returns the result of a componentwise division operation on two int3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator / (int3 lhs, int3 rhs) { return new int3 (lhs.x / rhs.x, lhs.y / rhs.y, lhs.z / rhs.z); } + + /// Returns the result of a componentwise division operation on an int3 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator / (int3 lhs, int rhs) { return new int3 (lhs.x / rhs, lhs.y / rhs, lhs.z / rhs); } + + /// Returns the result of a componentwise division operation on an int value and an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator / (int lhs, int3 rhs) { return new int3 (lhs / rhs.x, lhs / rhs.y, lhs / rhs.z); } + + + /// Returns the result of a componentwise modulus operation on two int3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator % (int3 lhs, int3 rhs) { return new int3 (lhs.x % rhs.x, lhs.y % rhs.y, lhs.z % rhs.z); } + + /// Returns the result of a componentwise modulus operation on an int3 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator % (int3 lhs, int rhs) { return new int3 (lhs.x % rhs, lhs.y % rhs, lhs.z % rhs); } + + /// Returns the result of a componentwise modulus operation on an int value and an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator % (int lhs, int3 rhs) { return new int3 (lhs % rhs.x, lhs % rhs.y, lhs % rhs.z); } + + + /// Returns the result of a componentwise increment operation on an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator ++ (int3 val) { return new int3 (++val.x, ++val.y, ++val.z); } + + + /// Returns the result of a componentwise decrement operation on an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator -- (int3 val) { return new int3 (--val.x, --val.y, --val.z); } + + + /// Returns the result of a componentwise less than operation on two int3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator < (int3 lhs, int3 rhs) { return new bool3 (lhs.x < rhs.x, lhs.y < rhs.y, lhs.z < rhs.z); } + + /// Returns the result of a componentwise less than operation on an int3 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator < (int3 lhs, int rhs) { return new bool3 (lhs.x < rhs, lhs.y < rhs, lhs.z < rhs); } + + /// Returns the result of a componentwise less than operation on an int value and an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator < (int lhs, int3 rhs) { return new bool3 (lhs < rhs.x, lhs < rhs.y, lhs < rhs.z); } + + + /// Returns the result of a componentwise less or equal operation on two int3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator <= (int3 lhs, int3 rhs) { return new bool3 (lhs.x <= rhs.x, lhs.y <= rhs.y, lhs.z <= rhs.z); } + + /// Returns the result of a componentwise less or equal operation on an int3 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator <= (int3 lhs, int rhs) { return new bool3 (lhs.x <= rhs, lhs.y <= rhs, lhs.z <= rhs); } + + /// Returns the result of a componentwise less or equal operation on an int value and an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator <= (int lhs, int3 rhs) { return new bool3 (lhs <= rhs.x, lhs <= rhs.y, lhs <= rhs.z); } + + + /// Returns the result of a componentwise greater than operation on two int3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator > (int3 lhs, int3 rhs) { return new bool3 (lhs.x > rhs.x, lhs.y > rhs.y, lhs.z > rhs.z); } + + /// Returns the result of a componentwise greater than operation on an int3 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator > (int3 lhs, int rhs) { return new bool3 (lhs.x > rhs, lhs.y > rhs, lhs.z > rhs); } + + /// Returns the result of a componentwise greater than operation on an int value and an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator > (int lhs, int3 rhs) { return new bool3 (lhs > rhs.x, lhs > rhs.y, lhs > rhs.z); } + + + /// Returns the result of a componentwise greater or equal operation on two int3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator >= (int3 lhs, int3 rhs) { return new bool3 (lhs.x >= rhs.x, lhs.y >= rhs.y, lhs.z >= rhs.z); } + + /// Returns the result of a componentwise greater or equal operation on an int3 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator >= (int3 lhs, int rhs) { return new bool3 (lhs.x >= rhs, lhs.y >= rhs, lhs.z >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on an int value and an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator >= (int lhs, int3 rhs) { return new bool3 (lhs >= rhs.x, lhs >= rhs.y, lhs >= rhs.z); } + + + /// Returns the result of a componentwise unary minus operation on an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator - (int3 val) { return new int3 (-val.x, -val.y, -val.z); } + + + /// Returns the result of a componentwise unary plus operation on an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator + (int3 val) { return new int3 (+val.x, +val.y, +val.z); } + + + /// Returns the result of a componentwise left shift operation on an int3 vector by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator << (int3 x, int n) { return new int3 (x.x << n, x.y << n, x.z << n); } + + /// Returns the result of a componentwise right shift operation on an int3 vector by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator >> (int3 x, int n) { return new int3 (x.x >> n, x.y >> n, x.z >> n); } + + /// Returns the result of a componentwise equality operation on two int3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator == (int3 lhs, int3 rhs) { return new bool3 (lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z); } + + /// Returns the result of a componentwise equality operation on an int3 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator == (int3 lhs, int rhs) { return new bool3 (lhs.x == rhs, lhs.y == rhs, lhs.z == rhs); } + + /// Returns the result of a componentwise equality operation on an int value and an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator == (int lhs, int3 rhs) { return new bool3 (lhs == rhs.x, lhs == rhs.y, lhs == rhs.z); } + + + /// Returns the result of a componentwise not equal operation on two int3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator != (int3 lhs, int3 rhs) { return new bool3 (lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z); } + + /// Returns the result of a componentwise not equal operation on an int3 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator != (int3 lhs, int rhs) { return new bool3 (lhs.x != rhs, lhs.y != rhs, lhs.z != rhs); } + + /// Returns the result of a componentwise not equal operation on an int value and an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 operator != (int lhs, int3 rhs) { return new bool3 (lhs != rhs.x, lhs != rhs.y, lhs != rhs.z); } + + + /// Returns the result of a componentwise bitwise not operation on an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator ~ (int3 val) { return new int3 (~val.x, ~val.y, ~val.z); } + + + /// Returns the result of a componentwise bitwise and operation on two int3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator & (int3 lhs, int3 rhs) { return new int3 (lhs.x & rhs.x, lhs.y & rhs.y, lhs.z & rhs.z); } + + /// Returns the result of a componentwise bitwise and operation on an int3 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator & (int3 lhs, int rhs) { return new int3 (lhs.x & rhs, lhs.y & rhs, lhs.z & rhs); } + + /// Returns the result of a componentwise bitwise and operation on an int value and an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator & (int lhs, int3 rhs) { return new int3 (lhs & rhs.x, lhs & rhs.y, lhs & rhs.z); } + + + /// Returns the result of a componentwise bitwise or operation on two int3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator | (int3 lhs, int3 rhs) { return new int3 (lhs.x | rhs.x, lhs.y | rhs.y, lhs.z | rhs.z); } + + /// Returns the result of a componentwise bitwise or operation on an int3 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator | (int3 lhs, int rhs) { return new int3 (lhs.x | rhs, lhs.y | rhs, lhs.z | rhs); } + + /// Returns the result of a componentwise bitwise or operation on an int value and an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator | (int lhs, int3 rhs) { return new int3 (lhs | rhs.x, lhs | rhs.y, lhs | rhs.z); } + + + /// Returns the result of a componentwise bitwise exclusive or operation on two int3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator ^ (int3 lhs, int3 rhs) { return new int3 (lhs.x ^ rhs.x, lhs.y ^ rhs.y, lhs.z ^ rhs.z); } + + /// Returns the result of a componentwise bitwise exclusive or operation on an int3 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator ^ (int3 lhs, int rhs) { return new int3 (lhs.x ^ rhs, lhs.y ^ rhs, lhs.z ^ rhs); } + + /// Returns the result of a componentwise bitwise exclusive or operation on an int value and an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 operator ^ (int lhs, int3 rhs) { return new int3 (lhs ^ rhs.x, lhs ^ rhs.y, lhs ^ rhs.z); } + + + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xyxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xyyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xyzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xyzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xyzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xzxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xzxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, z, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xzxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xzyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, z, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xzyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xzyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xzzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xzzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xzzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yyxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yyyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yyzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yyzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yyzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yzxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yzxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, z, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yzxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yzyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, z, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yzyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yzyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yzzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yzzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yzzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zxxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zxyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, x, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zxzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zxzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, x, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zxzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zyxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, y, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zyyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zyzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, y, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zyzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zyzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zzxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zzxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, z, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zzxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zzyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, z, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zzyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zzyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zzzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zzzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zzzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, y, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; y = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, z, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; z = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 yxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 yxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 yxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, x, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; x = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 yyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 yyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 yyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 yzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, z, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; z = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 yzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 yzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 zxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 zxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(z, x, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; x = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 zxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 zyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(z, y, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; y = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 zyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 zyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 zzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 zzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 zzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 xx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 xy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(x, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; y = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 xz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(x, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; z = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 yx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(y, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; x = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 yy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 yz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(y, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; z = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 zx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(z, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; x = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 zy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(z, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; y = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 zz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(z, z); } + } + + + + /// Returns the int element at a specified index. + unsafe public int this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 3) + throw new System.ArgumentException("index must be between[0...2]"); +#endif + fixed (int3* array = &this) { return ((int*)array)[index]; } + } + set + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 3) + throw new System.ArgumentException("index must be between[0...2]"); +#endif + fixed (int* array = &x) { array[index] = value; } + } + } + + /// Returns true if the int3 is equal to a given int3, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(int3 rhs) { return x == rhs.x && y == rhs.y && z == rhs.z; } + + /// Returns true if the int3 is equal to a given int3, false otherwise. + public override bool Equals(object o) { return Equals((int3)o); } + + + /// Returns a hash code for the int3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the int3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("int3({0}, {1}, {2})", x, y, z); + } + + /// Returns a string representation of the int3 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("int3({0}, {1}, {2})", x.ToString(format, formatProvider), y.ToString(format, formatProvider), z.ToString(format, formatProvider)); + } + + internal sealed class DebuggerProxy + { + public int x; + public int y; + public int z; + public DebuggerProxy(int3 v) + { + x = v.x; + y = v.y; + z = v.z; + } + } + + } + + public static partial class math + { + /// Returns a int3 vector constructed from three int values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 int3(int x, int y, int z) { return new int3(x, y, z); } + + /// Returns a int3 vector constructed from an int value and an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 int3(int x, int2 yz) { return new int3(x, yz); } + + /// Returns a int3 vector constructed from an int2 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 int3(int2 xy, int z) { return new int3(xy, z); } + + /// Returns a int3 vector constructed from an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 int3(int3 xyz) { return new int3(xyz); } + + /// Returns a int3 vector constructed from a single int value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 int3(int v) { return new int3(v); } + + /// Returns a int3 vector constructed from a single bool value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 int3(bool v) { return new int3(v); } + + /// Return a int3 vector constructed from a bool3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 int3(bool3 v) { return new int3(v); } + + /// Returns a int3 vector constructed from a single uint value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 int3(uint v) { return new int3(v); } + + /// Return a int3 vector constructed from a uint3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 int3(uint3 v) { return new int3(v); } + + /// Returns a int3 vector constructed from a single float value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 int3(float v) { return new int3(v); } + + /// Return a int3 vector constructed from a float3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 int3(float3 v) { return new int3(v); } + + /// Returns a int3 vector constructed from a single double value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 int3(double v) { return new int3(v); } + + /// Return a int3 vector constructed from a double3 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 int3(double3 v) { return new int3(v); } + + /// Returns a uint hash code of a int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(int3 v) + { + return csum(asuint(v) * uint3(0x4C7F6DD1u, 0x4822A3E9u, 0xAAC3C25Du)) + 0xD21D0945u; + } + + /// + /// Returns a uint3 vector hash code of a int3 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 hashwide(int3 v) + { + return (asuint(v) * uint3(0x88FCAB2Du, 0x614DA60Du, 0x5BA2C50Bu)) + 0x8C455ACBu; + } + + /// Returns the result of specified shuffling of the components from two int3 vectors into an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int shuffle(int3 a, int3 b, ShuffleComponent x) + { + return select_shuffle_component(a, b, x); + } + + /// Returns the result of specified shuffling of the components from two int3 vectors into an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 shuffle(int3 a, int3 b, ShuffleComponent x, ShuffleComponent y) + { + return int2( + select_shuffle_component(a, b, x), + select_shuffle_component(a, b, y)); + } + + /// Returns the result of specified shuffling of the components from two int3 vectors into an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 shuffle(int3 a, int3 b, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z) + { + return int3( + select_shuffle_component(a, b, x), + select_shuffle_component(a, b, y), + select_shuffle_component(a, b, z)); + } + + /// Returns the result of specified shuffling of the components from two int3 vectors into an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 shuffle(int3 a, int3 b, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w) + { + return int4( + select_shuffle_component(a, b, x), + select_shuffle_component(a, b, y), + select_shuffle_component(a, b, z), + select_shuffle_component(a, b, w)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static int select_shuffle_component(int3 a, int3 b, ShuffleComponent component) + { + switch(component) + { + case ShuffleComponent.LeftX: + return a.x; + case ShuffleComponent.LeftY: + return a.y; + case ShuffleComponent.LeftZ: + return a.z; + case ShuffleComponent.RightX: + return b.x; + case ShuffleComponent.RightY: + return b.y; + case ShuffleComponent.RightZ: + return b.z; + default: + throw new System.ArgumentException("Invalid shuffle component: " + component); + } + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int3.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int3.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..020e850a0d12e54a61fcfcd1ba021003ca748bad --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int3.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 87ec2d8734054e84fa6976e8e8d4decf +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int3x2.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int3x2.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..c917037b120a0448ec52b59f6bfd1f776fd8b5df --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int3x2.gen.cs @@ -0,0 +1,494 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [System.Serializable] + public partial struct int3x2 : System.IEquatable, IFormattable + { + public int3 c0; + public int3 c1; + + /// int3x2 zero value. + public static readonly int3x2 zero; + + /// Constructs a int3x2 matrix from two int3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x2(int3 c0, int3 c1) + { + this.c0 = c0; + this.c1 = c1; + } + + /// Constructs a int3x2 matrix from 6 int values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x2(int m00, int m01, + int m10, int m11, + int m20, int m21) + { + this.c0 = new int3(m00, m10, m20); + this.c1 = new int3(m01, m11, m21); + } + + /// Constructs a int3x2 matrix from a single int value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x2(int v) + { + this.c0 = v; + this.c1 = v; + } + + /// Constructs a int3x2 matrix from a single bool value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x2(bool v) + { + this.c0 = math.select(new int3(0), new int3(1), v); + this.c1 = math.select(new int3(0), new int3(1), v); + } + + /// Constructs a int3x2 matrix from a bool3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x2(bool3x2 v) + { + this.c0 = math.select(new int3(0), new int3(1), v.c0); + this.c1 = math.select(new int3(0), new int3(1), v.c1); + } + + /// Constructs a int3x2 matrix from a single uint value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x2(uint v) + { + this.c0 = (int3)v; + this.c1 = (int3)v; + } + + /// Constructs a int3x2 matrix from a uint3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x2(uint3x2 v) + { + this.c0 = (int3)v.c0; + this.c1 = (int3)v.c1; + } + + /// Constructs a int3x2 matrix from a single float value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x2(float v) + { + this.c0 = (int3)v; + this.c1 = (int3)v; + } + + /// Constructs a int3x2 matrix from a float3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x2(float3x2 v) + { + this.c0 = (int3)v.c0; + this.c1 = (int3)v.c1; + } + + /// Constructs a int3x2 matrix from a single double value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x2(double v) + { + this.c0 = (int3)v; + this.c1 = (int3)v; + } + + /// Constructs a int3x2 matrix from a double3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x2(double3x2 v) + { + this.c0 = (int3)v.c0; + this.c1 = (int3)v.c1; + } + + + /// Implicitly converts a single int value to a int3x2 matrix by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator int3x2(int v) { return new int3x2(v); } + + /// Explicitly converts a single bool value to a int3x2 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3x2(bool v) { return new int3x2(v); } + + /// Explicitly converts a bool3x2 matrix to a int3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3x2(bool3x2 v) { return new int3x2(v); } + + /// Explicitly converts a single uint value to a int3x2 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3x2(uint v) { return new int3x2(v); } + + /// Explicitly converts a uint3x2 matrix to a int3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3x2(uint3x2 v) { return new int3x2(v); } + + /// Explicitly converts a single float value to a int3x2 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3x2(float v) { return new int3x2(v); } + + /// Explicitly converts a float3x2 matrix to a int3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3x2(float3x2 v) { return new int3x2(v); } + + /// Explicitly converts a single double value to a int3x2 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3x2(double v) { return new int3x2(v); } + + /// Explicitly converts a double3x2 matrix to a int3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3x2(double3x2 v) { return new int3x2(v); } + + + /// Returns the result of a componentwise multiplication operation on two int3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator * (int3x2 lhs, int3x2 rhs) { return new int3x2 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1); } + + /// Returns the result of a componentwise multiplication operation on an int3x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator * (int3x2 lhs, int rhs) { return new int3x2 (lhs.c0 * rhs, lhs.c1 * rhs); } + + /// Returns the result of a componentwise multiplication operation on an int value and an int3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator * (int lhs, int3x2 rhs) { return new int3x2 (lhs * rhs.c0, lhs * rhs.c1); } + + + /// Returns the result of a componentwise addition operation on two int3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator + (int3x2 lhs, int3x2 rhs) { return new int3x2 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1); } + + /// Returns the result of a componentwise addition operation on an int3x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator + (int3x2 lhs, int rhs) { return new int3x2 (lhs.c0 + rhs, lhs.c1 + rhs); } + + /// Returns the result of a componentwise addition operation on an int value and an int3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator + (int lhs, int3x2 rhs) { return new int3x2 (lhs + rhs.c0, lhs + rhs.c1); } + + + /// Returns the result of a componentwise subtraction operation on two int3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator - (int3x2 lhs, int3x2 rhs) { return new int3x2 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1); } + + /// Returns the result of a componentwise subtraction operation on an int3x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator - (int3x2 lhs, int rhs) { return new int3x2 (lhs.c0 - rhs, lhs.c1 - rhs); } + + /// Returns the result of a componentwise subtraction operation on an int value and an int3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator - (int lhs, int3x2 rhs) { return new int3x2 (lhs - rhs.c0, lhs - rhs.c1); } + + + /// Returns the result of a componentwise division operation on two int3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator / (int3x2 lhs, int3x2 rhs) { return new int3x2 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1); } + + /// Returns the result of a componentwise division operation on an int3x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator / (int3x2 lhs, int rhs) { return new int3x2 (lhs.c0 / rhs, lhs.c1 / rhs); } + + /// Returns the result of a componentwise division operation on an int value and an int3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator / (int lhs, int3x2 rhs) { return new int3x2 (lhs / rhs.c0, lhs / rhs.c1); } + + + /// Returns the result of a componentwise modulus operation on two int3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator % (int3x2 lhs, int3x2 rhs) { return new int3x2 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1); } + + /// Returns the result of a componentwise modulus operation on an int3x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator % (int3x2 lhs, int rhs) { return new int3x2 (lhs.c0 % rhs, lhs.c1 % rhs); } + + /// Returns the result of a componentwise modulus operation on an int value and an int3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator % (int lhs, int3x2 rhs) { return new int3x2 (lhs % rhs.c0, lhs % rhs.c1); } + + + /// Returns the result of a componentwise increment operation on an int3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator ++ (int3x2 val) { return new int3x2 (++val.c0, ++val.c1); } + + + /// Returns the result of a componentwise decrement operation on an int3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator -- (int3x2 val) { return new int3x2 (--val.c0, --val.c1); } + + + /// Returns the result of a componentwise less than operation on two int3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator < (int3x2 lhs, int3x2 rhs) { return new bool3x2 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1); } + + /// Returns the result of a componentwise less than operation on an int3x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator < (int3x2 lhs, int rhs) { return new bool3x2 (lhs.c0 < rhs, lhs.c1 < rhs); } + + /// Returns the result of a componentwise less than operation on an int value and an int3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator < (int lhs, int3x2 rhs) { return new bool3x2 (lhs < rhs.c0, lhs < rhs.c1); } + + + /// Returns the result of a componentwise less or equal operation on two int3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator <= (int3x2 lhs, int3x2 rhs) { return new bool3x2 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1); } + + /// Returns the result of a componentwise less or equal operation on an int3x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator <= (int3x2 lhs, int rhs) { return new bool3x2 (lhs.c0 <= rhs, lhs.c1 <= rhs); } + + /// Returns the result of a componentwise less or equal operation on an int value and an int3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator <= (int lhs, int3x2 rhs) { return new bool3x2 (lhs <= rhs.c0, lhs <= rhs.c1); } + + + /// Returns the result of a componentwise greater than operation on two int3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator > (int3x2 lhs, int3x2 rhs) { return new bool3x2 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1); } + + /// Returns the result of a componentwise greater than operation on an int3x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator > (int3x2 lhs, int rhs) { return new bool3x2 (lhs.c0 > rhs, lhs.c1 > rhs); } + + /// Returns the result of a componentwise greater than operation on an int value and an int3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator > (int lhs, int3x2 rhs) { return new bool3x2 (lhs > rhs.c0, lhs > rhs.c1); } + + + /// Returns the result of a componentwise greater or equal operation on two int3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator >= (int3x2 lhs, int3x2 rhs) { return new bool3x2 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1); } + + /// Returns the result of a componentwise greater or equal operation on an int3x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator >= (int3x2 lhs, int rhs) { return new bool3x2 (lhs.c0 >= rhs, lhs.c1 >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on an int value and an int3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator >= (int lhs, int3x2 rhs) { return new bool3x2 (lhs >= rhs.c0, lhs >= rhs.c1); } + + + /// Returns the result of a componentwise unary minus operation on an int3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator - (int3x2 val) { return new int3x2 (-val.c0, -val.c1); } + + + /// Returns the result of a componentwise unary plus operation on an int3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator + (int3x2 val) { return new int3x2 (+val.c0, +val.c1); } + + + /// Returns the result of a componentwise left shift operation on an int3x2 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator << (int3x2 x, int n) { return new int3x2 (x.c0 << n, x.c1 << n); } + + /// Returns the result of a componentwise right shift operation on an int3x2 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator >> (int3x2 x, int n) { return new int3x2 (x.c0 >> n, x.c1 >> n); } + + /// Returns the result of a componentwise equality operation on two int3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator == (int3x2 lhs, int3x2 rhs) { return new bool3x2 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1); } + + /// Returns the result of a componentwise equality operation on an int3x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator == (int3x2 lhs, int rhs) { return new bool3x2 (lhs.c0 == rhs, lhs.c1 == rhs); } + + /// Returns the result of a componentwise equality operation on an int value and an int3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator == (int lhs, int3x2 rhs) { return new bool3x2 (lhs == rhs.c0, lhs == rhs.c1); } + + + /// Returns the result of a componentwise not equal operation on two int3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator != (int3x2 lhs, int3x2 rhs) { return new bool3x2 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1); } + + /// Returns the result of a componentwise not equal operation on an int3x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator != (int3x2 lhs, int rhs) { return new bool3x2 (lhs.c0 != rhs, lhs.c1 != rhs); } + + /// Returns the result of a componentwise not equal operation on an int value and an int3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x2 operator != (int lhs, int3x2 rhs) { return new bool3x2 (lhs != rhs.c0, lhs != rhs.c1); } + + + /// Returns the result of a componentwise bitwise not operation on an int3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator ~ (int3x2 val) { return new int3x2 (~val.c0, ~val.c1); } + + + /// Returns the result of a componentwise bitwise and operation on two int3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator & (int3x2 lhs, int3x2 rhs) { return new int3x2 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1); } + + /// Returns the result of a componentwise bitwise and operation on an int3x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator & (int3x2 lhs, int rhs) { return new int3x2 (lhs.c0 & rhs, lhs.c1 & rhs); } + + /// Returns the result of a componentwise bitwise and operation on an int value and an int3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator & (int lhs, int3x2 rhs) { return new int3x2 (lhs & rhs.c0, lhs & rhs.c1); } + + + /// Returns the result of a componentwise bitwise or operation on two int3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator | (int3x2 lhs, int3x2 rhs) { return new int3x2 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1); } + + /// Returns the result of a componentwise bitwise or operation on an int3x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator | (int3x2 lhs, int rhs) { return new int3x2 (lhs.c0 | rhs, lhs.c1 | rhs); } + + /// Returns the result of a componentwise bitwise or operation on an int value and an int3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator | (int lhs, int3x2 rhs) { return new int3x2 (lhs | rhs.c0, lhs | rhs.c1); } + + + /// Returns the result of a componentwise bitwise exclusive or operation on two int3x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator ^ (int3x2 lhs, int3x2 rhs) { return new int3x2 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1); } + + /// Returns the result of a componentwise bitwise exclusive or operation on an int3x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator ^ (int3x2 lhs, int rhs) { return new int3x2 (lhs.c0 ^ rhs, lhs.c1 ^ rhs); } + + /// Returns the result of a componentwise bitwise exclusive or operation on an int value and an int3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 operator ^ (int lhs, int3x2 rhs) { return new int3x2 (lhs ^ rhs.c0, lhs ^ rhs.c1); } + + + + /// Returns the int3 element at a specified index. + unsafe public ref int3 this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 2) + throw new System.ArgumentException("index must be between[0...1]"); +#endif + fixed (int3x2* array = &this) { return ref ((int3*)array)[index]; } + } + } + + /// Returns true if the int3x2 is equal to a given int3x2, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(int3x2 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1); } + + /// Returns true if the int3x2 is equal to a given int3x2, false otherwise. + public override bool Equals(object o) { return Equals((int3x2)o); } + + + /// Returns a hash code for the int3x2. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the int3x2. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("int3x2({0}, {1}, {2}, {3}, {4}, {5})", c0.x, c1.x, c0.y, c1.y, c0.z, c1.z); + } + + /// Returns a string representation of the int3x2 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("int3x2({0}, {1}, {2}, {3}, {4}, {5})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider)); + } + + } + + public static partial class math + { + /// Returns a int3x2 matrix constructed from two int3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 int3x2(int3 c0, int3 c1) { return new int3x2(c0, c1); } + + /// Returns a int3x2 matrix constructed from from 6 int values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 int3x2(int m00, int m01, + int m10, int m11, + int m20, int m21) + { + return new int3x2(m00, m01, + m10, m11, + m20, m21); + } + + /// Returns a int3x2 matrix constructed from a single int value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 int3x2(int v) { return new int3x2(v); } + + /// Returns a int3x2 matrix constructed from a single bool value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 int3x2(bool v) { return new int3x2(v); } + + /// Return a int3x2 matrix constructed from a bool3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 int3x2(bool3x2 v) { return new int3x2(v); } + + /// Returns a int3x2 matrix constructed from a single uint value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 int3x2(uint v) { return new int3x2(v); } + + /// Return a int3x2 matrix constructed from a uint3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 int3x2(uint3x2 v) { return new int3x2(v); } + + /// Returns a int3x2 matrix constructed from a single float value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 int3x2(float v) { return new int3x2(v); } + + /// Return a int3x2 matrix constructed from a float3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 int3x2(float3x2 v) { return new int3x2(v); } + + /// Returns a int3x2 matrix constructed from a single double value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 int3x2(double v) { return new int3x2(v); } + + /// Return a int3x2 matrix constructed from a double3x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 int3x2(double3x2 v) { return new int3x2(v); } + + /// Return the int2x3 transpose of a int3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 transpose(int3x2 v) + { + return int2x3( + v.c0.x, v.c0.y, v.c0.z, + v.c1.x, v.c1.y, v.c1.z); + } + + /// Returns a uint hash code of a int3x2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(int3x2 v) + { + return csum(asuint(v.c0) * uint3(0xDB3DE101u, 0x7B6D1B4Bu, 0x58399E77u) + + asuint(v.c1) * uint3(0x5EAC29C9u, 0xFC6014F9u, 0x6BF6693Fu)) + 0x9D1B1D9Bu; + } + + /// + /// Returns a uint3 vector hash code of a int3x2 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 hashwide(int3x2 v) + { + return (asuint(v.c0) * uint3(0xF842F5C1u, 0xA47EC335u, 0xA477DF57u) + + asuint(v.c1) * uint3(0xC4B1493Fu, 0xBA0966D3u, 0xAFBEE253u)) + 0x5B419C01u; + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int3x2.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int3x2.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..0b361416f36fbaae88b83219a12f719b3f11d057 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int3x2.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 6ddb7ba42f65c4292afd32dd847c8d3e +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int3x3.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int3x3.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..0032e4521a48883e28aaa053f91355ec1845a45d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int3x3.gen.cs @@ -0,0 +1,527 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [System.Serializable] + public partial struct int3x3 : System.IEquatable, IFormattable + { + public int3 c0; + public int3 c1; + public int3 c2; + + /// int3x3 identity transform. + public static readonly int3x3 identity = new int3x3(1, 0, 0, 0, 1, 0, 0, 0, 1); + + /// int3x3 zero value. + public static readonly int3x3 zero; + + /// Constructs a int3x3 matrix from three int3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x3(int3 c0, int3 c1, int3 c2) + { + this.c0 = c0; + this.c1 = c1; + this.c2 = c2; + } + + /// Constructs a int3x3 matrix from 9 int values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x3(int m00, int m01, int m02, + int m10, int m11, int m12, + int m20, int m21, int m22) + { + this.c0 = new int3(m00, m10, m20); + this.c1 = new int3(m01, m11, m21); + this.c2 = new int3(m02, m12, m22); + } + + /// Constructs a int3x3 matrix from a single int value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x3(int v) + { + this.c0 = v; + this.c1 = v; + this.c2 = v; + } + + /// Constructs a int3x3 matrix from a single bool value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x3(bool v) + { + this.c0 = math.select(new int3(0), new int3(1), v); + this.c1 = math.select(new int3(0), new int3(1), v); + this.c2 = math.select(new int3(0), new int3(1), v); + } + + /// Constructs a int3x3 matrix from a bool3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x3(bool3x3 v) + { + this.c0 = math.select(new int3(0), new int3(1), v.c0); + this.c1 = math.select(new int3(0), new int3(1), v.c1); + this.c2 = math.select(new int3(0), new int3(1), v.c2); + } + + /// Constructs a int3x3 matrix from a single uint value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x3(uint v) + { + this.c0 = (int3)v; + this.c1 = (int3)v; + this.c2 = (int3)v; + } + + /// Constructs a int3x3 matrix from a uint3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x3(uint3x3 v) + { + this.c0 = (int3)v.c0; + this.c1 = (int3)v.c1; + this.c2 = (int3)v.c2; + } + + /// Constructs a int3x3 matrix from a single float value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x3(float v) + { + this.c0 = (int3)v; + this.c1 = (int3)v; + this.c2 = (int3)v; + } + + /// Constructs a int3x3 matrix from a float3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x3(float3x3 v) + { + this.c0 = (int3)v.c0; + this.c1 = (int3)v.c1; + this.c2 = (int3)v.c2; + } + + /// Constructs a int3x3 matrix from a single double value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x3(double v) + { + this.c0 = (int3)v; + this.c1 = (int3)v; + this.c2 = (int3)v; + } + + /// Constructs a int3x3 matrix from a double3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x3(double3x3 v) + { + this.c0 = (int3)v.c0; + this.c1 = (int3)v.c1; + this.c2 = (int3)v.c2; + } + + + /// Implicitly converts a single int value to a int3x3 matrix by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator int3x3(int v) { return new int3x3(v); } + + /// Explicitly converts a single bool value to a int3x3 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3x3(bool v) { return new int3x3(v); } + + /// Explicitly converts a bool3x3 matrix to a int3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3x3(bool3x3 v) { return new int3x3(v); } + + /// Explicitly converts a single uint value to a int3x3 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3x3(uint v) { return new int3x3(v); } + + /// Explicitly converts a uint3x3 matrix to a int3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3x3(uint3x3 v) { return new int3x3(v); } + + /// Explicitly converts a single float value to a int3x3 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3x3(float v) { return new int3x3(v); } + + /// Explicitly converts a float3x3 matrix to a int3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3x3(float3x3 v) { return new int3x3(v); } + + /// Explicitly converts a single double value to a int3x3 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3x3(double v) { return new int3x3(v); } + + /// Explicitly converts a double3x3 matrix to a int3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3x3(double3x3 v) { return new int3x3(v); } + + + /// Returns the result of a componentwise multiplication operation on two int3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator * (int3x3 lhs, int3x3 rhs) { return new int3x3 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2); } + + /// Returns the result of a componentwise multiplication operation on an int3x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator * (int3x3 lhs, int rhs) { return new int3x3 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs); } + + /// Returns the result of a componentwise multiplication operation on an int value and an int3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator * (int lhs, int3x3 rhs) { return new int3x3 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2); } + + + /// Returns the result of a componentwise addition operation on two int3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator + (int3x3 lhs, int3x3 rhs) { return new int3x3 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2); } + + /// Returns the result of a componentwise addition operation on an int3x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator + (int3x3 lhs, int rhs) { return new int3x3 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs); } + + /// Returns the result of a componentwise addition operation on an int value and an int3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator + (int lhs, int3x3 rhs) { return new int3x3 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2); } + + + /// Returns the result of a componentwise subtraction operation on two int3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator - (int3x3 lhs, int3x3 rhs) { return new int3x3 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2); } + + /// Returns the result of a componentwise subtraction operation on an int3x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator - (int3x3 lhs, int rhs) { return new int3x3 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs); } + + /// Returns the result of a componentwise subtraction operation on an int value and an int3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator - (int lhs, int3x3 rhs) { return new int3x3 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2); } + + + /// Returns the result of a componentwise division operation on two int3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator / (int3x3 lhs, int3x3 rhs) { return new int3x3 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2); } + + /// Returns the result of a componentwise division operation on an int3x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator / (int3x3 lhs, int rhs) { return new int3x3 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs); } + + /// Returns the result of a componentwise division operation on an int value and an int3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator / (int lhs, int3x3 rhs) { return new int3x3 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2); } + + + /// Returns the result of a componentwise modulus operation on two int3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator % (int3x3 lhs, int3x3 rhs) { return new int3x3 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2); } + + /// Returns the result of a componentwise modulus operation on an int3x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator % (int3x3 lhs, int rhs) { return new int3x3 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs); } + + /// Returns the result of a componentwise modulus operation on an int value and an int3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator % (int lhs, int3x3 rhs) { return new int3x3 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2); } + + + /// Returns the result of a componentwise increment operation on an int3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator ++ (int3x3 val) { return new int3x3 (++val.c0, ++val.c1, ++val.c2); } + + + /// Returns the result of a componentwise decrement operation on an int3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator -- (int3x3 val) { return new int3x3 (--val.c0, --val.c1, --val.c2); } + + + /// Returns the result of a componentwise less than operation on two int3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator < (int3x3 lhs, int3x3 rhs) { return new bool3x3 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2); } + + /// Returns the result of a componentwise less than operation on an int3x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator < (int3x3 lhs, int rhs) { return new bool3x3 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs); } + + /// Returns the result of a componentwise less than operation on an int value and an int3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator < (int lhs, int3x3 rhs) { return new bool3x3 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2); } + + + /// Returns the result of a componentwise less or equal operation on two int3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator <= (int3x3 lhs, int3x3 rhs) { return new bool3x3 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2); } + + /// Returns the result of a componentwise less or equal operation on an int3x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator <= (int3x3 lhs, int rhs) { return new bool3x3 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs); } + + /// Returns the result of a componentwise less or equal operation on an int value and an int3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator <= (int lhs, int3x3 rhs) { return new bool3x3 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2); } + + + /// Returns the result of a componentwise greater than operation on two int3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator > (int3x3 lhs, int3x3 rhs) { return new bool3x3 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2); } + + /// Returns the result of a componentwise greater than operation on an int3x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator > (int3x3 lhs, int rhs) { return new bool3x3 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs); } + + /// Returns the result of a componentwise greater than operation on an int value and an int3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator > (int lhs, int3x3 rhs) { return new bool3x3 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2); } + + + /// Returns the result of a componentwise greater or equal operation on two int3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator >= (int3x3 lhs, int3x3 rhs) { return new bool3x3 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2); } + + /// Returns the result of a componentwise greater or equal operation on an int3x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator >= (int3x3 lhs, int rhs) { return new bool3x3 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on an int value and an int3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator >= (int lhs, int3x3 rhs) { return new bool3x3 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2); } + + + /// Returns the result of a componentwise unary minus operation on an int3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator - (int3x3 val) { return new int3x3 (-val.c0, -val.c1, -val.c2); } + + + /// Returns the result of a componentwise unary plus operation on an int3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator + (int3x3 val) { return new int3x3 (+val.c0, +val.c1, +val.c2); } + + + /// Returns the result of a componentwise left shift operation on an int3x3 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator << (int3x3 x, int n) { return new int3x3 (x.c0 << n, x.c1 << n, x.c2 << n); } + + /// Returns the result of a componentwise right shift operation on an int3x3 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator >> (int3x3 x, int n) { return new int3x3 (x.c0 >> n, x.c1 >> n, x.c2 >> n); } + + /// Returns the result of a componentwise equality operation on two int3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator == (int3x3 lhs, int3x3 rhs) { return new bool3x3 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2); } + + /// Returns the result of a componentwise equality operation on an int3x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator == (int3x3 lhs, int rhs) { return new bool3x3 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs); } + + /// Returns the result of a componentwise equality operation on an int value and an int3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator == (int lhs, int3x3 rhs) { return new bool3x3 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2); } + + + /// Returns the result of a componentwise not equal operation on two int3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator != (int3x3 lhs, int3x3 rhs) { return new bool3x3 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2); } + + /// Returns the result of a componentwise not equal operation on an int3x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator != (int3x3 lhs, int rhs) { return new bool3x3 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs); } + + /// Returns the result of a componentwise not equal operation on an int value and an int3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x3 operator != (int lhs, int3x3 rhs) { return new bool3x3 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2); } + + + /// Returns the result of a componentwise bitwise not operation on an int3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator ~ (int3x3 val) { return new int3x3 (~val.c0, ~val.c1, ~val.c2); } + + + /// Returns the result of a componentwise bitwise and operation on two int3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator & (int3x3 lhs, int3x3 rhs) { return new int3x3 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1, lhs.c2 & rhs.c2); } + + /// Returns the result of a componentwise bitwise and operation on an int3x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator & (int3x3 lhs, int rhs) { return new int3x3 (lhs.c0 & rhs, lhs.c1 & rhs, lhs.c2 & rhs); } + + /// Returns the result of a componentwise bitwise and operation on an int value and an int3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator & (int lhs, int3x3 rhs) { return new int3x3 (lhs & rhs.c0, lhs & rhs.c1, lhs & rhs.c2); } + + + /// Returns the result of a componentwise bitwise or operation on two int3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator | (int3x3 lhs, int3x3 rhs) { return new int3x3 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1, lhs.c2 | rhs.c2); } + + /// Returns the result of a componentwise bitwise or operation on an int3x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator | (int3x3 lhs, int rhs) { return new int3x3 (lhs.c0 | rhs, lhs.c1 | rhs, lhs.c2 | rhs); } + + /// Returns the result of a componentwise bitwise or operation on an int value and an int3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator | (int lhs, int3x3 rhs) { return new int3x3 (lhs | rhs.c0, lhs | rhs.c1, lhs | rhs.c2); } + + + /// Returns the result of a componentwise bitwise exclusive or operation on two int3x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator ^ (int3x3 lhs, int3x3 rhs) { return new int3x3 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1, lhs.c2 ^ rhs.c2); } + + /// Returns the result of a componentwise bitwise exclusive or operation on an int3x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator ^ (int3x3 lhs, int rhs) { return new int3x3 (lhs.c0 ^ rhs, lhs.c1 ^ rhs, lhs.c2 ^ rhs); } + + /// Returns the result of a componentwise bitwise exclusive or operation on an int value and an int3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 operator ^ (int lhs, int3x3 rhs) { return new int3x3 (lhs ^ rhs.c0, lhs ^ rhs.c1, lhs ^ rhs.c2); } + + + + /// Returns the int3 element at a specified index. + unsafe public ref int3 this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 3) + throw new System.ArgumentException("index must be between[0...2]"); +#endif + fixed (int3x3* array = &this) { return ref ((int3*)array)[index]; } + } + } + + /// Returns true if the int3x3 is equal to a given int3x3, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(int3x3 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2); } + + /// Returns true if the int3x3 is equal to a given int3x3, false otherwise. + public override bool Equals(object o) { return Equals((int3x3)o); } + + + /// Returns a hash code for the int3x3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the int3x3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("int3x3({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8})", c0.x, c1.x, c2.x, c0.y, c1.y, c2.y, c0.z, c1.z, c2.z); + } + + /// Returns a string representation of the int3x3 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("int3x3({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider), c2.z.ToString(format, formatProvider)); + } + + } + + public static partial class math + { + /// Returns a int3x3 matrix constructed from three int3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 int3x3(int3 c0, int3 c1, int3 c2) { return new int3x3(c0, c1, c2); } + + /// Returns a int3x3 matrix constructed from from 9 int values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 int3x3(int m00, int m01, int m02, + int m10, int m11, int m12, + int m20, int m21, int m22) + { + return new int3x3(m00, m01, m02, + m10, m11, m12, + m20, m21, m22); + } + + /// Returns a int3x3 matrix constructed from a single int value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 int3x3(int v) { return new int3x3(v); } + + /// Returns a int3x3 matrix constructed from a single bool value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 int3x3(bool v) { return new int3x3(v); } + + /// Return a int3x3 matrix constructed from a bool3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 int3x3(bool3x3 v) { return new int3x3(v); } + + /// Returns a int3x3 matrix constructed from a single uint value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 int3x3(uint v) { return new int3x3(v); } + + /// Return a int3x3 matrix constructed from a uint3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 int3x3(uint3x3 v) { return new int3x3(v); } + + /// Returns a int3x3 matrix constructed from a single float value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 int3x3(float v) { return new int3x3(v); } + + /// Return a int3x3 matrix constructed from a float3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 int3x3(float3x3 v) { return new int3x3(v); } + + /// Returns a int3x3 matrix constructed from a single double value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 int3x3(double v) { return new int3x3(v); } + + /// Return a int3x3 matrix constructed from a double3x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 int3x3(double3x3 v) { return new int3x3(v); } + + /// Return the int3x3 transpose of a int3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 transpose(int3x3 v) + { + return int3x3( + v.c0.x, v.c0.y, v.c0.z, + v.c1.x, v.c1.y, v.c1.z, + v.c2.x, v.c2.y, v.c2.z); + } + + /// Returns the determinant of a int3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int determinant(int3x3 m) + { + int3 c0 = m.c0; + int3 c1 = m.c1; + int3 c2 = m.c2; + + int m00 = c1.y * c2.z - c1.z * c2.y; + int m01 = c0.y * c2.z - c0.z * c2.y; + int m02 = c0.y * c1.z - c0.z * c1.y; + + return c0.x * m00 - c1.x * m01 + c2.x * m02; + } + + /// Returns a uint hash code of a int3x3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(int3x3 v) + { + return csum(asuint(v.c0) * uint3(0x93C30C2Bu, 0xDCAF0351u, 0x6E050B01u) + + asuint(v.c1) * uint3(0x750FDBF5u, 0x7F3DD499u, 0x52EAAEBBu) + + asuint(v.c2) * uint3(0x4599C793u, 0x83B5E729u, 0xC267163Fu)) + 0x67BC9149u; + } + + /// + /// Returns a uint3 vector hash code of a int3x3 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 hashwide(int3x3 v) + { + return (asuint(v.c0) * uint3(0xAD7C5EC1u, 0x822A7D6Du, 0xB492BF15u) + + asuint(v.c1) * uint3(0xD37220E3u, 0x7AA2C2BDu, 0xE16BC89Du) + + asuint(v.c2) * uint3(0x7AA07CD3u, 0xAF642BA9u, 0xA8F2213Bu)) + 0x9F3FDC37u; + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int3x3.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int3x3.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..c29c0bc2aebfb18ff37670bd7e1ca1f92a4498f8 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int3x3.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 217c0fb9c97594ff38dc97fdce4fc117 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int3x4.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int3x4.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..788f3d37e3c835fed99d278b079461bbd10781bc --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int3x4.gen.cs @@ -0,0 +1,524 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [System.Serializable] + public partial struct int3x4 : System.IEquatable, IFormattable + { + public int3 c0; + public int3 c1; + public int3 c2; + public int3 c3; + + /// int3x4 zero value. + public static readonly int3x4 zero; + + /// Constructs a int3x4 matrix from four int3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x4(int3 c0, int3 c1, int3 c2, int3 c3) + { + this.c0 = c0; + this.c1 = c1; + this.c2 = c2; + this.c3 = c3; + } + + /// Constructs a int3x4 matrix from 12 int values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x4(int m00, int m01, int m02, int m03, + int m10, int m11, int m12, int m13, + int m20, int m21, int m22, int m23) + { + this.c0 = new int3(m00, m10, m20); + this.c1 = new int3(m01, m11, m21); + this.c2 = new int3(m02, m12, m22); + this.c3 = new int3(m03, m13, m23); + } + + /// Constructs a int3x4 matrix from a single int value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x4(int v) + { + this.c0 = v; + this.c1 = v; + this.c2 = v; + this.c3 = v; + } + + /// Constructs a int3x4 matrix from a single bool value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x4(bool v) + { + this.c0 = math.select(new int3(0), new int3(1), v); + this.c1 = math.select(new int3(0), new int3(1), v); + this.c2 = math.select(new int3(0), new int3(1), v); + this.c3 = math.select(new int3(0), new int3(1), v); + } + + /// Constructs a int3x4 matrix from a bool3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x4(bool3x4 v) + { + this.c0 = math.select(new int3(0), new int3(1), v.c0); + this.c1 = math.select(new int3(0), new int3(1), v.c1); + this.c2 = math.select(new int3(0), new int3(1), v.c2); + this.c3 = math.select(new int3(0), new int3(1), v.c3); + } + + /// Constructs a int3x4 matrix from a single uint value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x4(uint v) + { + this.c0 = (int3)v; + this.c1 = (int3)v; + this.c2 = (int3)v; + this.c3 = (int3)v; + } + + /// Constructs a int3x4 matrix from a uint3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x4(uint3x4 v) + { + this.c0 = (int3)v.c0; + this.c1 = (int3)v.c1; + this.c2 = (int3)v.c2; + this.c3 = (int3)v.c3; + } + + /// Constructs a int3x4 matrix from a single float value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x4(float v) + { + this.c0 = (int3)v; + this.c1 = (int3)v; + this.c2 = (int3)v; + this.c3 = (int3)v; + } + + /// Constructs a int3x4 matrix from a float3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x4(float3x4 v) + { + this.c0 = (int3)v.c0; + this.c1 = (int3)v.c1; + this.c2 = (int3)v.c2; + this.c3 = (int3)v.c3; + } + + /// Constructs a int3x4 matrix from a single double value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x4(double v) + { + this.c0 = (int3)v; + this.c1 = (int3)v; + this.c2 = (int3)v; + this.c3 = (int3)v; + } + + /// Constructs a int3x4 matrix from a double3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3x4(double3x4 v) + { + this.c0 = (int3)v.c0; + this.c1 = (int3)v.c1; + this.c2 = (int3)v.c2; + this.c3 = (int3)v.c3; + } + + + /// Implicitly converts a single int value to a int3x4 matrix by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator int3x4(int v) { return new int3x4(v); } + + /// Explicitly converts a single bool value to a int3x4 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3x4(bool v) { return new int3x4(v); } + + /// Explicitly converts a bool3x4 matrix to a int3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3x4(bool3x4 v) { return new int3x4(v); } + + /// Explicitly converts a single uint value to a int3x4 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3x4(uint v) { return new int3x4(v); } + + /// Explicitly converts a uint3x4 matrix to a int3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3x4(uint3x4 v) { return new int3x4(v); } + + /// Explicitly converts a single float value to a int3x4 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3x4(float v) { return new int3x4(v); } + + /// Explicitly converts a float3x4 matrix to a int3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3x4(float3x4 v) { return new int3x4(v); } + + /// Explicitly converts a single double value to a int3x4 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3x4(double v) { return new int3x4(v); } + + /// Explicitly converts a double3x4 matrix to a int3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int3x4(double3x4 v) { return new int3x4(v); } + + + /// Returns the result of a componentwise multiplication operation on two int3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator * (int3x4 lhs, int3x4 rhs) { return new int3x4 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2, lhs.c3 * rhs.c3); } + + /// Returns the result of a componentwise multiplication operation on an int3x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator * (int3x4 lhs, int rhs) { return new int3x4 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs, lhs.c3 * rhs); } + + /// Returns the result of a componentwise multiplication operation on an int value and an int3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator * (int lhs, int3x4 rhs) { return new int3x4 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2, lhs * rhs.c3); } + + + /// Returns the result of a componentwise addition operation on two int3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator + (int3x4 lhs, int3x4 rhs) { return new int3x4 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2, lhs.c3 + rhs.c3); } + + /// Returns the result of a componentwise addition operation on an int3x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator + (int3x4 lhs, int rhs) { return new int3x4 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs, lhs.c3 + rhs); } + + /// Returns the result of a componentwise addition operation on an int value and an int3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator + (int lhs, int3x4 rhs) { return new int3x4 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2, lhs + rhs.c3); } + + + /// Returns the result of a componentwise subtraction operation on two int3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator - (int3x4 lhs, int3x4 rhs) { return new int3x4 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2, lhs.c3 - rhs.c3); } + + /// Returns the result of a componentwise subtraction operation on an int3x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator - (int3x4 lhs, int rhs) { return new int3x4 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs, lhs.c3 - rhs); } + + /// Returns the result of a componentwise subtraction operation on an int value and an int3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator - (int lhs, int3x4 rhs) { return new int3x4 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2, lhs - rhs.c3); } + + + /// Returns the result of a componentwise division operation on two int3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator / (int3x4 lhs, int3x4 rhs) { return new int3x4 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2, lhs.c3 / rhs.c3); } + + /// Returns the result of a componentwise division operation on an int3x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator / (int3x4 lhs, int rhs) { return new int3x4 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs, lhs.c3 / rhs); } + + /// Returns the result of a componentwise division operation on an int value and an int3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator / (int lhs, int3x4 rhs) { return new int3x4 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2, lhs / rhs.c3); } + + + /// Returns the result of a componentwise modulus operation on two int3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator % (int3x4 lhs, int3x4 rhs) { return new int3x4 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2, lhs.c3 % rhs.c3); } + + /// Returns the result of a componentwise modulus operation on an int3x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator % (int3x4 lhs, int rhs) { return new int3x4 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs, lhs.c3 % rhs); } + + /// Returns the result of a componentwise modulus operation on an int value and an int3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator % (int lhs, int3x4 rhs) { return new int3x4 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2, lhs % rhs.c3); } + + + /// Returns the result of a componentwise increment operation on an int3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator ++ (int3x4 val) { return new int3x4 (++val.c0, ++val.c1, ++val.c2, ++val.c3); } + + + /// Returns the result of a componentwise decrement operation on an int3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator -- (int3x4 val) { return new int3x4 (--val.c0, --val.c1, --val.c2, --val.c3); } + + + /// Returns the result of a componentwise less than operation on two int3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator < (int3x4 lhs, int3x4 rhs) { return new bool3x4 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2, lhs.c3 < rhs.c3); } + + /// Returns the result of a componentwise less than operation on an int3x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator < (int3x4 lhs, int rhs) { return new bool3x4 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs, lhs.c3 < rhs); } + + /// Returns the result of a componentwise less than operation on an int value and an int3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator < (int lhs, int3x4 rhs) { return new bool3x4 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2, lhs < rhs.c3); } + + + /// Returns the result of a componentwise less or equal operation on two int3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator <= (int3x4 lhs, int3x4 rhs) { return new bool3x4 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2, lhs.c3 <= rhs.c3); } + + /// Returns the result of a componentwise less or equal operation on an int3x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator <= (int3x4 lhs, int rhs) { return new bool3x4 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs, lhs.c3 <= rhs); } + + /// Returns the result of a componentwise less or equal operation on an int value and an int3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator <= (int lhs, int3x4 rhs) { return new bool3x4 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2, lhs <= rhs.c3); } + + + /// Returns the result of a componentwise greater than operation on two int3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator > (int3x4 lhs, int3x4 rhs) { return new bool3x4 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2, lhs.c3 > rhs.c3); } + + /// Returns the result of a componentwise greater than operation on an int3x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator > (int3x4 lhs, int rhs) { return new bool3x4 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs, lhs.c3 > rhs); } + + /// Returns the result of a componentwise greater than operation on an int value and an int3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator > (int lhs, int3x4 rhs) { return new bool3x4 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2, lhs > rhs.c3); } + + + /// Returns the result of a componentwise greater or equal operation on two int3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator >= (int3x4 lhs, int3x4 rhs) { return new bool3x4 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2, lhs.c3 >= rhs.c3); } + + /// Returns the result of a componentwise greater or equal operation on an int3x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator >= (int3x4 lhs, int rhs) { return new bool3x4 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs, lhs.c3 >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on an int value and an int3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator >= (int lhs, int3x4 rhs) { return new bool3x4 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2, lhs >= rhs.c3); } + + + /// Returns the result of a componentwise unary minus operation on an int3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator - (int3x4 val) { return new int3x4 (-val.c0, -val.c1, -val.c2, -val.c3); } + + + /// Returns the result of a componentwise unary plus operation on an int3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator + (int3x4 val) { return new int3x4 (+val.c0, +val.c1, +val.c2, +val.c3); } + + + /// Returns the result of a componentwise left shift operation on an int3x4 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator << (int3x4 x, int n) { return new int3x4 (x.c0 << n, x.c1 << n, x.c2 << n, x.c3 << n); } + + /// Returns the result of a componentwise right shift operation on an int3x4 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator >> (int3x4 x, int n) { return new int3x4 (x.c0 >> n, x.c1 >> n, x.c2 >> n, x.c3 >> n); } + + /// Returns the result of a componentwise equality operation on two int3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator == (int3x4 lhs, int3x4 rhs) { return new bool3x4 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2, lhs.c3 == rhs.c3); } + + /// Returns the result of a componentwise equality operation on an int3x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator == (int3x4 lhs, int rhs) { return new bool3x4 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs, lhs.c3 == rhs); } + + /// Returns the result of a componentwise equality operation on an int value and an int3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator == (int lhs, int3x4 rhs) { return new bool3x4 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2, lhs == rhs.c3); } + + + /// Returns the result of a componentwise not equal operation on two int3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator != (int3x4 lhs, int3x4 rhs) { return new bool3x4 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2, lhs.c3 != rhs.c3); } + + /// Returns the result of a componentwise not equal operation on an int3x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator != (int3x4 lhs, int rhs) { return new bool3x4 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs, lhs.c3 != rhs); } + + /// Returns the result of a componentwise not equal operation on an int value and an int3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3x4 operator != (int lhs, int3x4 rhs) { return new bool3x4 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2, lhs != rhs.c3); } + + + /// Returns the result of a componentwise bitwise not operation on an int3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator ~ (int3x4 val) { return new int3x4 (~val.c0, ~val.c1, ~val.c2, ~val.c3); } + + + /// Returns the result of a componentwise bitwise and operation on two int3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator & (int3x4 lhs, int3x4 rhs) { return new int3x4 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1, lhs.c2 & rhs.c2, lhs.c3 & rhs.c3); } + + /// Returns the result of a componentwise bitwise and operation on an int3x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator & (int3x4 lhs, int rhs) { return new int3x4 (lhs.c0 & rhs, lhs.c1 & rhs, lhs.c2 & rhs, lhs.c3 & rhs); } + + /// Returns the result of a componentwise bitwise and operation on an int value and an int3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator & (int lhs, int3x4 rhs) { return new int3x4 (lhs & rhs.c0, lhs & rhs.c1, lhs & rhs.c2, lhs & rhs.c3); } + + + /// Returns the result of a componentwise bitwise or operation on two int3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator | (int3x4 lhs, int3x4 rhs) { return new int3x4 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1, lhs.c2 | rhs.c2, lhs.c3 | rhs.c3); } + + /// Returns the result of a componentwise bitwise or operation on an int3x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator | (int3x4 lhs, int rhs) { return new int3x4 (lhs.c0 | rhs, lhs.c1 | rhs, lhs.c2 | rhs, lhs.c3 | rhs); } + + /// Returns the result of a componentwise bitwise or operation on an int value and an int3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator | (int lhs, int3x4 rhs) { return new int3x4 (lhs | rhs.c0, lhs | rhs.c1, lhs | rhs.c2, lhs | rhs.c3); } + + + /// Returns the result of a componentwise bitwise exclusive or operation on two int3x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator ^ (int3x4 lhs, int3x4 rhs) { return new int3x4 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1, lhs.c2 ^ rhs.c2, lhs.c3 ^ rhs.c3); } + + /// Returns the result of a componentwise bitwise exclusive or operation on an int3x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator ^ (int3x4 lhs, int rhs) { return new int3x4 (lhs.c0 ^ rhs, lhs.c1 ^ rhs, lhs.c2 ^ rhs, lhs.c3 ^ rhs); } + + /// Returns the result of a componentwise bitwise exclusive or operation on an int value and an int3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 operator ^ (int lhs, int3x4 rhs) { return new int3x4 (lhs ^ rhs.c0, lhs ^ rhs.c1, lhs ^ rhs.c2, lhs ^ rhs.c3); } + + + + /// Returns the int3 element at a specified index. + unsafe public ref int3 this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 4) + throw new System.ArgumentException("index must be between[0...3]"); +#endif + fixed (int3x4* array = &this) { return ref ((int3*)array)[index]; } + } + } + + /// Returns true if the int3x4 is equal to a given int3x4, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(int3x4 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2) && c3.Equals(rhs.c3); } + + /// Returns true if the int3x4 is equal to a given int3x4, false otherwise. + public override bool Equals(object o) { return Equals((int3x4)o); } + + + /// Returns a hash code for the int3x4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the int3x4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("int3x4({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11})", c0.x, c1.x, c2.x, c3.x, c0.y, c1.y, c2.y, c3.y, c0.z, c1.z, c2.z, c3.z); + } + + /// Returns a string representation of the int3x4 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("int3x4({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c3.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider), c3.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider), c2.z.ToString(format, formatProvider), c3.z.ToString(format, formatProvider)); + } + + } + + public static partial class math + { + /// Returns a int3x4 matrix constructed from four int3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 int3x4(int3 c0, int3 c1, int3 c2, int3 c3) { return new int3x4(c0, c1, c2, c3); } + + /// Returns a int3x4 matrix constructed from from 12 int values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 int3x4(int m00, int m01, int m02, int m03, + int m10, int m11, int m12, int m13, + int m20, int m21, int m22, int m23) + { + return new int3x4(m00, m01, m02, m03, + m10, m11, m12, m13, + m20, m21, m22, m23); + } + + /// Returns a int3x4 matrix constructed from a single int value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 int3x4(int v) { return new int3x4(v); } + + /// Returns a int3x4 matrix constructed from a single bool value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 int3x4(bool v) { return new int3x4(v); } + + /// Return a int3x4 matrix constructed from a bool3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 int3x4(bool3x4 v) { return new int3x4(v); } + + /// Returns a int3x4 matrix constructed from a single uint value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 int3x4(uint v) { return new int3x4(v); } + + /// Return a int3x4 matrix constructed from a uint3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 int3x4(uint3x4 v) { return new int3x4(v); } + + /// Returns a int3x4 matrix constructed from a single float value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 int3x4(float v) { return new int3x4(v); } + + /// Return a int3x4 matrix constructed from a float3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 int3x4(float3x4 v) { return new int3x4(v); } + + /// Returns a int3x4 matrix constructed from a single double value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 int3x4(double v) { return new int3x4(v); } + + /// Return a int3x4 matrix constructed from a double3x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 int3x4(double3x4 v) { return new int3x4(v); } + + /// Return the int4x3 transpose of a int3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 transpose(int3x4 v) + { + return int4x3( + v.c0.x, v.c0.y, v.c0.z, + v.c1.x, v.c1.y, v.c1.z, + v.c2.x, v.c2.y, v.c2.z, + v.c3.x, v.c3.y, v.c3.z); + } + + /// Returns a uint hash code of a int3x4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(int3x4 v) + { + return csum(asuint(v.c0) * uint3(0x5AB3E8CDu, 0x676E8407u, 0xB36DE767u) + + asuint(v.c1) * uint3(0x6FCA387Du, 0xAF0F3103u, 0xE4A056C7u) + + asuint(v.c2) * uint3(0x841D8225u, 0xC9393C7Du, 0xD42EAFA3u) + + asuint(v.c3) * uint3(0xD9AFD06Du, 0x97A65421u, 0x7809205Fu)) + 0x9C9F0823u; + } + + /// + /// Returns a uint3 vector hash code of a int3x4 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 hashwide(int3x4 v) + { + return (asuint(v.c0) * uint3(0x5A9CA13Bu, 0xAFCDD5EFu, 0xA88D187Du) + + asuint(v.c1) * uint3(0xCF6EBA1Du, 0x9D88E5A1u, 0xEADF0775u) + + asuint(v.c2) * uint3(0x747A9D7Bu, 0x4111F799u, 0xB5F05AF1u) + + asuint(v.c3) * uint3(0xFD80290Bu, 0x8B65ADB7u, 0xDFF4F563u)) + 0x7069770Du; + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int3x4.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int3x4.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..2a14dc2aefb563b2f9ecd8d45491b8c662a56764 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int3x4.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 67f00d3260d3e46778497ed1e2b93c92 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int4.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int4.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..d5f7795d29b2d1456f8b0c901d848196ae610e56 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int4.gen.cs @@ -0,0 +1,3480 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; +using System.Diagnostics; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [DebuggerTypeProxy(typeof(int4.DebuggerProxy))] + [System.Serializable] + public partial struct int4 : System.IEquatable, IFormattable + { + public int x; + public int y; + public int z; + public int w; + + /// int4 zero value. + public static readonly int4 zero; + + /// Constructs a int4 vector from four int values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4(int x, int y, int z, int w) + { + this.x = x; + this.y = y; + this.z = z; + this.w = w; + } + + /// Constructs a int4 vector from two int values and an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4(int x, int y, int2 zw) + { + this.x = x; + this.y = y; + this.z = zw.x; + this.w = zw.y; + } + + /// Constructs a int4 vector from an int value, an int2 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4(int x, int2 yz, int w) + { + this.x = x; + this.y = yz.x; + this.z = yz.y; + this.w = w; + } + + /// Constructs a int4 vector from an int value and an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4(int x, int3 yzw) + { + this.x = x; + this.y = yzw.x; + this.z = yzw.y; + this.w = yzw.z; + } + + /// Constructs a int4 vector from an int2 vector and two int values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4(int2 xy, int z, int w) + { + this.x = xy.x; + this.y = xy.y; + this.z = z; + this.w = w; + } + + /// Constructs a int4 vector from two int2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4(int2 xy, int2 zw) + { + this.x = xy.x; + this.y = xy.y; + this.z = zw.x; + this.w = zw.y; + } + + /// Constructs a int4 vector from an int3 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4(int3 xyz, int w) + { + this.x = xyz.x; + this.y = xyz.y; + this.z = xyz.z; + this.w = w; + } + + /// Constructs a int4 vector from an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4(int4 xyzw) + { + this.x = xyzw.x; + this.y = xyzw.y; + this.z = xyzw.z; + this.w = xyzw.w; + } + + /// Constructs a int4 vector from a single int value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4(int v) + { + this.x = v; + this.y = v; + this.z = v; + this.w = v; + } + + /// Constructs a int4 vector from a single bool value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4(bool v) + { + this.x = v ? 1 : 0; + this.y = v ? 1 : 0; + this.z = v ? 1 : 0; + this.w = v ? 1 : 0; + } + + /// Constructs a int4 vector from a bool4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4(bool4 v) + { + this.x = v.x ? 1 : 0; + this.y = v.y ? 1 : 0; + this.z = v.z ? 1 : 0; + this.w = v.w ? 1 : 0; + } + + /// Constructs a int4 vector from a single uint value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4(uint v) + { + this.x = (int)v; + this.y = (int)v; + this.z = (int)v; + this.w = (int)v; + } + + /// Constructs a int4 vector from a uint4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4(uint4 v) + { + this.x = (int)v.x; + this.y = (int)v.y; + this.z = (int)v.z; + this.w = (int)v.w; + } + + /// Constructs a int4 vector from a single float value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4(float v) + { + this.x = (int)v; + this.y = (int)v; + this.z = (int)v; + this.w = (int)v; + } + + /// Constructs a int4 vector from a float4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4(float4 v) + { + this.x = (int)v.x; + this.y = (int)v.y; + this.z = (int)v.z; + this.w = (int)v.w; + } + + /// Constructs a int4 vector from a single double value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4(double v) + { + this.x = (int)v; + this.y = (int)v; + this.z = (int)v; + this.w = (int)v; + } + + /// Constructs a int4 vector from a double4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4(double4 v) + { + this.x = (int)v.x; + this.y = (int)v.y; + this.z = (int)v.z; + this.w = (int)v.w; + } + + + /// Implicitly converts a single int value to a int4 vector by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator int4(int v) { return new int4(v); } + + /// Explicitly converts a single bool value to a int4 vector by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4(bool v) { return new int4(v); } + + /// Explicitly converts a bool4 vector to a int4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4(bool4 v) { return new int4(v); } + + /// Explicitly converts a single uint value to a int4 vector by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4(uint v) { return new int4(v); } + + /// Explicitly converts a uint4 vector to a int4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4(uint4 v) { return new int4(v); } + + /// Explicitly converts a single float value to a int4 vector by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4(float v) { return new int4(v); } + + /// Explicitly converts a float4 vector to a int4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4(float4 v) { return new int4(v); } + + /// Explicitly converts a single double value to a int4 vector by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4(double v) { return new int4(v); } + + /// Explicitly converts a double4 vector to a int4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4(double4 v) { return new int4(v); } + + + /// Returns the result of a componentwise multiplication operation on two int4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator * (int4 lhs, int4 rhs) { return new int4 (lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z, lhs.w * rhs.w); } + + /// Returns the result of a componentwise multiplication operation on an int4 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator * (int4 lhs, int rhs) { return new int4 (lhs.x * rhs, lhs.y * rhs, lhs.z * rhs, lhs.w * rhs); } + + /// Returns the result of a componentwise multiplication operation on an int value and an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator * (int lhs, int4 rhs) { return new int4 (lhs * rhs.x, lhs * rhs.y, lhs * rhs.z, lhs * rhs.w); } + + + /// Returns the result of a componentwise addition operation on two int4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator + (int4 lhs, int4 rhs) { return new int4 (lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z, lhs.w + rhs.w); } + + /// Returns the result of a componentwise addition operation on an int4 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator + (int4 lhs, int rhs) { return new int4 (lhs.x + rhs, lhs.y + rhs, lhs.z + rhs, lhs.w + rhs); } + + /// Returns the result of a componentwise addition operation on an int value and an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator + (int lhs, int4 rhs) { return new int4 (lhs + rhs.x, lhs + rhs.y, lhs + rhs.z, lhs + rhs.w); } + + + /// Returns the result of a componentwise subtraction operation on two int4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator - (int4 lhs, int4 rhs) { return new int4 (lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z, lhs.w - rhs.w); } + + /// Returns the result of a componentwise subtraction operation on an int4 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator - (int4 lhs, int rhs) { return new int4 (lhs.x - rhs, lhs.y - rhs, lhs.z - rhs, lhs.w - rhs); } + + /// Returns the result of a componentwise subtraction operation on an int value and an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator - (int lhs, int4 rhs) { return new int4 (lhs - rhs.x, lhs - rhs.y, lhs - rhs.z, lhs - rhs.w); } + + + /// Returns the result of a componentwise division operation on two int4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator / (int4 lhs, int4 rhs) { return new int4 (lhs.x / rhs.x, lhs.y / rhs.y, lhs.z / rhs.z, lhs.w / rhs.w); } + + /// Returns the result of a componentwise division operation on an int4 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator / (int4 lhs, int rhs) { return new int4 (lhs.x / rhs, lhs.y / rhs, lhs.z / rhs, lhs.w / rhs); } + + /// Returns the result of a componentwise division operation on an int value and an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator / (int lhs, int4 rhs) { return new int4 (lhs / rhs.x, lhs / rhs.y, lhs / rhs.z, lhs / rhs.w); } + + + /// Returns the result of a componentwise modulus operation on two int4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator % (int4 lhs, int4 rhs) { return new int4 (lhs.x % rhs.x, lhs.y % rhs.y, lhs.z % rhs.z, lhs.w % rhs.w); } + + /// Returns the result of a componentwise modulus operation on an int4 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator % (int4 lhs, int rhs) { return new int4 (lhs.x % rhs, lhs.y % rhs, lhs.z % rhs, lhs.w % rhs); } + + /// Returns the result of a componentwise modulus operation on an int value and an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator % (int lhs, int4 rhs) { return new int4 (lhs % rhs.x, lhs % rhs.y, lhs % rhs.z, lhs % rhs.w); } + + + /// Returns the result of a componentwise increment operation on an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator ++ (int4 val) { return new int4 (++val.x, ++val.y, ++val.z, ++val.w); } + + + /// Returns the result of a componentwise decrement operation on an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator -- (int4 val) { return new int4 (--val.x, --val.y, --val.z, --val.w); } + + + /// Returns the result of a componentwise less than operation on two int4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator < (int4 lhs, int4 rhs) { return new bool4 (lhs.x < rhs.x, lhs.y < rhs.y, lhs.z < rhs.z, lhs.w < rhs.w); } + + /// Returns the result of a componentwise less than operation on an int4 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator < (int4 lhs, int rhs) { return new bool4 (lhs.x < rhs, lhs.y < rhs, lhs.z < rhs, lhs.w < rhs); } + + /// Returns the result of a componentwise less than operation on an int value and an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator < (int lhs, int4 rhs) { return new bool4 (lhs < rhs.x, lhs < rhs.y, lhs < rhs.z, lhs < rhs.w); } + + + /// Returns the result of a componentwise less or equal operation on two int4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator <= (int4 lhs, int4 rhs) { return new bool4 (lhs.x <= rhs.x, lhs.y <= rhs.y, lhs.z <= rhs.z, lhs.w <= rhs.w); } + + /// Returns the result of a componentwise less or equal operation on an int4 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator <= (int4 lhs, int rhs) { return new bool4 (lhs.x <= rhs, lhs.y <= rhs, lhs.z <= rhs, lhs.w <= rhs); } + + /// Returns the result of a componentwise less or equal operation on an int value and an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator <= (int lhs, int4 rhs) { return new bool4 (lhs <= rhs.x, lhs <= rhs.y, lhs <= rhs.z, lhs <= rhs.w); } + + + /// Returns the result of a componentwise greater than operation on two int4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator > (int4 lhs, int4 rhs) { return new bool4 (lhs.x > rhs.x, lhs.y > rhs.y, lhs.z > rhs.z, lhs.w > rhs.w); } + + /// Returns the result of a componentwise greater than operation on an int4 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator > (int4 lhs, int rhs) { return new bool4 (lhs.x > rhs, lhs.y > rhs, lhs.z > rhs, lhs.w > rhs); } + + /// Returns the result of a componentwise greater than operation on an int value and an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator > (int lhs, int4 rhs) { return new bool4 (lhs > rhs.x, lhs > rhs.y, lhs > rhs.z, lhs > rhs.w); } + + + /// Returns the result of a componentwise greater or equal operation on two int4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator >= (int4 lhs, int4 rhs) { return new bool4 (lhs.x >= rhs.x, lhs.y >= rhs.y, lhs.z >= rhs.z, lhs.w >= rhs.w); } + + /// Returns the result of a componentwise greater or equal operation on an int4 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator >= (int4 lhs, int rhs) { return new bool4 (lhs.x >= rhs, lhs.y >= rhs, lhs.z >= rhs, lhs.w >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on an int value and an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator >= (int lhs, int4 rhs) { return new bool4 (lhs >= rhs.x, lhs >= rhs.y, lhs >= rhs.z, lhs >= rhs.w); } + + + /// Returns the result of a componentwise unary minus operation on an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator - (int4 val) { return new int4 (-val.x, -val.y, -val.z, -val.w); } + + + /// Returns the result of a componentwise unary plus operation on an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator + (int4 val) { return new int4 (+val.x, +val.y, +val.z, +val.w); } + + + /// Returns the result of a componentwise left shift operation on an int4 vector by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator << (int4 x, int n) { return new int4 (x.x << n, x.y << n, x.z << n, x.w << n); } + + /// Returns the result of a componentwise right shift operation on an int4 vector by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator >> (int4 x, int n) { return new int4 (x.x >> n, x.y >> n, x.z >> n, x.w >> n); } + + /// Returns the result of a componentwise equality operation on two int4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator == (int4 lhs, int4 rhs) { return new bool4 (lhs.x == rhs.x, lhs.y == rhs.y, lhs.z == rhs.z, lhs.w == rhs.w); } + + /// Returns the result of a componentwise equality operation on an int4 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator == (int4 lhs, int rhs) { return new bool4 (lhs.x == rhs, lhs.y == rhs, lhs.z == rhs, lhs.w == rhs); } + + /// Returns the result of a componentwise equality operation on an int value and an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator == (int lhs, int4 rhs) { return new bool4 (lhs == rhs.x, lhs == rhs.y, lhs == rhs.z, lhs == rhs.w); } + + + /// Returns the result of a componentwise not equal operation on two int4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator != (int4 lhs, int4 rhs) { return new bool4 (lhs.x != rhs.x, lhs.y != rhs.y, lhs.z != rhs.z, lhs.w != rhs.w); } + + /// Returns the result of a componentwise not equal operation on an int4 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator != (int4 lhs, int rhs) { return new bool4 (lhs.x != rhs, lhs.y != rhs, lhs.z != rhs, lhs.w != rhs); } + + /// Returns the result of a componentwise not equal operation on an int value and an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 operator != (int lhs, int4 rhs) { return new bool4 (lhs != rhs.x, lhs != rhs.y, lhs != rhs.z, lhs != rhs.w); } + + + /// Returns the result of a componentwise bitwise not operation on an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator ~ (int4 val) { return new int4 (~val.x, ~val.y, ~val.z, ~val.w); } + + + /// Returns the result of a componentwise bitwise and operation on two int4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator & (int4 lhs, int4 rhs) { return new int4 (lhs.x & rhs.x, lhs.y & rhs.y, lhs.z & rhs.z, lhs.w & rhs.w); } + + /// Returns the result of a componentwise bitwise and operation on an int4 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator & (int4 lhs, int rhs) { return new int4 (lhs.x & rhs, lhs.y & rhs, lhs.z & rhs, lhs.w & rhs); } + + /// Returns the result of a componentwise bitwise and operation on an int value and an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator & (int lhs, int4 rhs) { return new int4 (lhs & rhs.x, lhs & rhs.y, lhs & rhs.z, lhs & rhs.w); } + + + /// Returns the result of a componentwise bitwise or operation on two int4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator | (int4 lhs, int4 rhs) { return new int4 (lhs.x | rhs.x, lhs.y | rhs.y, lhs.z | rhs.z, lhs.w | rhs.w); } + + /// Returns the result of a componentwise bitwise or operation on an int4 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator | (int4 lhs, int rhs) { return new int4 (lhs.x | rhs, lhs.y | rhs, lhs.z | rhs, lhs.w | rhs); } + + /// Returns the result of a componentwise bitwise or operation on an int value and an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator | (int lhs, int4 rhs) { return new int4 (lhs | rhs.x, lhs | rhs.y, lhs | rhs.z, lhs | rhs.w); } + + + /// Returns the result of a componentwise bitwise exclusive or operation on two int4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator ^ (int4 lhs, int4 rhs) { return new int4 (lhs.x ^ rhs.x, lhs.y ^ rhs.y, lhs.z ^ rhs.z, lhs.w ^ rhs.w); } + + /// Returns the result of a componentwise bitwise exclusive or operation on an int4 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator ^ (int4 lhs, int rhs) { return new int4 (lhs.x ^ rhs, lhs.y ^ rhs, lhs.z ^ rhs, lhs.w ^ rhs); } + + /// Returns the result of a componentwise bitwise exclusive or operation on an int value and an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 operator ^ (int lhs, int4 rhs) { return new int4 (lhs ^ rhs.x, lhs ^ rhs.y, lhs ^ rhs.z, lhs ^ rhs.w); } + + + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xxww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, x, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xyxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xyxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xyyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xyyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xyzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xyzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xyzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xyzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, z, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; y = value.y; z = value.z; w = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xywx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xywy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xywz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, w, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; y = value.y; w = value.z; z = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xyww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, y, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xzxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xzxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, z, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xzxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xzxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, z, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xzyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, z, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xzyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xzyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xzyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, z, y, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; z = value.y; y = value.z; w = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xzzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xzzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xzzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xzzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, z, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xzwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, z, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xzwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, z, w, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; z = value.y; w = value.z; y = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xzwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, z, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xzww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, z, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xwxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, w, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xwxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, w, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xwxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, w, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xwxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, w, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xwyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, w, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xwyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, w, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xwyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, w, y, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; w = value.y; y = value.z; z = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xwyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, w, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xwzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, w, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xwzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, w, z, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; w = value.y; z = value.z; y = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xwzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, w, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xwzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, w, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xwwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, w, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xwwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, w, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xwwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, w, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 xwww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(x, w, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, z, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; x = value.y; z = value.z; w = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, w, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; x = value.y; w = value.z; z = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yxww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, x, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yyxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yyxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yyyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yyyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yyzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yyzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yyzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yyzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yywx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yywy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yywz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yyww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, y, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yzxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yzxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, z, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yzxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yzxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, z, x, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; z = value.y; x = value.z; w = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yzyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, z, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yzyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yzyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yzyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, z, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yzzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yzzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yzzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yzzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, z, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yzwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, z, w, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; z = value.y; w = value.z; x = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yzwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, z, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yzwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, z, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 yzww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, z, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 ywxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, w, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 ywxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, w, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 ywxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, w, x, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; w = value.y; x = value.z; z = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 ywxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, w, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 ywyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, w, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 ywyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, w, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 ywyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, w, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 ywyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, w, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 ywzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, w, z, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; w = value.y; z = value.z; x = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 ywzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, w, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 ywzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, w, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 ywzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, w, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 ywwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, w, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 ywwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, w, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 ywwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, w, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 ywww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(y, w, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zxxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zxxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, x, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zxyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, x, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zxyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, x, y, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; x = value.y; y = value.z; w = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zxzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zxzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, x, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zxzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zxzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, x, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zxwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, x, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zxwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, x, w, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; x = value.y; w = value.z; y = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zxwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, x, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zxww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, x, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zyxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, y, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zyxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, y, x, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; y = value.y; x = value.z; w = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zyyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zyyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, y, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zyzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, y, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zyzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zyzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zyzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, y, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zywx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, y, w, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; y = value.y; w = value.z; x = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zywy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, y, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zywz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, y, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zyww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, y, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zzxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zzxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, z, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zzxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zzxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, z, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zzyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, z, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zzyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zzyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zzyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, z, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zzzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zzzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zzzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zzzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, z, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zzwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, z, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zzwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, z, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zzwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, z, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zzww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, z, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zwxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, w, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zwxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, w, x, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; w = value.y; x = value.z; y = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zwxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, w, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zwxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, w, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zwyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, w, y, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; w = value.y; y = value.z; x = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zwyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, w, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zwyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, w, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zwyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, w, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zwzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, w, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zwzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, w, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zwzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, w, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zwzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, w, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zwwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, w, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zwwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, w, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zwwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, w, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 zwww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(z, w, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wxxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wxxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wxxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wxxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, x, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wxyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wxyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wxyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, x, y, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; x = value.y; y = value.z; z = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wxyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, x, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wxzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wxzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, x, z, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; x = value.y; z = value.z; y = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wxzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wxzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, x, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wxwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, x, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wxwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, x, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wxwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, x, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wxww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, x, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wyxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wyxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wyxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, y, x, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; y = value.y; x = value.z; z = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wyxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, y, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wyyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wyyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wyyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wyyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, y, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wyzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, y, z, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; y = value.y; z = value.z; x = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wyzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wyzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wyzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, y, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wywx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, y, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wywy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, y, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wywz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, y, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wyww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, y, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wzxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wzxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, z, x, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; z = value.y; x = value.z; y = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wzxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wzxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, z, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wzyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, z, y, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; z = value.y; y = value.z; x = value.w; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wzyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wzyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wzyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, z, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wzzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wzzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wzzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wzzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, z, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wzwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, z, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wzwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, z, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wzwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, z, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wzww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, z, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wwxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, w, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wwxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, w, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wwxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, w, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wwxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, w, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wwyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, w, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wwyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, w, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wwyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, w, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wwyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, w, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wwzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, w, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wwzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, w, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wwzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, w, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wwzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, w, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wwwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, w, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wwwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, w, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wwwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, w, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int4 wwww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int4(w, w, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, y, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; y = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, y, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; y = value.y; w = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, z, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; z = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, z, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; z = value.y; w = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, w, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; w = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, w, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; w = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 xww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(x, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 yxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 yxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, x, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 yxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, x, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; x = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 yxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, x, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; x = value.y; w = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 yyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, y, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 yyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 yyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 yyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 yzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, z, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; z = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 yzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 yzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 yzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, z, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; z = value.y; w = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 ywx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, w, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; w = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 ywy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 ywz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, w, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; w = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 yww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(y, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 zxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(z, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 zxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(z, x, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; x = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 zxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(z, x, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 zxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(z, x, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; x = value.y; w = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 zyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(z, y, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; y = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 zyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(z, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 zyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(z, y, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 zyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(z, y, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; y = value.y; w = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 zzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(z, z, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 zzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(z, z, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 zzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(z, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 zzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(z, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 zwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(z, w, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; w = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 zwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(z, w, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; w = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 zwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(z, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 zww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(z, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 wxx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(w, x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 wxy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(w, x, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; x = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 wxz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(w, x, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; x = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 wxw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(w, x, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 wyx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(w, y, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; y = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 wyy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(w, y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 wyz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(w, y, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; y = value.y; z = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 wyw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(w, y, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 wzx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(w, z, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; z = value.y; x = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 wzy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(w, z, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; z = value.y; y = value.z; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 wzz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(w, z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 wzw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(w, z, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 wwx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(w, w, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 wwy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(w, w, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 wwz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(w, w, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int3 www + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int3(w, w, w); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 xx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(x, x); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 xy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(x, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; y = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 xz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(x, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; z = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 xw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(x, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { x = value.x; w = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 yx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(y, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; x = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 yy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(y, y); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 yz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(y, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; z = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 yw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(y, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { y = value.x; w = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 zx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(z, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; x = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 zy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(z, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; y = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 zz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(z, z); } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 zw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(z, w); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { z = value.x; w = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 wx + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(w, x); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; x = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 wy + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(w, y); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; y = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 wz + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(w, z); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + set { w = value.x; z = value.y; } + } + + + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + public int2 ww + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get { return new int2(w, w); } + } + + + + /// Returns the int element at a specified index. + unsafe public int this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 4) + throw new System.ArgumentException("index must be between[0...3]"); +#endif + fixed (int4* array = &this) { return ((int*)array)[index]; } + } + set + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 4) + throw new System.ArgumentException("index must be between[0...3]"); +#endif + fixed (int* array = &x) { array[index] = value; } + } + } + + /// Returns true if the int4 is equal to a given int4, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(int4 rhs) { return x == rhs.x && y == rhs.y && z == rhs.z && w == rhs.w; } + + /// Returns true if the int4 is equal to a given int4, false otherwise. + public override bool Equals(object o) { return Equals((int4)o); } + + + /// Returns a hash code for the int4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the int4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("int4({0}, {1}, {2}, {3})", x, y, z, w); + } + + /// Returns a string representation of the int4 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("int4({0}, {1}, {2}, {3})", x.ToString(format, formatProvider), y.ToString(format, formatProvider), z.ToString(format, formatProvider), w.ToString(format, formatProvider)); + } + + internal sealed class DebuggerProxy + { + public int x; + public int y; + public int z; + public int w; + public DebuggerProxy(int4 v) + { + x = v.x; + y = v.y; + z = v.z; + w = v.w; + } + } + + } + + public static partial class math + { + /// Returns a int4 vector constructed from four int values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 int4(int x, int y, int z, int w) { return new int4(x, y, z, w); } + + /// Returns a int4 vector constructed from two int values and an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 int4(int x, int y, int2 zw) { return new int4(x, y, zw); } + + /// Returns a int4 vector constructed from an int value, an int2 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 int4(int x, int2 yz, int w) { return new int4(x, yz, w); } + + /// Returns a int4 vector constructed from an int value and an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 int4(int x, int3 yzw) { return new int4(x, yzw); } + + /// Returns a int4 vector constructed from an int2 vector and two int values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 int4(int2 xy, int z, int w) { return new int4(xy, z, w); } + + /// Returns a int4 vector constructed from two int2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 int4(int2 xy, int2 zw) { return new int4(xy, zw); } + + /// Returns a int4 vector constructed from an int3 vector and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 int4(int3 xyz, int w) { return new int4(xyz, w); } + + /// Returns a int4 vector constructed from an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 int4(int4 xyzw) { return new int4(xyzw); } + + /// Returns a int4 vector constructed from a single int value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 int4(int v) { return new int4(v); } + + /// Returns a int4 vector constructed from a single bool value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 int4(bool v) { return new int4(v); } + + /// Return a int4 vector constructed from a bool4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 int4(bool4 v) { return new int4(v); } + + /// Returns a int4 vector constructed from a single uint value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 int4(uint v) { return new int4(v); } + + /// Return a int4 vector constructed from a uint4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 int4(uint4 v) { return new int4(v); } + + /// Returns a int4 vector constructed from a single float value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 int4(float v) { return new int4(v); } + + /// Return a int4 vector constructed from a float4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 int4(float4 v) { return new int4(v); } + + /// Returns a int4 vector constructed from a single double value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 int4(double v) { return new int4(v); } + + /// Return a int4 vector constructed from a double4 vector by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 int4(double4 v) { return new int4(v); } + + /// Returns a uint hash code of a int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(int4 v) + { + return csum(asuint(v) * uint4(0x6E050B01u, 0x750FDBF5u, 0x7F3DD499u, 0x52EAAEBBu)) + 0x4599C793u; + } + + /// + /// Returns a uint4 vector hash code of a int4 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 hashwide(int4 v) + { + return (asuint(v) * uint4(0x83B5E729u, 0xC267163Fu, 0x67BC9149u, 0xAD7C5EC1u)) + 0x822A7D6Du; + } + + /// Returns the result of specified shuffling of the components from two int4 vectors into an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int shuffle(int4 a, int4 b, ShuffleComponent x) + { + return select_shuffle_component(a, b, x); + } + + /// Returns the result of specified shuffling of the components from two int4 vectors into an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 shuffle(int4 a, int4 b, ShuffleComponent x, ShuffleComponent y) + { + return int2( + select_shuffle_component(a, b, x), + select_shuffle_component(a, b, y)); + } + + /// Returns the result of specified shuffling of the components from two int4 vectors into an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 shuffle(int4 a, int4 b, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z) + { + return int3( + select_shuffle_component(a, b, x), + select_shuffle_component(a, b, y), + select_shuffle_component(a, b, z)); + } + + /// Returns the result of specified shuffling of the components from two int4 vectors into an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 shuffle(int4 a, int4 b, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w) + { + return int4( + select_shuffle_component(a, b, x), + select_shuffle_component(a, b, y), + select_shuffle_component(a, b, z), + select_shuffle_component(a, b, w)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static int select_shuffle_component(int4 a, int4 b, ShuffleComponent component) + { + switch(component) + { + case ShuffleComponent.LeftX: + return a.x; + case ShuffleComponent.LeftY: + return a.y; + case ShuffleComponent.LeftZ: + return a.z; + case ShuffleComponent.LeftW: + return a.w; + case ShuffleComponent.RightX: + return b.x; + case ShuffleComponent.RightY: + return b.y; + case ShuffleComponent.RightZ: + return b.z; + case ShuffleComponent.RightW: + return b.w; + default: + throw new System.ArgumentException("Invalid shuffle component: " + component); + } + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int4.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int4.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..8e0ea81399eb731cb5c72d7b2f8920aa7d1c3cec --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int4.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 9057960b12f46654798f69c411172f73 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int4x2.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int4x2.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..d63d8143f18a6e3eb291aafa8e8160c27a19430e --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int4x2.gen.cs @@ -0,0 +1,497 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [System.Serializable] + public partial struct int4x2 : System.IEquatable, IFormattable + { + public int4 c0; + public int4 c1; + + /// int4x2 zero value. + public static readonly int4x2 zero; + + /// Constructs a int4x2 matrix from two int4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x2(int4 c0, int4 c1) + { + this.c0 = c0; + this.c1 = c1; + } + + /// Constructs a int4x2 matrix from 8 int values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x2(int m00, int m01, + int m10, int m11, + int m20, int m21, + int m30, int m31) + { + this.c0 = new int4(m00, m10, m20, m30); + this.c1 = new int4(m01, m11, m21, m31); + } + + /// Constructs a int4x2 matrix from a single int value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x2(int v) + { + this.c0 = v; + this.c1 = v; + } + + /// Constructs a int4x2 matrix from a single bool value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x2(bool v) + { + this.c0 = math.select(new int4(0), new int4(1), v); + this.c1 = math.select(new int4(0), new int4(1), v); + } + + /// Constructs a int4x2 matrix from a bool4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x2(bool4x2 v) + { + this.c0 = math.select(new int4(0), new int4(1), v.c0); + this.c1 = math.select(new int4(0), new int4(1), v.c1); + } + + /// Constructs a int4x2 matrix from a single uint value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x2(uint v) + { + this.c0 = (int4)v; + this.c1 = (int4)v; + } + + /// Constructs a int4x2 matrix from a uint4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x2(uint4x2 v) + { + this.c0 = (int4)v.c0; + this.c1 = (int4)v.c1; + } + + /// Constructs a int4x2 matrix from a single float value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x2(float v) + { + this.c0 = (int4)v; + this.c1 = (int4)v; + } + + /// Constructs a int4x2 matrix from a float4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x2(float4x2 v) + { + this.c0 = (int4)v.c0; + this.c1 = (int4)v.c1; + } + + /// Constructs a int4x2 matrix from a single double value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x2(double v) + { + this.c0 = (int4)v; + this.c1 = (int4)v; + } + + /// Constructs a int4x2 matrix from a double4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x2(double4x2 v) + { + this.c0 = (int4)v.c0; + this.c1 = (int4)v.c1; + } + + + /// Implicitly converts a single int value to a int4x2 matrix by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator int4x2(int v) { return new int4x2(v); } + + /// Explicitly converts a single bool value to a int4x2 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4x2(bool v) { return new int4x2(v); } + + /// Explicitly converts a bool4x2 matrix to a int4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4x2(bool4x2 v) { return new int4x2(v); } + + /// Explicitly converts a single uint value to a int4x2 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4x2(uint v) { return new int4x2(v); } + + /// Explicitly converts a uint4x2 matrix to a int4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4x2(uint4x2 v) { return new int4x2(v); } + + /// Explicitly converts a single float value to a int4x2 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4x2(float v) { return new int4x2(v); } + + /// Explicitly converts a float4x2 matrix to a int4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4x2(float4x2 v) { return new int4x2(v); } + + /// Explicitly converts a single double value to a int4x2 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4x2(double v) { return new int4x2(v); } + + /// Explicitly converts a double4x2 matrix to a int4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4x2(double4x2 v) { return new int4x2(v); } + + + /// Returns the result of a componentwise multiplication operation on two int4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator * (int4x2 lhs, int4x2 rhs) { return new int4x2 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1); } + + /// Returns the result of a componentwise multiplication operation on an int4x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator * (int4x2 lhs, int rhs) { return new int4x2 (lhs.c0 * rhs, lhs.c1 * rhs); } + + /// Returns the result of a componentwise multiplication operation on an int value and an int4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator * (int lhs, int4x2 rhs) { return new int4x2 (lhs * rhs.c0, lhs * rhs.c1); } + + + /// Returns the result of a componentwise addition operation on two int4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator + (int4x2 lhs, int4x2 rhs) { return new int4x2 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1); } + + /// Returns the result of a componentwise addition operation on an int4x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator + (int4x2 lhs, int rhs) { return new int4x2 (lhs.c0 + rhs, lhs.c1 + rhs); } + + /// Returns the result of a componentwise addition operation on an int value and an int4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator + (int lhs, int4x2 rhs) { return new int4x2 (lhs + rhs.c0, lhs + rhs.c1); } + + + /// Returns the result of a componentwise subtraction operation on two int4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator - (int4x2 lhs, int4x2 rhs) { return new int4x2 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1); } + + /// Returns the result of a componentwise subtraction operation on an int4x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator - (int4x2 lhs, int rhs) { return new int4x2 (lhs.c0 - rhs, lhs.c1 - rhs); } + + /// Returns the result of a componentwise subtraction operation on an int value and an int4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator - (int lhs, int4x2 rhs) { return new int4x2 (lhs - rhs.c0, lhs - rhs.c1); } + + + /// Returns the result of a componentwise division operation on two int4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator / (int4x2 lhs, int4x2 rhs) { return new int4x2 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1); } + + /// Returns the result of a componentwise division operation on an int4x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator / (int4x2 lhs, int rhs) { return new int4x2 (lhs.c0 / rhs, lhs.c1 / rhs); } + + /// Returns the result of a componentwise division operation on an int value and an int4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator / (int lhs, int4x2 rhs) { return new int4x2 (lhs / rhs.c0, lhs / rhs.c1); } + + + /// Returns the result of a componentwise modulus operation on two int4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator % (int4x2 lhs, int4x2 rhs) { return new int4x2 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1); } + + /// Returns the result of a componentwise modulus operation on an int4x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator % (int4x2 lhs, int rhs) { return new int4x2 (lhs.c0 % rhs, lhs.c1 % rhs); } + + /// Returns the result of a componentwise modulus operation on an int value and an int4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator % (int lhs, int4x2 rhs) { return new int4x2 (lhs % rhs.c0, lhs % rhs.c1); } + + + /// Returns the result of a componentwise increment operation on an int4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator ++ (int4x2 val) { return new int4x2 (++val.c0, ++val.c1); } + + + /// Returns the result of a componentwise decrement operation on an int4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator -- (int4x2 val) { return new int4x2 (--val.c0, --val.c1); } + + + /// Returns the result of a componentwise less than operation on two int4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator < (int4x2 lhs, int4x2 rhs) { return new bool4x2 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1); } + + /// Returns the result of a componentwise less than operation on an int4x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator < (int4x2 lhs, int rhs) { return new bool4x2 (lhs.c0 < rhs, lhs.c1 < rhs); } + + /// Returns the result of a componentwise less than operation on an int value and an int4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator < (int lhs, int4x2 rhs) { return new bool4x2 (lhs < rhs.c0, lhs < rhs.c1); } + + + /// Returns the result of a componentwise less or equal operation on two int4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator <= (int4x2 lhs, int4x2 rhs) { return new bool4x2 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1); } + + /// Returns the result of a componentwise less or equal operation on an int4x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator <= (int4x2 lhs, int rhs) { return new bool4x2 (lhs.c0 <= rhs, lhs.c1 <= rhs); } + + /// Returns the result of a componentwise less or equal operation on an int value and an int4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator <= (int lhs, int4x2 rhs) { return new bool4x2 (lhs <= rhs.c0, lhs <= rhs.c1); } + + + /// Returns the result of a componentwise greater than operation on two int4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator > (int4x2 lhs, int4x2 rhs) { return new bool4x2 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1); } + + /// Returns the result of a componentwise greater than operation on an int4x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator > (int4x2 lhs, int rhs) { return new bool4x2 (lhs.c0 > rhs, lhs.c1 > rhs); } + + /// Returns the result of a componentwise greater than operation on an int value and an int4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator > (int lhs, int4x2 rhs) { return new bool4x2 (lhs > rhs.c0, lhs > rhs.c1); } + + + /// Returns the result of a componentwise greater or equal operation on two int4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator >= (int4x2 lhs, int4x2 rhs) { return new bool4x2 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1); } + + /// Returns the result of a componentwise greater or equal operation on an int4x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator >= (int4x2 lhs, int rhs) { return new bool4x2 (lhs.c0 >= rhs, lhs.c1 >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on an int value and an int4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator >= (int lhs, int4x2 rhs) { return new bool4x2 (lhs >= rhs.c0, lhs >= rhs.c1); } + + + /// Returns the result of a componentwise unary minus operation on an int4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator - (int4x2 val) { return new int4x2 (-val.c0, -val.c1); } + + + /// Returns the result of a componentwise unary plus operation on an int4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator + (int4x2 val) { return new int4x2 (+val.c0, +val.c1); } + + + /// Returns the result of a componentwise left shift operation on an int4x2 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator << (int4x2 x, int n) { return new int4x2 (x.c0 << n, x.c1 << n); } + + /// Returns the result of a componentwise right shift operation on an int4x2 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator >> (int4x2 x, int n) { return new int4x2 (x.c0 >> n, x.c1 >> n); } + + /// Returns the result of a componentwise equality operation on two int4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator == (int4x2 lhs, int4x2 rhs) { return new bool4x2 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1); } + + /// Returns the result of a componentwise equality operation on an int4x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator == (int4x2 lhs, int rhs) { return new bool4x2 (lhs.c0 == rhs, lhs.c1 == rhs); } + + /// Returns the result of a componentwise equality operation on an int value and an int4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator == (int lhs, int4x2 rhs) { return new bool4x2 (lhs == rhs.c0, lhs == rhs.c1); } + + + /// Returns the result of a componentwise not equal operation on two int4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator != (int4x2 lhs, int4x2 rhs) { return new bool4x2 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1); } + + /// Returns the result of a componentwise not equal operation on an int4x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator != (int4x2 lhs, int rhs) { return new bool4x2 (lhs.c0 != rhs, lhs.c1 != rhs); } + + /// Returns the result of a componentwise not equal operation on an int value and an int4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x2 operator != (int lhs, int4x2 rhs) { return new bool4x2 (lhs != rhs.c0, lhs != rhs.c1); } + + + /// Returns the result of a componentwise bitwise not operation on an int4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator ~ (int4x2 val) { return new int4x2 (~val.c0, ~val.c1); } + + + /// Returns the result of a componentwise bitwise and operation on two int4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator & (int4x2 lhs, int4x2 rhs) { return new int4x2 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1); } + + /// Returns the result of a componentwise bitwise and operation on an int4x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator & (int4x2 lhs, int rhs) { return new int4x2 (lhs.c0 & rhs, lhs.c1 & rhs); } + + /// Returns the result of a componentwise bitwise and operation on an int value and an int4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator & (int lhs, int4x2 rhs) { return new int4x2 (lhs & rhs.c0, lhs & rhs.c1); } + + + /// Returns the result of a componentwise bitwise or operation on two int4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator | (int4x2 lhs, int4x2 rhs) { return new int4x2 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1); } + + /// Returns the result of a componentwise bitwise or operation on an int4x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator | (int4x2 lhs, int rhs) { return new int4x2 (lhs.c0 | rhs, lhs.c1 | rhs); } + + /// Returns the result of a componentwise bitwise or operation on an int value and an int4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator | (int lhs, int4x2 rhs) { return new int4x2 (lhs | rhs.c0, lhs | rhs.c1); } + + + /// Returns the result of a componentwise bitwise exclusive or operation on two int4x2 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator ^ (int4x2 lhs, int4x2 rhs) { return new int4x2 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1); } + + /// Returns the result of a componentwise bitwise exclusive or operation on an int4x2 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator ^ (int4x2 lhs, int rhs) { return new int4x2 (lhs.c0 ^ rhs, lhs.c1 ^ rhs); } + + /// Returns the result of a componentwise bitwise exclusive or operation on an int value and an int4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 operator ^ (int lhs, int4x2 rhs) { return new int4x2 (lhs ^ rhs.c0, lhs ^ rhs.c1); } + + + + /// Returns the int4 element at a specified index. + unsafe public ref int4 this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 2) + throw new System.ArgumentException("index must be between[0...1]"); +#endif + fixed (int4x2* array = &this) { return ref ((int4*)array)[index]; } + } + } + + /// Returns true if the int4x2 is equal to a given int4x2, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(int4x2 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1); } + + /// Returns true if the int4x2 is equal to a given int4x2, false otherwise. + public override bool Equals(object o) { return Equals((int4x2)o); } + + + /// Returns a hash code for the int4x2. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the int4x2. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("int4x2({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7})", c0.x, c1.x, c0.y, c1.y, c0.z, c1.z, c0.w, c1.w); + } + + /// Returns a string representation of the int4x2 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("int4x2({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider), c0.w.ToString(format, formatProvider), c1.w.ToString(format, formatProvider)); + } + + } + + public static partial class math + { + /// Returns a int4x2 matrix constructed from two int4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 int4x2(int4 c0, int4 c1) { return new int4x2(c0, c1); } + + /// Returns a int4x2 matrix constructed from from 8 int values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 int4x2(int m00, int m01, + int m10, int m11, + int m20, int m21, + int m30, int m31) + { + return new int4x2(m00, m01, + m10, m11, + m20, m21, + m30, m31); + } + + /// Returns a int4x2 matrix constructed from a single int value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 int4x2(int v) { return new int4x2(v); } + + /// Returns a int4x2 matrix constructed from a single bool value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 int4x2(bool v) { return new int4x2(v); } + + /// Return a int4x2 matrix constructed from a bool4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 int4x2(bool4x2 v) { return new int4x2(v); } + + /// Returns a int4x2 matrix constructed from a single uint value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 int4x2(uint v) { return new int4x2(v); } + + /// Return a int4x2 matrix constructed from a uint4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 int4x2(uint4x2 v) { return new int4x2(v); } + + /// Returns a int4x2 matrix constructed from a single float value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 int4x2(float v) { return new int4x2(v); } + + /// Return a int4x2 matrix constructed from a float4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 int4x2(float4x2 v) { return new int4x2(v); } + + /// Returns a int4x2 matrix constructed from a single double value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 int4x2(double v) { return new int4x2(v); } + + /// Return a int4x2 matrix constructed from a double4x2 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 int4x2(double4x2 v) { return new int4x2(v); } + + /// Return the int2x4 transpose of a int4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 transpose(int4x2 v) + { + return int2x4( + v.c0.x, v.c0.y, v.c0.z, v.c0.w, + v.c1.x, v.c1.y, v.c1.z, v.c1.w); + } + + /// Returns a uint hash code of a int4x2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(int4x2 v) + { + return csum(asuint(v.c0) * uint4(0xFAAF07DDu, 0x625C45BDu, 0xC9F27FCBu, 0x6D2523B1u) + + asuint(v.c1) * uint4(0x6E2BF6A9u, 0xCC74B3B7u, 0x83B58237u, 0x833E3E29u)) + 0xA9D919BFu; + } + + /// + /// Returns a uint4 vector hash code of a int4x2 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 hashwide(int4x2 v) + { + return (asuint(v.c0) * uint4(0xC3EC1D97u, 0xB8B208C7u, 0x5D3ED947u, 0x4473BBB1u) + + asuint(v.c1) * uint4(0xCBA11D5Fu, 0x685835CFu, 0xC3D32AE1u, 0xB966942Fu)) + 0xFE9856B3u; + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int4x2.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int4x2.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..e974efe5a860ee7366a49e7c1daf5ce33d200701 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int4x2.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: ca7cf71984bec4b9081416653621d6df +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int4x3.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int4x3.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..5d5c55b8aba876c0da97692dd2495b924d4ff7c4 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int4x3.gen.cs @@ -0,0 +1,512 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [System.Serializable] + public partial struct int4x3 : System.IEquatable, IFormattable + { + public int4 c0; + public int4 c1; + public int4 c2; + + /// int4x3 zero value. + public static readonly int4x3 zero; + + /// Constructs a int4x3 matrix from three int4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x3(int4 c0, int4 c1, int4 c2) + { + this.c0 = c0; + this.c1 = c1; + this.c2 = c2; + } + + /// Constructs a int4x3 matrix from 12 int values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x3(int m00, int m01, int m02, + int m10, int m11, int m12, + int m20, int m21, int m22, + int m30, int m31, int m32) + { + this.c0 = new int4(m00, m10, m20, m30); + this.c1 = new int4(m01, m11, m21, m31); + this.c2 = new int4(m02, m12, m22, m32); + } + + /// Constructs a int4x3 matrix from a single int value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x3(int v) + { + this.c0 = v; + this.c1 = v; + this.c2 = v; + } + + /// Constructs a int4x3 matrix from a single bool value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x3(bool v) + { + this.c0 = math.select(new int4(0), new int4(1), v); + this.c1 = math.select(new int4(0), new int4(1), v); + this.c2 = math.select(new int4(0), new int4(1), v); + } + + /// Constructs a int4x3 matrix from a bool4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x3(bool4x3 v) + { + this.c0 = math.select(new int4(0), new int4(1), v.c0); + this.c1 = math.select(new int4(0), new int4(1), v.c1); + this.c2 = math.select(new int4(0), new int4(1), v.c2); + } + + /// Constructs a int4x3 matrix from a single uint value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x3(uint v) + { + this.c0 = (int4)v; + this.c1 = (int4)v; + this.c2 = (int4)v; + } + + /// Constructs a int4x3 matrix from a uint4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x3(uint4x3 v) + { + this.c0 = (int4)v.c0; + this.c1 = (int4)v.c1; + this.c2 = (int4)v.c2; + } + + /// Constructs a int4x3 matrix from a single float value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x3(float v) + { + this.c0 = (int4)v; + this.c1 = (int4)v; + this.c2 = (int4)v; + } + + /// Constructs a int4x3 matrix from a float4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x3(float4x3 v) + { + this.c0 = (int4)v.c0; + this.c1 = (int4)v.c1; + this.c2 = (int4)v.c2; + } + + /// Constructs a int4x3 matrix from a single double value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x3(double v) + { + this.c0 = (int4)v; + this.c1 = (int4)v; + this.c2 = (int4)v; + } + + /// Constructs a int4x3 matrix from a double4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x3(double4x3 v) + { + this.c0 = (int4)v.c0; + this.c1 = (int4)v.c1; + this.c2 = (int4)v.c2; + } + + + /// Implicitly converts a single int value to a int4x3 matrix by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator int4x3(int v) { return new int4x3(v); } + + /// Explicitly converts a single bool value to a int4x3 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4x3(bool v) { return new int4x3(v); } + + /// Explicitly converts a bool4x3 matrix to a int4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4x3(bool4x3 v) { return new int4x3(v); } + + /// Explicitly converts a single uint value to a int4x3 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4x3(uint v) { return new int4x3(v); } + + /// Explicitly converts a uint4x3 matrix to a int4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4x3(uint4x3 v) { return new int4x3(v); } + + /// Explicitly converts a single float value to a int4x3 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4x3(float v) { return new int4x3(v); } + + /// Explicitly converts a float4x3 matrix to a int4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4x3(float4x3 v) { return new int4x3(v); } + + /// Explicitly converts a single double value to a int4x3 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4x3(double v) { return new int4x3(v); } + + /// Explicitly converts a double4x3 matrix to a int4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4x3(double4x3 v) { return new int4x3(v); } + + + /// Returns the result of a componentwise multiplication operation on two int4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator * (int4x3 lhs, int4x3 rhs) { return new int4x3 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2); } + + /// Returns the result of a componentwise multiplication operation on an int4x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator * (int4x3 lhs, int rhs) { return new int4x3 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs); } + + /// Returns the result of a componentwise multiplication operation on an int value and an int4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator * (int lhs, int4x3 rhs) { return new int4x3 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2); } + + + /// Returns the result of a componentwise addition operation on two int4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator + (int4x3 lhs, int4x3 rhs) { return new int4x3 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2); } + + /// Returns the result of a componentwise addition operation on an int4x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator + (int4x3 lhs, int rhs) { return new int4x3 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs); } + + /// Returns the result of a componentwise addition operation on an int value and an int4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator + (int lhs, int4x3 rhs) { return new int4x3 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2); } + + + /// Returns the result of a componentwise subtraction operation on two int4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator - (int4x3 lhs, int4x3 rhs) { return new int4x3 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2); } + + /// Returns the result of a componentwise subtraction operation on an int4x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator - (int4x3 lhs, int rhs) { return new int4x3 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs); } + + /// Returns the result of a componentwise subtraction operation on an int value and an int4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator - (int lhs, int4x3 rhs) { return new int4x3 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2); } + + + /// Returns the result of a componentwise division operation on two int4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator / (int4x3 lhs, int4x3 rhs) { return new int4x3 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2); } + + /// Returns the result of a componentwise division operation on an int4x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator / (int4x3 lhs, int rhs) { return new int4x3 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs); } + + /// Returns the result of a componentwise division operation on an int value and an int4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator / (int lhs, int4x3 rhs) { return new int4x3 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2); } + + + /// Returns the result of a componentwise modulus operation on two int4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator % (int4x3 lhs, int4x3 rhs) { return new int4x3 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2); } + + /// Returns the result of a componentwise modulus operation on an int4x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator % (int4x3 lhs, int rhs) { return new int4x3 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs); } + + /// Returns the result of a componentwise modulus operation on an int value and an int4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator % (int lhs, int4x3 rhs) { return new int4x3 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2); } + + + /// Returns the result of a componentwise increment operation on an int4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator ++ (int4x3 val) { return new int4x3 (++val.c0, ++val.c1, ++val.c2); } + + + /// Returns the result of a componentwise decrement operation on an int4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator -- (int4x3 val) { return new int4x3 (--val.c0, --val.c1, --val.c2); } + + + /// Returns the result of a componentwise less than operation on two int4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator < (int4x3 lhs, int4x3 rhs) { return new bool4x3 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2); } + + /// Returns the result of a componentwise less than operation on an int4x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator < (int4x3 lhs, int rhs) { return new bool4x3 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs); } + + /// Returns the result of a componentwise less than operation on an int value and an int4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator < (int lhs, int4x3 rhs) { return new bool4x3 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2); } + + + /// Returns the result of a componentwise less or equal operation on two int4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator <= (int4x3 lhs, int4x3 rhs) { return new bool4x3 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2); } + + /// Returns the result of a componentwise less or equal operation on an int4x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator <= (int4x3 lhs, int rhs) { return new bool4x3 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs); } + + /// Returns the result of a componentwise less or equal operation on an int value and an int4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator <= (int lhs, int4x3 rhs) { return new bool4x3 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2); } + + + /// Returns the result of a componentwise greater than operation on two int4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator > (int4x3 lhs, int4x3 rhs) { return new bool4x3 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2); } + + /// Returns the result of a componentwise greater than operation on an int4x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator > (int4x3 lhs, int rhs) { return new bool4x3 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs); } + + /// Returns the result of a componentwise greater than operation on an int value and an int4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator > (int lhs, int4x3 rhs) { return new bool4x3 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2); } + + + /// Returns the result of a componentwise greater or equal operation on two int4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator >= (int4x3 lhs, int4x3 rhs) { return new bool4x3 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2); } + + /// Returns the result of a componentwise greater or equal operation on an int4x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator >= (int4x3 lhs, int rhs) { return new bool4x3 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on an int value and an int4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator >= (int lhs, int4x3 rhs) { return new bool4x3 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2); } + + + /// Returns the result of a componentwise unary minus operation on an int4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator - (int4x3 val) { return new int4x3 (-val.c0, -val.c1, -val.c2); } + + + /// Returns the result of a componentwise unary plus operation on an int4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator + (int4x3 val) { return new int4x3 (+val.c0, +val.c1, +val.c2); } + + + /// Returns the result of a componentwise left shift operation on an int4x3 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator << (int4x3 x, int n) { return new int4x3 (x.c0 << n, x.c1 << n, x.c2 << n); } + + /// Returns the result of a componentwise right shift operation on an int4x3 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator >> (int4x3 x, int n) { return new int4x3 (x.c0 >> n, x.c1 >> n, x.c2 >> n); } + + /// Returns the result of a componentwise equality operation on two int4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator == (int4x3 lhs, int4x3 rhs) { return new bool4x3 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2); } + + /// Returns the result of a componentwise equality operation on an int4x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator == (int4x3 lhs, int rhs) { return new bool4x3 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs); } + + /// Returns the result of a componentwise equality operation on an int value and an int4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator == (int lhs, int4x3 rhs) { return new bool4x3 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2); } + + + /// Returns the result of a componentwise not equal operation on two int4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator != (int4x3 lhs, int4x3 rhs) { return new bool4x3 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2); } + + /// Returns the result of a componentwise not equal operation on an int4x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator != (int4x3 lhs, int rhs) { return new bool4x3 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs); } + + /// Returns the result of a componentwise not equal operation on an int value and an int4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x3 operator != (int lhs, int4x3 rhs) { return new bool4x3 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2); } + + + /// Returns the result of a componentwise bitwise not operation on an int4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator ~ (int4x3 val) { return new int4x3 (~val.c0, ~val.c1, ~val.c2); } + + + /// Returns the result of a componentwise bitwise and operation on two int4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator & (int4x3 lhs, int4x3 rhs) { return new int4x3 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1, lhs.c2 & rhs.c2); } + + /// Returns the result of a componentwise bitwise and operation on an int4x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator & (int4x3 lhs, int rhs) { return new int4x3 (lhs.c0 & rhs, lhs.c1 & rhs, lhs.c2 & rhs); } + + /// Returns the result of a componentwise bitwise and operation on an int value and an int4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator & (int lhs, int4x3 rhs) { return new int4x3 (lhs & rhs.c0, lhs & rhs.c1, lhs & rhs.c2); } + + + /// Returns the result of a componentwise bitwise or operation on two int4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator | (int4x3 lhs, int4x3 rhs) { return new int4x3 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1, lhs.c2 | rhs.c2); } + + /// Returns the result of a componentwise bitwise or operation on an int4x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator | (int4x3 lhs, int rhs) { return new int4x3 (lhs.c0 | rhs, lhs.c1 | rhs, lhs.c2 | rhs); } + + /// Returns the result of a componentwise bitwise or operation on an int value and an int4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator | (int lhs, int4x3 rhs) { return new int4x3 (lhs | rhs.c0, lhs | rhs.c1, lhs | rhs.c2); } + + + /// Returns the result of a componentwise bitwise exclusive or operation on two int4x3 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator ^ (int4x3 lhs, int4x3 rhs) { return new int4x3 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1, lhs.c2 ^ rhs.c2); } + + /// Returns the result of a componentwise bitwise exclusive or operation on an int4x3 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator ^ (int4x3 lhs, int rhs) { return new int4x3 (lhs.c0 ^ rhs, lhs.c1 ^ rhs, lhs.c2 ^ rhs); } + + /// Returns the result of a componentwise bitwise exclusive or operation on an int value and an int4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 operator ^ (int lhs, int4x3 rhs) { return new int4x3 (lhs ^ rhs.c0, lhs ^ rhs.c1, lhs ^ rhs.c2); } + + + + /// Returns the int4 element at a specified index. + unsafe public ref int4 this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 3) + throw new System.ArgumentException("index must be between[0...2]"); +#endif + fixed (int4x3* array = &this) { return ref ((int4*)array)[index]; } + } + } + + /// Returns true if the int4x3 is equal to a given int4x3, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(int4x3 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2); } + + /// Returns true if the int4x3 is equal to a given int4x3, false otherwise. + public override bool Equals(object o) { return Equals((int4x3)o); } + + + /// Returns a hash code for the int4x3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the int4x3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("int4x3({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11})", c0.x, c1.x, c2.x, c0.y, c1.y, c2.y, c0.z, c1.z, c2.z, c0.w, c1.w, c2.w); + } + + /// Returns a string representation of the int4x3 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("int4x3({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider), c2.z.ToString(format, formatProvider), c0.w.ToString(format, formatProvider), c1.w.ToString(format, formatProvider), c2.w.ToString(format, formatProvider)); + } + + } + + public static partial class math + { + /// Returns a int4x3 matrix constructed from three int4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 int4x3(int4 c0, int4 c1, int4 c2) { return new int4x3(c0, c1, c2); } + + /// Returns a int4x3 matrix constructed from from 12 int values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 int4x3(int m00, int m01, int m02, + int m10, int m11, int m12, + int m20, int m21, int m22, + int m30, int m31, int m32) + { + return new int4x3(m00, m01, m02, + m10, m11, m12, + m20, m21, m22, + m30, m31, m32); + } + + /// Returns a int4x3 matrix constructed from a single int value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 int4x3(int v) { return new int4x3(v); } + + /// Returns a int4x3 matrix constructed from a single bool value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 int4x3(bool v) { return new int4x3(v); } + + /// Return a int4x3 matrix constructed from a bool4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 int4x3(bool4x3 v) { return new int4x3(v); } + + /// Returns a int4x3 matrix constructed from a single uint value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 int4x3(uint v) { return new int4x3(v); } + + /// Return a int4x3 matrix constructed from a uint4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 int4x3(uint4x3 v) { return new int4x3(v); } + + /// Returns a int4x3 matrix constructed from a single float value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 int4x3(float v) { return new int4x3(v); } + + /// Return a int4x3 matrix constructed from a float4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 int4x3(float4x3 v) { return new int4x3(v); } + + /// Returns a int4x3 matrix constructed from a single double value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 int4x3(double v) { return new int4x3(v); } + + /// Return a int4x3 matrix constructed from a double4x3 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 int4x3(double4x3 v) { return new int4x3(v); } + + /// Return the int3x4 transpose of a int4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 transpose(int4x3 v) + { + return int3x4( + v.c0.x, v.c0.y, v.c0.z, v.c0.w, + v.c1.x, v.c1.y, v.c1.z, v.c1.w, + v.c2.x, v.c2.y, v.c2.z, v.c2.w); + } + + /// Returns a uint hash code of a int4x3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(int4x3 v) + { + return csum(asuint(v.c0) * uint4(0x69B60C81u, 0xE0EB6C25u, 0xF648BEABu, 0x6BDB2B07u) + + asuint(v.c1) * uint4(0xEF63C699u, 0x9001903Fu, 0xA895B9CDu, 0x9D23B201u) + + asuint(v.c2) * uint4(0x4B01D3E1u, 0x7461CA0Du, 0x79725379u, 0xD6258E5Bu)) + 0xEE390C97u; + } + + /// + /// Returns a uint4 vector hash code of a int4x3 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 hashwide(int4x3 v) + { + return (asuint(v.c0) * uint4(0x9C8A2F05u, 0x4DDC6509u, 0x7CF083CBu, 0x5C4D6CEDu) + + asuint(v.c1) * uint4(0xF9137117u, 0xE857DCE1u, 0xF62213C5u, 0x9CDAA959u) + + asuint(v.c2) * uint4(0xAA269ABFu, 0xD54BA36Fu, 0xFD0847B9u, 0x8189A683u)) + 0xB139D651u; + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int4x3.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int4x3.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..f6d07ecbd8f6cd21636f75252b751e5f7bb4ca08 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int4x3.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 625f7c407b9c1474bbfcb1c17db16571 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int4x4.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int4x4.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..2125aac96f636338e9f9b19da9eed8a758c8043f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int4x4.gen.cs @@ -0,0 +1,546 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + [System.Serializable] + public partial struct int4x4 : System.IEquatable, IFormattable + { + public int4 c0; + public int4 c1; + public int4 c2; + public int4 c3; + + /// int4x4 identity transform. + public static readonly int4x4 identity = new int4x4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1); + + /// int4x4 zero value. + public static readonly int4x4 zero; + + /// Constructs a int4x4 matrix from four int4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x4(int4 c0, int4 c1, int4 c2, int4 c3) + { + this.c0 = c0; + this.c1 = c1; + this.c2 = c2; + this.c3 = c3; + } + + /// Constructs a int4x4 matrix from 16 int values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x4(int m00, int m01, int m02, int m03, + int m10, int m11, int m12, int m13, + int m20, int m21, int m22, int m23, + int m30, int m31, int m32, int m33) + { + this.c0 = new int4(m00, m10, m20, m30); + this.c1 = new int4(m01, m11, m21, m31); + this.c2 = new int4(m02, m12, m22, m32); + this.c3 = new int4(m03, m13, m23, m33); + } + + /// Constructs a int4x4 matrix from a single int value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x4(int v) + { + this.c0 = v; + this.c1 = v; + this.c2 = v; + this.c3 = v; + } + + /// Constructs a int4x4 matrix from a single bool value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x4(bool v) + { + this.c0 = math.select(new int4(0), new int4(1), v); + this.c1 = math.select(new int4(0), new int4(1), v); + this.c2 = math.select(new int4(0), new int4(1), v); + this.c3 = math.select(new int4(0), new int4(1), v); + } + + /// Constructs a int4x4 matrix from a bool4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x4(bool4x4 v) + { + this.c0 = math.select(new int4(0), new int4(1), v.c0); + this.c1 = math.select(new int4(0), new int4(1), v.c1); + this.c2 = math.select(new int4(0), new int4(1), v.c2); + this.c3 = math.select(new int4(0), new int4(1), v.c3); + } + + /// Constructs a int4x4 matrix from a single uint value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x4(uint v) + { + this.c0 = (int4)v; + this.c1 = (int4)v; + this.c2 = (int4)v; + this.c3 = (int4)v; + } + + /// Constructs a int4x4 matrix from a uint4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x4(uint4x4 v) + { + this.c0 = (int4)v.c0; + this.c1 = (int4)v.c1; + this.c2 = (int4)v.c2; + this.c3 = (int4)v.c3; + } + + /// Constructs a int4x4 matrix from a single float value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x4(float v) + { + this.c0 = (int4)v; + this.c1 = (int4)v; + this.c2 = (int4)v; + this.c3 = (int4)v; + } + + /// Constructs a int4x4 matrix from a float4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x4(float4x4 v) + { + this.c0 = (int4)v.c0; + this.c1 = (int4)v.c1; + this.c2 = (int4)v.c2; + this.c3 = (int4)v.c3; + } + + /// Constructs a int4x4 matrix from a single double value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x4(double v) + { + this.c0 = (int4)v; + this.c1 = (int4)v; + this.c2 = (int4)v; + this.c3 = (int4)v; + } + + /// Constructs a int4x4 matrix from a double4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4x4(double4x4 v) + { + this.c0 = (int4)v.c0; + this.c1 = (int4)v.c1; + this.c2 = (int4)v.c2; + this.c3 = (int4)v.c3; + } + + + /// Implicitly converts a single int value to a int4x4 matrix by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator int4x4(int v) { return new int4x4(v); } + + /// Explicitly converts a single bool value to a int4x4 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4x4(bool v) { return new int4x4(v); } + + /// Explicitly converts a bool4x4 matrix to a int4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4x4(bool4x4 v) { return new int4x4(v); } + + /// Explicitly converts a single uint value to a int4x4 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4x4(uint v) { return new int4x4(v); } + + /// Explicitly converts a uint4x4 matrix to a int4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4x4(uint4x4 v) { return new int4x4(v); } + + /// Explicitly converts a single float value to a int4x4 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4x4(float v) { return new int4x4(v); } + + /// Explicitly converts a float4x4 matrix to a int4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4x4(float4x4 v) { return new int4x4(v); } + + /// Explicitly converts a single double value to a int4x4 matrix by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4x4(double v) { return new int4x4(v); } + + /// Explicitly converts a double4x4 matrix to a int4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static explicit operator int4x4(double4x4 v) { return new int4x4(v); } + + + /// Returns the result of a componentwise multiplication operation on two int4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator * (int4x4 lhs, int4x4 rhs) { return new int4x4 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2, lhs.c3 * rhs.c3); } + + /// Returns the result of a componentwise multiplication operation on an int4x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator * (int4x4 lhs, int rhs) { return new int4x4 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs, lhs.c3 * rhs); } + + /// Returns the result of a componentwise multiplication operation on an int value and an int4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator * (int lhs, int4x4 rhs) { return new int4x4 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2, lhs * rhs.c3); } + + + /// Returns the result of a componentwise addition operation on two int4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator + (int4x4 lhs, int4x4 rhs) { return new int4x4 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2, lhs.c3 + rhs.c3); } + + /// Returns the result of a componentwise addition operation on an int4x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator + (int4x4 lhs, int rhs) { return new int4x4 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs, lhs.c3 + rhs); } + + /// Returns the result of a componentwise addition operation on an int value and an int4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator + (int lhs, int4x4 rhs) { return new int4x4 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2, lhs + rhs.c3); } + + + /// Returns the result of a componentwise subtraction operation on two int4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator - (int4x4 lhs, int4x4 rhs) { return new int4x4 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2, lhs.c3 - rhs.c3); } + + /// Returns the result of a componentwise subtraction operation on an int4x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator - (int4x4 lhs, int rhs) { return new int4x4 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs, lhs.c3 - rhs); } + + /// Returns the result of a componentwise subtraction operation on an int value and an int4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator - (int lhs, int4x4 rhs) { return new int4x4 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2, lhs - rhs.c3); } + + + /// Returns the result of a componentwise division operation on two int4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator / (int4x4 lhs, int4x4 rhs) { return new int4x4 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2, lhs.c3 / rhs.c3); } + + /// Returns the result of a componentwise division operation on an int4x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator / (int4x4 lhs, int rhs) { return new int4x4 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs, lhs.c3 / rhs); } + + /// Returns the result of a componentwise division operation on an int value and an int4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator / (int lhs, int4x4 rhs) { return new int4x4 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2, lhs / rhs.c3); } + + + /// Returns the result of a componentwise modulus operation on two int4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator % (int4x4 lhs, int4x4 rhs) { return new int4x4 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2, lhs.c3 % rhs.c3); } + + /// Returns the result of a componentwise modulus operation on an int4x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator % (int4x4 lhs, int rhs) { return new int4x4 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs, lhs.c3 % rhs); } + + /// Returns the result of a componentwise modulus operation on an int value and an int4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator % (int lhs, int4x4 rhs) { return new int4x4 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2, lhs % rhs.c3); } + + + /// Returns the result of a componentwise increment operation on an int4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator ++ (int4x4 val) { return new int4x4 (++val.c0, ++val.c1, ++val.c2, ++val.c3); } + + + /// Returns the result of a componentwise decrement operation on an int4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator -- (int4x4 val) { return new int4x4 (--val.c0, --val.c1, --val.c2, --val.c3); } + + + /// Returns the result of a componentwise less than operation on two int4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator < (int4x4 lhs, int4x4 rhs) { return new bool4x4 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2, lhs.c3 < rhs.c3); } + + /// Returns the result of a componentwise less than operation on an int4x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator < (int4x4 lhs, int rhs) { return new bool4x4 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs, lhs.c3 < rhs); } + + /// Returns the result of a componentwise less than operation on an int value and an int4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator < (int lhs, int4x4 rhs) { return new bool4x4 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2, lhs < rhs.c3); } + + + /// Returns the result of a componentwise less or equal operation on two int4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator <= (int4x4 lhs, int4x4 rhs) { return new bool4x4 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2, lhs.c3 <= rhs.c3); } + + /// Returns the result of a componentwise less or equal operation on an int4x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator <= (int4x4 lhs, int rhs) { return new bool4x4 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs, lhs.c3 <= rhs); } + + /// Returns the result of a componentwise less or equal operation on an int value and an int4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator <= (int lhs, int4x4 rhs) { return new bool4x4 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2, lhs <= rhs.c3); } + + + /// Returns the result of a componentwise greater than operation on two int4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator > (int4x4 lhs, int4x4 rhs) { return new bool4x4 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2, lhs.c3 > rhs.c3); } + + /// Returns the result of a componentwise greater than operation on an int4x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator > (int4x4 lhs, int rhs) { return new bool4x4 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs, lhs.c3 > rhs); } + + /// Returns the result of a componentwise greater than operation on an int value and an int4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator > (int lhs, int4x4 rhs) { return new bool4x4 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2, lhs > rhs.c3); } + + + /// Returns the result of a componentwise greater or equal operation on two int4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator >= (int4x4 lhs, int4x4 rhs) { return new bool4x4 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2, lhs.c3 >= rhs.c3); } + + /// Returns the result of a componentwise greater or equal operation on an int4x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator >= (int4x4 lhs, int rhs) { return new bool4x4 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs, lhs.c3 >= rhs); } + + /// Returns the result of a componentwise greater or equal operation on an int value and an int4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator >= (int lhs, int4x4 rhs) { return new bool4x4 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2, lhs >= rhs.c3); } + + + /// Returns the result of a componentwise unary minus operation on an int4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator - (int4x4 val) { return new int4x4 (-val.c0, -val.c1, -val.c2, -val.c3); } + + + /// Returns the result of a componentwise unary plus operation on an int4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator + (int4x4 val) { return new int4x4 (+val.c0, +val.c1, +val.c2, +val.c3); } + + + /// Returns the result of a componentwise left shift operation on an int4x4 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator << (int4x4 x, int n) { return new int4x4 (x.c0 << n, x.c1 << n, x.c2 << n, x.c3 << n); } + + /// Returns the result of a componentwise right shift operation on an int4x4 matrix by a number of bits specified by a single int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator >> (int4x4 x, int n) { return new int4x4 (x.c0 >> n, x.c1 >> n, x.c2 >> n, x.c3 >> n); } + + /// Returns the result of a componentwise equality operation on two int4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator == (int4x4 lhs, int4x4 rhs) { return new bool4x4 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2, lhs.c3 == rhs.c3); } + + /// Returns the result of a componentwise equality operation on an int4x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator == (int4x4 lhs, int rhs) { return new bool4x4 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs, lhs.c3 == rhs); } + + /// Returns the result of a componentwise equality operation on an int value and an int4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator == (int lhs, int4x4 rhs) { return new bool4x4 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2, lhs == rhs.c3); } + + + /// Returns the result of a componentwise not equal operation on two int4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator != (int4x4 lhs, int4x4 rhs) { return new bool4x4 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2, lhs.c3 != rhs.c3); } + + /// Returns the result of a componentwise not equal operation on an int4x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator != (int4x4 lhs, int rhs) { return new bool4x4 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs, lhs.c3 != rhs); } + + /// Returns the result of a componentwise not equal operation on an int value and an int4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4x4 operator != (int lhs, int4x4 rhs) { return new bool4x4 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2, lhs != rhs.c3); } + + + /// Returns the result of a componentwise bitwise not operation on an int4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator ~ (int4x4 val) { return new int4x4 (~val.c0, ~val.c1, ~val.c2, ~val.c3); } + + + /// Returns the result of a componentwise bitwise and operation on two int4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator & (int4x4 lhs, int4x4 rhs) { return new int4x4 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1, lhs.c2 & rhs.c2, lhs.c3 & rhs.c3); } + + /// Returns the result of a componentwise bitwise and operation on an int4x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator & (int4x4 lhs, int rhs) { return new int4x4 (lhs.c0 & rhs, lhs.c1 & rhs, lhs.c2 & rhs, lhs.c3 & rhs); } + + /// Returns the result of a componentwise bitwise and operation on an int value and an int4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator & (int lhs, int4x4 rhs) { return new int4x4 (lhs & rhs.c0, lhs & rhs.c1, lhs & rhs.c2, lhs & rhs.c3); } + + + /// Returns the result of a componentwise bitwise or operation on two int4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator | (int4x4 lhs, int4x4 rhs) { return new int4x4 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1, lhs.c2 | rhs.c2, lhs.c3 | rhs.c3); } + + /// Returns the result of a componentwise bitwise or operation on an int4x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator | (int4x4 lhs, int rhs) { return new int4x4 (lhs.c0 | rhs, lhs.c1 | rhs, lhs.c2 | rhs, lhs.c3 | rhs); } + + /// Returns the result of a componentwise bitwise or operation on an int value and an int4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator | (int lhs, int4x4 rhs) { return new int4x4 (lhs | rhs.c0, lhs | rhs.c1, lhs | rhs.c2, lhs | rhs.c3); } + + + /// Returns the result of a componentwise bitwise exclusive or operation on two int4x4 matrices. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator ^ (int4x4 lhs, int4x4 rhs) { return new int4x4 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1, lhs.c2 ^ rhs.c2, lhs.c3 ^ rhs.c3); } + + /// Returns the result of a componentwise bitwise exclusive or operation on an int4x4 matrix and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator ^ (int4x4 lhs, int rhs) { return new int4x4 (lhs.c0 ^ rhs, lhs.c1 ^ rhs, lhs.c2 ^ rhs, lhs.c3 ^ rhs); } + + /// Returns the result of a componentwise bitwise exclusive or operation on an int value and an int4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 operator ^ (int lhs, int4x4 rhs) { return new int4x4 (lhs ^ rhs.c0, lhs ^ rhs.c1, lhs ^ rhs.c2, lhs ^ rhs.c3); } + + + + /// Returns the int4 element at a specified index. + unsafe public ref int4 this[int index] + { + get + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if ((uint)index >= 4) + throw new System.ArgumentException("index must be between[0...3]"); +#endif + fixed (int4x4* array = &this) { return ref ((int4*)array)[index]; } + } + } + + /// Returns true if the int4x4 is equal to a given int4x4, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(int4x4 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2) && c3.Equals(rhs.c3); } + + /// Returns true if the int4x4 is equal to a given int4x4, false otherwise. + public override bool Equals(object o) { return Equals((int4x4)o); } + + + /// Returns a hash code for the int4x4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + + /// Returns a string representation of the int4x4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("int4x4({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11}, {12}, {13}, {14}, {15})", c0.x, c1.x, c2.x, c3.x, c0.y, c1.y, c2.y, c3.y, c0.z, c1.z, c2.z, c3.z, c0.w, c1.w, c2.w, c3.w); + } + + /// Returns a string representation of the int4x4 using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("int4x4({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11}, {12}, {13}, {14}, {15})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c3.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider), c3.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider), c2.z.ToString(format, formatProvider), c3.z.ToString(format, formatProvider), c0.w.ToString(format, formatProvider), c1.w.ToString(format, formatProvider), c2.w.ToString(format, formatProvider), c3.w.ToString(format, formatProvider)); + } + + } + + public static partial class math + { + /// Returns a int4x4 matrix constructed from four int4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 int4x4(int4 c0, int4 c1, int4 c2, int4 c3) { return new int4x4(c0, c1, c2, c3); } + + /// Returns a int4x4 matrix constructed from from 16 int values given in row-major order. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 int4x4(int m00, int m01, int m02, int m03, + int m10, int m11, int m12, int m13, + int m20, int m21, int m22, int m23, + int m30, int m31, int m32, int m33) + { + return new int4x4(m00, m01, m02, m03, + m10, m11, m12, m13, + m20, m21, m22, m23, + m30, m31, m32, m33); + } + + /// Returns a int4x4 matrix constructed from a single int value by assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 int4x4(int v) { return new int4x4(v); } + + /// Returns a int4x4 matrix constructed from a single bool value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 int4x4(bool v) { return new int4x4(v); } + + /// Return a int4x4 matrix constructed from a bool4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 int4x4(bool4x4 v) { return new int4x4(v); } + + /// Returns a int4x4 matrix constructed from a single uint value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 int4x4(uint v) { return new int4x4(v); } + + /// Return a int4x4 matrix constructed from a uint4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 int4x4(uint4x4 v) { return new int4x4(v); } + + /// Returns a int4x4 matrix constructed from a single float value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 int4x4(float v) { return new int4x4(v); } + + /// Return a int4x4 matrix constructed from a float4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 int4x4(float4x4 v) { return new int4x4(v); } + + /// Returns a int4x4 matrix constructed from a single double value by converting it to int and assigning it to every component. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 int4x4(double v) { return new int4x4(v); } + + /// Return a int4x4 matrix constructed from a double4x4 matrix by componentwise conversion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 int4x4(double4x4 v) { return new int4x4(v); } + + /// Return the int4x4 transpose of a int4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 transpose(int4x4 v) + { + return int4x4( + v.c0.x, v.c0.y, v.c0.z, v.c0.w, + v.c1.x, v.c1.y, v.c1.z, v.c1.w, + v.c2.x, v.c2.y, v.c2.z, v.c2.w, + v.c3.x, v.c3.y, v.c3.z, v.c3.w); + } + + /// Returns the determinant of a int4x4 matrix. + public static int determinant(int4x4 m) + { + int4 c0 = m.c0; + int4 c1 = m.c1; + int4 c2 = m.c2; + int4 c3 = m.c3; + + int m00 = c1.y * (c2.z * c3.w - c2.w * c3.z) - c2.y * (c1.z * c3.w - c1.w * c3.z) + c3.y * (c1.z * c2.w - c1.w * c2.z); + int m01 = c0.y * (c2.z * c3.w - c2.w * c3.z) - c2.y * (c0.z * c3.w - c0.w * c3.z) + c3.y * (c0.z * c2.w - c0.w * c2.z); + int m02 = c0.y * (c1.z * c3.w - c1.w * c3.z) - c1.y * (c0.z * c3.w - c0.w * c3.z) + c3.y * (c0.z * c1.w - c0.w * c1.z); + int m03 = c0.y * (c1.z * c2.w - c1.w * c2.z) - c1.y * (c0.z * c2.w - c0.w * c2.z) + c2.y * (c0.z * c1.w - c0.w * c1.z); + + return c0.x * m00 - c1.x * m01 + c2.x * m02 - c3.x * m03; + } + + /// Returns a uint hash code of a int4x4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(int4x4 v) + { + return csum(asuint(v.c0) * uint4(0x5D1B165Bu, 0x87096CD7u, 0x4C7F6DD1u, 0x4822A3E9u) + + asuint(v.c1) * uint4(0xAAC3C25Du, 0xD21D0945u, 0x88FCAB2Du, 0x614DA60Du) + + asuint(v.c2) * uint4(0x5BA2C50Bu, 0x8C455ACBu, 0xCD266C89u, 0xF1852A33u) + + asuint(v.c3) * uint4(0x77E35E77u, 0x863E3729u, 0xE191B035u, 0x68586FAFu)) + 0xD4DFF6D3u; + } + + /// + /// Returns a uint4 vector hash code of a int4x4 vector. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 hashwide(int4x4 v) + { + return (asuint(v.c0) * uint4(0xCB634F4Du, 0x9B13B92Du, 0x4ABF0813u, 0x86068063u) + + asuint(v.c1) * uint4(0xD75513F9u, 0x5AB3E8CDu, 0x676E8407u, 0xB36DE767u) + + asuint(v.c2) * uint4(0x6FCA387Du, 0xAF0F3103u, 0xE4A056C7u, 0x841D8225u) + + asuint(v.c3) * uint4(0xC9393C7Du, 0xD42EAFA3u, 0xD9AFD06Du, 0x97A65421u)) + 0x7809205Fu; + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int4x4.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int4x4.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..25bcfbf3966b701fbfccd65764ce12f5c8b5b366 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/int4x4.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 4d606f419b22349e1a0d1d639bdfac05 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/math.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/math.cs new file mode 100644 index 0000000000000000000000000000000000000000..bf84dbdb7813fdd8fc31a52644b3e0c8b32e8557 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/math.cs @@ -0,0 +1,3470 @@ +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; + +namespace Unity.Mathematics +{ + public static partial class math + { + /// Extrinsic rotation order. Specifies in which order rotations around the principal axes (x, y and z) are to be applied. + public enum RotationOrder : byte + { + /// Extrinsic rotation around the x axis, then around the y axis and finally around the z axis. + XYZ, + /// Extrinsic rotation around the x axis, then around the z axis and finally around the y axis. + XZY, + /// Extrinsic rotation around the y axis, then around the x axis and finally around the z axis. + YXZ, + /// Extrinsic rotation around the y axis, then around the z axis and finally around the x axis. + YZX, + /// Extrinsic rotation around the z axis, then around the x axis and finally around the y axis. + ZXY, + /// Extrinsic rotation around the z axis, then around the y axis and finally around the x axis. + ZYX, + /// Unity default rotation order. Extrinsic Rotation around the z axis, then around the x axis and finally around the y axis. + Default = ZXY + }; + + /// Specifies a shuffle component. + public enum ShuffleComponent : byte + { + /// Specified the x component of the left vector. + LeftX, + /// Specified the y component of the left vector. + LeftY, + /// Specified the z component of the left vector. + LeftZ, + /// Specified the w component of the left vector. + LeftW, + + /// Specified the x component of the right vector. + RightX, + /// Specified the y component of the right vector. + RightY, + /// Specified the z component of the right vector. + RightZ, + /// Specified the w component of the right vector. + RightW + }; + + /// The mathematical constant e also known as Euler's number. Approximately 2.72. This is a f64/double precision constant. + public const double E_DBL = 2.71828182845904523536; + + /// The base 2 logarithm of e. Approximately 1.44. This is a f64/double precision constant. + public const double LOG2E_DBL = 1.44269504088896340736; + + /// The base 10 logarithm of e. Approximately 0.43. This is a f64/double precision constant. + public const double LOG10E_DBL = 0.434294481903251827651; + + /// The natural logarithm of 2. Approximately 0.69. This is a f64/double precision constant. + public const double LN2_DBL = 0.693147180559945309417; + + /// The natural logarithm of 10. Approximately 2.30. This is a f64/double precision constant. + public const double LN10_DBL = 2.30258509299404568402; + + /// The mathematical constant pi. Approximately 3.14. This is a f64/double precision constant. + public const double PI_DBL = 3.14159265358979323846; + + /// The square root 2. Approximately 1.41. This is a f64/double precision constant. + public const double SQRT2_DBL = 1.41421356237309504880; + + /// The smallest positive normal number representable in a float. + public const float FLT_MIN_NORMAL = 1.175494351e-38F; + + /// The smallest positive normal number representable in a double. This is a f64/double precision constant. + public const double DBL_MIN_NORMAL = 2.2250738585072014e-308; + + /// The mathematical constant e also known as Euler's number. Approximately 2.72. + public const float E = (float)E_DBL; + + /// The base 2 logarithm of e. Approximately 1.44. + public const float LOG2E = (float)LOG2E_DBL; + + /// The base 10 logarithm of e. Approximately 0.43. + public const float LOG10E = (float)LOG10E_DBL; + + /// The natural logarithm of 2. Approximately 0.69. + public const float LN2 = (float)LN2_DBL; + + /// The natural logarithm of 10. Approximately 2.30. + public const float LN10 = (float)LN10_DBL; + + /// The mathematical constant pi. Approximately 3.14. + public const float PI = (float)PI_DBL; + + /// The square root 2. Approximately 1.41. + public const float SQRT2 = (float)SQRT2_DBL; + + /// Returns the bit pattern of a uint as an int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int asint(uint x) { return (int)x; } + + /// Returns the bit pattern of a uint2 as an int2. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 asint(uint2 x) { return int2((int)x.x, (int)x.y); } + + /// Returns the bit pattern of a uint3 as an int3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 asint(uint3 x) { return int3((int)x.x, (int)x.y, (int)x.z); } + + /// Returns the bit pattern of a uint4 as an int4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 asint(uint4 x) { return int4((int)x.x, (int)x.y, (int)x.z, (int)x.w); } + + + /// Returns the bit pattern of a float as an int. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int asint(float x) { + IntFloatUnion u; + u.intValue = 0; + u.floatValue = x; + return u.intValue; + } + + /// Returns the bit pattern of a float2 as an int2. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 asint(float2 x) { return int2(asint(x.x), asint(x.y)); } + + /// Returns the bit pattern of a float3 as an int3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 asint(float3 x) { return int3(asint(x.x), asint(x.y), asint(x.z)); } + + /// Returns the bit pattern of a float4 as an int4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 asint(float4 x) { return int4(asint(x.x), asint(x.y), asint(x.z), asint(x.w)); } + + + /// Returns the bit pattern of an int as a uint. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint asuint(int x) { return (uint)x; } + + /// Returns the bit pattern of an int2 as a uint2. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2 asuint(int2 x) { return uint2((uint)x.x, (uint)x.y); } + + /// Returns the bit pattern of an int3 as a uint3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 asuint(int3 x) { return uint3((uint)x.x, (uint)x.y, (uint)x.z); } + + /// Returns the bit pattern of an int4 as a uint4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 asuint(int4 x) { return uint4((uint)x.x, (uint)x.y, (uint)x.z, (uint)x.w); } + + + /// Returns the bit pattern of a float as a uint. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint asuint(float x) { return (uint)asint(x); } + + /// Returns the bit pattern of a float2 as a uint2. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2 asuint(float2 x) { return uint2(asuint(x.x), asuint(x.y)); } + + /// Returns the bit pattern of a float3 as a uint3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 asuint(float3 x) { return uint3(asuint(x.x), asuint(x.y), asuint(x.z)); } + + /// Returns the bit pattern of a float4 as a uint4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 asuint(float4 x) { return uint4(asuint(x.x), asuint(x.y), asuint(x.z), asuint(x.w)); } + + + /// Returns the bit pattern of a ulong as a long. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static long aslong(ulong x) { return (long)x; } + + /// Returns the bit pattern of a double as a long. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static long aslong(double x) + { + LongDoubleUnion u; + u.longValue = 0; + u.doubleValue = x; + return u.longValue; + } + + + /// Returns the bit pattern of a long as a ulong. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static ulong asulong(long x) { return (ulong)x; } + + /// Returns the bit pattern of a double as a ulong. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static ulong asulong(double x) { return (ulong) aslong(x); } + + + /// Returns the bit pattern of an int as a float. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float asfloat(int x) + { + IntFloatUnion u; + u.floatValue = 0; + u.intValue = x; + + return u.floatValue; + } + + /// Returns the bit pattern of an int2 as a float2. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 asfloat(int2 x) { return float2(asfloat(x.x), asfloat(x.y)); } + + /// Returns the bit pattern of an int3 as a float3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 asfloat(int3 x) { return float3(asfloat(x.x), asfloat(x.y), asfloat(x.z)); } + + /// Returns the bit pattern of an int4 as a float4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 asfloat(int4 x) { return float4(asfloat(x.x), asfloat(x.y), asfloat(x.z), asfloat(x.w)); } + + + /// Returns the bit pattern of a uint as a float. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float asfloat(uint x) { return asfloat((int)x); } + + /// Returns the bit pattern of a uint2 as a float2. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 asfloat(uint2 x) { return float2(asfloat(x.x), asfloat(x.y)); } + + /// Returns the bit pattern of a uint3 as a float3. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 asfloat(uint3 x) { return float3(asfloat(x.x), asfloat(x.y), asfloat(x.z)); } + + /// Returns the bit pattern of a uint4 as a float4. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 asfloat(uint4 x) { return float4(asfloat(x.x), asfloat(x.y), asfloat(x.z), asfloat(x.w)); } + + /// + /// Returns a bitmask representation of a bool4. Storing one 1 bit per component + /// in LSB order, from lower to higher bits (so 4 bits in total). + /// The component x is stored at bit 0, + /// The component y is stored at bit 1, + /// The component z is stored at bit 2, + /// The component w is stored at bit 3 + /// The bool4(x = true, y = true, z = false, w = true) would produce the value 1011 = 0xB + /// + /// The input bool4 to calculate the bitmask for + /// A bitmask representation of the bool4, in LSB order + public static int bitmask(bool4 value) + { + int mask = 0; + if (value.x) mask |= 0x01; + if (value.y) mask |= 0x02; + if (value.z) mask |= 0x04; + if (value.w) mask |= 0x08; + return mask; + } + + /// Returns the bit pattern of a long as a double. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double asdouble(long x) + { + LongDoubleUnion u; + u.doubleValue = 0; + u.longValue = x; + return u.doubleValue; + } + + + /// Returns the bit pattern of a ulong as a double. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double asdouble(ulong x) { return asdouble((long)x); } + + + /// Returns true if the input float is a finite floating point value, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool isfinite(float x) { return abs(x) < float.PositiveInfinity; } + + /// Returns a bool2 indicating for each component of a float2 whether it is a finite floating point value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 isfinite(float2 x) { return abs(x) < float.PositiveInfinity; } + + /// Returns a bool3 indicating for each component of a float3 whether it is a finite floating point value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 isfinite(float3 x) { return abs(x) < float.PositiveInfinity; } + + /// Returns a bool4 indicating for each component of a float4 whether it is a finite floating point value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 isfinite(float4 x) { return abs(x) < float.PositiveInfinity; } + + + /// Returns true if the input double is a finite floating point value, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool isfinite(double x) { return abs(x) < double.PositiveInfinity; } + + /// Returns a bool2 indicating for each component of a double2 whether it is a finite floating point value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 isfinite(double2 x) { return abs(x) < double.PositiveInfinity; } + + /// Returns a bool3 indicating for each component of a double3 whether it is a finite floating point value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 isfinite(double3 x) { return abs(x) < double.PositiveInfinity; } + + /// Returns a bool4 indicating for each component of a double4 whether it is a finite floating point value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 isfinite(double4 x) { return abs(x) < double.PositiveInfinity; } + + + /// Returns true if the input float is an infinite floating point value, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool isinf(float x) { return abs(x) == float.PositiveInfinity; } + + /// Returns a bool2 indicating for each component of a float2 whether it is an infinite floating point value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 isinf(float2 x) { return abs(x) == float.PositiveInfinity; } + + /// Returns a bool3 indicating for each component of a float3 whether it is an infinite floating point value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 isinf(float3 x) { return abs(x) == float.PositiveInfinity; } + + /// Returns a bool4 indicating for each component of a float4 whether it is an infinite floating point value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 isinf(float4 x) { return abs(x) == float.PositiveInfinity; } + + /// Returns true if the input double is an infinite floating point value, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool isinf(double x) { return abs(x) == double.PositiveInfinity; } + + /// Returns a bool2 indicating for each component of a double2 whether it is an infinite floating point value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 isinf(double2 x) { return abs(x) == double.PositiveInfinity; } + + /// Returns a bool3 indicating for each component of a double3 whether it is an infinite floating point value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 isinf(double3 x) { return abs(x) == double.PositiveInfinity; } + + /// Returns a bool4 indicating for each component of a double4 whether it is an infinite floating point value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 isinf(double4 x) { return abs(x) == double.PositiveInfinity; } + + + /// Returns true if the input float is a NaN (not a number) floating point value, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool isnan(float x) { return (asuint(x) & 0x7FFFFFFF) > 0x7F800000; } + + /// Returns a bool2 indicating for each component of a float2 whether it is a NaN (not a number) floating point value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 isnan(float2 x) { return (asuint(x) & 0x7FFFFFFF) > 0x7F800000; } + + /// Returns a bool3 indicating for each component of a float3 whether it is a NaN (not a number) floating point value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 isnan(float3 x) { return (asuint(x) & 0x7FFFFFFF) > 0x7F800000; } + + /// Returns a bool4 indicating for each component of a float4 whether it is a NaN (not a number) floating point value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 isnan(float4 x) { return (asuint(x) & 0x7FFFFFFF) > 0x7F800000; } + + + /// Returns true if the input double is a NaN (not a number) floating point value, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool isnan(double x) { return (asulong(x) & 0x7FFFFFFFFFFFFFFF) > 0x7FF0000000000000; } + + /// Returns a bool2 indicating for each component of a double2 whether it is a NaN (not a number) floating point value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool2 isnan(double2 x) { + return bool2((asulong(x.x) & 0x7FFFFFFFFFFFFFFF) > 0x7FF0000000000000, + (asulong(x.y) & 0x7FFFFFFFFFFFFFFF) > 0x7FF0000000000000); + } + + /// Returns a bool3 indicating for each component of a double3 whether it is a NaN (not a number) floating point value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool3 isnan(double3 x) + { + return bool3((asulong(x.x) & 0x7FFFFFFFFFFFFFFF) > 0x7FF0000000000000, + (asulong(x.y) & 0x7FFFFFFFFFFFFFFF) > 0x7FF0000000000000, + (asulong(x.z) & 0x7FFFFFFFFFFFFFFF) > 0x7FF0000000000000); + } + + /// Returns a bool4 indicating for each component of a double4 whether it is a NaN (not a number) floating point value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool4 isnan(double4 x) + { + return bool4((asulong(x.x) & 0x7FFFFFFFFFFFFFFF) > 0x7FF0000000000000, + (asulong(x.y) & 0x7FFFFFFFFFFFFFFF) > 0x7FF0000000000000, + (asulong(x.z) & 0x7FFFFFFFFFFFFFFF) > 0x7FF0000000000000, + (asulong(x.w) & 0x7FFFFFFFFFFFFFFF) > 0x7FF0000000000000); + } + + + /// Returns the minimum of two int values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int min(int x, int y) { return x < y ? x : y; } + + /// Returns the componentwise minimum of two int2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 min(int2 x, int2 y) { return new int2(min(x.x, y.x), min(x.y, y.y)); } + + /// Returns the componentwise minimum of two int3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 min(int3 x, int3 y) { return new int3(min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)); } + + /// Returns the componentwise minimum of two int4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 min(int4 x, int4 y) { return new int4(min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)); } + + + /// Returns the minimum of two uint values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint min(uint x, uint y) { return x < y ? x : y; } + + /// Returns the componentwise minimum of two uint2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2 min(uint2 x, uint2 y) { return new uint2(min(x.x, y.x), min(x.y, y.y)); } + + /// Returns the componentwise minimum of two uint3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 min(uint3 x, uint3 y) { return new uint3(min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)); } + + /// Returns the componentwise minimum of two uint4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 min(uint4 x, uint4 y) { return new uint4(min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)); } + + + /// Returns the minimum of two long values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static long min(long x, long y) { return x < y ? x : y; } + + + /// Returns the minimum of two ulong values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static ulong min(ulong x, ulong y) { return x < y ? x : y; } + + + /// Returns the minimum of two float values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float min(float x, float y) { return float.IsNaN(y) || x < y ? x : y; } + + /// Returns the componentwise minimum of two float2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 min(float2 x, float2 y) { return new float2(min(x.x, y.x), min(x.y, y.y)); } + + /// Returns the componentwise minimum of two float3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 min(float3 x, float3 y) { return new float3(min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)); } + + /// Returns the componentwise minimum of two float4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 min(float4 x, float4 y) { return new float4(min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)); } + + + /// Returns the minimum of two double values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double min(double x, double y) { return double.IsNaN(y) || x < y ? x : y; } + + /// Returns the componentwise minimum of two double2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2 min(double2 x, double2 y) { return new double2(min(x.x, y.x), min(x.y, y.y)); } + + /// Returns the componentwise minimum of two double3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3 min(double3 x, double3 y) { return new double3(min(x.x, y.x), min(x.y, y.y), min(x.z, y.z)); } + + /// Returns the componentwise minimum of two double4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4 min(double4 x, double4 y) { return new double4(min(x.x, y.x), min(x.y, y.y), min(x.z, y.z), min(x.w, y.w)); } + + + /// Returns the maximum of two int values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int max(int x, int y) { return x > y ? x : y; } + + /// Returns the componentwise maximum of two int2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 max(int2 x, int2 y) { return new int2(max(x.x, y.x), max(x.y, y.y)); } + + /// Returns the componentwise maximum of two int3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 max(int3 x, int3 y) { return new int3(max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)); } + + /// Returns the componentwise maximum of two int4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 max(int4 x, int4 y) { return new int4(max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)); } + + + /// Returns the maximum of two uint values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint max(uint x, uint y) { return x > y ? x : y; } + + /// Returns the componentwise maximum of two uint2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2 max(uint2 x, uint2 y) { return new uint2(max(x.x, y.x), max(x.y, y.y)); } + + /// Returns the componentwise maximum of two uint3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 max(uint3 x, uint3 y) { return new uint3(max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)); } + + /// Returns the componentwise maximum of two uint4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 max(uint4 x, uint4 y) { return new uint4(max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)); } + + + /// Returns the maximum of two long values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static long max(long x, long y) { return x > y ? x : y; } + + + /// Returns the maximum of two ulong values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static ulong max(ulong x, ulong y) { return x > y ? x : y; } + + + /// Returns the maximum of two float values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float max(float x, float y) { return float.IsNaN(y) || x > y ? x : y; } + + /// Returns the componentwise maximum of two float2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 max(float2 x, float2 y) { return new float2(max(x.x, y.x), max(x.y, y.y)); } + + /// Returns the componentwise maximum of two float3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 max(float3 x, float3 y) { return new float3(max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)); } + + /// Returns the componentwise maximum of two float4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 max(float4 x, float4 y) { return new float4(max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)); } + + + /// Returns the maximum of two double values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double max(double x, double y) { return double.IsNaN(y) || x > y ? x : y; } + + /// Returns the componentwise maximum of two double2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2 max(double2 x, double2 y) { return new double2(max(x.x, y.x), max(x.y, y.y)); } + + /// Returns the componentwise maximum of two double3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3 max(double3 x, double3 y) { return new double3(max(x.x, y.x), max(x.y, y.y), max(x.z, y.z)); } + + /// Returns the componentwise maximum of two double4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4 max(double4 x, double4 y) { return new double4(max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)); } + + + /// Returns the result of linearly interpolating from x to y using the interpolation parameter s. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float lerp(float x, float y, float s) { return x + s * (y - x); } + + /// Returns the result of a componentwise linear interpolating from x to y using the interpolation parameter s. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 lerp(float2 x, float2 y, float s) { return x + s * (y - x); } + + /// Returns the result of a componentwise linear interpolating from x to y using the interpolation parameter s. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 lerp(float3 x, float3 y, float s) { return x + s * (y - x); } + + /// Returns the result of a componentwise linear interpolating from x to y using the interpolation parameter s. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 lerp(float4 x, float4 y, float s) { return x + s * (y - x); } + + + /// Returns the result of a componentwise linear interpolating from x to y using the corresponding components of the interpolation parameter s. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 lerp(float2 x, float2 y, float2 s) { return x + s * (y - x); } + + /// Returns the result of a componentwise linear interpolating from x to y using the corresponding components of the interpolation parameter s. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 lerp(float3 x, float3 y, float3 s) { return x + s * (y - x); } + + /// Returns the result of a componentwise linear interpolating from x to y using the corresponding components of the interpolation parameter s. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 lerp(float4 x, float4 y, float4 s) { return x + s * (y - x); } + + + /// Returns the result of linearly interpolating from x to y using the interpolation parameter s. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double lerp(double x, double y, double s) { return x + s * (y - x); } + + /// Returns the result of a componentwise linear interpolating from x to y using the interpolation parameter s. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2 lerp(double2 x, double2 y, double s) { return x + s * (y - x); } + + /// Returns the result of a componentwise linear interpolating from x to y using the interpolation parameter s. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3 lerp(double3 x, double3 y, double s) { return x + s * (y - x); } + + /// Returns the result of a componentwise linear interpolating from x to y using the interpolation parameter s. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4 lerp(double4 x, double4 y, double s) { return x + s * (y - x); } + + + /// Returns the result of a componentwise linear interpolating from x to y using the corresponding components of the interpolation parameter s. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2 lerp(double2 x, double2 y, double2 s) { return x + s * (y - x); } + + /// Returns the result of a componentwise linear interpolating from x to y using the corresponding components of the interpolation parameter s. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3 lerp(double3 x, double3 y, double3 s) { return x + s * (y - x); } + + /// Returns the result of a componentwise linear interpolating from x to y using the corresponding components of the interpolation parameter s. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4 lerp(double4 x, double4 y, double4 s) { return x + s * (y - x); } + + + /// Returns the result of normalizing a floating point value x to a range [a, b]. The opposite of lerp. Equivalent to (x - a) / (b - a). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float unlerp(float a, float b, float x) { return (x - a) / (b - a); } + + /// Returns the componentwise result of normalizing a floating point value x to a range [a, b]. The opposite of lerp. Equivalent to (x - a) / (b - a). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 unlerp(float2 a, float2 b, float2 x) { return (x - a) / (b - a); } + + /// Returns the componentwise result of normalizing a floating point value x to a range [a, b]. The opposite of lerp. Equivalent to (x - a) / (b - a). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 unlerp(float3 a, float3 b, float3 x) { return (x - a) / (b - a); } + + /// Returns the componentwise result of normalizing a floating point value x to a range [a, b]. The opposite of lerp. Equivalent to (x - a) / (b - a). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 unlerp(float4 a, float4 b, float4 x) { return (x - a) / (b - a); } + + + /// Returns the result of normalizing a floating point value x to a range [a, b]. The opposite of lerp. Equivalent to (x - a) / (b - a). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double unlerp(double a, double b, double x) { return (x - a) / (b - a); } + + /// Returns the componentwise result of normalizing a floating point value x to a range [a, b]. The opposite of lerp. Equivalent to (x - a) / (b - a). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2 unlerp(double2 a, double2 b, double2 x) { return (x - a) / (b - a); } + + /// Returns the componentwise result of normalizing a floating point value x to a range [a, b]. The opposite of lerp. Equivalent to (x - a) / (b - a). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3 unlerp(double3 a, double3 b, double3 x) { return (x - a) / (b - a); } + + /// Returns the componentwise result of normalizing a floating point value x to a range [a, b]. The opposite of lerp. Equivalent to (x - a) / (b - a). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4 unlerp(double4 a, double4 b, double4 x) { return (x - a) / (b - a); } + + + /// Returns the result of a non-clamping linear remapping of a value x from [a, b] to [c, d]. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float remap(float a, float b, float c, float d, float x) { return lerp(c, d, unlerp(a, b, x)); } + + /// Returns the componentwise result of a non-clamping linear remapping of a value x from [a, b] to [c, d]. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 remap(float2 a, float2 b, float2 c, float2 d, float2 x) { return lerp(c, d, unlerp(a, b, x)); } + + /// Returns the componentwise result of a non-clamping linear remapping of a value x from [a, b] to [c, d]. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 remap(float3 a, float3 b, float3 c, float3 d, float3 x) { return lerp(c, d, unlerp(a, b, x)); } + + /// Returns the componentwise result of a non-clamping linear remapping of a value x from [a, b] to [c, d]. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 remap(float4 a, float4 b, float4 c, float4 d, float4 x) { return lerp(c, d, unlerp(a, b, x)); } + + + /// Returns the result of a non-clamping linear remapping of a value x from [a, b] to [c, d]. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double remap(double a, double b, double c, double d, double x) { return lerp(c, d, unlerp(a, b, x)); } + + /// Returns the componentwise result of a non-clamping linear remapping of a value x from [a, b] to [c, d]. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2 remap(double2 a, double2 b, double2 c, double2 d, double2 x) { return lerp(c, d, unlerp(a, b, x)); } + + /// Returns the componentwise result of a non-clamping linear remapping of a value x from [a, b] to [c, d]. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3 remap(double3 a, double3 b, double3 c, double3 d, double3 x) { return lerp(c, d, unlerp(a, b, x)); } + + /// Returns the componentwise result of a non-clamping linear remapping of a value x from [a, b] to [c, d]. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4 remap(double4 a, double4 b, double4 c, double4 d, double4 x) { return lerp(c, d, unlerp(a, b, x)); } + + + /// Returns the result of a multiply-add operation (a * b + c) on 3 int values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int mad(int a, int b, int c) { return a * b + c; } + + /// Returns the result of a componentwise multiply-add operation (a * b + c) on 3 int2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 mad(int2 a, int2 b, int2 c) { return a * b + c; } + + /// Returns the result of a componentwise multiply-add operation (a * b + c) on 3 int3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 mad(int3 a, int3 b, int3 c) { return a * b + c; } + + /// Returns the result of a componentwise multiply-add operation (a * b + c) on 3 int4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 mad(int4 a, int4 b, int4 c) { return a * b + c; } + + + /// Returns the result of a multiply-add operation (a * b + c) on 3 uint values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint mad(uint a, uint b, uint c) { return a * b + c; } + + /// Returns the result of a componentwise multiply-add operation (a * b + c) on 3 uint2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2 mad(uint2 a, uint2 b, uint2 c) { return a * b + c; } + + /// Returns the result of a componentwise multiply-add operation (a * b + c) on 3 uint3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 mad(uint3 a, uint3 b, uint3 c) { return a * b + c; } + + /// Returns the result of a componentwise multiply-add operation (a * b + c) on 3 uint4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 mad(uint4 a, uint4 b, uint4 c) { return a * b + c; } + + + /// Returns the result of a multiply-add operation (a * b + c) on 3 long values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static long mad(long a, long b, long c) { return a * b + c; } + + + /// Returns the result of a multiply-add operation (a * b + c) on 3 ulong values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static ulong mad(ulong a, ulong b, ulong c) { return a * b + c; } + + + /// Returns the result of a multiply-add operation (a * b + c) on 3 float values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float mad(float a, float b, float c) { return a * b + c; } + + /// Returns the result of a componentwise multiply-add operation (a * b + c) on 3 float2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 mad(float2 a, float2 b, float2 c) { return a * b + c; } + + /// Returns the result of a componentwise multiply-add operation (a * b + c) on 3 float3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 mad(float3 a, float3 b, float3 c) { return a * b + c; } + + /// Returns the result of a componentwise multiply-add operation (a * b + c) on 3 float4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 mad(float4 a, float4 b, float4 c) { return a * b + c; } + + + /// Returns the result of a multiply-add operation (a * b + c) on 3 double values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double mad(double a, double b, double c) { return a * b + c; } + + /// Returns the result of a componentwise multiply-add operation (a * b + c) on 3 double2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2 mad(double2 a, double2 b, double2 c) { return a * b + c; } + + /// Returns the result of a componentwise multiply-add operation (a * b + c) on 3 double3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3 mad(double3 a, double3 b, double3 c) { return a * b + c; } + + /// Returns the result of a componentwise multiply-add operation (a * b + c) on 3 double4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4 mad(double4 a, double4 b, double4 c) { return a * b + c; } + + + /// Returns the result of clamping the value x into the interval [a, b], where x, a and b are int values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int clamp(int x, int a, int b) { return max(a, min(b, x)); } + + /// Returns the result of a componentwise clamping of the int2 x into the interval [a, b], where a and b are int2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 clamp(int2 x, int2 a, int2 b) { return max(a, min(b, x)); } + + /// Returns the result of a componentwise clamping of the int3 x into the interval [a, b], where x, a and b are int3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 clamp(int3 x, int3 a, int3 b) { return max(a, min(b, x)); } + + /// Returns the result of a componentwise clamping of the value x into the interval [a, b], where x, a and b are int4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 clamp(int4 x, int4 a, int4 b) { return max(a, min(b, x)); } + + + /// Returns the result of clamping the value x into the interval [a, b], where x, a and b are uint values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint clamp(uint x, uint a, uint b) { return max(a, min(b, x)); } + + /// Returns the result of a componentwise clamping of the value x into the interval [a, b], where x, a and b are uint2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2 clamp(uint2 x, uint2 a, uint2 b) { return max(a, min(b, x)); } + + /// Returns the result of a componentwise clamping of the value x into the interval [a, b], where x, a and b are uint3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 clamp(uint3 x, uint3 a, uint3 b) { return max(a, min(b, x)); } + + /// Returns the result of a componentwise clamping of the value x into the interval [a, b], where x, a and b are uint4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 clamp(uint4 x, uint4 a, uint4 b) { return max(a, min(b, x)); } + + + /// Returns the result of clamping the value x into the interval [a, b], where x, a and b are long values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static long clamp(long x, long a, long b) { return max(a, min(b, x)); } + + /// Returns the result of clamping the value x into the interval [a, b], where x, a and b are ulong values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static ulong clamp(ulong x, ulong a, ulong b) { return max(a, min(b, x)); } + + + /// Returns the result of clamping the value x into the interval [a, b], where x, a and b are float values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float clamp(float x, float a, float b) { return max(a, min(b, x)); } + + /// Returns the result of a componentwise clamping of the value x into the interval [a, b], where x, a and b are float2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 clamp(float2 x, float2 a, float2 b) { return max(a, min(b, x)); } + + /// Returns the result of a componentwise clamping of the value x into the interval [a, b], where x, a and b are float3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 clamp(float3 x, float3 a, float3 b) { return max(a, min(b, x)); } + + /// Returns the result of a componentwise clamping of the value x into the interval [a, b], where x, a and b are float4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 clamp(float4 x, float4 a, float4 b) { return max(a, min(b, x)); } + + + /// Returns the result of clamping the value x into the interval [a, b], where x, a and b are double values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double clamp(double x, double a, double b) { return max(a, min(b, x)); } + + /// Returns the result of a componentwise clamping of the value x into the interval [a, b], where x, a and b are double2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2 clamp(double2 x, double2 a, double2 b) { return max(a, min(b, x)); } + + /// Returns the result of a componentwise clamping of the value x into the interval [a, b], where x, a and b are double3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3 clamp(double3 x, double3 a, double3 b) { return max(a, min(b, x)); } + + /// Returns the result of a componentwise clamping of the value x into the interval [a, b], where x, a and b are double4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4 clamp(double4 x, double4 a, double4 b) { return max(a, min(b, x)); } + + + /// Returns the result of clamping the float value x into the interval [0, 1]. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float saturate(float x) { return clamp(x, 0.0f, 1.0f); } + + /// Returns the result of a componentwise clamping of the float2 vector x into the interval [0, 1]. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 saturate(float2 x) { return clamp(x, new float2(0.0f), new float2(1.0f)); } + + /// Returns the result of a componentwise clamping of the float3 vector x into the interval [0, 1]. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 saturate(float3 x) { return clamp(x, new float3(0.0f), new float3(1.0f)); } + + /// Returns the result of a componentwise clamping of the float4 vector x into the interval [0, 1]. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 saturate(float4 x) { return clamp(x, new float4(0.0f), new float4(1.0f)); } + + + /// Returns the result of clamping the double value x into the interval [0, 1]. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double saturate(double x) { return clamp(x, 0.0, 1.0); } + + /// Returns the result of a componentwise clamping of the double2 vector x into the interval [0, 1]. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2 saturate(double2 x) { return clamp(x, new double2(0.0), new double2(1.0)); } + + /// Returns the result of a componentwise clamping of the double3 vector x into the interval [0, 1]. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3 saturate(double3 x) { return clamp(x, new double3(0.0), new double3(1.0)); } + + /// Returns the result of a componentwise clamping of the double4 vector x into the interval [0, 1]. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4 saturate(double4 x) { return clamp(x, new double4(0.0), new double4(1.0)); } + + + /// Returns the absolute value of a int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int abs(int x) { return max(-x, x); } + + /// Returns the componentwise absolute value of a int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 abs(int2 x) { return max(-x, x); } + + /// Returns the componentwise absolute value of a int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 abs(int3 x) { return max(-x, x); } + + /// Returns the componentwise absolute value of a int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 abs(int4 x) { return max(-x, x); } + + /// Returns the absolute value of a long value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static long abs(long x) { return max(-x, x); } + + + /// Returns the absolute value of a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float abs(float x) { return asfloat(asuint(x) & 0x7FFFFFFF); } + + /// Returns the componentwise absolute value of a float2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 abs(float2 x) { return asfloat(asuint(x) & 0x7FFFFFFF); } + + /// Returns the componentwise absolute value of a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 abs(float3 x) { return asfloat(asuint(x) & 0x7FFFFFFF); } + + /// Returns the componentwise absolute value of a float4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 abs(float4 x) { return asfloat(asuint(x) & 0x7FFFFFFF); } + + + /// Returns the absolute value of a double value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double abs(double x) { return asdouble(asulong(x) & 0x7FFFFFFFFFFFFFFF); } + + /// Returns the componentwise absolute value of a double2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2 abs(double2 x) { return double2(asdouble(asulong(x.x) & 0x7FFFFFFFFFFFFFFF), asdouble(asulong(x.y) & 0x7FFFFFFFFFFFFFFF)); } + + /// Returns the componentwise absolute value of a double3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3 abs(double3 x) { return double3(asdouble(asulong(x.x) & 0x7FFFFFFFFFFFFFFF), asdouble(asulong(x.y) & 0x7FFFFFFFFFFFFFFF), asdouble(asulong(x.z) & 0x7FFFFFFFFFFFFFFF)); } + + /// Returns the componentwise absolute value of a double4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4 abs(double4 x) { return double4(asdouble(asulong(x.x) & 0x7FFFFFFFFFFFFFFF), asdouble(asulong(x.y) & 0x7FFFFFFFFFFFFFFF), asdouble(asulong(x.z) & 0x7FFFFFFFFFFFFFFF), asdouble(asulong(x.w) & 0x7FFFFFFFFFFFFFFF)); } + + + /// Returns the dot product of two int values. Equivalent to multiplication. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int dot(int x, int y) { return x * y; } + + /// Returns the dot product of two int2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int dot(int2 x, int2 y) { return x.x * y.x + x.y * y.y; } + + /// Returns the dot product of two int3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int dot(int3 x, int3 y) { return x.x * y.x + x.y * y.y + x.z * y.z; } + + /// Returns the dot product of two int4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int dot(int4 x, int4 y) { return x.x * y.x + x.y * y.y + x.z * y.z + x.w * y.w; } + + + /// Returns the dot product of two uint values. Equivalent to multiplication. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint dot(uint x, uint y) { return x * y; } + + /// Returns the dot product of two uint2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint dot(uint2 x, uint2 y) { return x.x * y.x + x.y * y.y; } + + /// Returns the dot product of two uint3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint dot(uint3 x, uint3 y) { return x.x * y.x + x.y * y.y + x.z * y.z; } + + /// Returns the dot product of two uint4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint dot(uint4 x, uint4 y) { return x.x * y.x + x.y * y.y + x.z * y.z + x.w * y.w; } + + + /// Returns the dot product of two float values. Equivalent to multiplication. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float dot(float x, float y) { return x * y; } + + /// Returns the dot product of two float2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float dot(float2 x, float2 y) { return x.x * y.x + x.y * y.y; } + + /// Returns the dot product of two float3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float dot(float3 x, float3 y) { return x.x * y.x + x.y * y.y + x.z * y.z; } + + /// Returns the dot product of two float4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float dot(float4 x, float4 y) { return x.x * y.x + x.y * y.y + x.z * y.z + x.w * y.w; } + + + /// Returns the dot product of two double values. Equivalent to multiplication. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double dot(double x, double y) { return x * y; } + + /// Returns the dot product of two double2 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double dot(double2 x, double2 y) { return x.x * y.x + x.y * y.y; } + + /// Returns the dot product of two double3 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double dot(double3 x, double3 y) { return x.x * y.x + x.y * y.y + x.z * y.z; } + + /// Returns the dot product of two double4 vectors. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double dot(double4 x, double4 y) { return x.x * y.x + x.y * y.y + x.z * y.z + x.w * y.w; } + + + /// Returns the tangent of a float value. + public static float tan(float x) { return (float)System.Math.Tan(x); } + + /// Returns the componentwise tangent of a float2 vector. + public static float2 tan(float2 x) { return new float2(tan(x.x), tan(x.y)); } + + /// Returns the componentwise tangent of a float3 vector. + public static float3 tan(float3 x) { return new float3(tan(x.x), tan(x.y), tan(x.z)); } + + /// Returns the componentwise tangent of a float4 vector. + public static float4 tan(float4 x) { return new float4(tan(x.x), tan(x.y), tan(x.z), tan(x.w)); } + + + /// Returns the tangent of a double value. + public static double tan(double x) { return System.Math.Tan(x); } + + /// Returns the componentwise tangent of a double2 vector. + public static double2 tan(double2 x) { return new double2(tan(x.x), tan(x.y)); } + + /// Returns the componentwise tangent of a double3 vector. + public static double3 tan(double3 x) { return new double3(tan(x.x), tan(x.y), tan(x.z)); } + + /// Returns the componentwise tangent of a double4 vector. + public static double4 tan(double4 x) { return new double4(tan(x.x), tan(x.y), tan(x.z), tan(x.w)); } + + + /// Returns the hyperbolic tangent of a float value. + public static float tanh(float x) { return (float)System.Math.Tanh(x); } + + /// Returns the componentwise hyperbolic tangent of a float2 vector. + public static float2 tanh(float2 x) { return new float2(tanh(x.x), tanh(x.y)); } + + /// Returns the componentwise hyperbolic tangent of a float3 vector. + public static float3 tanh(float3 x) { return new float3(tanh(x.x), tanh(x.y), tanh(x.z)); } + + /// Returns the componentwise hyperbolic tangent of a float4 vector. + public static float4 tanh(float4 x) { return new float4(tanh(x.x), tanh(x.y), tanh(x.z), tanh(x.w)); } + + + /// Returns the hyperbolic tangent of a double value. + public static double tanh(double x) { return System.Math.Tanh(x); } + + /// Returns the componentwise hyperbolic tangent of a double2 vector. + public static double2 tanh(double2 x) { return new double2(tanh(x.x), tanh(x.y)); } + + /// Returns the componentwise hyperbolic tangent of a double3 vector. + public static double3 tanh(double3 x) { return new double3(tanh(x.x), tanh(x.y), tanh(x.z)); } + + /// Returns the componentwise hyperbolic tangent of a double4 vector. + public static double4 tanh(double4 x) { return new double4(tanh(x.x), tanh(x.y), tanh(x.z), tanh(x.w)); } + + + /// Returns the arctangent of a float value. + public static float atan(float x) { return (float)System.Math.Atan(x); } + + /// Returns the componentwise arctangent of a float2 vector. + public static float2 atan(float2 x) { return new float2(atan(x.x), atan(x.y)); } + + /// Returns the componentwise arctangent of a float3 vector. + public static float3 atan(float3 x) { return new float3(atan(x.x), atan(x.y), atan(x.z)); } + + /// Returns the componentwise arctangent of a float4 vector. + public static float4 atan(float4 x) { return new float4(atan(x.x), atan(x.y), atan(x.z), atan(x.w)); } + + + /// Returns the arctangent of a double value. + public static double atan(double x) { return System.Math.Atan(x); } + + /// Returns the componentwise arctangent of a double2 vector. + public static double2 atan(double2 x) { return new double2(atan(x.x), atan(x.y)); } + + /// Returns the componentwise arctangent of a double3 vector. + public static double3 atan(double3 x) { return new double3(atan(x.x), atan(x.y), atan(x.z)); } + + /// Returns the componentwise arctangent of a double4 vector. + public static double4 atan(double4 x) { return new double4(atan(x.x), atan(x.y), atan(x.z), atan(x.w)); } + + + /// Returns the 2-argument arctangent of a pair of float values. + public static float atan2(float y, float x) { return (float)System.Math.Atan2(y, x); } + + /// Returns the componentwise 2-argument arctangent of a pair of floats2 vectors. + public static float2 atan2(float2 y, float2 x) { return new float2(atan2(y.x, x.x), atan2(y.y, x.y)); } + + /// Returns the componentwise 2-argument arctangent of a pair of floats3 vectors. + public static float3 atan2(float3 y, float3 x) { return new float3(atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z)); } + + /// Returns the componentwise 2-argument arctangent of a pair of floats4 vectors. + public static float4 atan2(float4 y, float4 x) { return new float4(atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z), atan2(y.w, x.w)); } + + + /// Returns the 2-argument arctangent of a pair of double values. + public static double atan2(double y, double x) { return System.Math.Atan2(y, x); } + + /// Returns the 2-argument arctangent of a pair of double2 vectors. + public static double2 atan2(double2 y, double2 x) { return new double2(atan2(y.x, x.x), atan2(y.y, x.y)); } + + /// Returns the 2-argument arctangent of a pair of double3 vectors. + public static double3 atan2(double3 y, double3 x) { return new double3(atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z)); } + + /// Returns the 2-argument arctangent of a pair of double4 vectors. + public static double4 atan2(double4 y, double4 x) { return new double4(atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z), atan2(y.w, x.w)); } + + + /// Returns the cosine of a float value. + public static float cos(float x) { return (float)System.Math.Cos(x); } + + /// Returns the componentwise cosine of a float2 vector. + public static float2 cos(float2 x) { return new float2(cos(x.x), cos(x.y)); } + + /// Returns the componentwise cosine of a float3 vector. + public static float3 cos(float3 x) { return new float3(cos(x.x), cos(x.y), cos(x.z)); } + + /// Returns the componentwise cosine of a float4 vector. + public static float4 cos(float4 x) { return new float4(cos(x.x), cos(x.y), cos(x.z), cos(x.w)); } + + + /// Returns the cosine of a double value. + public static double cos(double x) { return System.Math.Cos(x); } + + /// Returns the componentwise cosine of a double2 vector. + public static double2 cos(double2 x) { return new double2(cos(x.x), cos(x.y)); } + + /// Returns the componentwise cosine of a double3 vector. + public static double3 cos(double3 x) { return new double3(cos(x.x), cos(x.y), cos(x.z)); } + + /// Returns the componentwise cosine of a double4 vector. + public static double4 cos(double4 x) { return new double4(cos(x.x), cos(x.y), cos(x.z), cos(x.w)); } + + + /// Returns the hyperbolic cosine of a float value. + public static float cosh(float x) { return (float)System.Math.Cosh(x); } + + /// Returns the componentwise hyperbolic cosine of a float2 vector. + public static float2 cosh(float2 x) { return new float2(cosh(x.x), cosh(x.y)); } + + /// Returns the componentwise hyperbolic cosine of a float3 vector. + public static float3 cosh(float3 x) { return new float3(cosh(x.x), cosh(x.y), cosh(x.z)); } + + /// Returns the componentwise hyperbolic cosine of a float4 vector. + public static float4 cosh(float4 x) { return new float4(cosh(x.x), cosh(x.y), cosh(x.z), cosh(x.w)); } + + + /// Returns the hyperbolic cosine of a double value. + public static double cosh(double x) { return System.Math.Cosh(x); } + + /// Returns the componentwise hyperbolic cosine of a double2 vector. + public static double2 cosh(double2 x) { return new double2(cosh(x.x), cosh(x.y)); } + + /// Returns the componentwise hyperbolic cosine of a double3 vector. + public static double3 cosh(double3 x) { return new double3(cosh(x.x), cosh(x.y), cosh(x.z)); } + + /// Returns the componentwise hyperbolic cosine of a double4 vector. + public static double4 cosh(double4 x) { return new double4(cosh(x.x), cosh(x.y), cosh(x.z), cosh(x.w)); } + + + /// Returns the arccosine of a float value. + public static float acos(float x) { return (float)System.Math.Acos((float)x); } + + /// Returns the componentwise arccosine of a float2 vector. + public static float2 acos(float2 x) { return new float2(acos(x.x), acos(x.y)); } + + /// Returns the componentwise arccosine of a float3 vector. + public static float3 acos(float3 x) { return new float3(acos(x.x), acos(x.y), acos(x.z)); } + + /// Returns the componentwise arccosine of a float4 vector. + public static float4 acos(float4 x) { return new float4(acos(x.x), acos(x.y), acos(x.z), acos(x.w)); } + + + /// Returns the arccosine of a double value. + public static double acos(double x) { return System.Math.Acos(x); } + + /// Returns the componentwise arccosine of a double2 vector. + public static double2 acos(double2 x) { return new double2(acos(x.x), acos(x.y)); } + + /// Returns the componentwise arccosine of a double3 vector. + public static double3 acos(double3 x) { return new double3(acos(x.x), acos(x.y), acos(x.z)); } + + /// Returns the componentwise arccosine of a double4 vector. + public static double4 acos(double4 x) { return new double4(acos(x.x), acos(x.y), acos(x.z), acos(x.w)); } + + + /// Returns the sine of a float value. + public static float sin(float x) { return (float)System.Math.Sin((float)x); } + + /// Returns the componentwise sine of a float2 vector. + public static float2 sin(float2 x) { return new float2(sin(x.x), sin(x.y)); } + + /// Returns the componentwise sine of a float3 vector. + public static float3 sin(float3 x) { return new float3(sin(x.x), sin(x.y), sin(x.z)); } + + /// Returns the componentwise sine of a float4 vector. + public static float4 sin(float4 x) { return new float4(sin(x.x), sin(x.y), sin(x.z), sin(x.w)); } + + + /// Returns the sine of a double value. + public static double sin(double x) { return System.Math.Sin(x); } + + /// Returns the componentwise sine of a double2 vector. + public static double2 sin(double2 x) { return new double2(sin(x.x), sin(x.y)); } + + /// Returns the componentwise sine of a double3 vector. + public static double3 sin(double3 x) { return new double3(sin(x.x), sin(x.y), sin(x.z)); } + + /// Returns the componentwise sine of a double4 vector. + public static double4 sin(double4 x) { return new double4(sin(x.x), sin(x.y), sin(x.z), sin(x.w)); } + + + /// Returns the hyperbolic sine of a float value. + public static float sinh(float x) { return (float)System.Math.Sinh((float)x); } + + /// Returns the componentwise hyperbolic sine of a float2 vector. + public static float2 sinh(float2 x) { return new float2(sinh(x.x), sinh(x.y)); } + + /// Returns the componentwise hyperbolic sine of a float3 vector. + public static float3 sinh(float3 x) { return new float3(sinh(x.x), sinh(x.y), sinh(x.z)); } + + /// Returns the componentwise hyperbolic sine of a float4 vector. + public static float4 sinh(float4 x) { return new float4(sinh(x.x), sinh(x.y), sinh(x.z), sinh(x.w)); } + + + /// Returns the hyperbolic sine of a double value. + public static double sinh(double x) { return System.Math.Sinh(x); } + + /// Returns the componentwise hyperbolic sine of a double2 vector. + public static double2 sinh(double2 x) { return new double2(sinh(x.x), sinh(x.y)); } + + /// Returns the componentwise hyperbolic sine of a double3 vector. + public static double3 sinh(double3 x) { return new double3(sinh(x.x), sinh(x.y), sinh(x.z)); } + + /// Returns the componentwise hyperbolic sine of a double4 vector. + public static double4 sinh(double4 x) { return new double4(sinh(x.x), sinh(x.y), sinh(x.z), sinh(x.w)); } + + + /// Returns the arcsine of a float value. + public static float asin(float x) { return (float)System.Math.Asin((float)x); } + + /// Returns the componentwise arcsine of a float2 vector. + public static float2 asin(float2 x) { return new float2(asin(x.x), asin(x.y)); } + + /// Returns the componentwise arcsine of a float3 vector. + public static float3 asin(float3 x) { return new float3(asin(x.x), asin(x.y), asin(x.z)); } + + /// Returns the componentwise arcsine of a float4 vector. + public static float4 asin(float4 x) { return new float4(asin(x.x), asin(x.y), asin(x.z), asin(x.w)); } + + + /// Returns the arcsine of a double value. + public static double asin(double x) { return System.Math.Asin(x); } + + /// Returns the componentwise arcsine of a double2 vector. + public static double2 asin(double2 x) { return new double2(asin(x.x), asin(x.y)); } + + /// Returns the componentwise arcsine of a double3 vector. + public static double3 asin(double3 x) { return new double3(asin(x.x), asin(x.y), asin(x.z)); } + + /// Returns the componentwise arcsine of a double4 vector. + public static double4 asin(double4 x) { return new double4(asin(x.x), asin(x.y), asin(x.z), asin(x.w)); } + + + /// Returns the result of rounding a float value up to the nearest integral value less or equal to the original value. + public static float floor(float x) { return (float)System.Math.Floor((float)x); } + + /// Returns the result of rounding each component of a float2 vector value down to the nearest value less or equal to the original value. + public static float2 floor(float2 x) { return new float2(floor(x.x), floor(x.y)); } + + /// Returns the result of rounding each component of a float3 vector value down to the nearest value less or equal to the original value. + public static float3 floor(float3 x) { return new float3(floor(x.x), floor(x.y), floor(x.z)); } + + /// Returns the result of rounding each component of a float4 vector value down to the nearest value less or equal to the original value. + public static float4 floor(float4 x) { return new float4(floor(x.x), floor(x.y), floor(x.z), floor(x.w)); } + + + /// Returns the result of rounding a double value up to the nearest integral value less or equal to the original value. + public static double floor(double x) { return System.Math.Floor(x); } + + /// Returns the result of rounding each component of a double2 vector value down to the nearest value less or equal to the original value. + public static double2 floor(double2 x) { return new double2(floor(x.x), floor(x.y)); } + + /// Returns the result of rounding each component of a double3 vector value down to the nearest value less or equal to the original value. + public static double3 floor(double3 x) { return new double3(floor(x.x), floor(x.y), floor(x.z)); } + + /// Returns the result of rounding each component of a double4 vector value down to the nearest value less or equal to the original value. + public static double4 floor(double4 x) { return new double4(floor(x.x), floor(x.y), floor(x.z), floor(x.w)); } + + + /// Returns the result of rounding a float value up to the nearest integral value greater or equal to the original value. + public static float ceil(float x) { return (float)System.Math.Ceiling((float)x); } + + /// Returns the result of rounding each component of a float2 vector value up to the nearest value greater or equal to the original value. + public static float2 ceil(float2 x) { return new float2(ceil(x.x), ceil(x.y)); } + + /// Returns the result of rounding each component of a float3 vector value up to the nearest value greater or equal to the original value. + public static float3 ceil(float3 x) { return new float3(ceil(x.x), ceil(x.y), ceil(x.z)); } + + /// Returns the result of rounding each component of a float4 vector value up to the nearest value greater or equal to the original value. + public static float4 ceil(float4 x) { return new float4(ceil(x.x), ceil(x.y), ceil(x.z), ceil(x.w)); } + + + /// Returns the result of rounding a double value up to the nearest greater integral value greater or equal to the original value. + public static double ceil(double x) { return System.Math.Ceiling(x); } + + /// Returns the result of rounding each component of a double2 vector value up to the nearest integral value greater or equal to the original value. + public static double2 ceil(double2 x) { return new double2(ceil(x.x), ceil(x.y)); } + + /// Returns the result of rounding each component of a double3 vector value up to the nearest integral value greater or equal to the original value.. + public static double3 ceil(double3 x) { return new double3(ceil(x.x), ceil(x.y), ceil(x.z)); } + + /// Returns the result of rounding each component of a double4 vector value up to the nearest integral value greater or equal to the original value. + public static double4 ceil(double4 x) { return new double4(ceil(x.x), ceil(x.y), ceil(x.z), ceil(x.w)); } + + + /// Returns the result of rounding a float value to the nearest integral value. + public static float round(float x) { return (float)System.Math.Round((float)x); } + + /// Returns the result of rounding each component of a float2 vector value to the nearest integral value. + public static float2 round(float2 x) { return new float2(round(x.x), round(x.y)); } + + /// Returns the result of rounding each component of a float3 vector value to the nearest integral value. + public static float3 round(float3 x) { return new float3(round(x.x), round(x.y), round(x.z)); } + + /// Returns the result of rounding each component of a float4 vector value to the nearest integral value. + public static float4 round(float4 x) { return new float4(round(x.x), round(x.y), round(x.z), round(x.w)); } + + + /// Returns the result of rounding a double value to the nearest integral value. + public static double round(double x) { return System.Math.Round(x); } + + /// Returns the result of rounding each component of a double2 vector value to the nearest integral value. + public static double2 round(double2 x) { return new double2(round(x.x), round(x.y)); } + + /// Returns the result of rounding each component of a double3 vector value to the nearest integral value. + public static double3 round(double3 x) { return new double3(round(x.x), round(x.y), round(x.z)); } + + /// Returns the result of rounding each component of a double4 vector value to the nearest integral value. + public static double4 round(double4 x) { return new double4(round(x.x), round(x.y), round(x.z), round(x.w)); } + + + /// Returns the result of truncating a float value to an integral float value. + public static float trunc(float x) { return (float)System.Math.Truncate((float)x); } + + /// Returns the result of a componentwise truncation of a float2 value to an integral float2 value. + public static float2 trunc(float2 x) { return new float2(trunc(x.x), trunc(x.y)); } + + /// Returns the result of a componentwise truncation of a float3 value to an integral float3 value. + public static float3 trunc(float3 x) { return new float3(trunc(x.x), trunc(x.y), trunc(x.z)); } + + /// Returns the result of a componentwise truncation of a float4 value to an integral float4 value. + public static float4 trunc(float4 x) { return new float4(trunc(x.x), trunc(x.y), trunc(x.z), trunc(x.w)); } + + + /// Returns the result of truncating a double value to an integral double value. + public static double trunc(double x) { return System.Math.Truncate(x); } + + /// Returns the result of a componentwise truncation of a double2 value to an integral double2 value. + public static double2 trunc(double2 x) { return new double2(trunc(x.x), trunc(x.y)); } + + /// Returns the result of a componentwise truncation of a double3 value to an integral double3 value. + public static double3 trunc(double3 x) { return new double3(trunc(x.x), trunc(x.y), trunc(x.z)); } + + /// Returns the result of a componentwise truncation of a double4 value to an integral double4 value. + public static double4 trunc(double4 x) { return new double4(trunc(x.x), trunc(x.y), trunc(x.z), trunc(x.w)); } + + + /// Returns the fractional part of a float value. + public static float frac(float x) { return x - floor(x); } + + /// Returns the componentwise fractional parts of a float2 vector. + public static float2 frac(float2 x) { return x - floor(x); } + + /// Returns the componentwise fractional parts of a float3 vector. + public static float3 frac(float3 x) { return x - floor(x); } + + /// Returns the componentwise fractional parts of a float4 vector. + public static float4 frac(float4 x) { return x - floor(x); } + + + /// Returns the fractional part of a double value. + public static double frac(double x) { return x - floor(x); } + + /// Returns the componentwise fractional parts of a double2 vector. + public static double2 frac(double2 x) { return x - floor(x); } + + /// Returns the componentwise fractional parts of a double3 vector. + public static double3 frac(double3 x) { return x - floor(x); } + + /// Returns the componentwise fractional parts of a double4 vector. + public static double4 frac(double4 x) { return x - floor(x); } + + + /// Returns the reciprocal a float value. + public static float rcp(float x) { return 1.0f / x; } + + /// Returns the componentwise reciprocal a float2 vector. + public static float2 rcp(float2 x) { return 1.0f / x; } + + /// Returns the componentwise reciprocal a float3 vector. + public static float3 rcp(float3 x) { return 1.0f / x; } + + /// Returns the componentwise reciprocal a float4 vector. + public static float4 rcp(float4 x) { return 1.0f / x; } + + + /// Returns the reciprocal a double value. + public static double rcp(double x) { return 1.0 / x; } + + /// Returns the componentwise reciprocal a double2 vector. + public static double2 rcp(double2 x) { return 1.0 / x; } + + /// Returns the componentwise reciprocal a double3 vector. + public static double3 rcp(double3 x) { return 1.0 / x; } + + /// Returns the componentwise reciprocal a double4 vector. + public static double4 rcp(double4 x) { return 1.0 / x; } + + + /// Returns the sign of a float value. -1.0f if it is less than zero, 0.0f if it is zero and 1.0f if it greater than zero. + public static float sign(float x) { return (x > 0.0f ? 1.0f : 0.0f) - (x < 0.0f ? 1.0f : 0.0f); } + + /// Returns the componentwise sign of a float2 value. 1.0f for positive components, 0.0f for zero components and -1.0f for negative components. + public static float2 sign(float2 x) { return new float2(sign(x.x), sign(x.y)); } + + /// Returns the componentwise sign of a float3 value. 1.0f for positive components, 0.0f for zero components and -1.0f for negative components. + public static float3 sign(float3 x) { return new float3(sign(x.x), sign(x.y), sign(x.z)); } + + /// Returns the componentwise sign of a float4 value. 1.0f for positive components, 0.0f for zero components and -1.0f for negative components. + public static float4 sign(float4 x) { return new float4(sign(x.x), sign(x.y), sign(x.z), sign(x.w)); } + + + /// Returns the sign of a double value. -1.0 if it is less than zero, 0.0 if it is zero and 1.0 if it greater than zero. + public static double sign(double x) { return x == 0 ? 0 : (x > 0.0 ? 1.0 : 0.0) - (x < 0.0 ? 1.0 : 0.0); } + + /// Returns the componentwise sign of a double2 value. 1.0 for positive components, 0.0 for zero components and -1.0 for negative components. + public static double2 sign(double2 x) { return new double2(sign(x.x), sign(x.y)); } + + /// Returns the componentwise sign of a double3 value. 1.0 for positive components, 0.0 for zero components and -1.0 for negative components. + public static double3 sign(double3 x) { return new double3(sign(x.x), sign(x.y), sign(x.z)); } + + /// Returns the componentwise sign of a double4 value. 1.0 for positive components, 0.0 for zero components and -1.0 for negative components. + public static double4 sign(double4 x) { return new double4(sign(x.x), sign(x.y), sign(x.z), sign(x.w)); } + + + /// Returns x raised to the power y. + public static float pow(float x, float y) { return (float)System.Math.Pow((float)x, (float)y); } + + /// Returns the componentwise result of raising x to the power y. + public static float2 pow(float2 x, float2 y) { return new float2(pow(x.x, y.x), pow(x.y, y.y)); } + + /// Returns the componentwise result of raising x to the power y. + public static float3 pow(float3 x, float3 y) { return new float3(pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z)); } + + /// Returns the componentwise result of raising x to the power y. + public static float4 pow(float4 x, float4 y) { return new float4(pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z), pow(x.w, y.w)); } + + + /// Returns x raised to the power y. + public static double pow(double x, double y) { return System.Math.Pow(x, y); } + + /// Returns the componentwise result of raising x to the power y. + public static double2 pow(double2 x, double2 y) { return new double2(pow(x.x, y.x), pow(x.y, y.y)); } + + /// Returns the componentwise result of raising x to the power y. + public static double3 pow(double3 x, double3 y) { return new double3(pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z)); } + + /// Returns the componentwise result of raising x to the power y. + public static double4 pow(double4 x, double4 y) { return new double4(pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z), pow(x.w, y.w)); } + + + /// Returns the base-e exponential of x. + public static float exp(float x) { return (float)System.Math.Exp((float)x); } + + /// Returns the componentwise base-e exponential of x. + public static float2 exp(float2 x) { return new float2(exp(x.x), exp(x.y)); } + + /// Returns the componentwise base-e exponential of x. + public static float3 exp(float3 x) { return new float3(exp(x.x), exp(x.y), exp(x.z)); } + + /// Returns the componentwise base-e exponential of x. + public static float4 exp(float4 x) { return new float4(exp(x.x), exp(x.y), exp(x.z), exp(x.w)); } + + + /// Returns the base-e exponential of x. + public static double exp(double x) { return System.Math.Exp(x); } + + /// Returns the componentwise base-e exponential of x. + public static double2 exp(double2 x) { return new double2(exp(x.x), exp(x.y)); } + + /// Returns the componentwise base-e exponential of x. + public static double3 exp(double3 x) { return new double3(exp(x.x), exp(x.y), exp(x.z)); } + + /// Returns the componentwise base-e exponential of x. + public static double4 exp(double4 x) { return new double4(exp(x.x), exp(x.y), exp(x.z), exp(x.w)); } + + + /// Returns the base-2 exponential of x. + public static float exp2(float x) { return (float)System.Math.Exp((float)x * 0.69314718f); } + + /// Returns the componentwise base-2 exponential of x. + public static float2 exp2(float2 x) { return new float2(exp2(x.x), exp2(x.y)); } + + /// Returns the componentwise base-2 exponential of x. + public static float3 exp2(float3 x) { return new float3(exp2(x.x), exp2(x.y), exp2(x.z)); } + + /// Returns the componentwise base-2 exponential of x. + public static float4 exp2(float4 x) { return new float4(exp2(x.x), exp2(x.y), exp2(x.z), exp2(x.w)); } + + + /// Returns the base-2 exponential of x. + public static double exp2(double x) { return System.Math.Exp(x * 0.693147180559945309); } + + /// Returns the componentwise base-2 exponential of x. + public static double2 exp2(double2 x) { return new double2(exp2(x.x), exp2(x.y)); } + + /// Returns the componentwise base-2 exponential of x. + public static double3 exp2(double3 x) { return new double3(exp2(x.x), exp2(x.y), exp2(x.z)); } + + /// Returns the componentwise base-2 exponential of x. + public static double4 exp2(double4 x) { return new double4(exp2(x.x), exp2(x.y), exp2(x.z), exp2(x.w)); } + + + /// Returns the base-10 exponential of x. + public static float exp10(float x) { return (float)System.Math.Exp((float)x * 2.30258509f); } + + /// Returns the componentwise base-10 exponential of x. + public static float2 exp10(float2 x) { return new float2(exp10(x.x), exp10(x.y)); } + + /// Returns the componentwise base-10 exponential of x. + public static float3 exp10(float3 x) { return new float3(exp10(x.x), exp10(x.y), exp10(x.z)); } + + /// Returns the componentwise base-10 exponential of x. + public static float4 exp10(float4 x) { return new float4(exp10(x.x), exp10(x.y), exp10(x.z), exp10(x.w)); } + + + /// Returns the base-10 exponential of x. + public static double exp10(double x) { return System.Math.Exp(x * 2.302585092994045684); } + + /// Returns the componentwise base-10 exponential of x. + public static double2 exp10(double2 x) { return new double2(exp10(x.x), exp10(x.y)); } + + /// Returns the componentwise base-10 exponential of x. + public static double3 exp10(double3 x) { return new double3(exp10(x.x), exp10(x.y), exp10(x.z)); } + + /// Returns the componentwise base-10 exponential of x. + public static double4 exp10(double4 x) { return new double4(exp10(x.x), exp10(x.y), exp10(x.z), exp10(x.w)); } + + + /// Returns the natural logarithm of a float value. + public static float log(float x) { return (float)System.Math.Log((float)x); } + + /// Returns the componentwise natural logarithm of a float2 vector. + public static float2 log(float2 x) { return new float2(log(x.x), log(x.y)); } + + /// Returns the componentwise natural logarithm of a float3 vector. + public static float3 log(float3 x) { return new float3(log(x.x), log(x.y), log(x.z)); } + + /// Returns the componentwise natural logarithm of a float4 vector. + public static float4 log(float4 x) { return new float4(log(x.x), log(x.y), log(x.z), log(x.w)); } + + + /// Returns the natural logarithm of a double value. + public static double log(double x) { return System.Math.Log(x); } + + /// Returns the componentwise natural logarithm of a double2 vector. + public static double2 log(double2 x) { return new double2(log(x.x), log(x.y)); } + + /// Returns the componentwise natural logarithm of a double3 vector. + public static double3 log(double3 x) { return new double3(log(x.x), log(x.y), log(x.z)); } + + /// Returns the componentwise natural logarithm of a double4 vector. + public static double4 log(double4 x) { return new double4(log(x.x), log(x.y), log(x.z), log(x.w)); } + + + /// Returns the base-2 logarithm of a float value. + public static float log2(float x) { return (float)System.Math.Log((float)x, 2.0f); } + + /// Returns the componentwise base-2 logarithm of a float2 vector. + public static float2 log2(float2 x) { return new float2(log2(x.x), log2(x.y)); } + + /// Returns the componentwise base-2 logarithm of a float3 vector. + public static float3 log2(float3 x) { return new float3(log2(x.x), log2(x.y), log2(x.z)); } + + /// Returns the componentwise base-2 logarithm of a float4 vector. + public static float4 log2(float4 x) { return new float4(log2(x.x), log2(x.y), log2(x.z), log2(x.w)); } + + + /// Returns the base-2 logarithm of a double value. + public static double log2(double x) { return System.Math.Log(x, 2.0); } + + /// Returns the componentwise base-2 logarithm of a double2 vector. + public static double2 log2(double2 x) { return new double2(log2(x.x), log2(x.y)); } + + /// Returns the componentwise base-2 logarithm of a double3 vector. + public static double3 log2(double3 x) { return new double3(log2(x.x), log2(x.y), log2(x.z)); } + + /// Returns the componentwise base-2 logarithm of a double4 vector. + public static double4 log2(double4 x) { return new double4(log2(x.x), log2(x.y), log2(x.z), log2(x.w)); } + + + /// Returns the base-10 logarithm of a float value. + public static float log10(float x) { return (float)System.Math.Log10((float)x); } + + /// Returns the componentwise base-10 logarithm of a float2 vector. + public static float2 log10(float2 x) { return new float2(log10(x.x), log10(x.y)); } + + /// Returns the componentwise base-10 logarithm of a float3 vector. + public static float3 log10(float3 x) { return new float3(log10(x.x), log10(x.y), log10(x.z)); } + + /// Returns the componentwise base-10 logarithm of a float4 vector. + public static float4 log10(float4 x) { return new float4(log10(x.x), log10(x.y), log10(x.z), log10(x.w)); } + + + /// Returns the base-10 logarithm of a double value. + public static double log10(double x) { return System.Math.Log10(x); } + + /// Returns the componentwise base-10 logarithm of a double2 vector. + public static double2 log10(double2 x) { return new double2(log10(x.x), log10(x.y)); } + + /// Returns the componentwise base-10 logarithm of a double3 vector. + public static double3 log10(double3 x) { return new double3(log10(x.x), log10(x.y), log10(x.z)); } + + /// Returns the componentwise base-10 logarithm of a double4 vector. + public static double4 log10(double4 x) { return new double4(log10(x.x), log10(x.y), log10(x.z), log10(x.w)); } + + + /// Returns the floating point remainder of x/y. + public static float fmod(float x, float y) { return x % y; } + + /// Returns the componentwise floating point remainder of x/y. + public static float2 fmod(float2 x, float2 y) { return new float2(x.x % y.x, x.y % y.y); } + + /// Returns the componentwise floating point remainder of x/y. + public static float3 fmod(float3 x, float3 y) { return new float3(x.x % y.x, x.y % y.y, x.z % y.z); } + + /// Returns the componentwise floating point remainder of x/y. + public static float4 fmod(float4 x, float4 y) { return new float4(x.x % y.x, x.y % y.y, x.z % y.z, x.w % y.w); } + + + /// Returns the double precision floating point remainder of x/y. + public static double fmod(double x, double y) { return x % y; } + + /// Returns the componentwise double precision floating point remainder of x/y. + public static double2 fmod(double2 x, double2 y) { return new double2(x.x % y.x, x.y % y.y); } + + /// Returns the componentwise double precision floating point remainder of x/y. + public static double3 fmod(double3 x, double3 y) { return new double3(x.x % y.x, x.y % y.y, x.z % y.z); } + + /// Returns the componentwise double precision floating point remainder of x/y. + public static double4 fmod(double4 x, double4 y) { return new double4(x.x % y.x, x.y % y.y, x.z % y.z, x.w % y.w); } + + + /// Splits a float value into an integral part i and a fractional part that gets returned. Both parts take the sign of the input. + public static float modf(float x, out float i) { i = trunc(x); return x - i; } + + /// + // Performs a componentwise split of a float2 vector into an integral part i and a fractional part that gets returned. + // Both parts take the sign of the corresponding input component. + // + public static float2 modf(float2 x, out float2 i) { i = trunc(x); return x - i; } + + /// + // Performs a componentwise split of a float3 vector into an integral part i and a fractional part that gets returned. + // Both parts take the sign of the corresponding input component. + // + public static float3 modf(float3 x, out float3 i) { i = trunc(x); return x - i; } + + /// + // Performs a componentwise split of a float4 vector into an integral part i and a fractional part that gets returned. + // Both parts take the sign of the corresponding input component. + // + public static float4 modf(float4 x, out float4 i) { i = trunc(x); return x - i; } + + + /// Splits a double value into an integral part i and a fractional part that gets returned. Both parts take the sign of the input. + public static double modf(double x, out double i) { i = trunc(x); return x - i; } + + /// + // Performs a componentwise split of a double2 vector into an integral part i and a fractional part that gets returned. + // Both parts take the sign of the corresponding input component. + // + public static double2 modf(double2 x, out double2 i) { i = trunc(x); return x - i; } + + /// + // Performs a componentwise split of a double3 vector into an integral part i and a fractional part that gets returned. + // Both parts take the sign of the corresponding input component. + // + public static double3 modf(double3 x, out double3 i) { i = trunc(x); return x - i; } + + /// + // Performs a componentwise split of a double4 vector into an integral part i and a fractional part that gets returned. + // Both parts take the sign of the corresponding input component. + // + public static double4 modf(double4 x, out double4 i) { i = trunc(x); return x - i; } + + + /// Returns the square root of a float value. + public static float sqrt(float x) { return (float)System.Math.Sqrt((float)x); } + + /// Returns the componentwise square root of a float2 vector. + public static float2 sqrt(float2 x) { return new float2(sqrt(x.x), sqrt(x.y)); } + + /// Returns the componentwise square root of a float3 vector. + public static float3 sqrt(float3 x) { return new float3(sqrt(x.x), sqrt(x.y), sqrt(x.z)); } + + /// Returns the componentwise square root of a float4 vector. + public static float4 sqrt(float4 x) { return new float4(sqrt(x.x), sqrt(x.y), sqrt(x.z), sqrt(x.w)); } + + + /// Returns the square root of a double value. + public static double sqrt(double x) { return System.Math.Sqrt(x); } + + /// Returns the componentwise square root of a double2 vector. + public static double2 sqrt(double2 x) { return new double2(sqrt(x.x), sqrt(x.y)); } + + /// Returns the componentwise square root of a double3 vector. + public static double3 sqrt(double3 x) { return new double3(sqrt(x.x), sqrt(x.y), sqrt(x.z)); } + + /// Returns the componentwise square root of a double4 vector. + public static double4 sqrt(double4 x) { return new double4(sqrt(x.x), sqrt(x.y), sqrt(x.z), sqrt(x.w)); } + + + /// Returns the reciprocal square root of a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float rsqrt(float x) { return 1.0f / sqrt(x); } + + /// Returns the componentwise reciprocal square root of a float2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 rsqrt(float2 x) { return 1.0f / sqrt(x); } + + /// Returns the componentwise reciprocal square root of a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 rsqrt(float3 x) { return 1.0f / sqrt(x); } + + /// Returns the componentwise reciprocal square root of a float4 vector + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 rsqrt(float4 x) { return 1.0f / sqrt(x); } + + + /// Returns the reciprocal square root of a double value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double rsqrt(double x) { return 1.0 / sqrt(x); } + + /// Returns the componentwise reciprocal square root of a double2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2 rsqrt(double2 x) { return 1.0 / sqrt(x); } + + /// Returns the componentwise reciprocal square root of a double3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3 rsqrt(double3 x) { return 1.0 / sqrt(x); } + + /// Returns the componentwise reciprocal square root of a double4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4 rsqrt(double4 x) { return 1.0 / sqrt(x); } + + + /// Returns a normalized version of the float2 vector x by scaling it by 1 / length(x). + public static float2 normalize(float2 x) { return rsqrt(dot(x, x)) * x; } + + /// Returns a normalized version of the float3 vector x by scaling it by 1 / length(x). + public static float3 normalize(float3 x) { return rsqrt(dot(x, x)) * x; } + + /// Returns a normalized version of the float4 vector x by scaling it by 1 / length(x). + public static float4 normalize(float4 x) { return rsqrt(dot(x, x)) * x; } + + + /// Returns a normalized version of the double2 vector x by scaling it by 1 / length(x). + public static double2 normalize(double2 x) { return rsqrt(dot(x, x)) * x; } + + /// Returns a normalized version of the double3 vector x by scaling it by 1 / length(x). + public static double3 normalize(double3 x) { return rsqrt(dot(x, x)) * x; } + + /// Returns a normalized version of the double4 vector x by scaling it by 1 / length(x). + public static double4 normalize(double4 x) { return rsqrt(dot(x, x)) * x; } + + + /// + /// Returns a safe normalized version of the float2 vector x by scaling it by 1 / length(x). + /// Returns the given default value when 1 / length(x) does not produce a finite number. + /// + static public float2 normalizesafe(float2 x, float2 defaultvalue = new float2()) + { + float len = math.dot(x, x); + return math.select(defaultvalue, x * math.rsqrt(len), len > FLT_MIN_NORMAL); + } + + /// + /// Returns a safe normalized version of the float3 vector x by scaling it by 1 / length(x). + /// Returns the given default value when 1 / length(x) does not produce a finite number. + /// + static public float3 normalizesafe(float3 x, float3 defaultvalue = new float3()) + { + float len = math.dot(x, x); + return math.select(defaultvalue, x * math.rsqrt(len), len > FLT_MIN_NORMAL); + } + + /// + /// Returns a safe normalized version of the float4 vector x by scaling it by 1 / length(x). + /// Returns the given default value when 1 / length(x) does not produce a finite number. + /// + static public float4 normalizesafe(float4 x, float4 defaultvalue = new float4()) + { + float len = math.dot(x, x); + return math.select(defaultvalue, x * math.rsqrt(len), len > FLT_MIN_NORMAL); + } + + + /// + /// Returns a safe normalized version of the double4 vector x by scaling it by 1 / length(x). + /// Returns the given default value when 1 / length(x) does not produce a finite number. + /// + static public double2 normalizesafe(double2 x, double2 defaultvalue = new double2()) + { + double len = math.dot(x, x); + return math.select(defaultvalue, x * math.rsqrt(len), len > FLT_MIN_NORMAL); + } + + /// + /// Returns a safe normalized version of the double4 vector x by scaling it by 1 / length(x). + /// Returns the given default value when 1 / length(x) does not produce a finite number. + /// + static public double3 normalizesafe(double3 x, double3 defaultvalue = new double3()) + { + double len = math.dot(x, x); + return math.select(defaultvalue, x * math.rsqrt(len), len > FLT_MIN_NORMAL); + } + + /// + /// Returns a safe normalized version of the double4 vector x by scaling it by 1 / length(x). + /// Returns the given default value when 1 / length(x) does not produce a finite number. + /// + static public double4 normalizesafe(double4 x, double4 defaultvalue = new double4()) + { + double len = math.dot(x, x); + return math.select(defaultvalue, x * math.rsqrt(len), len > FLT_MIN_NORMAL); + } + + + /// Returns the length of a float value. Equivalent to the absolute value. + public static float length(float x) { return abs(x); } + + /// Returns the length of a float2 vector. + public static float length(float2 x) { return sqrt(dot(x, x)); } + + /// Returns the length of a float3 vector. + public static float length(float3 x) { return sqrt(dot(x, x)); } + + /// Returns the length of a float4 vector. + public static float length(float4 x) { return sqrt(dot(x, x)); } + + + /// Returns the length of a double value. Equivalent to the absolute value. + public static double length(double x) { return abs(x); } + + /// Returns the length of a double2 vector. + public static double length(double2 x) { return sqrt(dot(x, x)); } + + /// Returns the length of a double3 vector. + public static double length(double3 x) { return sqrt(dot(x, x)); } + + /// Returns the length of a double4 vector. + public static double length(double4 x) { return sqrt(dot(x, x)); } + + + /// Returns the squared length of a float value. Equivalent to squaring the value. + public static float lengthsq(float x) { return x*x; } + + /// Returns the squared length of a float2 vector. + public static float lengthsq(float2 x) { return dot(x, x); } + + /// Returns the squared length of a float3 vector. + public static float lengthsq(float3 x) { return dot(x, x); } + + /// Returns the squared length of a float4 vector. + public static float lengthsq(float4 x) { return dot(x, x); } + + + /// Returns the squared length of a double value. Equivalent to squaring the value. + public static double lengthsq(double x) { return x * x; } + + /// Returns the squared length of a double2 vector. + public static double lengthsq(double2 x) { return dot(x, x); } + + /// Returns the squared length of a double3 vector. + public static double lengthsq(double3 x) { return dot(x, x); } + + /// Returns the squared length of a double4 vector. + public static double lengthsq(double4 x) { return dot(x, x); } + + + /// Returns the distance between two float values. + public static float distance(float x, float y) { return abs(y - x); } + + /// Returns the distance between two float2 vectors. + public static float distance(float2 x, float2 y) { return length(y - x); } + + /// Returns the distance between two float3 vectors. + public static float distance(float3 x, float3 y) { return length(y - x); } + + /// Returns the distance between two float4 vectors. + public static float distance(float4 x, float4 y) { return length(y - x); } + + + /// Returns the distance between two double values. + public static double distance(double x, double y) { return abs(y - x); } + + /// Returns the distance between two double2 vectors. + public static double distance(double2 x, double2 y) { return length(y - x); } + + /// Returns the distance between two double3 vectors. + public static double distance(double3 x, double3 y) { return length(y - x); } + + /// Returns the distance between two double4 vectors. + public static double distance(double4 x, double4 y) { return length(y - x); } + + + /// Returns the distance between two float values. + public static float distancesq(float x, float y) { return (y - x) * (y - x); } + + /// Returns the distance between two float2 vectors. + public static float distancesq(float2 x, float2 y) { return lengthsq(y - x); } + + /// Returns the distance between two float3 vectors. + public static float distancesq(float3 x, float3 y) { return lengthsq(y - x); } + + /// Returns the distance between two float4 vectors. + public static float distancesq(float4 x, float4 y) { return lengthsq(y - x); } + + + /// Returns the distance between two double values. + public static double distancesq(double x, double y) { return (y - x) * (y - x); } + + /// Returns the distance between two double2 vectors. + public static double distancesq(double2 x, double2 y) { return lengthsq(y - x); } + + /// Returns the distance between two double3 vectors. + public static double distancesq(double3 x, double3 y) { return lengthsq(y - x); } + + /// Returns the distance between two double4 vectors. + public static double distancesq(double4 x, double4 y) { return lengthsq(y - x); } + + + /// Returns the cross product of two float3 vectors. + public static float3 cross(float3 x, float3 y) { return (x * y.yzx - x.yzx * y).yzx; } + + /// Returns the cross product of two double3 vectors. + public static double3 cross(double3 x, double3 y) { return (x * y.yzx - x.yzx * y).yzx; } + + + /// Returns a smooth Hermite interpolation between 0.0f and 1.0f when x is in [a, b]. + public static float smoothstep(float a, float b, float x) + { + var t = saturate((x - a) / (b - a)); + return t * t * (3.0f - (2.0f * t)); + } + + /// Returns a componentwise smooth Hermite interpolation between 0.0f and 1.0f when x is in [a, b]. + public static float2 smoothstep(float2 a, float2 b, float2 x) + { + var t = saturate((x - a) / (b - a)); + return t * t * (3.0f - (2.0f * t)); + } + + /// Returns a componentwise smooth Hermite interpolation between 0.0f and 1.0f when x is in [a, b]. + public static float3 smoothstep(float3 a, float3 b, float3 x) + { + var t = saturate((x - a) / (b - a)); + return t * t * (3.0f - (2.0f * t)); + } + + /// Returns a componentwise smooth Hermite interpolation between 0.0f and 1.0f when x is in [a, b]. + public static float4 smoothstep(float4 a, float4 b, float4 x) + { + var t = saturate((x - a) / (b - a)); + return t * t * (3.0f - (2.0f * t)); + } + + + /// Returns a smooth Hermite interpolation between 0.0 and 1.0 when x is in [a, b]. + public static double smoothstep(double a, double b, double x) + { + var t = saturate((x - a) / (b - a)); + return t * t * (3.0 - (2.0 * t)); + } + + /// Returns a componentwise smooth Hermite interpolation between 0.0 and 1.0 when x is in [a, b]. + public static double2 smoothstep(double2 a, double2 b, double2 x) + { + var t = saturate((x - a) / (b - a)); + return t * t * (3.0 - (2.0 * t)); + } + + /// Returns a componentwise smooth Hermite interpolation between 0.0 and 1.0 when x is in [a, b]. + public static double3 smoothstep(double3 a, double3 b, double3 x) + { + var t = saturate((x - a) / (b - a)); + return t * t * (3.0 - (2.0 * t)); + } + + /// Returns a componentwise smooth Hermite interpolation between 0.0 and 1.0 when x is in [a, b]. + public static double4 smoothstep(double4 a, double4 b, double4 x) + { + var t = saturate((x - a) / (b - a)); + return t * t * (3.0 - (2.0 * t)); + } + + + /// Returns true if any component of the input bool2 vector is true, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool any(bool2 x) { return x.x || x.y; } + + /// Returns true if any component of the input bool3 vector is true, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool any(bool3 x) { return x.x || x.y || x.z; } + + /// Returns true if any components of the input bool4 vector is true, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool any(bool4 x) { return x.x || x.y || x.z || x.w; } + + + /// Returns true if any component of the input int2 vector is non-zero, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool any(int2 x) { return x.x != 0 || x.y != 0; } + + /// Returns true if any component of the input int3 vector is non-zero, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool any(int3 x) { return x.x != 0 || x.y != 0 || x.z != 0; } + + /// Returns true if any components of the input int4 vector is non-zero, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool any(int4 x) { return x.x != 0 || x.y != 0 || x.z != 0 || x.w != 0; } + + + /// Returns true if any component of the input uint2 vector is non-zero, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool any(uint2 x) { return x.x != 0 || x.y != 0; } + + /// Returns true if any component of the input uint3 vector is non-zero, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool any(uint3 x) { return x.x != 0 || x.y != 0 || x.z != 0; } + + /// Returns true if any components of the input uint4 vector is non-zero, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool any(uint4 x) { return x.x != 0 || x.y != 0 || x.z != 0 || x.w != 0; } + + + /// Returns true if any component of the input float2 vector is non-zero, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool any(float2 x) { return x.x != 0.0f || x.y != 0.0f; } + + /// Returns true if any component of the input float3 vector is non-zero, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool any(float3 x) { return x.x != 0.0f || x.y != 0.0f || x.z != 0.0f; } + + /// Returns true if any component of the input float4 vector is non-zero, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool any(float4 x) { return x.x != 0.0f || x.y != 0.0f || x.z != 0.0f || x.w != 0.0f; } + + + /// Returns true if any component of the input double2 vector is non-zero, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool any(double2 x) { return x.x != 0.0 || x.y != 0.0; } + + /// Returns true if any component of the input double3 vector is non-zero, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool any(double3 x) { return x.x != 0.0 || x.y != 0.0 || x.z != 0.0; } + + /// Returns true if any component of the input double4 vector is non-zero, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool any(double4 x) { return x.x != 0.0 || x.y != 0.0 || x.z != 0.0 || x.w != 0.0; } + + + /// Returns true if all components of the input bool2 vector are true, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool all(bool2 x) { return x.x && x.y; } + + /// Returns true if all components of the input bool3 vector are true, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool all(bool3 x) { return x.x && x.y && x.z; } + + /// Returns true if all components of the input bool4 vector are true, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool all(bool4 x) { return x.x && x.y && x.z && x.w; } + + + /// Returns true if all components of the input int2 vector are non-zero, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool all(int2 x) { return x.x != 0 && x.y != 0; } + + /// Returns true if all components of the input int3 vector are non-zero, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool all(int3 x) { return x.x != 0 && x.y != 0 && x.z != 0; } + + /// Returns true if all components of the input int4 vector are non-zero, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool all(int4 x) { return x.x != 0 && x.y != 0 && x.z != 0 && x.w != 0; } + + + /// Returns true if all components of the input uint2 vector are non-zero, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool all(uint2 x) { return x.x != 0 && x.y != 0; } + + /// Returns true if all components of the input uint3 vector are non-zero, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool all(uint3 x) { return x.x != 0 && x.y != 0 && x.z != 0; } + + /// Returns true if all components of the input uint4 vector are non-zero, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool all(uint4 x) { return x.x != 0 && x.y != 0 && x.z != 0 && x.w != 0; } + + + /// Returns true if all components of the input float2 vector are non-zero, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool all(float2 x) { return x.x != 0.0f && x.y != 0.0f; } + + /// Returns true if all components of the input float3 vector are non-zero, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool all(float3 x) { return x.x != 0.0f && x.y != 0.0f && x.z != 0.0f; } + + /// Returns true if all components of the input float4 vector are non-zero, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool all(float4 x) { return x.x != 0.0f && x.y != 0.0f && x.z != 0.0f && x.w != 0.0f; } + + + /// Returns true if all components of the input double2 vector are non-zero, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool all(double2 x) { return x.x != 0.0 && x.y != 0.0; } + + /// Returns true if all components of the input double3 vector are non-zero, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool all(double3 x) { return x.x != 0.0 && x.y != 0.0 && x.z != 0.0; } + + /// Returns true if all components of the input double4 vector are non-zero, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool all(double4 x) { return x.x != 0.0 && x.y != 0.0 && x.z != 0.0 && x.w != 0.0; } + + + /// Returns b if c is true, a otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int select(int a, int b, bool c) { return c ? b : a; } + + /// Returns b if c is true, a otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 select(int2 a, int2 b, bool c) { return c ? b : a; } + + /// Returns b if c is true, a otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 select(int3 a, int3 b, bool c) { return c ? b : a; } + + /// Returns b if c is true, a otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 select(int4 a, int4 b, bool c) { return c ? b : a; } + + + /// + /// Returns a componentwise selection between two int2 vectors a and b based on a bool2 selection mask c. + /// Per component, the component from b is selected when c is true, otherwise the component from a is selected. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 select(int2 a, int2 b, bool2 c) { return new int2(c.x ? b.x : a.x, c.y ? b.y : a.y); } + + /// + /// Returns a componentwise selection between two int3 vectors a and b based on a bool3 selection mask c. + /// Per component, the component from b is selected when c is true, otherwise the component from a is selected. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 select(int3 a, int3 b, bool3 c) { return new int3(c.x ? b.x : a.x, c.y ? b.y : a.y, c.z ? b.z : a.z); } + + /// + /// Returns a componentwise selection between two int4 vectors a and b based on a bool4 selection mask c. + /// Per component, the component from b is selected when c is true, otherwise the component from a is selected. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 select(int4 a, int4 b, bool4 c) { return new int4(c.x ? b.x : a.x, c.y ? b.y : a.y, c.z ? b.z : a.z, c.w ? b.w : a.w); } + + + /// Returns b if c is true, a otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint select(uint a, uint b, bool c) { return c ? b : a; } + + /// Returns b if c is true, a otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2 select(uint2 a, uint2 b, bool c) { return c ? b : a; } + + /// Returns b if c is true, a otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 select(uint3 a, uint3 b, bool c) { return c ? b : a; } + + /// Returns b if c is true, a otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 select(uint4 a, uint4 b, bool c) { return c ? b : a; } + + + /// + /// Returns a componentwise selection between two uint2 vectors a and b based on a bool2 selection mask c. + /// Per component, the component from b is selected when c is true, otherwise the component from a is selected. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2 select(uint2 a, uint2 b, bool2 c) { return new uint2(c.x ? b.x : a.x, c.y ? b.y : a.y); } + + /// + /// Returns a componentwise selection between two uint3 vectors a and b based on a bool3 selection mask c. + /// Per component, the component from b is selected when c is true, otherwise the component from a is selected. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 select(uint3 a, uint3 b, bool3 c) { return new uint3(c.x ? b.x : a.x, c.y ? b.y : a.y, c.z ? b.z : a.z); } + + /// + /// Returns a componentwise selection between two uint4 vectors a and b based on a bool4 selection mask c. + /// Per component, the component from b is selected when c is true, otherwise the component from a is selected. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 select(uint4 a, uint4 b, bool4 c) { return new uint4(c.x ? b.x : a.x, c.y ? b.y : a.y, c.z ? b.z : a.z, c.w ? b.w : a.w); } + + + /// Returns b if c is true, a otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static long select(long a, long b, bool c) { return c ? b : a; } + + /// Returns b if c is true, a otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static ulong select(ulong a, ulong b, bool c) { return c ? b : a; } + + + /// Returns b if c is true, a otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float select(float a, float b, bool c) { return c ? b : a; } + + /// Returns b if c is true, a otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 select(float2 a, float2 b, bool c) { return c ? b : a; } + + /// Returns b if c is true, a otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 select(float3 a, float3 b, bool c) { return c ? b : a; } + + /// Returns b if c is true, a otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 select(float4 a, float4 b, bool c) { return c ? b : a; } + + + /// + /// Returns a componentwise selection between two float2 vectors a and b based on a bool2 selection mask c. + /// Per component, the component from b is selected when c is true, otherwise the component from a is selected. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 select(float2 a, float2 b, bool2 c) { return new float2(c.x ? b.x : a.x, c.y ? b.y : a.y); } + + /// + /// Returns a componentwise selection between two float3 vectors a and b based on a bool3 selection mask c. + /// Per component, the component from b is selected when c is true, otherwise the component from a is selected. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 select(float3 a, float3 b, bool3 c) { return new float3(c.x ? b.x : a.x, c.y ? b.y : a.y, c.z ? b.z : a.z); } + + /// + /// Returns a componentwise selection between two float4 vectors a and b based on a bool4 selection mask c. + /// Per component, the component from b is selected when c is true, otherwise the component from a is selected. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 select(float4 a, float4 b, bool4 c) { return new float4(c.x ? b.x : a.x, c.y ? b.y : a.y, c.z ? b.z : a.z, c.w ? b.w : a.w); } + + + /// Returns b if c is true, a otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double select(double a, double b, bool c) { return c ? b : a; } + + /// Returns b if c is true, a otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2 select(double2 a, double2 b, bool c) { return c ? b : a; } + + /// Returns b if c is true, a otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3 select(double3 a, double3 b, bool c) { return c ? b : a; } + + /// Returns b if c is true, a otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4 select(double4 a, double4 b, bool c) { return c ? b : a; } + + /// + /// Returns a componentwise selection between two double2 vectors a and b based on a bool2 selection mask c. + /// Per component, the component from b is selected when c is true, otherwise the component from a is selected. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2 select(double2 a, double2 b, bool2 c) { return new double2(c.x ? b.x : a.x, c.y ? b.y : a.y); } + + /// + /// Returns a componentwise selection between two double3 vectors a and b based on a bool3 selection mask c. + /// Per component, the component from b is selected when c is true, otherwise the component from a is selected. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3 select(double3 a, double3 b, bool3 c) { return new double3(c.x ? b.x : a.x, c.y ? b.y : a.y, c.z ? b.z : a.z); } + + /// + /// Returns a componentwise selection between two double4 vectors a and b based on a bool4 selection mask c. + /// Per component, the component from b is selected when c is true, otherwise the component from a is selected. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4 select(double4 a, double4 b, bool4 c) { return new double4(c.x ? b.x : a.x, c.y ? b.y : a.y, c.z ? b.z : a.z, c.w ? b.w : a.w); } + + + /// Computes a step function. Returns 1.0f when x >= y, 0.0f otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float step(float y, float x) { return select(0.0f, 1.0f, x >= y); } + + /// Returns the result of a componentwise step function where each component is 1.0f when x >= y and 0.0f otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 step(float2 y, float2 x) { return select(float2(0.0f), float2(1.0f), x >= y); } + + /// Returns the result of a componentwise step function where each component is 1.0f when x >= y and 0.0f otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 step(float3 y, float3 x) { return select(float3(0.0f), float3(1.0f), x >= y); } + + /// Returns the result of a componentwise step function where each component is 1.0f when x >= y and 0.0f otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 step(float4 y, float4 x) { return select(float4(0.0f), float4(1.0f), x >= y); } + + + /// Computes a step function. Returns 1.0 when x >= y, 0.0 otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double step(double y, double x) { return select(0.0, 1.0, x >= y); } + + /// Returns the result of a componentwise step function where each component is 1.0f when x >= y and 0.0f otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2 step(double2 y, double2 x) { return select(double2(0.0), double2(1.0), x >= y); } + + /// Returns the result of a componentwise step function where each component is 1.0f when x >= y and 0.0f otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3 step(double3 y, double3 x) { return select(double3(0.0), double3(1.0), x >= y); } + + /// Returns the result of a componentwise step function where each component is 1.0f when x >= y and 0.0f otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4 step(double4 y, double4 x) { return select(double4(0.0), double4(1.0), x >= y); } + + + /// Given an incident vector i and a normal vector n, returns the reflection vector r = i - 2.0f * dot(i, n) * n. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 reflect(float2 i, float2 n) { return i - 2f * n * dot(i, n); } + + /// Given an incident vector i and a normal vector n, returns the reflection vector r = i - 2.0f * dot(i, n) * n. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 reflect(float3 i, float3 n) { return i - 2f * n * dot(i, n); } + + /// Given an incident vector i and a normal vector n, returns the reflection vector r = i - 2.0f * dot(i, n) * n. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 reflect(float4 i, float4 n) { return i - 2f * n * dot(i, n); } + + + /// Given an incident vector i and a normal vector n, returns the reflection vector r = i - 2.0 * dot(i, n) * n. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2 reflect(double2 i, double2 n) { return i - 2 * n * dot(i, n); } + + /// Given an incident vector i and a normal vector n, returns the reflection vector r = i - 2.0 * dot(i, n) * n. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3 reflect(double3 i, double3 n) { return i - 2 * n * dot(i, n); } + + /// Given an incident vector i and a normal vector n, returns the reflection vector r = i - 2.0 * dot(i, n) * n. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4 reflect(double4 i, double4 n) { return i - 2 * n * dot(i, n); } + + + /// Returns the refraction vector given the incident vector i, the normal vector n and the refraction index eta. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 refract(float2 i, float2 n, float eta) + { + float ni = dot(n, i); + float k = 1.0f - eta * eta * (1.0f - ni * ni); + return select(0.0f, eta * i - (eta * ni + sqrt(k)) * n, k >= 0); + } + + /// Returns the refraction vector given the incident vector i, the normal vector n and the refraction index eta. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 refract(float3 i, float3 n, float eta) + { + float ni = dot(n, i); + float k = 1.0f - eta * eta * (1.0f - ni * ni); + return select(0.0f, eta * i - (eta * ni + sqrt(k)) * n, k >= 0); + } + + /// Returns the refraction vector given the incident vector i, the normal vector n and the refraction index eta. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 refract(float4 i, float4 n, float eta) + { + float ni = dot(n, i); + float k = 1.0f - eta * eta * (1.0f - ni * ni); + return select(0.0f, eta * i - (eta * ni + sqrt(k)) * n, k >= 0); + } + + + /// Returns the refraction vector given the incident vector i, the normal vector n and the refraction index eta. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2 refract(double2 i, double2 n, double eta) + { + double ni = dot(n, i); + double k = 1.0 - eta * eta * (1.0 - ni * ni); + return select(0.0f, eta * i - (eta * ni + sqrt(k)) * n, k >= 0); + } + + /// Returns the refraction vector given the incident vector i, the normal vector n and the refraction index eta. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3 refract(double3 i, double3 n, double eta) + { + double ni = dot(n, i); + double k = 1.0 - eta * eta * (1.0 - ni * ni); + return select(0.0f, eta * i - (eta * ni + sqrt(k)) * n, k >= 0); + } + + /// Returns the refraction vector given the incident vector i, the normal vector n and the refraction index eta. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4 refract(double4 i, double4 n, double eta) + { + double ni = dot(n, i); + double k = 1.0 - eta * eta * (1.0 - ni * ni); + return select(0.0f, eta * i - (eta * ni + sqrt(k)) * n, k >= 0); + } + + + /// Conditionally flips a vector n to face in the direction of i. Returns n if dot(i, ng) < 0, -n otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 faceforward(float2 n, float2 i, float2 ng) { return select(n, -n, dot(ng, i) >= 0.0f); } + + /// Conditionally flips a vector n to face in the direction of i. Returns n if dot(i, ng) < 0, -n otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 faceforward(float3 n, float3 i, float3 ng) { return select(n, -n, dot(ng, i) >= 0.0f); } + + /// Conditionally flips a vector n to face in the direction of i. Returns n if dot(i, ng) < 0, -n otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 faceforward(float4 n, float4 i, float4 ng) { return select(n, -n, dot(ng, i) >= 0.0f); } + + + /// Conditionally flips a vector n to face in the direction of i. Returns n if dot(i, ng) < 0, -n otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2 faceforward(double2 n, double2 i, double2 ng) { return select(n, -n, dot(ng, i) >= 0.0f); } + + /// Conditionally flips a vector n to face in the direction of i. Returns n if dot(i, ng) < 0, -n otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3 faceforward(double3 n, double3 i, double3 ng) { return select(n, -n, dot(ng, i) >= 0.0f); } + + /// Conditionally flips a vector n to face in the direction of i. Returns n if dot(i, ng) < 0, -n otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4 faceforward(double4 n, double4 i, double4 ng) { return select(n, -n, dot(ng, i) >= 0.0f); } + + + /// Returns the sine and cosine of the input float value x through the out parameters s and c. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void sincos(float x, out float s, out float c) { s = sin(x); c = cos(x); } + + /// Returns the componentwise sine and cosine of the input float2 vector x through the out parameters s and c. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void sincos(float2 x, out float2 s, out float2 c) { s = sin(x); c = cos(x); } + + /// Returns the componentwise sine and cosine of the input float3 vector x through the out parameters s and c. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void sincos(float3 x, out float3 s, out float3 c) { s = sin(x); c = cos(x); } + + /// Returns the componentwise sine and cosine of the input float4 vector x through the out parameters s and c. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void sincos(float4 x, out float4 s, out float4 c) { s = sin(x); c = cos(x); } + + + /// Returns the sine and cosine of the input double value x through the out parameters s and c. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void sincos(double x, out double s, out double c) { s = sin(x); c = cos(x); } + + /// Returns the componentwise sine and cosine of the input double2 vector x through the out parameters s and c. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void sincos(double2 x, out double2 s, out double2 c) { s = sin(x); c = cos(x); } + + /// Returns the componentwise sine and cosine of the input double3 vector x through the out parameters s and c. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void sincos(double3 x, out double3 s, out double3 c) { s = sin(x); c = cos(x); } + + /// Returns the componentwise sine and cosine of the input double4 vector x through the out parameters s and c. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void sincos(double4 x, out double4 s, out double4 c) { s = sin(x); c = cos(x); } + + + /// Returns number of 1-bits in the binary representations of an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int countbits(int x) { return countbits((uint)x); } + + /// Returns componentwise number of 1-bits in the binary representations of an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 countbits(int2 x) { return countbits((uint2)x); } + + /// Returns componentwise number of 1-bits in the binary representations of an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 countbits(int3 x) { return countbits((uint3)x); } + + /// Returns componentwise number of 1-bits in the binary representations of an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 countbits(int4 x) { return countbits((uint4)x); } + + + /// Returns number of 1-bits in the binary representations of a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int countbits(uint x) + { + x = x - ((x >> 1) & 0x55555555); + x = (x & 0x33333333) + ((x >> 2) & 0x33333333); + return (int)((((x + (x >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24); + } + + /// Returns componentwise number of 1-bits in the binary representations of a uint2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 countbits(uint2 x) + { + x = x - ((x >> 1) & 0x55555555); + x = (x & 0x33333333) + ((x >> 2) & 0x33333333); + return int2((((x + (x >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24); + } + + /// Returns componentwise number of 1-bits in the binary representations of a uint3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 countbits(uint3 x) + { + x = x - ((x >> 1) & 0x55555555); + x = (x & 0x33333333) + ((x >> 2) & 0x33333333); + return int3((((x + (x >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24); + } + + /// Returns componentwise number of 1-bits in the binary representations of a uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 countbits(uint4 x) + { + x = x - ((x >> 1) & 0x55555555); + x = (x & 0x33333333) + ((x >> 2) & 0x33333333); + return int4((((x + (x >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24); + } + + /// Returns number of 1-bits in the binary representations of a ulong value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int countbits(ulong x) + { + x = x - ((x >> 1) & 0x5555555555555555); + x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333); + return (int)((((x + (x >> 4)) & 0x0F0F0F0F0F0F0F0F) * 0x0101010101010101) >> 56); + } + + /// Returns number of 1-bits in the binary representations of a long value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int countbits(long x) { return countbits((ulong)x); } + + + /// Returns the componentwise number of leading zeros in the binary representations of an int vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int lzcnt(int x) { return lzcnt((uint)x); } + + /// Returns the componentwise number of leading zeros in the binary representations of an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 lzcnt(int2 x) { return int2(lzcnt(x.x), lzcnt(x.y)); } + + /// Returns the componentwise number of leading zeros in the binary representations of an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 lzcnt(int3 x) { return int3(lzcnt(x.x), lzcnt(x.y), lzcnt(x.z)); } + + /// Returns the componentwise number of leading zeros in the binary representations of an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 lzcnt(int4 x) { return int4(lzcnt(x.x), lzcnt(x.y), lzcnt(x.z), lzcnt(x.w)); } + + + /// Returns number of leading zeros in the binary representations of a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int lzcnt(uint x) + { + if (x == 0) + return 32; + LongDoubleUnion u; + u.doubleValue = 0.0; + u.longValue = 0x4330000000000000L + x; + u.doubleValue -= 4503599627370496.0; + return 0x41E - (int)(u.longValue >> 52); + } + + /// Returns the componentwise number of leading zeros in the binary representations of a uint2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 lzcnt(uint2 x) { return int2(lzcnt(x.x), lzcnt(x.y)); } + + /// Returns the componentwise number of leading zeros in the binary representations of a uint3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 lzcnt(uint3 x) { return int3(lzcnt(x.x), lzcnt(x.y), lzcnt(x.z)); } + + /// Returns the componentwise number of leading zeros in the binary representations of a uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 lzcnt(uint4 x) { return int4(lzcnt(x.x), lzcnt(x.y), lzcnt(x.z), lzcnt(x.w)); } + + + /// Returns number of leading zeros in the binary representations of a long value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int lzcnt(long x) { return lzcnt((ulong)x); } + + + /// Returns number of leading zeros in the binary representations of a ulong value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int lzcnt(ulong x) + { + if (x == 0) + return 64; + + uint xh = (uint)(x >> 32); + uint bits = xh != 0 ? xh : (uint)x; + int offset = xh != 0 ? 0x41E : 0x43E; + + LongDoubleUnion u; + u.doubleValue = 0.0; + u.longValue = 0x4330000000000000L + bits; + u.doubleValue -= 4503599627370496.0; + return offset - (int)(u.longValue >> 52); + } + + + /// Returns number of trailing zeros in the binary representations of an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int tzcnt(int x) { return tzcnt((uint)x); } + + /// Returns the componentwise number of leading zeros in the binary representations of an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 tzcnt(int2 x) { return int2(tzcnt(x.x), tzcnt(x.y)); } + + /// Returns the componentwise number of leading zeros in the binary representations of an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 tzcnt(int3 v) { return int3(tzcnt(v.x), tzcnt(v.y), tzcnt(v.z)); } + + /// Returns the componentwise number of leading zeros in the binary representations of an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 tzcnt(int4 v) { return int4(tzcnt(v.x), tzcnt(v.y), tzcnt(v.z), tzcnt(v.w)); } + + + /// Returns number of trailing zeros in the binary representations of a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int tzcnt(uint x) + { + if (x == 0) + return 32; + + x &= (uint)-x; + LongDoubleUnion u; + u.doubleValue = 0.0; + u.longValue = 0x4330000000000000L + x; + u.doubleValue -= 4503599627370496.0; + return (int)(u.longValue >> 52) - 0x3FF; + } + + /// Returns the componentwise number of leading zeros in the binary representations of an uint2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 tzcnt(uint2 x) { return int2(tzcnt(x.x), tzcnt(x.y)); } + + /// Returns the componentwise number of leading zeros in the binary representations of an uint3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 tzcnt(uint3 x) { return int3(tzcnt(x.x), tzcnt(x.y), tzcnt(x.z)); } + + /// Returns the componentwise number of leading zeros in the binary representations of an uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 tzcnt(uint4 x) { return int4(tzcnt(x.x), tzcnt(x.y), tzcnt(x.z), tzcnt(x.w)); } + + + /// Returns number of trailing zeros in the binary representations of a long value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int tzcnt(long x) { return tzcnt((ulong)x); } + + + /// Returns number of trailing zeros in the binary representations of a ulong value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int tzcnt(ulong x) + { + if (x == 0) + return 64; + + x = x & (ulong)-(long)x; + uint xl = (uint)x; + + uint bits = xl != 0 ? xl : (uint)(x >> 32); + int offset = xl != 0 ? 0x3FF : 0x3DF; + + LongDoubleUnion u; + u.doubleValue = 0.0; + u.longValue = 0x4330000000000000L + bits; + u.doubleValue -= 4503599627370496.0; + return (int)(u.longValue >> 52) - offset; + } + + + + /// Returns the result of performing a reversal of the bit pattern of an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int reversebits(int x) { return (int)reversebits((uint)x); } + + /// Returns the result of performing a componentwise reversal of the bit pattern of an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 reversebits(int2 x) { return (int2)reversebits((uint2)x); } + + /// Returns the result of performing a componentwise reversal of the bit pattern of an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 reversebits(int3 x) { return (int3)reversebits((uint3)x); } + + /// Returns the result of performing a componentwise reversal of the bit pattern of an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 reversebits(int4 x) { return (int4)reversebits((uint4)x); } + + + /// Returns the result of performing a reversal of the bit pattern of a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint reversebits(uint x) { + x = ((x >> 1) & 0x55555555) | ((x & 0x55555555) << 1); + x = ((x >> 2) & 0x33333333) | ((x & 0x33333333) << 2); + x = ((x >> 4) & 0x0F0F0F0F) | ((x & 0x0F0F0F0F) << 4); + x = ((x >> 8) & 0x00FF00FF) | ((x & 0x00FF00FF) << 8); + return (x >> 16) | (x << 16); + } + + /// Returns the result of performing a componentwise reversal of the bit pattern of an uint2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2 reversebits(uint2 x) + { + x = ((x >> 1) & 0x55555555) | ((x & 0x55555555) << 1); + x = ((x >> 2) & 0x33333333) | ((x & 0x33333333) << 2); + x = ((x >> 4) & 0x0F0F0F0F) | ((x & 0x0F0F0F0F) << 4); + x = ((x >> 8) & 0x00FF00FF) | ((x & 0x00FF00FF) << 8); + return (x >> 16) | (x << 16); + } + + /// Returns the result of performing a componentwise reversal of the bit pattern of an uint3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 reversebits(uint3 x) + { + x = ((x >> 1) & 0x55555555) | ((x & 0x55555555) << 1); + x = ((x >> 2) & 0x33333333) | ((x & 0x33333333) << 2); + x = ((x >> 4) & 0x0F0F0F0F) | ((x & 0x0F0F0F0F) << 4); + x = ((x >> 8) & 0x00FF00FF) | ((x & 0x00FF00FF) << 8); + return (x >> 16) | (x << 16); + } + + /// Returns the result of performing a componentwise reversal of the bit pattern of an uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 reversebits(uint4 x) + { + x = ((x >> 1) & 0x55555555) | ((x & 0x55555555) << 1); + x = ((x >> 2) & 0x33333333) | ((x & 0x33333333) << 2); + x = ((x >> 4) & 0x0F0F0F0F) | ((x & 0x0F0F0F0F) << 4); + x = ((x >> 8) & 0x00FF00FF) | ((x & 0x00FF00FF) << 8); + return (x >> 16) | (x << 16); + } + + + /// Returns the result of performing a reversal of the bit pattern of a long value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static long reversebits(long x) { return (long)reversebits((ulong)x); } + + + /// Returns the result of performing a reversal of the bit pattern of a ulong value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static ulong reversebits(ulong x) + { + x = ((x >> 1) & 0x5555555555555555ul) | ((x & 0x5555555555555555ul) << 1); + x = ((x >> 2) & 0x3333333333333333ul) | ((x & 0x3333333333333333ul) << 2); + x = ((x >> 4) & 0x0F0F0F0F0F0F0F0Ful) | ((x & 0x0F0F0F0F0F0F0F0Ful) << 4); + x = ((x >> 8) & 0x00FF00FF00FF00FFul) | ((x & 0x00FF00FF00FF00FFul) << 8); + x = ((x >> 16) & 0x0000FFFF0000FFFFul) | ((x & 0x0000FFFF0000FFFFul) << 16); + return (x >> 32) | (x << 32); + } + + + /// Returns the result of rotating the bits of an int left by bits n. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int rol(int x, int n) { return (int)rol((uint)x, n); } + + /// Returns the componentwise result of rotating the bits of an int2 left by bits n. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 rol(int2 x, int n) { return (int2)rol((uint2)x, n); } + + /// Returns the componentwise result of rotating the bits of an int3 left by bits n. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 rol(int3 x, int n) { return (int3)rol((uint3)x, n); } + + /// Returns the componentwise result of rotating the bits of an int4 left by bits n. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 rol(int4 x, int n) { return (int4)rol((uint4)x, n); } + + + /// Returns the result of rotating the bits of a uint left by bits n. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint rol(uint x, int n) { return (x << n) | (x >> (32 - n)); } + + /// Returns the componentwise result of rotating the bits of a uint2 left by bits n. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2 rol(uint2 x, int n) { return (x << n) | (x >> (32 - n)); } + + /// Returns the componentwise result of rotating the bits of a uint3 left by bits n. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 rol(uint3 x, int n) { return (x << n) | (x >> (32 - n)); } + + /// Returns the componentwise result of rotating the bits of a uint4 left by bits n. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 rol(uint4 x, int n) { return (x << n) | (x >> (32 - n)); } + + + /// Returns the result of rotating the bits of a long left by bits n. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static long rol(long x, int n) { return (long)rol((ulong)x, n); } + + + /// Returns the result of rotating the bits of a ulong left by bits n. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static ulong rol(ulong x, int n) { return (x << n) | (x >> (64 - n)); } + + + /// Returns the result of rotating the bits of an int right by bits n. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int ror(int x, int n) { return (int)ror((uint)x, n); } + + /// Returns the componentwise result of rotating the bits of an int2 right by bits n. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 ror(int2 x, int n) { return (int2)ror((uint2)x, n); } + + /// Returns the componentwise result of rotating the bits of an int3 right by bits n. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 ror(int3 x, int n) { return (int3)ror((uint3)x, n); } + + /// Returns the componentwise result of rotating the bits of an int4 right by bits n. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 ror(int4 x, int n) { return (int4)ror((uint4)x, n); } + + + /// Returns the result of rotating the bits of a uint right by bits n. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint ror(uint x, int n) { return (x >> n) | (x << (32 - n)); } + + /// Returns the componentwise result of rotating the bits of a uint2 right by bits n. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2 ror(uint2 x, int n) { return (x >> n) | (x << (32 - n)); } + + /// Returns the componentwise result of rotating the bits of a uint3 right by bits n. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 ror(uint3 x, int n) { return (x >> n) | (x << (32 - n)); } + + /// Returns the componentwise result of rotating the bits of a uint4 right by bits n. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 ror(uint4 x, int n) { return (x >> n) | (x << (32 - n)); } + + + /// Returns the result of rotating the bits of a long right by bits n. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static long ror(long x, int n) { return (long)ror((ulong)x, n); } + + + /// Returns the result of rotating the bits of a ulong right by bits n. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static ulong ror(ulong x, int n) { return (x >> n) | (x << (64 - n)); } + + + /// Returns the smallest power of two greater than or equal to the input. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int ceilpow2(int x) + { + x -= 1; + x |= x >> 1; + x |= x >> 2; + x |= x >> 4; + x |= x >> 8; + x |= x >> 16; + return x + 1; + } + + /// Returns the result of a componentwise calculation of the smallest power of two greater than or equal to the input. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 ceilpow2(int2 x) + { + x -= 1; + x |= x >> 1; + x |= x >> 2; + x |= x >> 4; + x |= x >> 8; + x |= x >> 16; + return x + 1; + } + + /// Returns the result of a componentwise calculation of the smallest power of two greater than or equal to the input. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 ceilpow2(int3 x) + { + x -= 1; + x |= x >> 1; + x |= x >> 2; + x |= x >> 4; + x |= x >> 8; + x |= x >> 16; + return x + 1; + } + + /// Returns the result of a componentwise calculation of the smallest power of two greater than or equal to the input. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 ceilpow2(int4 x) + { + x -= 1; + x |= x >> 1; + x |= x >> 2; + x |= x >> 4; + x |= x >> 8; + x |= x >> 16; + return x + 1; + } + + + /// Returns the smallest power of two greater than or equal to the input. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint ceilpow2(uint x) + { + x -= 1; + x |= x >> 1; + x |= x >> 2; + x |= x >> 4; + x |= x >> 8; + x |= x >> 16; + return x + 1; + } + + /// Returns the result of a componentwise calculation of the smallest power of two greater than or equal to the input. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2 ceilpow2(uint2 x) + { + x -= 1; + x |= x >> 1; + x |= x >> 2; + x |= x >> 4; + x |= x >> 8; + x |= x >> 16; + return x + 1; + } + + /// Returns the result of a componentwise calculation of the smallest power of two greater than or equal to the input. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 ceilpow2(uint3 x) + { + x -= 1; + x |= x >> 1; + x |= x >> 2; + x |= x >> 4; + x |= x >> 8; + x |= x >> 16; + return x + 1; + } + + /// Returns the result of a componentwise calculation of the smallest power of two greater than or equal to the input. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 ceilpow2(uint4 x) + { + x -= 1; + x |= x >> 1; + x |= x >> 2; + x |= x >> 4; + x |= x >> 8; + x |= x >> 16; + return x + 1; + } + + + /// Returns the smallest power of two greater than or equal to the input. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static long ceilpow2(long x) + { + x -= 1; + x |= x >> 1; + x |= x >> 2; + x |= x >> 4; + x |= x >> 8; + x |= x >> 16; + x |= x >> 32; + return x + 1; + } + + + /// Returns the smallest power of two greater than or equal to the input. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static ulong ceilpow2(ulong x) + { + x -= 1; + x |= x >> 1; + x |= x >> 2; + x |= x >> 4; + x |= x >> 8; + x |= x >> 16; + x |= x >> 32; + return x + 1; + } + + /// Returns the result of converting a float value from degrees to radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float radians(float x) { return x * 0.0174532925f; } + + /// Returns the result of a componentwise conversion of a float2 vector from degrees to radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 radians(float2 x) { return x * 0.0174532925f; } + + /// Returns the result of a componentwise conversion of a float3 vector from degrees to radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 radians(float3 x) { return x * 0.0174532925f; } + + /// Returns the result of a componentwise conversion of a float4 vector from degrees to radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 radians(float4 x) { return x * 0.0174532925f; } + + + /// Returns the result of converting a float value from degrees to radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double radians(double x) { return x * 0.017453292519943296; } + + /// Returns the result of a componentwise conversion of a float2 vector from degrees to radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2 radians(double2 x) { return x * 0.017453292519943296; } + + /// Returns the result of a componentwise conversion of a float3 vector from degrees to radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3 radians(double3 x) { return x * 0.017453292519943296; } + + /// Returns the result of a componentwise conversion of a float4 vector from degrees to radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4 radians(double4 x) { return x * 0.017453292519943296; } + + + /// Returns the result of converting a double value from radians to degrees. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float degrees(float x) { return x * 57.295779513f; } + + /// Returns the result of a componentwise conversion of a double2 vector from radians to degrees. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 degrees(float2 x) { return x * 57.295779513f; } + + /// Returns the result of a componentwise conversion of a double3 vector from radians to degrees. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 degrees(float3 x) { return x * 57.295779513f; } + + /// Returns the result of a componentwise conversion of a double4 vector from radians to degrees. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 degrees(float4 x) { return x * 57.295779513f; } + + + /// Returns the result of converting a double value from radians to degrees. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double degrees(double x) { return x * 57.29577951308232; } + + /// Returns the result of a componentwise conversion of a double2 vector from radians to degrees. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2 degrees(double2 x) { return x * 57.29577951308232; } + + /// Returns the result of a componentwise conversion of a double3 vector from radians to degrees. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3 degrees(double3 x) { return x * 57.29577951308232; } + + /// Returns the result of a componentwise conversion of a double4 vector from radians to degrees. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4 degrees(double4 x) { return x * 57.29577951308232; } + + + /// Returns the minimum component of an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int cmin(int2 x) { return min(x.x, x.y); } + + /// Returns the minimum component of an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int cmin(int3 x) { return min(min(x.x, x.y), x.z); } + + /// Returns the minimum component of an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int cmin(int4 x) { return min(min(x.x, x.y), min(x.z, x.w)); } + + + /// Returns the minimum component of a uint2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint cmin(uint2 x) { return min(x.x, x.y); } + + /// Returns the minimum component of a uint3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint cmin(uint3 x) { return min(min(x.x, x.y), x.z); } + + /// Returns the minimum component of a uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint cmin(uint4 x) { return min(min(x.x, x.y), min(x.z, x.w)); } + + + /// Returns the minimum component of a float2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float cmin(float2 x) { return min(x.x, x.y); } + + /// Returns the minimum component of a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float cmin(float3 x) { return min(min(x.x, x.y), x.z); } + + /// Returns the maximum component of a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float cmin(float4 x) { return min(min(x.x, x.y), min(x.z, x.w)); } + + + /// Returns the minimum component of a float2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double cmin(double2 x) { return min(x.x, x.y); } + + /// Returns the minimum component of a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double cmin(double3 x) { return min(min(x.x, x.y), x.z); } + + /// Returns the maximum component of a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double cmin(double4 x) { return min(min(x.x, x.y), min(x.z, x.w)); } + + + /// Returns the maximum component of an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int cmax(int2 x) { return max(x.x, x.y); } + + /// Returns the maximum component of an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int cmax(int3 x) { return max(max(x.x, x.y), x.z); } + + /// Returns the maximum component of an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int cmax(int4 x) { return max(max(x.x, x.y), max(x.z, x.w)); } + + + /// Returns the maximum component of a uint2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint cmax(uint2 x) { return max(x.x, x.y); } + + /// Returns the maximum component of a uint3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint cmax(uint3 x) { return max(max(x.x, x.y), x.z); } + + /// Returns the maximum component of a uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint cmax(uint4 x) { return max(max(x.x, x.y), max(x.z, x.w)); } + + + /// Returns the maximum component of a float2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float cmax(float2 x) { return max(x.x, x.y); } + + /// Returns the maximum component of a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float cmax(float3 x) { return max(max(x.x, x.y), x.z); } + + /// Returns the maximum component of a float4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float cmax(float4 x) { return max(max(x.x, x.y), max(x.z, x.w)); } + + + /// Returns the maximum component of a double2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double cmax(double2 x) { return max(x.x, x.y); } + + /// Returns the maximum component of a double3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double cmax(double3 x) { return max(max(x.x, x.y), x.z); } + + /// Returns the maximum component of a double4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double cmax(double4 x) { return max(max(x.x, x.y), max(x.z, x.w)); } + + + /// Returns the horizontal sum of components of an int2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int csum(int2 x) { return x.x + x.y; } + + /// Returns the horizontal sum of components of an int3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int csum(int3 x) { return x.x + x.y + x.z; } + + /// Returns the horizontal sum of components of an int4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int csum(int4 x) { return x.x + x.y + x.z + x.w; } + + + /// Returns the horizontal sum of components of a uint2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint csum(uint2 x) { return x.x + x.y; } + + /// Returns the horizontal sum of components of a uint3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint csum(uint3 x) { return x.x + x.y + x.z; } + + /// Returns the horizontal sum of components of a uint4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint csum(uint4 x) { return x.x + x.y + x.z + x.w; } + + + /// Returns the horizontal sum of components of a float2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float csum(float2 x) { return x.x + x.y; } + + /// Returns the horizontal sum of components of a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float csum(float3 x) { return x.x + x.y + x.z; } + + /// Returns the horizontal sum of components of a float4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float csum(float4 x) { return (x.x + x.y) + (x.z + x.w); } + + + /// Returns the horizontal sum of components of a double2 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double csum(double2 x) { return x.x + x.y; } + + /// Returns the horizontal sum of components of a double3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double csum(double3 x) { return x.x + x.y + x.z; } + + /// Returns the horizontal sum of components of a double4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double csum(double4 x) { return (x.x + x.y) + (x.z + x.w); } + + /// + /// Packs components with an enabled mask (LSB) to the left + /// The value of components after the last packed component are undefined. + /// Returns the number of enabled mask bits. (0 ... 4) + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static unsafe int compress(int* output, int index, int4 val, bool4 mask) + { + if (mask.x) + output[index++] = val.x; + if (mask.y) + output[index++] = val.y; + if (mask.z) + output[index++] = val.z; + if (mask.w) + output[index++] = val.w; + + return index; + } + + /// Returns the floating point representation of a half-precision floating point value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float f16tof32(uint x) + { + const uint shifted_exp = (0x7c00 << 13); + uint uf = (x & 0x7fff) << 13; + uint e = uf & shifted_exp; + uf += (127 - 15) << 23; + uf += select(0, (128u - 16u) << 23, e == shifted_exp); + uf = select(uf, asuint(asfloat(uf + (1 << 23)) - 6.10351563e-05f), e == 0); + uf |= (x & 0x8000) << 16; + return asfloat(uf); + } + + /// Returns the floating point representation of a half-precision floating point vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 f16tof32(uint2 x) + { + const uint shifted_exp = (0x7c00 << 13); + uint2 uf = (x & 0x7fff) << 13; + uint2 e = uf & shifted_exp; + uf += (127 - 15) << 23; + uf += select(0, (128u - 16u) << 23, e == shifted_exp); + uf = select(uf, asuint(asfloat(uf + (1 << 23)) - 6.10351563e-05f), e == 0); + uf |= (x & 0x8000) << 16; + return asfloat(uf); + } + + /// Returns the floating point representation of a half-precision floating point vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 f16tof32(uint3 x) + { + const uint shifted_exp = (0x7c00 << 13); + uint3 uf = (x & 0x7fff) << 13; + uint3 e = uf & shifted_exp; + uf += (127 - 15) << 23; + uf += select(0, (128u - 16u) << 23, e == shifted_exp); + uf = select(uf, asuint(asfloat(uf + (1 << 23)) - 6.10351563e-05f), e == 0); + uf |= (x & 0x8000) << 16; + return asfloat(uf); + } + + /// Returns the floating point representation of a half-precision floating point vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 f16tof32(uint4 x) + { + const uint shifted_exp = (0x7c00 << 13); + uint4 uf = (x & 0x7fff) << 13; + uint4 e = uf & shifted_exp; + uf += (127 - 15) << 23; + uf += select(0, (128u - 16u) << 23, e == shifted_exp); + uf = select(uf, asuint(asfloat(uf + (1 << 23)) - 6.10351563e-05f), e == 0); + uf |= (x & 0x8000) << 16; + return asfloat(uf); + } + + /// Returns the result converting a float value to its nearest half-precision floating point representation. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint f32tof16(float x) + { + const int infinity_32 = 255 << 23; + const uint msk = 0x7FFFF000u; + + uint ux = asuint(x); + uint uux = ux & msk; + uint h = (uint)(asuint(min(asfloat(uux) * 1.92592994e-34f, 260042752.0f)) + 0x1000) >> 13; // Clamp to signed infinity if overflowed + h = select(h, select(0x7c00u, 0x7e00u, (int)uux > infinity_32), (int)uux >= infinity_32); // NaN->qNaN and Inf->Inf + return h | (ux & ~msk) >> 16; + } + + /// Returns the result of a componentwise conversion of a float2 vector to its nearest half-precision floating point representation. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2 f32tof16(float2 x) + { + const int infinity_32 = 255 << 23; + const uint msk = 0x7FFFF000u; + + uint2 ux = asuint(x); + uint2 uux = ux & msk; + uint2 h = (uint2)(asint(min(asfloat(uux) * 1.92592994e-34f, 260042752.0f)) + 0x1000) >> 13; // Clamp to signed infinity if overflowed + h = select(h, select(0x7c00u, 0x7e00u, (int2)uux > infinity_32), (int2)uux >= infinity_32); // NaN->qNaN and Inf->Inf + return h | (ux & ~msk) >> 16; + } + + /// Returns the result of a componentwise conversion of a float3 vector to its nearest half-precision floating point representation. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 f32tof16(float3 x) + { + const int infinity_32 = 255 << 23; + const uint msk = 0x7FFFF000u; + + uint3 ux = asuint(x); + uint3 uux = ux & msk; + uint3 h = (uint3)(asint(min(asfloat(uux) * 1.92592994e-34f, 260042752.0f)) + 0x1000) >> 13; // Clamp to signed infinity if overflowed + h = select(h, select(0x7c00u, 0x7e00u, (int3)uux > infinity_32), (int3)uux >= infinity_32); // NaN->qNaN and Inf->Inf + return h | (ux & ~msk) >> 16; + } + + /// Returns the result of a componentwise conversion of a float4 vector to its nearest half-precision floating point representation. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 f32tof16(float4 x) + { + const int infinity_32 = 255 << 23; + const uint msk = 0x7FFFF000u; + + uint4 ux = asuint(x); + uint4 uux = ux & msk; + uint4 h = (uint4)(asint(min(asfloat(uux) * 1.92592994e-34f, 260042752.0f)) + 0x1000) >> 13; // Clamp to signed infinity if overflowed + h = select(h, select(0x7c00u, 0x7e00u, (int4)uux > infinity_32), (int4)uux >= infinity_32); // NaN->qNaN and Inf->Inf + return h | (ux & ~msk) >> 16; + } + + + /// Returns a uint hash from a block of memory using the xxhash32 algorithm. Can only be used in an unsafe context. + /// A pointer to the beginning of the data. + /// Number of bytes to hash. + /// Starting seed value. + public static unsafe uint hash(void* pBuffer, int numBytes, uint seed = 0) + { + unchecked + { + const uint Prime1 = 2654435761; + const uint Prime2 = 2246822519; + const uint Prime3 = 3266489917; + const uint Prime4 = 668265263; + const uint Prime5 = 374761393; + + uint4* p = (uint4*)pBuffer; + uint hash = seed + Prime5; + if (numBytes >= 16) + { + uint4 state = new uint4(Prime1 + Prime2, Prime2, 0, (uint)-Prime1) + seed; + + int count = numBytes >> 4; + for (int i = 0; i < count; ++i) + { + state += *p++ * Prime2; + state = (state << 13) | (state >> 19); + state *= Prime1; + } + + hash = rol(state.x, 1) + rol(state.y, 7) + rol(state.z, 12) + rol(state.w, 18); + } + + hash += (uint)numBytes; + + uint* puint = (uint*)p; + for (int i = 0; i < ((numBytes >> 2) & 3); ++i) + { + hash += *puint++ * Prime3; + hash = rol(hash, 17) * Prime4; + } + + byte* pbyte = (byte*)puint; + for (int i = 0; i < ((numBytes) & 3); ++i) + { + hash += (*pbyte++) * Prime5; + hash = rol(hash, 11) * Prime1; + } + + hash ^= hash >> 15; + hash *= Prime2; + hash ^= hash >> 13; + hash *= Prime3; + hash ^= hash >> 16; + + return hash; + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 up() { return new float3(0.0f, 1.0f, 0.0f); } // for compatibility + + + // Internal + + // SSE shuffles + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static float4 unpacklo(float4 a, float4 b) + { + return shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.RightY); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static double4 unpacklo(double4 a, double4 b) + { + return shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.RightY); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static float4 unpackhi(float4 a, float4 b) + { + return shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.LeftW, ShuffleComponent.RightW); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static double4 unpackhi(double4 a, double4 b) + { + return shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.LeftW, ShuffleComponent.RightW); + } + + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static float4 movelh(float4 a, float4 b) + { + return shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftY, ShuffleComponent.RightX, ShuffleComponent.RightY); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static double4 movelh(double4 a, double4 b) + { + return shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftY, ShuffleComponent.RightX, ShuffleComponent.RightY); + } + + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static float4 movehl(float4 a, float4 b) + { + return shuffle(b, a, ShuffleComponent.LeftZ, ShuffleComponent.LeftW, ShuffleComponent.RightZ, ShuffleComponent.RightW); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static double4 movehl(double4 a, double4 b) + { + return shuffle(b, a, ShuffleComponent.LeftZ, ShuffleComponent.LeftW, ShuffleComponent.RightZ, ShuffleComponent.RightW); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static uint fold_to_uint(double x) // utility for double hashing + { + LongDoubleUnion u; + u.longValue = 0; + u.doubleValue = x; + return (uint)(u.longValue >> 32) ^ (uint)u.longValue; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static uint2 fold_to_uint(double2 x) { return uint2(fold_to_uint(x.x), fold_to_uint(x.y)); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static uint3 fold_to_uint(double3 x) { return uint3(fold_to_uint(x.x), fold_to_uint(x.y), fold_to_uint(x.z)); } + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static uint4 fold_to_uint(double4 x) { return uint4(fold_to_uint(x.x), fold_to_uint(x.y), fold_to_uint(x.z), fold_to_uint(x.w)); } + + [StructLayout(LayoutKind.Explicit)] + internal struct IntFloatUnion + { + [FieldOffset(0)] + public int intValue; + [FieldOffset(0)] + public float floatValue; + } + + [StructLayout(LayoutKind.Explicit)] + internal struct LongDoubleUnion + { + [FieldOffset(0)] + public long longValue; + [FieldOffset(0)] + public double doubleValue; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/math.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/math.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..b04f0bee5d86f391644ec6860e471fbe472ccb15 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/math.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a54902d8339407348996f4a12702eaff +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/math_unity_conversion.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/math_unity_conversion.cs new file mode 100644 index 0000000000000000000000000000000000000000..e8db079803fb86621ad21b2b9a4e30b8e97ab2ba --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/math_unity_conversion.cs @@ -0,0 +1,38 @@ +#if !UNITY_DOTSPLAYER +using UnityEngine; + +#pragma warning disable 0660, 0661 + +namespace Unity.Mathematics +{ + public partial struct float2 + { + public static implicit operator Vector2(float2 v) { return new Vector2(v.x, v.y); } + public static implicit operator float2(Vector2 v) { return new float2(v.x, v.y); } + } + + public partial struct float3 + { + public static implicit operator Vector3(float3 v) { return new Vector3(v.x, v.y, v.z); } + public static implicit operator float3(Vector3 v) { return new float3(v.x, v.y, v.z); } + } + + public partial struct float4 + { + public static implicit operator float4(Vector4 v) { return new float4(v.x, v.y, v.z, v.w); } + public static implicit operator Vector4(float4 v) { return new Vector4(v.x, v.y, v.z, v.w); } + } + + public partial struct quaternion + { + public static implicit operator Quaternion(quaternion q) { return new Quaternion(q.value.x, q.value.y, q.value.z, q.value.w); } + public static implicit operator quaternion(Quaternion q) { return new quaternion(q.x, q.y, q.z, q.w); } + } + + public partial struct float4x4 + { + public static implicit operator float4x4(Matrix4x4 m) { return new float4x4(m.GetColumn(0), m.GetColumn(1), m.GetColumn(2), m.GetColumn(3)); } + public static implicit operator Matrix4x4(float4x4 m) { return new Matrix4x4(m.c0, m.c1, m.c2, m.c3); } + } +} +#endif diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/math_unity_conversion.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/math_unity_conversion.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..1261674ef494edfe0e54debd552a04b8d2cf7146 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/math_unity_conversion.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: ff55c152384775745b54032825a4ef2c +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/matrix.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/matrix.cs new file mode 100644 index 0000000000000000000000000000000000000000..b3cd01e13bc2c805474b9d559ee370c89108728c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/matrix.cs @@ -0,0 +1,901 @@ +using System.Runtime.CompilerServices; +using static Unity.Mathematics.math; + +namespace Unity.Mathematics +{ + public partial struct float2x2 + { + /// Returns a float2x2 matrix representing a counter-clockwise rotation of angle degrees. + public static float2x2 Rotate(float angle) + { + float s, c; + sincos(angle, out s, out c); + return float2x2(c, -s, + s, c); + } + + /// Returns a float2x2 matrix representing a uniform scaling of both axes by s. + public static float2x2 Scale(float s) + { + return float2x2(s, 0.0f, + 0.0f, s); + } + + /// Returns a float2x2 matrix representing a non-uniform axis scaling by x and y. + public static float2x2 Scale(float x, float y) + { + return float2x2(x, 0.0f, + 0.0f, y); + } + + /// Returns a float2x2 matrix representing a non-uniform axis scaling by the components of the float2 vector v. + public static float2x2 Scale(float2 v) + { + return Scale(v.x, v.y); + } + } + + public partial struct float3x3 + { + /// Constructs a float3x3 matrix from a unit quaternion. + public float3x3(quaternion q) + { + float4 v = q.value; + float4 v2 = v + v; + + uint3 npn = uint3(0x80000000, 0x00000000, 0x80000000); + uint3 nnp = uint3(0x80000000, 0x80000000, 0x00000000); + uint3 pnn = uint3(0x00000000, 0x80000000, 0x80000000); + c0 = v2.y * asfloat(asuint(v.yxw) ^ npn) - v2.z * asfloat(asuint(v.zwx) ^ pnn) + float3(1, 0, 0); + c1 = v2.z * asfloat(asuint(v.wzy) ^ nnp) - v2.x * asfloat(asuint(v.yxw) ^ npn) + float3(0, 1, 0); + c2 = v2.x * asfloat(asuint(v.zwx) ^ pnn) - v2.y * asfloat(asuint(v.wzy) ^ nnp) + float3(0, 0, 1); + } + + /// + /// Returns a float3x3 matrix representing a rotation around a unit axis by an angle in radians. + /// The rotation direction is clockwise when looking along the rotation axis towards the origin. + /// + public static float3x3 AxisAngle(float3 axis, float angle) + { + float sina, cosa; + math.sincos(angle, out sina, out cosa); + + float3 u = axis; + float3 u_yzx = u.yzx; + float3 u_zxy = u.zxy; + float3 u_inv_cosa = u - u * cosa; // u * (1.0f - cosa); + float4 t = float4(u * sina, cosa); + + uint3 ppn = uint3(0x00000000, 0x00000000, 0x80000000); + uint3 npp = uint3(0x80000000, 0x00000000, 0x00000000); + uint3 pnp = uint3(0x00000000, 0x80000000, 0x00000000); + + return float3x3( + u.x * u_inv_cosa + asfloat(asuint(t.wzy) ^ ppn), + u.y * u_inv_cosa + asfloat(asuint(t.zwx) ^ npp), + u.z * u_inv_cosa + asfloat(asuint(t.yxw) ^ pnp) + ); + /* + return float3x3( + cosa + u.x * u.x * (1.0f - cosa), u.y * u.x * (1.0f - cosa) - u.z * sina, u.z * u.x * (1.0f - cosa) + u.y * sina, + u.x * u.y * (1.0f - cosa) + u.z * sina, cosa + u.y * u.y * (1.0f - cosa), u.y * u.z * (1.0f - cosa) - u.x * sina, + u.x * u.z * (1.0f - cosa) - u.y * sina, u.y * u.z * (1.0f - cosa) + u.x * sina, cosa + u.z * u.z * (1.0f - cosa) + ); + */ + } + + /// + /// Returns a float3x3 rotation matrix constructed by first performing a rotation around the x-axis, then the y-axis and finally the z-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// A float3 vector containing the rotation angles around the x-, y- and z-axis measures in radians. + public static float3x3 EulerXYZ(float3 xyz) + { + // return mul(rotateZ(xyz.z), mul(rotateY(xyz.y), rotateX(xyz.x))); + float3 s, c; + sincos(xyz, out s, out c); + return float3x3( + c.y * c.z, c.z * s.x * s.y - c.x * s.z, c.x * c.z * s.y + s.x * s.z, + c.y * s.z, c.x * c.z + s.x * s.y * s.z, c.x * s.y * s.z - c.z * s.x, + -s.y, c.y * s.x, c.x * c.y + ); + } + + /// + /// Returns a float3x3 rotation matrix constructed by first performing a rotation around the x-axis, then the z-axis and finally the y-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// A float3 vector containing the rotation angles around the x-, y- and z-axis measures in radians. + public static float3x3 EulerXZY(float3 xyz) + { + // return mul(rotateY(xyz.y), mul(rotateZ(xyz.z), rotateX(xyz.x))); } + float3 s, c; + sincos(xyz, out s, out c); + return float3x3( + c.y * c.z, s.x * s.y - c.x * c.y * s.z, c.x * s.y + c.y * s.x * s.z, + s.z, c.x * c.z, -c.z * s.x, + -c.z * s.y, c.y * s.x + c.x * s.y * s.z, c.x * c.y - s.x * s.y * s.z + ); + } + + /// + /// Returns a float3x3 rotation matrix constructed by first performing a rotation around the y-axis, then the x-axis and finally the z-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// A float3 vector containing the rotation angles around the x-, y- and z-axis measures in radians. + public static float3x3 EulerYXZ(float3 xyz) + { + // return mul(rotateZ(xyz.z), mul(rotateX(xyz.x), rotateY(xyz.y))); + float3 s, c; + sincos(xyz, out s, out c); + return float3x3( + c.y * c.z - s.x * s.y * s.z, -c.x * s.z, c.z * s.y + c.y * s.x * s.z, + c.z * s.x * s.y + c.y * s.z, c.x * c.z, s.y * s.z - c.y * c.z * s.x, + -c.x * s.y, s.x, c.x * c.y + ); + } + + /// + /// Returns a float3x3 rotation matrix constructed by first performing a rotation around the y-axis, then the z-axis and finally the x-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// A float3 vector containing the rotation angles around the x-, y- and z-axis measures in radians. + public static float3x3 EulerYZX(float3 xyz) + { + // return mul(rotateX(xyz.x), mul(rotateZ(xyz.z), rotateY(xyz.y))); + float3 s, c; + sincos(xyz, out s, out c); + return float3x3( + c.y * c.z, -s.z, c.z * s.y, + s.x * s.y + c.x * c.y * s.z, c.x * c.z, c.x * s.y * s.z - c.y * s.x, + c.y * s.x * s.z - c.x * s.y, c.z * s.x, c.x * c.y + s.x * s.y * s.z + ); + } + + /// + /// Returns a float3x3 rotation matrix constructed by first performing a rotation around the z-axis, then the x-axis and finally the y-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// This is the default order rotation order in Unity. + /// + /// A float3 vector containing the rotation angles around the x-, y- and z-axis measures in radians. + public static float3x3 EulerZXY(float3 xyz) + { + // return mul(rotateY(xyz.y), mul(rotateX(xyz.x), rotateZ(xyz.z))); + float3 s, c; + sincos(xyz, out s, out c); + return float3x3( + c.y * c.z + s.x * s.y * s.z, c.z * s.x * s.y - c.y * s.z, c.x * s.y, + c.x * s.z, c.x * c.z, -s.x, + c.y * s.x * s.z - c.z * s.y, c.y * c.z * s.x + s.y * s.z, c.x * c.y + ); + } + + /// + /// Returns a float3x3 rotation matrix constructed by first performing a rotation around the z-axis, then the y-axis and finally the x-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// A float3 vector containing the rotation angles around the x-, y- and z-axis measures in radians. + public static float3x3 EulerZYX(float3 xyz) + { + // return mul(rotateX(xyz.x), mul(rotateY(xyz.y), rotateZ(xyz.z))); + float3 s, c; + sincos(xyz, out s, out c); + return float3x3( + c.y * c.z, -c.y * s.z, s.y, + c.z * s.x * s.y + c.x * s.z, c.x * c.z - s.x * s.y * s.z, -c.y * s.x, + s.x * s.z - c.x * c.z * s.y, c.z * s.x + c.x * s.y * s.z, c.x * c.y + ); + } + + /// + /// Returns a float3x3 rotation matrix constructed by first performing a rotation around the x-axis, then the y-axis and finally the z-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// The rotation angle around the x-axis in radians. + /// The rotation angle around the y-axis in radians. + /// The rotation angle around the z-axis in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 EulerXYZ(float x, float y, float z) { return EulerXYZ(float3(x, y, z)); } + + /// + /// Returns a float3x3 rotation matrix constructed by first performing a rotation around the x-axis, then the z-axis and finally the y-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// The rotation angle around the x-axis in radians. + /// The rotation angle around the y-axis in radians. + /// The rotation angle around the z-axis in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 EulerXZY(float x, float y, float z) { return EulerXZY(float3(x, y, z)); } + + /// + /// Returns a float3x3 rotation matrix constructed by first performing a rotation around the y-axis, then the x-axis and finally the z-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// The rotation angle around the x-axis in radians. + /// The rotation angle around the y-axis in radians. + /// The rotation angle around the z-axis in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 EulerYXZ(float x, float y, float z) { return EulerYXZ(float3(x, y, z)); } + + /// + /// Returns a float3x3 rotation matrix constructed by first performing a rotation around the y-axis, then the z-axis and finally the x-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// The rotation angle around the x-axis in radians. + /// The rotation angle around the y-axis in radians. + /// The rotation angle around the z-axis in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 EulerYZX(float x, float y, float z) { return EulerYZX(float3(x, y, z)); } + + /// + /// Returns a float3x3 rotation matrix constructed by first performing a rotation around the z-axis, then the x-axis and finally the y-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// This is the default order rotation order in Unity. + /// + /// The rotation angle around the x-axis in radians. + /// The rotation angle around the y-axis in radians. + /// The rotation angle around the z-axis in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 EulerZXY(float x, float y, float z) { return EulerZXY(float3(x, y, z)); } + + /// + /// Returns a float3x3 rotation matrix constructed by first performing a rotation around the z-axis, then the y-axis and finally the x-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// The rotation angle around the x-axis in radians. + /// The rotation angle around the y-axis in radians. + /// The rotation angle around the z-axis in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 EulerZYX(float x, float y, float z) { return EulerZYX(float3(x, y, z)); } + + /// + /// Returns a float3x3 rotation matrix constructed by first performing 3 rotations around the principal axes in a given order. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// When the rotation order is known at compile time, it is recommended for performance reasons to use specific + /// Euler rotation constructors such as EulerZXY(...). + /// + /// A float3 vector containing the rotation angles around the x-, y- and z-axis measures in radians. + /// The order in which the rotations are applied. + public static float3x3 Euler(float3 xyz, RotationOrder order = RotationOrder.Default) + { + switch (order) + { + case RotationOrder.XYZ: + return EulerXYZ(xyz); + case RotationOrder.XZY: + return EulerXZY(xyz); + case RotationOrder.YXZ: + return EulerYXZ(xyz); + case RotationOrder.YZX: + return EulerYZX(xyz); + case RotationOrder.ZXY: + return EulerZXY(xyz); + case RotationOrder.ZYX: + return EulerZYX(xyz); + default: + return float3x3.identity; + } + } + + /// + /// Returns a float3x3 rotation matrix constructed by first performing 3 rotations around the principal axes in a given order. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// When the rotation order is known at compile time, it is recommended for performance reasons to use specific + /// Euler rotation constructors such as EulerZXY(...). + /// + /// The rotation angle around the x-axis in radians. + /// The rotation angle around the y-axis in radians. + /// The rotation angle around the z-axis in radians. + /// The order in which the rotations are applied. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 Euler(float x, float y, float z, RotationOrder order = RotationOrder.Default) + { + return Euler(float3(x, y, z), order); + } + + /// Returns a float4x4 matrix that rotates around the x-axis by a given number of radians. + /// The clockwise rotation angle when looking along the x-axis towards the origin in radians. + public static float3x3 RotateX(float angle) + { + // {{1, 0, 0}, {0, c_0, -s_0}, {0, s_0, c_0}} + float s, c; + sincos(angle, out s, out c); + return float3x3(1.0f, 0.0f, 0.0f, + 0.0f, c, -s, + 0.0f, s, c); + } + + /// Returns a float4x4 matrix that rotates around the y-axis by a given number of radians. + /// The clockwise rotation angle when looking along the y-axis towards the origin in radians. + public static float3x3 RotateY(float angle) + { + // {{c_1, 0, s_1}, {0, 1, 0}, {-s_1, 0, c_1}} + float s, c; + sincos(angle, out s, out c); + return float3x3(c, 0.0f, s, + 0.0f, 1.0f, 0.0f, + -s, 0.0f, c); + } + + /// Returns a float4x4 matrix that rotates around the z-axis by a given number of radians. + /// The clockwise rotation angle when looking along the z-axis towards the origin in radians. + public static float3x3 RotateZ(float angle) + { + // {{c_2, -s_2, 0}, {s_2, c_2, 0}, {0, 0, 1}} + float s, c; + sincos(angle, out s, out c); + return float3x3(c, -s, 0.0f, + s, c, 0.0f, + 0.0f, 0.0f, 1.0f); + } + + //Returns a float3x3 matrix representing a uniform scaling of all axes by s. + public static float3x3 Scale(float s) + { + return float3x3(s, 0.0f, 0.0f, + 0.0f, s, 0.0f, + 0.0f, 0.0f, s); + } + + /// Returns a float3x3 matrix representing a non-uniform axis scaling by x, y and z. + public static float3x3 Scale(float x, float y, float z) + { + return float3x3(x, 0.0f, 0.0f, + 0.0f, y, 0.0f, + 0.0f, 0.0f, z); + } + + /// Returns a float3x3 matrix representing a non-uniform axis scaling by the components of the float3 vector v. + public static float3x3 Scale(float3 v) + { + return Scale(v.x, v.y, v.z); + } + + /// + /// Returns a float3x3 view rotation matrix given a unit length forward vector and a unit length up vector. + /// The two input vectors are assumed to be unit length and not collinear. + /// If these assumptions are not met use float3x3.LookRotationSafe instead. + /// + public static float3x3 LookRotation(float3 forward, float3 up) + { + float3 t = normalize(cross(up, forward)); + return float3x3(t, cross(forward, t), forward); + } + + /// + /// Returns a float3x3 view rotation matrix given a forward vector and an up vector. + /// The two input vectors are not assumed to be unit length. + /// If the magnitude of either of the vectors is so extreme that the calculation cannot be carried out reliably or the vectors are collinear, + /// the identity will be returned instead. + /// + public static float3x3 LookRotationSafe(float3 forward, float3 up) + { + float forwardLengthSq = dot(forward, forward); + float upLengthSq = dot(up, up); + + forward *= rsqrt(forwardLengthSq); + up *= rsqrt(upLengthSq); + + float3 t = cross(up, forward); + float tLengthSq = dot(t, t); + t *= rsqrt(tLengthSq); + + float mn = min(min(forwardLengthSq, upLengthSq), tLengthSq); + float mx = max(max(forwardLengthSq, upLengthSq), tLengthSq); + + bool accept = mn > 1e-35f && mx < 1e35f && isfinite(forwardLengthSq) && isfinite(upLengthSq) && isfinite(tLengthSq); + return float3x3( + select(float3(1,0,0), t, accept), + select(float3(0,1,0), cross(forward, t), accept), + select(float3(0,0,1), forward, accept)); + } + } + + public partial struct float4x4 + { + /// Constructs a float4x4 from a float3x3 rotation matrix and a float3 translation vector. + public float4x4(float3x3 rotation, float3 translation) + { + c0 = float4(rotation.c0, 0.0f); + c1 = float4(rotation.c1, 0.0f); + c2 = float4(rotation.c2, 0.0f); + c3 = float4(translation, 1.0f); + } + + /// Constructs a float4x4 from a quaternion and a float3 translation vector. + public float4x4(quaternion rotation, float3 translation) + { + float3x3 rot = float3x3(rotation); + c0 = float4(rot.c0, 0.0f); + c1 = float4(rot.c1, 0.0f); + c2 = float4(rot.c2, 0.0f); + c3 = float4(translation, 1.0f); + } + + /// Constructs a float4x4 from a RigidTransform. + public float4x4(RigidTransform transform) + { + float3x3 rot = float3x3(transform.rot); + c0 = float4(rot.c0, 0.0f); + c1 = float4(rot.c1, 0.0f); + c2 = float4(rot.c2, 0.0f); + c3 = float4(transform.pos, 1.0f); + } + + /// + /// Returns a float4x4 matrix representing a rotation around a unit axis by an angle in radians. + /// The rotation direction is clockwise when looking along the rotation axis towards the origin. + /// + public static float4x4 AxisAngle(float3 axis, float angle) + { + float sina, cosa; + math.sincos(angle, out sina, out cosa); + + float4 u = float4(axis, 0.0f); + float4 u_yzx = u.yzxx; + float4 u_zxy = u.zxyx; + float4 u_inv_cosa = u - u * cosa; // u * (1.0f - cosa); + float4 t = float4(u.xyz * sina, cosa); + + uint4 ppnp = uint4(0x00000000, 0x00000000, 0x80000000, 0x00000000); + uint4 nppp = uint4(0x80000000, 0x00000000, 0x00000000, 0x00000000); + uint4 pnpp = uint4(0x00000000, 0x80000000, 0x00000000, 0x00000000); + uint4 mask = uint4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000); + + return float4x4( + u.x * u_inv_cosa + asfloat((asuint(t.wzyx) ^ ppnp) & mask), + u.y * u_inv_cosa + asfloat((asuint(t.zwxx) ^ nppp) & mask), + u.z * u_inv_cosa + asfloat((asuint(t.yxwx) ^ pnpp) & mask), + float4(0.0f, 0.0f, 0.0f, 1.0f) + ); + + } + + /// + /// Returns a float4x4 rotation matrix constructed by first performing a rotation around the x-axis, then the y-axis and finally the z-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// A float3 vector containing the rotation angles around the x-, y- and z-axis measures in radians. + public static float4x4 EulerXYZ(float3 xyz) + { + // return mul(rotateZ(xyz.z), mul(rotateY(xyz.y), rotateX(xyz.x))); + float3 s, c; + sincos(xyz, out s, out c); + return float4x4( + c.y * c.z, c.z * s.x * s.y - c.x * s.z, c.x * c.z * s.y + s.x * s.z, 0.0f, + c.y * s.z, c.x * c.z + s.x * s.y * s.z, c.x * s.y * s.z - c.z * s.x, 0.0f, + -s.y, c.y * s.x, c.x * c.y, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f + ); + } + + /// + /// Returns a float4x4 rotation matrix constructed by first performing a rotation around the x-axis, then the z-axis and finally the y-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// A float3 vector containing the rotation angles around the x-, y- and z-axis measures in radians. + public static float4x4 EulerXZY(float3 xyz) + { + // return mul(rotateY(xyz.y), mul(rotateZ(xyz.z), rotateX(xyz.x))); } + float3 s, c; + sincos(xyz, out s, out c); + return float4x4( + c.y * c.z, s.x * s.y - c.x * c.y * s.z, c.x * s.y + c.y * s.x * s.z, 0.0f, + s.z, c.x * c.z, -c.z * s.x, 0.0f, + -c.z * s.y, c.y * s.x + c.x * s.y * s.z, c.x * c.y - s.x * s.y * s.z, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f + ); + } + + /// + /// Returns a float4x4 rotation matrix constructed by first performing a rotation around the y-axis, then the x-axis and finally the z-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// A float3 vector containing the rotation angles around the x-, y- and z-axis measures in radians. + public static float4x4 EulerYXZ(float3 xyz) + { + // return mul(rotateZ(xyz.z), mul(rotateX(xyz.x), rotateY(xyz.y))); + float3 s, c; + sincos(xyz, out s, out c); + return float4x4( + c.y * c.z - s.x * s.y * s.z, -c.x * s.z, c.z * s.y + c.y * s.x * s.z, 0.0f, + c.z * s.x * s.y + c.y * s.z, c.x * c.z, s.y * s.z - c.y * c.z * s.x, 0.0f, + -c.x * s.y, s.x, c.x * c.y, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f + ); + } + + /// + /// Returns a float4x4 rotation matrix constructed by first performing a rotation around the y-axis, then the z-axis and finally the x-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// A float3 vector containing the rotation angles around the x-, y- and z-axis measures in radians. + public static float4x4 EulerYZX(float3 xyz) + { + // return mul(rotateX(xyz.x), mul(rotateZ(xyz.z), rotateY(xyz.y))); + float3 s, c; + sincos(xyz, out s, out c); + return float4x4( + c.y * c.z, -s.z, c.z * s.y, 0.0f, + s.x * s.y + c.x * c.y * s.z, c.x * c.z, c.x * s.y * s.z - c.y * s.x, 0.0f, + c.y * s.x * s.z - c.x * s.y, c.z * s.x, c.x * c.y + s.x * s.y * s.z, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f + ); + } + + /// + /// Returns a float4x4 rotation matrix constructed by first performing a rotation around the z-axis, then the x-axis and finally the y-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// This is the default order rotation order in Unity. + /// + /// A float3 vector containing the rotation angles around the x-, y- and z-axis measures in radians. + public static float4x4 EulerZXY(float3 xyz) + { + // return mul(rotateY(xyz.y), mul(rotateX(xyz.x), rotateZ(xyz.z))); + float3 s, c; + sincos(xyz, out s, out c); + return float4x4( + c.y * c.z + s.x * s.y * s.z, c.z * s.x * s.y - c.y * s.z, c.x * s.y, 0.0f, + c.x * s.z, c.x * c.z, -s.x, 0.0f, + c.y * s.x * s.z - c.z * s.y, c.y * c.z * s.x + s.y * s.z, c.x * c.y, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f + ); + } + + /// + /// Returns a float4x4 rotation matrix constructed by first performing a rotation around the z-axis, then the y-axis and finally the x-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// A float3 vector containing the rotation angles around the x-, y- and z-axis measures in radians. + public static float4x4 EulerZYX(float3 xyz) + { + // return mul(rotateX(xyz.x), mul(rotateY(xyz.y), rotateZ(xyz.z))); + float3 s, c; + sincos(xyz, out s, out c); + return float4x4( + c.y * c.z, -c.y * s.z, s.y, 0.0f, + c.z * s.x * s.y + c.x * s.z, c.x * c.z - s.x * s.y * s.z, -c.y * s.x, 0.0f, + s.x * s.z - c.x * c.z * s.y, c.z * s.x + c.x * s.y * s.z, c.x * c.y, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f + ); + } + + /// + /// Returns a float4x4 rotation matrix constructed by first performing a rotation around the x-axis, then the y-axis and finally the z-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// The rotation angle around the x-axis in radians. + /// The rotation angle around the y-axis in radians. + /// The rotation angle around the z-axis in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 EulerXYZ(float x, float y, float z) { return EulerXYZ(float3(x, y, z)); } + + /// + /// Returns a float4x4 rotation matrix constructed by first performing a rotation around the x-axis, then the z-axis and finally the y-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// The rotation angle around the x-axis in radians. + /// The rotation angle around the y-axis in radians. + /// The rotation angle around the z-axis in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 EulerXZY(float x, float y, float z) { return EulerXZY(float3(x, y, z)); } + + /// + /// Returns a float4x4 rotation matrix constructed by first performing a rotation around the y-axis, then the x-axis and finally the z-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// The rotation angle around the x-axis in radians. + /// The rotation angle around the y-axis in radians. + /// The rotation angle around the z-axis in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 EulerYXZ(float x, float y, float z) { return EulerYXZ(float3(x, y, z)); } + + /// + /// Returns a float4x4 rotation matrix constructed by first performing a rotation around the y-axis, then the z-axis and finally the x-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// The rotation angle around the x-axis in radians. + /// The rotation angle around the y-axis in radians. + /// The rotation angle around the z-axis in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 EulerYZX(float x, float y, float z) { return EulerYZX(float3(x, y, z)); } + + /// + /// Returns a float4x4 rotation matrix constructed by first performing a rotation around the z-axis, then the x-axis and finally the y-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// This is the default order rotation order in Unity. + /// + /// The rotation angle around the x-axis in radians. + /// The rotation angle around the y-axis in radians. + /// The rotation angle around the z-axis in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 EulerZXY(float x, float y, float z) { return EulerZXY(float3(x, y, z)); } + + /// + /// Returns a float4x4 rotation matrix constructed by first performing a rotation around the z-axis, then the y-axis and finally the x-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// The rotation angle around the x-axis in radians. + /// The rotation angle around the y-axis in radians. + /// The rotation angle around the z-axis in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 EulerZYX(float x, float y, float z) { return EulerZYX(float3(x, y, z)); } + + public static float4x4 Euler(float3 xyz, RotationOrder order = RotationOrder.Default) + { + switch (order) + { + case RotationOrder.XYZ: + return EulerXYZ(xyz); + case RotationOrder.XZY: + return EulerXZY(xyz); + case RotationOrder.YXZ: + return EulerYXZ(xyz); + case RotationOrder.YZX: + return EulerYZX(xyz); + case RotationOrder.ZXY: + return EulerZXY(xyz); + case RotationOrder.ZYX: + return EulerZYX(xyz); + default: + return float4x4.identity; + } + } + + /// + /// Returns a float4x4 rotation matrix constructed by first performing 3 rotations around the principal axes in a given order. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// When the rotation order is known at compile time, it is recommended for performance reasons to use specific + /// Euler rotation constructors such as EulerZXY(...). + /// + /// The rotation angle around the x-axis in radians. + /// The rotation angle around the y-axis in radians. + /// The rotation angle around the z-axis in radians. + /// The order in which the rotations are applied. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 Euler(float x, float y, float z, RotationOrder order = RotationOrder.Default) + { + return Euler(float3(x, y, z), order); + } + + /// Returns a float4x4 matrix that rotates around the x-axis by a given number of radians. + /// The clockwise rotation angle when looking along the x-axis towards the origin in radians. + public static float4x4 RotateX(float angle) + { + // {{1, 0, 0}, {0, c_0, -s_0}, {0, s_0, c_0}} + float s, c; + sincos(angle, out s, out c); + return float4x4(1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, c, -s, 0.0f, + 0.0f, s, c, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f); + + } + + /// Returns a float4x4 matrix that rotates around the y-axis by a given number of radians. + /// The clockwise rotation angle when looking along the y-axis towards the origin in radians. + public static float4x4 RotateY(float angle) + { + // {{c_1, 0, s_1}, {0, 1, 0}, {-s_1, 0, c_1}} + float s, c; + sincos(angle, out s, out c); + return float4x4(c, 0.0f, s, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + -s, 0.0f, c, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f); + + } + + /// Returns a float4x4 matrix that rotates around the z-axis by a given number of radians. + /// The clockwise rotation angle when looking along the z-axis towards the origin in radians. + public static float4x4 RotateZ(float angle) + { + // {{c_2, -s_2, 0}, {s_2, c_2, 0}, {0, 0, 1}} + float s, c; + sincos(angle, out s, out c); + return float4x4(c, -s, 0.0f, 0.0f, + s, c, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f); + + } + + /// Returns a float4x4 scale matrix given 3 axis scales. + public static float4x4 Scale(float s) + { + return float4x4(s, 0.0f, 0.0f, 0.0f, + 0.0f, s, 0.0f, 0.0f, + 0.0f, 0.0f, s, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f); + } + + /// Returns a float4x4 scale matrix given a float3 vector containing the 3 axis scales. + public static float4x4 Scale(float x, float y, float z) + { + return float4x4(x, 0.0f, 0.0f, 0.0f, + 0.0f, y, 0.0f, 0.0f, + 0.0f, 0.0f, z, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f); + } + + /// Returns a float4x4 scale matrix given a float3 vector containing the 3 axis scales. + public static float4x4 Scale(float3 scales) + { + return Scale(scales.x, scales.y, scales.z); + } + + /// Returns a float4x4 translation matrix given a float3 translation vector. + public static float4x4 Translate(float3 vector) + { + return float4x4(float4(1.0f, 0.0f, 0.0f, 0.0f), + float4(0.0f, 1.0f, 0.0f, 0.0f), + float4(0.0f, 0.0f, 1.0f, 0.0f), + float4(vector.x, vector.y, vector.z, 1.0f)); + } + + /// + /// Returns a float4x4 view matrix given an eye position, a target point and a unit length up vector. + /// The up vector is assumed to be unit length, the eye and target points are assumed to be distinct and + /// the vector between them is assumes to be collinear with the up vector. + /// If these assumptions are not met use float4x4.LookRotationSafe instead. + /// + public static float4x4 LookAt(float3 eye, float3 target, float3 up) + { + float3x3 rot = float3x3.LookRotation(normalize(target - eye), up); + + float4x4 matrix; + matrix.c0 = float4(rot.c0, 0.0F); + matrix.c1 = float4(rot.c1, 0.0F); + matrix.c2 = float4(rot.c2, 0.0F); + matrix.c3 = float4(eye, 1.0F); + return matrix; + } + + /// + /// Returns a float4x4 centered orthographic projection matrix. + /// + /// The width of the view volume. + /// The height of the view volume. + /// The distance to the near plane. + /// The distance to the far plane. + public static float4x4 Ortho(float width, float height, float near, float far) + { + float rcpdx = 1.0f / width; + float rcpdy = 1.0f / height; + float rcpdz = 1.0f / (far - near); + + return float4x4( + 2.0f * rcpdx, 0.0f, 0.0f, 0.0f, + 0.0f, 2.0f * rcpdy, 0.0f, 0.0f, + 0.0f, 0.0f, -2.0f * rcpdz, -(far + near) * rcpdz, + 0.0f, 0.0f, 0.0f, 1.0f + ); + } + + /// + /// Returns a float4x4 off-center orthographic projection matrix. + /// + /// The minimum x-coordinate of the view volume. + /// The maximum x-coordinate of the view volume. + /// The minimum y-coordinate of the view volume. + /// The minimum y-coordinate of the view volume. + /// The distance to the near plane. + /// The distance to the far plane. + public static float4x4 OrthoOffCenter(float left, float right, float bottom, float top, float near, float far) + { + float rcpdx = 1.0f / (right - left); + float rcpdy = 1.0f / (top - bottom); + float rcpdz = 1.0f / (far - near); + + return float4x4( + 2.0f * rcpdx, 0.0f, 0.0f, -(right + left) * rcpdx, + 0.0f, 2.0f * rcpdy, 0.0f, -(top + bottom) * rcpdy, + 0.0f, 0.0f, -2.0f * rcpdz, -(far + near) * rcpdz, + 0.0f, 0.0f, 0.0f, 1.0f + ); + } + + /// + /// Returns a float4x4 perspective projection matrix based on field of view. + /// + /// Vertical Field of view in radians. + /// X:Y aspect ratio. + /// Distance to near plane. Must be greater than zero. + /// Distance to far plane. Must be greater than zero. + public static float4x4 PerspectiveFov(float verticalFov, float aspect, float near, float far) + { + float cotangent = 1.0f / tan(verticalFov * 0.5f); + float rcpdz = 1.0f / (near - far); + + return float4x4( + cotangent / aspect, 0.0f, 0.0f, 0.0f, + 0.0f, cotangent, 0.0f, 0.0f, + 0.0f, 0.0f, (far + near) * rcpdz, 2.0f * near * far * rcpdz, + 0.0f, 0.0f, -1.0f, 0.0f + ); + } + + /// + /// Returns a float4x4 off-center perspective projection matrix. + /// + /// The x-coordinate of the left side of the clipping frustum at the near plane. + /// The x-coordinate of the right side of the clipping frustum at the near plane. + /// The y-coordinate of the bottom side of the clipping frustum at the near plane. + /// The y-coordinate of the top side of the clipping frustum at the near plane. + /// Distance to the near plane. Must be greater than zero. + /// Distance to the far plane. Must be greater than zero. + public static float4x4 PerspectiveOffCenter(float left, float right, float bottom, float top, float near, float far) + { + float rcpdz = 1.0f / (near - far); + float rcpWidth = 1.0f / (right - left); + float rcpHeight = 1.0f / (top - bottom); + + return float4x4( + 2.0f * near * rcpWidth, 0.0f, (left + right) * rcpWidth, 0.0f, + 0.0f, 2.0f * near * rcpHeight, (bottom + top) * rcpHeight, 0.0f, + 0.0f, 0.0f, (far + near) * rcpdz, 2.0f * near * far * rcpdz, + 0.0f, 0.0f, -1.0f, 0.0f + ); + } + + /// + /// Returns a float4x4 matrix representing a combined scale-, rotation- and translation transform. + /// Equivalent to mul(translationTransform, mul(rotationTransform, scaleTransform)). + /// + public static float4x4 TRS(float3 translation, quaternion rotation, float3 scale) + { + float3x3 r = float3x3(rotation); + return float4x4( float4(r.c0 * scale.x, 0.0f), + float4(r.c1 * scale.y, 0.0f), + float4(r.c2 * scale.z, 0.0f), + float4(translation, 1.0f)); + } + } + + partial class math + { + /// Returns a float3x3 matrix constructed from a quaternion. + public static float3x3 float3x3(quaternion rotation) + { + return new float3x3(rotation); + } + + /// Returns a float4x4 constructed from a float3x3 rotation matrix and a float3 translation vector. + public static float4x4 float4x4(float3x3 rotation, float3 translation) + { + return new float4x4(rotation, translation); + } + + /// Returns a float4x4 constructed from a quaternion and a float3 translation vector. + public static float4x4 float4x4(quaternion rotation, float3 translation) + { + return new float4x4(rotation, translation); + } + + /// Returns a float4x4 constructed from a RigidTransform. + public static float4x4 float4x4(RigidTransform transform) + { + return new float4x4(transform); + } + + /// Returns an orthonormalized version of a float3x3 matrix. + public static float3x3 orthonormalize(float3x3 i) + { + float3x3 o; + + float3 u = i.c0; + float3 v = i.c1 - i.c0 * math.dot(i.c1, i.c0); + + float lenU = math.length(u); + float lenV = math.length(v); + + bool c = lenU > 1e-30f && lenV > 1e-30f; + + o.c0 = math.select(float3(1, 0, 0), u / lenU, c); + o.c1 = math.select(float3(0, 1, 0), v / lenV, c); + o.c2 = math.cross(o.c0, o.c1); + + return o; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/matrix.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/matrix.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..571931823f9ce38513143722f7fe81485d055be7 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/matrix.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e378472eca9810946b664b8ff70f4edf +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/matrix.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/matrix.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..4bd21af20ed6fbfc243575f1b8d4e33ec63eb622 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/matrix.gen.cs @@ -0,0 +1,1821 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using System; +using System.Runtime.CompilerServices; + +namespace Unity.Mathematics +{ + partial class math + { + /// Returns the float value result of a matrix multiplication between a float value and a float value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float mul(float a, float b) + { + return a * b; + } + + /// Returns the float value result of a matrix multiplication between a float2 row vector and a float2 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float mul(float2 a, float2 b) + { + return a.x * b.x + a.y * b.y; + } + + /// Returns the float2 row vector result of a matrix multiplication between a float2 row vector and a float2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 mul(float2 a, float2x2 b) + { + return float2( + a.x * b.c0.x + a.y * b.c0.y, + a.x * b.c1.x + a.y * b.c1.y); + } + + /// Returns the float3 row vector result of a matrix multiplication between a float2 row vector and a float2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 mul(float2 a, float2x3 b) + { + return float3( + a.x * b.c0.x + a.y * b.c0.y, + a.x * b.c1.x + a.y * b.c1.y, + a.x * b.c2.x + a.y * b.c2.y); + } + + /// Returns the float4 row vector result of a matrix multiplication between a float2 row vector and a float2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 mul(float2 a, float2x4 b) + { + return float4( + a.x * b.c0.x + a.y * b.c0.y, + a.x * b.c1.x + a.y * b.c1.y, + a.x * b.c2.x + a.y * b.c2.y, + a.x * b.c3.x + a.y * b.c3.y); + } + + /// Returns the float value result of a matrix multiplication between a float3 row vector and a float3 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float mul(float3 a, float3 b) + { + return a.x * b.x + a.y * b.y + a.z * b.z; + } + + /// Returns the float2 row vector result of a matrix multiplication between a float3 row vector and a float3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 mul(float3 a, float3x2 b) + { + return float2( + a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z, + a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z); + } + + /// Returns the float3 row vector result of a matrix multiplication between a float3 row vector and a float3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 mul(float3 a, float3x3 b) + { + return float3( + a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z, + a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z, + a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z); + } + + /// Returns the float4 row vector result of a matrix multiplication between a float3 row vector and a float3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 mul(float3 a, float3x4 b) + { + return float4( + a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z, + a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z, + a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z, + a.x * b.c3.x + a.y * b.c3.y + a.z * b.c3.z); + } + + /// Returns the float value result of a matrix multiplication between a float4 row vector and a float4 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float mul(float4 a, float4 b) + { + return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w; + } + + /// Returns the float2 row vector result of a matrix multiplication between a float4 row vector and a float4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 mul(float4 a, float4x2 b) + { + return float2( + a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z + a.w * b.c0.w, + a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z + a.w * b.c1.w); + } + + /// Returns the float3 row vector result of a matrix multiplication between a float4 row vector and a float4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 mul(float4 a, float4x3 b) + { + return float3( + a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z + a.w * b.c0.w, + a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z + a.w * b.c1.w, + a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z + a.w * b.c2.w); + } + + /// Returns the float4 row vector result of a matrix multiplication between a float4 row vector and a float4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 mul(float4 a, float4x4 b) + { + return float4( + a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z + a.w * b.c0.w, + a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z + a.w * b.c1.w, + a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z + a.w * b.c2.w, + a.x * b.c3.x + a.y * b.c3.y + a.z * b.c3.z + a.w * b.c3.w); + } + + /// Returns the float2 column vector result of a matrix multiplication between a float2x2 matrix and a float2 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 mul(float2x2 a, float2 b) + { + return a.c0 * b.x + a.c1 * b.y; + } + + /// Returns the float2x2 matrix result of a matrix multiplication between a float2x2 matrix and a float2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 mul(float2x2 a, float2x2 b) + { + return float2x2( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y); + } + + /// Returns the float2x3 matrix result of a matrix multiplication between a float2x2 matrix and a float2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 mul(float2x2 a, float2x3 b) + { + return float2x3( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y, + a.c0 * b.c2.x + a.c1 * b.c2.y); + } + + /// Returns the float2x4 matrix result of a matrix multiplication between a float2x2 matrix and a float2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 mul(float2x2 a, float2x4 b) + { + return float2x4( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y, + a.c0 * b.c2.x + a.c1 * b.c2.y, + a.c0 * b.c3.x + a.c1 * b.c3.y); + } + + /// Returns the float2 column vector result of a matrix multiplication between a float2x3 matrix and a float3 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 mul(float2x3 a, float3 b) + { + return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z; + } + + /// Returns the float2x2 matrix result of a matrix multiplication between a float2x3 matrix and a float3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 mul(float2x3 a, float3x2 b) + { + return float2x2( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z); + } + + /// Returns the float2x3 matrix result of a matrix multiplication between a float2x3 matrix and a float3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 mul(float2x3 a, float3x3 b) + { + return float2x3( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z); + } + + /// Returns the float2x4 matrix result of a matrix multiplication between a float2x3 matrix and a float3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 mul(float2x3 a, float3x4 b) + { + return float2x4( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z, + a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z); + } + + /// Returns the float2 column vector result of a matrix multiplication between a float2x4 matrix and a float4 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2 mul(float2x4 a, float4 b) + { + return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3 * b.w; + } + + /// Returns the float2x2 matrix result of a matrix multiplication between a float2x4 matrix and a float4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x2 mul(float2x4 a, float4x2 b) + { + return float2x2( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w); + } + + /// Returns the float2x3 matrix result of a matrix multiplication between a float2x4 matrix and a float4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x3 mul(float2x4 a, float4x3 b) + { + return float2x3( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w); + } + + /// Returns the float2x4 matrix result of a matrix multiplication between a float2x4 matrix and a float4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float2x4 mul(float2x4 a, float4x4 b) + { + return float2x4( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w, + a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z + a.c3 * b.c3.w); + } + + /// Returns the float3 column vector result of a matrix multiplication between a float3x2 matrix and a float2 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 mul(float3x2 a, float2 b) + { + return a.c0 * b.x + a.c1 * b.y; + } + + /// Returns the float3x2 matrix result of a matrix multiplication between a float3x2 matrix and a float2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 mul(float3x2 a, float2x2 b) + { + return float3x2( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y); + } + + /// Returns the float3x3 matrix result of a matrix multiplication between a float3x2 matrix and a float2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 mul(float3x2 a, float2x3 b) + { + return float3x3( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y, + a.c0 * b.c2.x + a.c1 * b.c2.y); + } + + /// Returns the float3x4 matrix result of a matrix multiplication between a float3x2 matrix and a float2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 mul(float3x2 a, float2x4 b) + { + return float3x4( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y, + a.c0 * b.c2.x + a.c1 * b.c2.y, + a.c0 * b.c3.x + a.c1 * b.c3.y); + } + + /// Returns the float3 column vector result of a matrix multiplication between a float3x3 matrix and a float3 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 mul(float3x3 a, float3 b) + { + return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z; + } + + /// Returns the float3x2 matrix result of a matrix multiplication between a float3x3 matrix and a float3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 mul(float3x3 a, float3x2 b) + { + return float3x2( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z); + } + + /// Returns the float3x3 matrix result of a matrix multiplication between a float3x3 matrix and a float3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 mul(float3x3 a, float3x3 b) + { + return float3x3( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z); + } + + /// Returns the float3x4 matrix result of a matrix multiplication between a float3x3 matrix and a float3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 mul(float3x3 a, float3x4 b) + { + return float3x4( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z, + a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z); + } + + /// Returns the float3 column vector result of a matrix multiplication between a float3x4 matrix and a float4 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 mul(float3x4 a, float4 b) + { + return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3 * b.w; + } + + /// Returns the float3x2 matrix result of a matrix multiplication between a float3x4 matrix and a float4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x2 mul(float3x4 a, float4x2 b) + { + return float3x2( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w); + } + + /// Returns the float3x3 matrix result of a matrix multiplication between a float3x4 matrix and a float4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x3 mul(float3x4 a, float4x3 b) + { + return float3x3( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w); + } + + /// Returns the float3x4 matrix result of a matrix multiplication between a float3x4 matrix and a float4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3x4 mul(float3x4 a, float4x4 b) + { + return float3x4( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w, + a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z + a.c3 * b.c3.w); + } + + /// Returns the float4 column vector result of a matrix multiplication between a float4x2 matrix and a float2 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 mul(float4x2 a, float2 b) + { + return a.c0 * b.x + a.c1 * b.y; + } + + /// Returns the float4x2 matrix result of a matrix multiplication between a float4x2 matrix and a float2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 mul(float4x2 a, float2x2 b) + { + return float4x2( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y); + } + + /// Returns the float4x3 matrix result of a matrix multiplication between a float4x2 matrix and a float2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 mul(float4x2 a, float2x3 b) + { + return float4x3( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y, + a.c0 * b.c2.x + a.c1 * b.c2.y); + } + + /// Returns the float4x4 matrix result of a matrix multiplication between a float4x2 matrix and a float2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 mul(float4x2 a, float2x4 b) + { + return float4x4( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y, + a.c0 * b.c2.x + a.c1 * b.c2.y, + a.c0 * b.c3.x + a.c1 * b.c3.y); + } + + /// Returns the float4 column vector result of a matrix multiplication between a float4x3 matrix and a float3 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 mul(float4x3 a, float3 b) + { + return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z; + } + + /// Returns the float4x2 matrix result of a matrix multiplication between a float4x3 matrix and a float3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 mul(float4x3 a, float3x2 b) + { + return float4x2( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z); + } + + /// Returns the float4x3 matrix result of a matrix multiplication between a float4x3 matrix and a float3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 mul(float4x3 a, float3x3 b) + { + return float4x3( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z); + } + + /// Returns the float4x4 matrix result of a matrix multiplication between a float4x3 matrix and a float3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 mul(float4x3 a, float3x4 b) + { + return float4x4( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z, + a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z); + } + + /// Returns the float4 column vector result of a matrix multiplication between a float4x4 matrix and a float4 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 mul(float4x4 a, float4 b) + { + return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3 * b.w; + } + + /// Returns the float4x2 matrix result of a matrix multiplication between a float4x4 matrix and a float4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x2 mul(float4x4 a, float4x2 b) + { + return float4x2( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w); + } + + /// Returns the float4x3 matrix result of a matrix multiplication between a float4x4 matrix and a float4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x3 mul(float4x4 a, float4x3 b) + { + return float4x3( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w); + } + + /// Returns the float4x4 matrix result of a matrix multiplication between a float4x4 matrix and a float4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4x4 mul(float4x4 a, float4x4 b) + { + return float4x4( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w, + a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z + a.c3 * b.c3.w); + } + + /// Returns the double value result of a matrix multiplication between a double value and a double value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double mul(double a, double b) + { + return a * b; + } + + /// Returns the double value result of a matrix multiplication between a double2 row vector and a double2 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double mul(double2 a, double2 b) + { + return a.x * b.x + a.y * b.y; + } + + /// Returns the double2 row vector result of a matrix multiplication between a double2 row vector and a double2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2 mul(double2 a, double2x2 b) + { + return double2( + a.x * b.c0.x + a.y * b.c0.y, + a.x * b.c1.x + a.y * b.c1.y); + } + + /// Returns the double3 row vector result of a matrix multiplication between a double2 row vector and a double2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3 mul(double2 a, double2x3 b) + { + return double3( + a.x * b.c0.x + a.y * b.c0.y, + a.x * b.c1.x + a.y * b.c1.y, + a.x * b.c2.x + a.y * b.c2.y); + } + + /// Returns the double4 row vector result of a matrix multiplication between a double2 row vector and a double2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4 mul(double2 a, double2x4 b) + { + return double4( + a.x * b.c0.x + a.y * b.c0.y, + a.x * b.c1.x + a.y * b.c1.y, + a.x * b.c2.x + a.y * b.c2.y, + a.x * b.c3.x + a.y * b.c3.y); + } + + /// Returns the double value result of a matrix multiplication between a double3 row vector and a double3 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double mul(double3 a, double3 b) + { + return a.x * b.x + a.y * b.y + a.z * b.z; + } + + /// Returns the double2 row vector result of a matrix multiplication between a double3 row vector and a double3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2 mul(double3 a, double3x2 b) + { + return double2( + a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z, + a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z); + } + + /// Returns the double3 row vector result of a matrix multiplication between a double3 row vector and a double3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3 mul(double3 a, double3x3 b) + { + return double3( + a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z, + a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z, + a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z); + } + + /// Returns the double4 row vector result of a matrix multiplication between a double3 row vector and a double3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4 mul(double3 a, double3x4 b) + { + return double4( + a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z, + a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z, + a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z, + a.x * b.c3.x + a.y * b.c3.y + a.z * b.c3.z); + } + + /// Returns the double value result of a matrix multiplication between a double4 row vector and a double4 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double mul(double4 a, double4 b) + { + return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w; + } + + /// Returns the double2 row vector result of a matrix multiplication between a double4 row vector and a double4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2 mul(double4 a, double4x2 b) + { + return double2( + a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z + a.w * b.c0.w, + a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z + a.w * b.c1.w); + } + + /// Returns the double3 row vector result of a matrix multiplication between a double4 row vector and a double4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3 mul(double4 a, double4x3 b) + { + return double3( + a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z + a.w * b.c0.w, + a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z + a.w * b.c1.w, + a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z + a.w * b.c2.w); + } + + /// Returns the double4 row vector result of a matrix multiplication between a double4 row vector and a double4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4 mul(double4 a, double4x4 b) + { + return double4( + a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z + a.w * b.c0.w, + a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z + a.w * b.c1.w, + a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z + a.w * b.c2.w, + a.x * b.c3.x + a.y * b.c3.y + a.z * b.c3.z + a.w * b.c3.w); + } + + /// Returns the double2 column vector result of a matrix multiplication between a double2x2 matrix and a double2 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2 mul(double2x2 a, double2 b) + { + return a.c0 * b.x + a.c1 * b.y; + } + + /// Returns the double2x2 matrix result of a matrix multiplication between a double2x2 matrix and a double2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2x2 mul(double2x2 a, double2x2 b) + { + return double2x2( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y); + } + + /// Returns the double2x3 matrix result of a matrix multiplication between a double2x2 matrix and a double2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2x3 mul(double2x2 a, double2x3 b) + { + return double2x3( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y, + a.c0 * b.c2.x + a.c1 * b.c2.y); + } + + /// Returns the double2x4 matrix result of a matrix multiplication between a double2x2 matrix and a double2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2x4 mul(double2x2 a, double2x4 b) + { + return double2x4( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y, + a.c0 * b.c2.x + a.c1 * b.c2.y, + a.c0 * b.c3.x + a.c1 * b.c3.y); + } + + /// Returns the double2 column vector result of a matrix multiplication between a double2x3 matrix and a double3 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2 mul(double2x3 a, double3 b) + { + return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z; + } + + /// Returns the double2x2 matrix result of a matrix multiplication between a double2x3 matrix and a double3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2x2 mul(double2x3 a, double3x2 b) + { + return double2x2( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z); + } + + /// Returns the double2x3 matrix result of a matrix multiplication between a double2x3 matrix and a double3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2x3 mul(double2x3 a, double3x3 b) + { + return double2x3( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z); + } + + /// Returns the double2x4 matrix result of a matrix multiplication between a double2x3 matrix and a double3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2x4 mul(double2x3 a, double3x4 b) + { + return double2x4( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z, + a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z); + } + + /// Returns the double2 column vector result of a matrix multiplication between a double2x4 matrix and a double4 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2 mul(double2x4 a, double4 b) + { + return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3 * b.w; + } + + /// Returns the double2x2 matrix result of a matrix multiplication between a double2x4 matrix and a double4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2x2 mul(double2x4 a, double4x2 b) + { + return double2x2( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w); + } + + /// Returns the double2x3 matrix result of a matrix multiplication between a double2x4 matrix and a double4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2x3 mul(double2x4 a, double4x3 b) + { + return double2x3( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w); + } + + /// Returns the double2x4 matrix result of a matrix multiplication between a double2x4 matrix and a double4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double2x4 mul(double2x4 a, double4x4 b) + { + return double2x4( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w, + a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z + a.c3 * b.c3.w); + } + + /// Returns the double3 column vector result of a matrix multiplication between a double3x2 matrix and a double2 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3 mul(double3x2 a, double2 b) + { + return a.c0 * b.x + a.c1 * b.y; + } + + /// Returns the double3x2 matrix result of a matrix multiplication between a double3x2 matrix and a double2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3x2 mul(double3x2 a, double2x2 b) + { + return double3x2( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y); + } + + /// Returns the double3x3 matrix result of a matrix multiplication between a double3x2 matrix and a double2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3x3 mul(double3x2 a, double2x3 b) + { + return double3x3( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y, + a.c0 * b.c2.x + a.c1 * b.c2.y); + } + + /// Returns the double3x4 matrix result of a matrix multiplication between a double3x2 matrix and a double2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3x4 mul(double3x2 a, double2x4 b) + { + return double3x4( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y, + a.c0 * b.c2.x + a.c1 * b.c2.y, + a.c0 * b.c3.x + a.c1 * b.c3.y); + } + + /// Returns the double3 column vector result of a matrix multiplication between a double3x3 matrix and a double3 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3 mul(double3x3 a, double3 b) + { + return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z; + } + + /// Returns the double3x2 matrix result of a matrix multiplication between a double3x3 matrix and a double3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3x2 mul(double3x3 a, double3x2 b) + { + return double3x2( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z); + } + + /// Returns the double3x3 matrix result of a matrix multiplication between a double3x3 matrix and a double3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3x3 mul(double3x3 a, double3x3 b) + { + return double3x3( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z); + } + + /// Returns the double3x4 matrix result of a matrix multiplication between a double3x3 matrix and a double3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3x4 mul(double3x3 a, double3x4 b) + { + return double3x4( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z, + a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z); + } + + /// Returns the double3 column vector result of a matrix multiplication between a double3x4 matrix and a double4 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3 mul(double3x4 a, double4 b) + { + return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3 * b.w; + } + + /// Returns the double3x2 matrix result of a matrix multiplication between a double3x4 matrix and a double4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3x2 mul(double3x4 a, double4x2 b) + { + return double3x2( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w); + } + + /// Returns the double3x3 matrix result of a matrix multiplication between a double3x4 matrix and a double4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3x3 mul(double3x4 a, double4x3 b) + { + return double3x3( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w); + } + + /// Returns the double3x4 matrix result of a matrix multiplication between a double3x4 matrix and a double4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double3x4 mul(double3x4 a, double4x4 b) + { + return double3x4( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w, + a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z + a.c3 * b.c3.w); + } + + /// Returns the double4 column vector result of a matrix multiplication between a double4x2 matrix and a double2 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4 mul(double4x2 a, double2 b) + { + return a.c0 * b.x + a.c1 * b.y; + } + + /// Returns the double4x2 matrix result of a matrix multiplication between a double4x2 matrix and a double2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4x2 mul(double4x2 a, double2x2 b) + { + return double4x2( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y); + } + + /// Returns the double4x3 matrix result of a matrix multiplication between a double4x2 matrix and a double2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4x3 mul(double4x2 a, double2x3 b) + { + return double4x3( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y, + a.c0 * b.c2.x + a.c1 * b.c2.y); + } + + /// Returns the double4x4 matrix result of a matrix multiplication between a double4x2 matrix and a double2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4x4 mul(double4x2 a, double2x4 b) + { + return double4x4( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y, + a.c0 * b.c2.x + a.c1 * b.c2.y, + a.c0 * b.c3.x + a.c1 * b.c3.y); + } + + /// Returns the double4 column vector result of a matrix multiplication between a double4x3 matrix and a double3 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4 mul(double4x3 a, double3 b) + { + return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z; + } + + /// Returns the double4x2 matrix result of a matrix multiplication between a double4x3 matrix and a double3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4x2 mul(double4x3 a, double3x2 b) + { + return double4x2( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z); + } + + /// Returns the double4x3 matrix result of a matrix multiplication between a double4x3 matrix and a double3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4x3 mul(double4x3 a, double3x3 b) + { + return double4x3( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z); + } + + /// Returns the double4x4 matrix result of a matrix multiplication between a double4x3 matrix and a double3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4x4 mul(double4x3 a, double3x4 b) + { + return double4x4( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z, + a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z); + } + + /// Returns the double4 column vector result of a matrix multiplication between a double4x4 matrix and a double4 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4 mul(double4x4 a, double4 b) + { + return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3 * b.w; + } + + /// Returns the double4x2 matrix result of a matrix multiplication between a double4x4 matrix and a double4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4x2 mul(double4x4 a, double4x2 b) + { + return double4x2( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w); + } + + /// Returns the double4x3 matrix result of a matrix multiplication between a double4x4 matrix and a double4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4x3 mul(double4x4 a, double4x3 b) + { + return double4x3( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w); + } + + /// Returns the double4x4 matrix result of a matrix multiplication between a double4x4 matrix and a double4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static double4x4 mul(double4x4 a, double4x4 b) + { + return double4x4( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w, + a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z + a.c3 * b.c3.w); + } + + /// Returns the int value result of a matrix multiplication between an int value and an int value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int mul(int a, int b) + { + return a * b; + } + + /// Returns the int value result of a matrix multiplication between an int2 row vector and an int2 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int mul(int2 a, int2 b) + { + return a.x * b.x + a.y * b.y; + } + + /// Returns the int2 row vector result of a matrix multiplication between an int2 row vector and an int2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 mul(int2 a, int2x2 b) + { + return int2( + a.x * b.c0.x + a.y * b.c0.y, + a.x * b.c1.x + a.y * b.c1.y); + } + + /// Returns the int3 row vector result of a matrix multiplication between an int2 row vector and an int2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 mul(int2 a, int2x3 b) + { + return int3( + a.x * b.c0.x + a.y * b.c0.y, + a.x * b.c1.x + a.y * b.c1.y, + a.x * b.c2.x + a.y * b.c2.y); + } + + /// Returns the int4 row vector result of a matrix multiplication between an int2 row vector and an int2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 mul(int2 a, int2x4 b) + { + return int4( + a.x * b.c0.x + a.y * b.c0.y, + a.x * b.c1.x + a.y * b.c1.y, + a.x * b.c2.x + a.y * b.c2.y, + a.x * b.c3.x + a.y * b.c3.y); + } + + /// Returns the int value result of a matrix multiplication between an int3 row vector and an int3 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int mul(int3 a, int3 b) + { + return a.x * b.x + a.y * b.y + a.z * b.z; + } + + /// Returns the int2 row vector result of a matrix multiplication between an int3 row vector and an int3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 mul(int3 a, int3x2 b) + { + return int2( + a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z, + a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z); + } + + /// Returns the int3 row vector result of a matrix multiplication between an int3 row vector and an int3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 mul(int3 a, int3x3 b) + { + return int3( + a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z, + a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z, + a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z); + } + + /// Returns the int4 row vector result of a matrix multiplication between an int3 row vector and an int3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 mul(int3 a, int3x4 b) + { + return int4( + a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z, + a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z, + a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z, + a.x * b.c3.x + a.y * b.c3.y + a.z * b.c3.z); + } + + /// Returns the int value result of a matrix multiplication between an int4 row vector and an int4 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int mul(int4 a, int4 b) + { + return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w; + } + + /// Returns the int2 row vector result of a matrix multiplication between an int4 row vector and an int4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 mul(int4 a, int4x2 b) + { + return int2( + a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z + a.w * b.c0.w, + a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z + a.w * b.c1.w); + } + + /// Returns the int3 row vector result of a matrix multiplication between an int4 row vector and an int4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 mul(int4 a, int4x3 b) + { + return int3( + a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z + a.w * b.c0.w, + a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z + a.w * b.c1.w, + a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z + a.w * b.c2.w); + } + + /// Returns the int4 row vector result of a matrix multiplication between an int4 row vector and an int4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 mul(int4 a, int4x4 b) + { + return int4( + a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z + a.w * b.c0.w, + a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z + a.w * b.c1.w, + a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z + a.w * b.c2.w, + a.x * b.c3.x + a.y * b.c3.y + a.z * b.c3.z + a.w * b.c3.w); + } + + /// Returns the int2 column vector result of a matrix multiplication between an int2x2 matrix and an int2 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 mul(int2x2 a, int2 b) + { + return a.c0 * b.x + a.c1 * b.y; + } + + /// Returns the int2x2 matrix result of a matrix multiplication between an int2x2 matrix and an int2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 mul(int2x2 a, int2x2 b) + { + return int2x2( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y); + } + + /// Returns the int2x3 matrix result of a matrix multiplication between an int2x2 matrix and an int2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 mul(int2x2 a, int2x3 b) + { + return int2x3( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y, + a.c0 * b.c2.x + a.c1 * b.c2.y); + } + + /// Returns the int2x4 matrix result of a matrix multiplication between an int2x2 matrix and an int2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 mul(int2x2 a, int2x4 b) + { + return int2x4( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y, + a.c0 * b.c2.x + a.c1 * b.c2.y, + a.c0 * b.c3.x + a.c1 * b.c3.y); + } + + /// Returns the int2 column vector result of a matrix multiplication between an int2x3 matrix and an int3 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 mul(int2x3 a, int3 b) + { + return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z; + } + + /// Returns the int2x2 matrix result of a matrix multiplication between an int2x3 matrix and an int3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 mul(int2x3 a, int3x2 b) + { + return int2x2( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z); + } + + /// Returns the int2x3 matrix result of a matrix multiplication between an int2x3 matrix and an int3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 mul(int2x3 a, int3x3 b) + { + return int2x3( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z); + } + + /// Returns the int2x4 matrix result of a matrix multiplication between an int2x3 matrix and an int3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 mul(int2x3 a, int3x4 b) + { + return int2x4( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z, + a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z); + } + + /// Returns the int2 column vector result of a matrix multiplication between an int2x4 matrix and an int4 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2 mul(int2x4 a, int4 b) + { + return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3 * b.w; + } + + /// Returns the int2x2 matrix result of a matrix multiplication between an int2x4 matrix and an int4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x2 mul(int2x4 a, int4x2 b) + { + return int2x2( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w); + } + + /// Returns the int2x3 matrix result of a matrix multiplication between an int2x4 matrix and an int4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x3 mul(int2x4 a, int4x3 b) + { + return int2x3( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w); + } + + /// Returns the int2x4 matrix result of a matrix multiplication between an int2x4 matrix and an int4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int2x4 mul(int2x4 a, int4x4 b) + { + return int2x4( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w, + a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z + a.c3 * b.c3.w); + } + + /// Returns the int3 column vector result of a matrix multiplication between an int3x2 matrix and an int2 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 mul(int3x2 a, int2 b) + { + return a.c0 * b.x + a.c1 * b.y; + } + + /// Returns the int3x2 matrix result of a matrix multiplication between an int3x2 matrix and an int2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 mul(int3x2 a, int2x2 b) + { + return int3x2( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y); + } + + /// Returns the int3x3 matrix result of a matrix multiplication between an int3x2 matrix and an int2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 mul(int3x2 a, int2x3 b) + { + return int3x3( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y, + a.c0 * b.c2.x + a.c1 * b.c2.y); + } + + /// Returns the int3x4 matrix result of a matrix multiplication between an int3x2 matrix and an int2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 mul(int3x2 a, int2x4 b) + { + return int3x4( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y, + a.c0 * b.c2.x + a.c1 * b.c2.y, + a.c0 * b.c3.x + a.c1 * b.c3.y); + } + + /// Returns the int3 column vector result of a matrix multiplication between an int3x3 matrix and an int3 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 mul(int3x3 a, int3 b) + { + return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z; + } + + /// Returns the int3x2 matrix result of a matrix multiplication between an int3x3 matrix and an int3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 mul(int3x3 a, int3x2 b) + { + return int3x2( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z); + } + + /// Returns the int3x3 matrix result of a matrix multiplication between an int3x3 matrix and an int3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 mul(int3x3 a, int3x3 b) + { + return int3x3( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z); + } + + /// Returns the int3x4 matrix result of a matrix multiplication between an int3x3 matrix and an int3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 mul(int3x3 a, int3x4 b) + { + return int3x4( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z, + a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z); + } + + /// Returns the int3 column vector result of a matrix multiplication between an int3x4 matrix and an int4 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3 mul(int3x4 a, int4 b) + { + return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3 * b.w; + } + + /// Returns the int3x2 matrix result of a matrix multiplication between an int3x4 matrix and an int4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x2 mul(int3x4 a, int4x2 b) + { + return int3x2( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w); + } + + /// Returns the int3x3 matrix result of a matrix multiplication between an int3x4 matrix and an int4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x3 mul(int3x4 a, int4x3 b) + { + return int3x3( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w); + } + + /// Returns the int3x4 matrix result of a matrix multiplication between an int3x4 matrix and an int4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int3x4 mul(int3x4 a, int4x4 b) + { + return int3x4( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w, + a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z + a.c3 * b.c3.w); + } + + /// Returns the int4 column vector result of a matrix multiplication between an int4x2 matrix and an int2 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 mul(int4x2 a, int2 b) + { + return a.c0 * b.x + a.c1 * b.y; + } + + /// Returns the int4x2 matrix result of a matrix multiplication between an int4x2 matrix and an int2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 mul(int4x2 a, int2x2 b) + { + return int4x2( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y); + } + + /// Returns the int4x3 matrix result of a matrix multiplication between an int4x2 matrix and an int2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 mul(int4x2 a, int2x3 b) + { + return int4x3( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y, + a.c0 * b.c2.x + a.c1 * b.c2.y); + } + + /// Returns the int4x4 matrix result of a matrix multiplication between an int4x2 matrix and an int2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 mul(int4x2 a, int2x4 b) + { + return int4x4( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y, + a.c0 * b.c2.x + a.c1 * b.c2.y, + a.c0 * b.c3.x + a.c1 * b.c3.y); + } + + /// Returns the int4 column vector result of a matrix multiplication between an int4x3 matrix and an int3 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 mul(int4x3 a, int3 b) + { + return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z; + } + + /// Returns the int4x2 matrix result of a matrix multiplication between an int4x3 matrix and an int3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 mul(int4x3 a, int3x2 b) + { + return int4x2( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z); + } + + /// Returns the int4x3 matrix result of a matrix multiplication between an int4x3 matrix and an int3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 mul(int4x3 a, int3x3 b) + { + return int4x3( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z); + } + + /// Returns the int4x4 matrix result of a matrix multiplication between an int4x3 matrix and an int3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 mul(int4x3 a, int3x4 b) + { + return int4x4( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z, + a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z); + } + + /// Returns the int4 column vector result of a matrix multiplication between an int4x4 matrix and an int4 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4 mul(int4x4 a, int4 b) + { + return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3 * b.w; + } + + /// Returns the int4x2 matrix result of a matrix multiplication between an int4x4 matrix and an int4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x2 mul(int4x4 a, int4x2 b) + { + return int4x2( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w); + } + + /// Returns the int4x3 matrix result of a matrix multiplication between an int4x4 matrix and an int4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x3 mul(int4x4 a, int4x3 b) + { + return int4x3( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w); + } + + /// Returns the int4x4 matrix result of a matrix multiplication between an int4x4 matrix and an int4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int4x4 mul(int4x4 a, int4x4 b) + { + return int4x4( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w, + a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z + a.c3 * b.c3.w); + } + + /// Returns the uint value result of a matrix multiplication between a uint value and a uint value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint mul(uint a, uint b) + { + return a * b; + } + + /// Returns the uint value result of a matrix multiplication between a uint2 row vector and a uint2 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint mul(uint2 a, uint2 b) + { + return a.x * b.x + a.y * b.y; + } + + /// Returns the uint2 row vector result of a matrix multiplication between a uint2 row vector and a uint2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2 mul(uint2 a, uint2x2 b) + { + return uint2( + a.x * b.c0.x + a.y * b.c0.y, + a.x * b.c1.x + a.y * b.c1.y); + } + + /// Returns the uint3 row vector result of a matrix multiplication between a uint2 row vector and a uint2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 mul(uint2 a, uint2x3 b) + { + return uint3( + a.x * b.c0.x + a.y * b.c0.y, + a.x * b.c1.x + a.y * b.c1.y, + a.x * b.c2.x + a.y * b.c2.y); + } + + /// Returns the uint4 row vector result of a matrix multiplication between a uint2 row vector and a uint2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 mul(uint2 a, uint2x4 b) + { + return uint4( + a.x * b.c0.x + a.y * b.c0.y, + a.x * b.c1.x + a.y * b.c1.y, + a.x * b.c2.x + a.y * b.c2.y, + a.x * b.c3.x + a.y * b.c3.y); + } + + /// Returns the uint value result of a matrix multiplication between a uint3 row vector and a uint3 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint mul(uint3 a, uint3 b) + { + return a.x * b.x + a.y * b.y + a.z * b.z; + } + + /// Returns the uint2 row vector result of a matrix multiplication between a uint3 row vector and a uint3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2 mul(uint3 a, uint3x2 b) + { + return uint2( + a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z, + a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z); + } + + /// Returns the uint3 row vector result of a matrix multiplication between a uint3 row vector and a uint3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 mul(uint3 a, uint3x3 b) + { + return uint3( + a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z, + a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z, + a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z); + } + + /// Returns the uint4 row vector result of a matrix multiplication between a uint3 row vector and a uint3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 mul(uint3 a, uint3x4 b) + { + return uint4( + a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z, + a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z, + a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z, + a.x * b.c3.x + a.y * b.c3.y + a.z * b.c3.z); + } + + /// Returns the uint value result of a matrix multiplication between a uint4 row vector and a uint4 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint mul(uint4 a, uint4 b) + { + return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w; + } + + /// Returns the uint2 row vector result of a matrix multiplication between a uint4 row vector and a uint4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2 mul(uint4 a, uint4x2 b) + { + return uint2( + a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z + a.w * b.c0.w, + a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z + a.w * b.c1.w); + } + + /// Returns the uint3 row vector result of a matrix multiplication between a uint4 row vector and a uint4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 mul(uint4 a, uint4x3 b) + { + return uint3( + a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z + a.w * b.c0.w, + a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z + a.w * b.c1.w, + a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z + a.w * b.c2.w); + } + + /// Returns the uint4 row vector result of a matrix multiplication between a uint4 row vector and a uint4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 mul(uint4 a, uint4x4 b) + { + return uint4( + a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z + a.w * b.c0.w, + a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z + a.w * b.c1.w, + a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z + a.w * b.c2.w, + a.x * b.c3.x + a.y * b.c3.y + a.z * b.c3.z + a.w * b.c3.w); + } + + /// Returns the uint2 column vector result of a matrix multiplication between a uint2x2 matrix and a uint2 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2 mul(uint2x2 a, uint2 b) + { + return a.c0 * b.x + a.c1 * b.y; + } + + /// Returns the uint2x2 matrix result of a matrix multiplication between a uint2x2 matrix and a uint2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2x2 mul(uint2x2 a, uint2x2 b) + { + return uint2x2( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y); + } + + /// Returns the uint2x3 matrix result of a matrix multiplication between a uint2x2 matrix and a uint2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2x3 mul(uint2x2 a, uint2x3 b) + { + return uint2x3( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y, + a.c0 * b.c2.x + a.c1 * b.c2.y); + } + + /// Returns the uint2x4 matrix result of a matrix multiplication between a uint2x2 matrix and a uint2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2x4 mul(uint2x2 a, uint2x4 b) + { + return uint2x4( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y, + a.c0 * b.c2.x + a.c1 * b.c2.y, + a.c0 * b.c3.x + a.c1 * b.c3.y); + } + + /// Returns the uint2 column vector result of a matrix multiplication between a uint2x3 matrix and a uint3 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2 mul(uint2x3 a, uint3 b) + { + return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z; + } + + /// Returns the uint2x2 matrix result of a matrix multiplication between a uint2x3 matrix and a uint3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2x2 mul(uint2x3 a, uint3x2 b) + { + return uint2x2( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z); + } + + /// Returns the uint2x3 matrix result of a matrix multiplication between a uint2x3 matrix and a uint3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2x3 mul(uint2x3 a, uint3x3 b) + { + return uint2x3( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z); + } + + /// Returns the uint2x4 matrix result of a matrix multiplication between a uint2x3 matrix and a uint3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2x4 mul(uint2x3 a, uint3x4 b) + { + return uint2x4( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z, + a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z); + } + + /// Returns the uint2 column vector result of a matrix multiplication between a uint2x4 matrix and a uint4 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2 mul(uint2x4 a, uint4 b) + { + return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3 * b.w; + } + + /// Returns the uint2x2 matrix result of a matrix multiplication between a uint2x4 matrix and a uint4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2x2 mul(uint2x4 a, uint4x2 b) + { + return uint2x2( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w); + } + + /// Returns the uint2x3 matrix result of a matrix multiplication between a uint2x4 matrix and a uint4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2x3 mul(uint2x4 a, uint4x3 b) + { + return uint2x3( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w); + } + + /// Returns the uint2x4 matrix result of a matrix multiplication between a uint2x4 matrix and a uint4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint2x4 mul(uint2x4 a, uint4x4 b) + { + return uint2x4( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w, + a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z + a.c3 * b.c3.w); + } + + /// Returns the uint3 column vector result of a matrix multiplication between a uint3x2 matrix and a uint2 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 mul(uint3x2 a, uint2 b) + { + return a.c0 * b.x + a.c1 * b.y; + } + + /// Returns the uint3x2 matrix result of a matrix multiplication between a uint3x2 matrix and a uint2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 mul(uint3x2 a, uint2x2 b) + { + return uint3x2( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y); + } + + /// Returns the uint3x3 matrix result of a matrix multiplication between a uint3x2 matrix and a uint2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 mul(uint3x2 a, uint2x3 b) + { + return uint3x3( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y, + a.c0 * b.c2.x + a.c1 * b.c2.y); + } + + /// Returns the uint3x4 matrix result of a matrix multiplication between a uint3x2 matrix and a uint2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 mul(uint3x2 a, uint2x4 b) + { + return uint3x4( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y, + a.c0 * b.c2.x + a.c1 * b.c2.y, + a.c0 * b.c3.x + a.c1 * b.c3.y); + } + + /// Returns the uint3 column vector result of a matrix multiplication between a uint3x3 matrix and a uint3 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 mul(uint3x3 a, uint3 b) + { + return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z; + } + + /// Returns the uint3x2 matrix result of a matrix multiplication between a uint3x3 matrix and a uint3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 mul(uint3x3 a, uint3x2 b) + { + return uint3x2( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z); + } + + /// Returns the uint3x3 matrix result of a matrix multiplication between a uint3x3 matrix and a uint3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 mul(uint3x3 a, uint3x3 b) + { + return uint3x3( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z); + } + + /// Returns the uint3x4 matrix result of a matrix multiplication between a uint3x3 matrix and a uint3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 mul(uint3x3 a, uint3x4 b) + { + return uint3x4( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z, + a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z); + } + + /// Returns the uint3 column vector result of a matrix multiplication between a uint3x4 matrix and a uint4 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3 mul(uint3x4 a, uint4 b) + { + return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3 * b.w; + } + + /// Returns the uint3x2 matrix result of a matrix multiplication between a uint3x4 matrix and a uint4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x2 mul(uint3x4 a, uint4x2 b) + { + return uint3x2( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w); + } + + /// Returns the uint3x3 matrix result of a matrix multiplication between a uint3x4 matrix and a uint4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x3 mul(uint3x4 a, uint4x3 b) + { + return uint3x3( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w); + } + + /// Returns the uint3x4 matrix result of a matrix multiplication between a uint3x4 matrix and a uint4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint3x4 mul(uint3x4 a, uint4x4 b) + { + return uint3x4( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w, + a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z + a.c3 * b.c3.w); + } + + /// Returns the uint4 column vector result of a matrix multiplication between a uint4x2 matrix and a uint2 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 mul(uint4x2 a, uint2 b) + { + return a.c0 * b.x + a.c1 * b.y; + } + + /// Returns the uint4x2 matrix result of a matrix multiplication between a uint4x2 matrix and a uint2x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 mul(uint4x2 a, uint2x2 b) + { + return uint4x2( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y); + } + + /// Returns the uint4x3 matrix result of a matrix multiplication between a uint4x2 matrix and a uint2x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 mul(uint4x2 a, uint2x3 b) + { + return uint4x3( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y, + a.c0 * b.c2.x + a.c1 * b.c2.y); + } + + /// Returns the uint4x4 matrix result of a matrix multiplication between a uint4x2 matrix and a uint2x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 mul(uint4x2 a, uint2x4 b) + { + return uint4x4( + a.c0 * b.c0.x + a.c1 * b.c0.y, + a.c0 * b.c1.x + a.c1 * b.c1.y, + a.c0 * b.c2.x + a.c1 * b.c2.y, + a.c0 * b.c3.x + a.c1 * b.c3.y); + } + + /// Returns the uint4 column vector result of a matrix multiplication between a uint4x3 matrix and a uint3 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 mul(uint4x3 a, uint3 b) + { + return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z; + } + + /// Returns the uint4x2 matrix result of a matrix multiplication between a uint4x3 matrix and a uint3x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 mul(uint4x3 a, uint3x2 b) + { + return uint4x2( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z); + } + + /// Returns the uint4x3 matrix result of a matrix multiplication between a uint4x3 matrix and a uint3x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 mul(uint4x3 a, uint3x3 b) + { + return uint4x3( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z); + } + + /// Returns the uint4x4 matrix result of a matrix multiplication between a uint4x3 matrix and a uint3x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 mul(uint4x3 a, uint3x4 b) + { + return uint4x4( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z, + a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z); + } + + /// Returns the uint4 column vector result of a matrix multiplication between a uint4x4 matrix and a uint4 column vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 mul(uint4x4 a, uint4 b) + { + return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3 * b.w; + } + + /// Returns the uint4x2 matrix result of a matrix multiplication between a uint4x4 matrix and a uint4x2 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x2 mul(uint4x4 a, uint4x2 b) + { + return uint4x2( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w); + } + + /// Returns the uint4x3 matrix result of a matrix multiplication between a uint4x4 matrix and a uint4x3 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x3 mul(uint4x4 a, uint4x3 b) + { + return uint4x3( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w); + } + + /// Returns the uint4x4 matrix result of a matrix multiplication between a uint4x4 matrix and a uint4x4 matrix. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4x4 mul(uint4x4 a, uint4x4 b) + { + return uint4x4( + a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w, + a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w, + a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w, + a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z + a.c3 * b.c3.w); + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/matrix.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/matrix.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..4ad76a131a7cf29e0b7dba151f2b3aaefbc2a3ca --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/matrix.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: d1064bad8f85342fd912d0d27f279601 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/quaternion.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/quaternion.cs new file mode 100644 index 0000000000000000000000000000000000000000..3f9a447675b87897171b6887d8cabce28373ced7 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/quaternion.cs @@ -0,0 +1,610 @@ +using System; +using System.Runtime.CompilerServices; +using static Unity.Mathematics.math; + +namespace Unity.Mathematics +{ + [Serializable] + public partial struct quaternion : System.IEquatable, IFormattable + { + public float4 value; + + /// A quaternion representing the identity transform. + public static readonly quaternion identity = new quaternion(0.0f, 0.0f, 0.0f, 1.0f); + + /// Constructs a quaternion from four float values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public quaternion(float x, float y, float z, float w) { value.x = x; value.y = y; value.z = z; value.w = w; } + + /// Constructs a quaternion from float4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public quaternion(float4 value) { this.value = value; } + + /// Implicitly converts a float4 vector to a quaternion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static implicit operator quaternion(float4 v) { return new quaternion(v); } + + /// Constructs a unit quaternion from a float3x3 rotation matrix. The matrix must be orthonormal. + public quaternion(float3x3 m) + { + float3 u = m.c0; + float3 v = m.c1; + float3 w = m.c2; + + uint u_sign = (asuint(u.x) & 0x80000000); + float t = v.y + asfloat(asuint(w.z) ^ u_sign); + uint4 u_mask = uint4((int)u_sign >> 31); + uint4 t_mask = uint4(asint(t) >> 31); + + float tr = 1.0f + abs(u.x); + + uint4 sign_flips = uint4(0x00000000, 0x80000000, 0x80000000, 0x80000000) ^ (u_mask & uint4(0x00000000, 0x80000000, 0x00000000, 0x80000000)) ^ (t_mask & uint4(0x80000000, 0x80000000, 0x80000000, 0x00000000)); + + value = float4(tr, u.y, w.x, v.z) + asfloat(asuint(float4(t, v.x, u.z, w.y)) ^ sign_flips); // +---, +++-, ++-+, +-++ + + value = asfloat((asuint(value) & ~u_mask) | (asuint(value.zwxy) & u_mask)); + value = asfloat((asuint(value.wzyx) & ~t_mask) | (asuint(value) & t_mask)); + value = normalize(value); + } + + /// Constructs a unit quaternion from an orthonormal float4x4 matrix. + public quaternion(float4x4 m) + { + float4 u = m.c0; + float4 v = m.c1; + float4 w = m.c2; + + uint u_sign = (asuint(u.x) & 0x80000000); + float t = v.y + asfloat(asuint(w.z) ^ u_sign); + uint4 u_mask = uint4((int)u_sign >> 31); + uint4 t_mask = uint4(asint(t) >> 31); + + float tr = 1.0f + abs(u.x); + + uint4 sign_flips = uint4(0x00000000, 0x80000000, 0x80000000, 0x80000000) ^ (u_mask & uint4(0x00000000, 0x80000000, 0x00000000, 0x80000000)) ^ (t_mask & uint4(0x80000000, 0x80000000, 0x80000000, 0x00000000)); + + value = float4(tr, u.y, w.x, v.z) + asfloat(asuint(float4(t, v.x, u.z, w.y)) ^ sign_flips); // +---, +++-, ++-+, +-++ + + value = asfloat((asuint(value) & ~u_mask) | (asuint(value.zwxy) & u_mask)); + value = asfloat((asuint(value.wzyx) & ~t_mask) | (asuint(value) & t_mask)); + + value = normalize(value); + } + + /// + /// Returns a quaternion representing a rotation around a unit axis by an angle in radians. + /// The rotation direction is clockwise when looking along the rotation axis towards the origin. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static quaternion AxisAngle(float3 axis, float angle) + { + float sina, cosa; + math.sincos(0.5f * angle, out sina, out cosa); + return quaternion(float4(axis * sina, cosa)); + } + + /// + /// Returns a quaternion constructed by first performing a rotation around the x-axis, then the y-axis and finally the z-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// A float3 vector containing the rotation angles around the x-, y- and z-axis measures in radians. + public static quaternion EulerXYZ(float3 xyz) + { + // return mul(rotateZ(xyz.z), mul(rotateY(xyz.y), rotateX(xyz.x))); + float3 s, c; + sincos(0.5f * xyz, out s, out c); + return quaternion( + // s.x * c.y * c.z - s.y * s.z * c.x, + // s.y * c.x * c.z + s.x * s.z * c.y, + // s.z * c.x * c.y - s.x * s.y * c.z, + // c.x * c.y * c.z + s.y * s.z * s.x + float4(s.xyz, c.x) * c.yxxy * c.zzyz + s.yxxy * s.zzyz * float4(c.xyz, s.x) * float4(-1.0f, 1.0f, -1.0f, 1.0f) + ); + } + + /// + /// Returns a quaternion constructed by first performing a rotation around the x-axis, then the z-axis and finally the y-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// A float3 vector containing the rotation angles around the x-, y- and z-axis measures in radians. + public static quaternion EulerXZY(float3 xyz) + { + // return mul(rotateY(xyz.y), mul(rotateZ(xyz.z), rotateX(xyz.x))); + float3 s, c; + sincos(0.5f * xyz, out s, out c); + return quaternion( + // s.x * c.y * c.z + s.y * s.z * c.x, + // s.y * c.x * c.z + s.x * s.z * c.y, + // s.z * c.x * c.y - s.x * s.y * c.z, + // c.x * c.y * c.z - s.y * s.z * s.x + float4(s.xyz, c.x) * c.yxxy * c.zzyz + s.yxxy * s.zzyz * float4(c.xyz, s.x) * float4(1.0f, 1.0f, -1.0f, -1.0f) + ); + } + + /// + /// Returns a quaternion constructed by first performing a rotation around the y-axis, then the x-axis and finally the z-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// A float3 vector containing the rotation angles around the x-, y- and z-axis measures in radians. + public static quaternion EulerYXZ(float3 xyz) + { + // return mul(rotateZ(xyz.z), mul(rotateX(xyz.x), rotateY(xyz.y))); + float3 s, c; + sincos(0.5f * xyz, out s, out c); + return quaternion( + // s.x * c.y * c.z - s.y * s.z * c.x, + // s.y * c.x * c.z + s.x * s.z * c.y, + // s.z * c.x * c.y + s.x * s.y * c.z, + // c.x * c.y * c.z - s.y * s.z * s.x + float4(s.xyz, c.x) * c.yxxy * c.zzyz + s.yxxy * s.zzyz * float4(c.xyz, s.x) * float4(-1.0f, 1.0f, 1.0f, -1.0f) + ); + } + + /// + /// Returns a quaternion constructed by first performing a rotation around the y-axis, then the z-axis and finally the x-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// A float3 vector containing the rotation angles around the x-, y- and z-axis measures in radians. + public static quaternion EulerYZX(float3 xyz) + { + // return mul(rotateX(xyz.x), mul(rotateZ(xyz.z), rotateY(xyz.y))); + float3 s, c; + sincos(0.5f * xyz, out s, out c); + return quaternion( + // s.x * c.y * c.z - s.y * s.z * c.x, + // s.y * c.x * c.z - s.x * s.z * c.y, + // s.z * c.x * c.y + s.x * s.y * c.z, + // c.x * c.y * c.z + s.y * s.z * s.x + float4(s.xyz, c.x) * c.yxxy * c.zzyz + s.yxxy * s.zzyz * float4(c.xyz, s.x) * float4(-1.0f, -1.0f, 1.0f, 1.0f) + ); + } + + /// + /// Returns a quaternion constructed by first performing a rotation around the z-axis, then the x-axis and finally the y-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// This is the default order rotation order in Unity. + /// + /// A float3 vector containing the rotation angles around the x-, y- and z-axis measures in radians. + public static quaternion EulerZXY(float3 xyz) + { + // return mul(rotateY(xyz.y), mul(rotateX(xyz.x), rotateZ(xyz.z))); + float3 s, c; + sincos(0.5f * xyz, out s, out c); + return quaternion( + // s.x * c.y * c.z + s.y * s.z * c.x, + // s.y * c.x * c.z - s.x * s.z * c.y, + // s.z * c.x * c.y - s.x * s.y * c.z, + // c.x * c.y * c.z + s.y * s.z * s.x + float4(s.xyz, c.x) * c.yxxy * c.zzyz + s.yxxy * s.zzyz * float4(c.xyz, s.x) * float4(1.0f, -1.0f, -1.0f, 1.0f) + ); + } + + /// + /// Returns a quaternion constructed by first performing a rotation around the z-axis, then the y-axis and finally the x-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// A float3 vector containing the rotation angles around the x-, y- and z-axis measures in radians. + public static quaternion EulerZYX(float3 xyz) + { + // return mul(rotateX(xyz.x), mul(rotateY(xyz.y), rotateZ(xyz.z))); + float3 s, c; + sincos(0.5f * xyz, out s, out c); + return quaternion( + // s.x * c.y * c.z + s.y * s.z * c.x, + // s.y * c.x * c.z - s.x * s.z * c.y, + // s.z * c.x * c.y + s.x * s.y * c.z, + // c.x * c.y * c.z - s.y * s.x * s.z + float4(s.xyz, c.x) * c.yxxy * c.zzyz + s.yxxy * s.zzyz * float4(c.xyz, s.x) * float4(1.0f, -1.0f, 1.0f, -1.0f) + ); + } + + /// + /// Returns a quaternion constructed by first performing a rotation around the x-axis, then the y-axis and finally the z-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// The rotation angle around the x-axis in radians. + /// The rotation angle around the y-axis in radians. + /// The rotation angle around the z-axis in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static quaternion EulerXYZ(float x, float y, float z) { return EulerXYZ(float3(x, y, z)); } + + /// + /// Returns a quaternion constructed by first performing a rotation around the x-axis, then the z-axis and finally the y-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// The rotation angle around the x-axis in radians. + /// The rotation angle around the y-axis in radians. + /// The rotation angle around the z-axis in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static quaternion EulerXZY(float x, float y, float z) { return EulerXZY(float3(x, y, z)); } + + /// + /// Returns a quaternion constructed by first performing a rotation around the y-axis, then the x-axis and finally the z-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// The rotation angle around the x-axis in radians. + /// The rotation angle around the y-axis in radians. + /// The rotation angle around the z-axis in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static quaternion EulerYXZ(float x, float y, float z) { return EulerYXZ(float3(x, y, z)); } + + /// + /// Returns a quaternion constructed by first performing a rotation around the y-axis, then the z-axis and finally the x-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// The rotation angle around the x-axis in radians. + /// The rotation angle around the y-axis in radians. + /// The rotation angle around the z-axis in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static quaternion EulerYZX(float x, float y, float z) { return EulerYZX(float3(x, y, z)); } + + /// + /// Returns a quaternion constructed by first performing a rotation around the z-axis, then the x-axis and finally the y-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// This is the default order rotation order in Unity. + /// + /// The rotation angle around the x-axis in radians. + /// The rotation angle around the y-axis in radians. + /// The rotation angle around the z-axis in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static quaternion EulerZXY(float x, float y, float z) { return EulerZXY(float3(x, y, z)); } + + /// + /// Returns a quaternion constructed by first performing a rotation around the z-axis, then the y-axis and finally the x-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// The rotation angle around the x-axis in radians. + /// The rotation angle around the y-axis in radians. + /// The rotation angle around the z-axis in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static quaternion EulerZYX(float x, float y, float z) { return EulerZYX(float3(x, y, z)); } + + /// + /// Returns a quaternion constructed by first performing 3 rotations around the principal axes in a given order. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// When the rotation order is known at compile time, it is recommended for performance reasons to use specific + /// Euler rotation constructors such as EulerZXY(...). + /// + /// A float3 vector containing the rotation angles around the x-, y- and z-axis measures in radians. + /// The order in which the rotations are applied. + public static quaternion Euler(float3 xyz, RotationOrder order = RotationOrder.ZXY) + { + switch (order) + { + case RotationOrder.XYZ: + return EulerXYZ(xyz); + case RotationOrder.XZY: + return EulerXZY(xyz); + case RotationOrder.YXZ: + return EulerYXZ(xyz); + case RotationOrder.YZX: + return EulerYZX(xyz); + case RotationOrder.ZXY: + return EulerZXY(xyz); + case RotationOrder.ZYX: + return EulerZYX(xyz); + default: + return quaternion.identity; + } + } + + /// + /// Returns a quaternion constructed by first performing 3 rotations around the principal axes in a given order. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// When the rotation order is known at compile time, it is recommended for performance reasons to use specific + /// Euler rotation constructors such as EulerZXY(...). + /// + /// The rotation angle around the x-axis in radians. + /// The rotation angle around the y-axis in radians. + /// The rotation angle around the z-axis in radians. + /// The order in which the rotations are applied. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static quaternion Euler(float x, float y, float z, RotationOrder order = RotationOrder.Default) + { + return Euler(float3(x, y, z), order); + } + + /// Returns a float4x4 matrix that rotates around the x-axis by a given number of radians. + /// The clockwise rotation angle when looking along the x-axis towards the origin in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static quaternion RotateX(float angle) + { + float sina, cosa; + math.sincos(0.5f * angle, out sina, out cosa); + return quaternion(sina, 0.0f, 0.0f, cosa); + } + + /// Returns a float4x4 matrix that rotates around the y-axis by a given number of radians. + /// The clockwise rotation angle when looking along the y-axis towards the origin in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static quaternion RotateY(float angle) + { + float sina, cosa; + math.sincos(0.5f * angle, out sina, out cosa); + return quaternion(0.0f, sina, 0.0f, cosa); + } + + /// Returns a float4x4 matrix that rotates around the z-axis by a given number of radians. + /// The clockwise rotation angle when looking along the z-axis towards the origin in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static quaternion RotateZ(float angle) + { + float sina, cosa; + math.sincos(0.5f * angle, out sina, out cosa); + return quaternion(0.0f, 0.0f, sina, cosa); + } + + /// + /// Returns a quaternion view rotation given a unit length forward vector and a unit length up vector. + /// The two input vectors are assumed to be unit length and not collinear. + /// If these assumptions are not met use float3x3.LookRotationSafe instead. + /// + public static quaternion LookRotation(float3 forward, float3 up) + { + float3 t = normalize(cross(up, forward)); + return quaternion(float3x3(t, cross(forward, t), forward)); + } + + /// + /// Returns a quaternion view rotation given a forward vector and an up vector. + /// The two input vectors are not assumed to be unit length. + /// If the magnitude of either of the vectors is so extreme that the calculation cannot be carried out reliably or the vectors are collinear, + /// the identity will be returned instead. + /// + public static quaternion LookRotationSafe(float3 forward, float3 up) + { + float forwardLengthSq = dot(forward, forward); + float upLengthSq = dot(up, up); + + forward *= rsqrt(forwardLengthSq); + up *= rsqrt(upLengthSq); + + float3 t = cross(up, forward); + float tLengthSq = dot(t, t); + t *= rsqrt(tLengthSq); + + float mn = min(min(forwardLengthSq, upLengthSq), tLengthSq); + float mx = max(max(forwardLengthSq, upLengthSq), tLengthSq); + + bool accept = mn > 1e-35f && mx < 1e35f && isfinite(forwardLengthSq) && isfinite(upLengthSq) && isfinite(tLengthSq); + return quaternion(select(float4(0.0f, 0.0f, 0.0f, 1.0f), quaternion(float3x3(t, cross(forward, t),forward)).value, accept)); + } + + /// Returns true if the quaternion is equal to a given quaternion, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(quaternion x) { return value.x == x.value.x && value.y == x.value.y && value.z == x.value.z && value.w == x.value.w; } + + /// Returns whether true if the quaternion is equal to a given quaternion, false otherwise. + public override bool Equals(object x) { return Equals((quaternion)x); } + + /// Returns a hash code for the quaternion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + /// Returns a string representation of the quaternion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("quaternion({0}f, {1}f, {2}f, {3}f)", value.x, value.y, value.z, value.w); + } + + /// Returns a string representation of the quaternion using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("quaternion({0}f, {1}f, {2}f, {3}f)", value.x.ToString(format, formatProvider), value.y.ToString(format, formatProvider), value.z.ToString(format, formatProvider), value.w.ToString(format, formatProvider)); + } + } + + public static partial class math + { + /// Returns a quaternion constructed from four float values. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static quaternion quaternion(float x, float y, float z, float w) { return new quaternion(x, y, z, w); } + + /// Returns a quaternion constructed from a float4 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static quaternion quaternion(float4 value) { return new quaternion(value); } + + /// Returns a unit quaternion constructed from a float3x3 rotation matrix. The matrix must be orthonormal. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static quaternion quaternion(float3x3 m) { return new quaternion(m); } + + /// Returns a unit quaternion constructed from a float4x4 matrix. The matrix must be orthonormal. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static quaternion quaternion(float4x4 m) { return new quaternion(m); } + + /// Returns the conjugate of a quaternion value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static quaternion conjugate(quaternion q) + { + return quaternion(q.value * float4(-1.0f, -1.0f, -1.0f, 1.0f)); + } + + /// Returns the inverse of a quaternion value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static quaternion inverse(quaternion q) + { + float4 x = q.value; + return quaternion(rcp(dot(x, x)) * x * float4(-1.0f, -1.0f, -1.0f, 1.0f)); + } + + /// Returns the dot product of two quaternions. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float dot(quaternion a, quaternion b) + { + return dot(a.value, b.value); + } + + /// Returns the length of a quaternion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float length(quaternion q) + { + return sqrt(dot(q.value, q.value)); + } + + /// Returns the squared length of a quaternion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float lengthsq(quaternion q) + { + return dot(q.value, q.value); + } + + /// Returns a normalized version of a quaternion q by scaling it by 1 / length(q). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static quaternion normalize(quaternion q) + { + float4 x = q.value; + return quaternion(rsqrt(dot(x, x)) * x); + } + + /// + /// Returns a safe normalized version of the q by scaling it by 1 / length(q). + /// Returns the identity when 1 / length(q) does not produce a finite number. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static quaternion normalizesafe(quaternion q) + { + float4 x = q.value; + float len = math.dot(x, x); + return quaternion(math.select(Mathematics.quaternion.identity.value, x * math.rsqrt(len), len > FLT_MIN_NORMAL)); + } + + /// + /// Returns a safe normalized version of the q by scaling it by 1 / length(q). + /// Returns the given default value when 1 / length(q) does not produce a finite number. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static quaternion normalizesafe(quaternion q, quaternion defaultvalue) + { + float4 x = q.value; + float len = math.dot(x, x); + return quaternion(math.select(defaultvalue.value, x * math.rsqrt(len), len > FLT_MIN_NORMAL)); + } + + /// Returns the natural exponent of a quaternion. Assumes w is zero. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static quaternion unitexp(quaternion q) + { + float v_rcp_len = rsqrt(dot(q.value.xyz, q.value.xyz)); + float v_len = rcp(v_rcp_len); + float sin_v_len, cos_v_len; + sincos(v_len, out sin_v_len, out cos_v_len); + return quaternion(float4(q.value.xyz * v_rcp_len * sin_v_len, cos_v_len)); + } + + /// Returns the natural exponent of a quaternion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static quaternion exp(quaternion q) + { + float v_rcp_len = rsqrt(dot(q.value.xyz, q.value.xyz)); + float v_len = rcp(v_rcp_len); + float sin_v_len, cos_v_len; + sincos(v_len, out sin_v_len, out cos_v_len); + return quaternion(float4(q.value.xyz * v_rcp_len * sin_v_len, cos_v_len) * exp(q.value.w)); + } + + /// Returns the natural logarithm of a unit length quaternion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static quaternion unitlog(quaternion q) + { + float w = clamp(q.value.w, -1.0f, 1.0f); + float s = acos(w) * rsqrt(1.0f - w*w); + return quaternion(float4(q.value.xyz * s, 0.0f)); + } + + /// Returns the natural logarithm of a quaternion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static quaternion log(quaternion q) + { + float v_len_sq = dot(q.value.xyz, q.value.xyz); + float q_len_sq = v_len_sq + q.value.w*q.value.w; + + float s = acos(clamp(q.value.w * rsqrt(q_len_sq), -1.0f, 1.0f)) * rsqrt(v_len_sq); + return quaternion(float4(q.value.xyz * s, 0.5f * log(q_len_sq))); + } + + /// Returns the result of transforming the quaternion b by the quaternion a. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static quaternion mul(quaternion a, quaternion b) + { + return quaternion(a.value.wwww * b.value + (a.value.xyzx * b.value.wwwx + a.value.yzxy * b.value.zxyy) * float4(1.0f, 1.0f, 1.0f, -1.0f) - a.value.zxyz * b.value.yzxz); + } + + /// Returns the result of transforming a vector by a quaternion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 mul(quaternion q, float3 v) + { + float3 t = 2 * cross(q.value.xyz, v); + return v + q.value.w * t + cross(q.value.xyz, t); + } + + /// Returns the result of rotating a vector by a unit quaternion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 rotate(quaternion q, float3 v) + { + float3 t = 2 * cross(q.value.xyz, v); + return v + q.value.w * t + cross(q.value.xyz, t); + } + + /// Returns the result of a normalized linear interpolation between two quaternions q1 and a2 using an interpolation parameter t. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static quaternion nlerp(quaternion q1, quaternion q2, float t) + { + float dt = dot(q1, q2); + if(dt < 0.0f) + { + q2.value = -q2.value; + } + + return normalize(quaternion(lerp(q1.value, q2.value, t))); + } + + /// Returns the result of a spherical interpolation between two quaternions q1 and a2 using an interpolation parameter t. + public static quaternion slerp(quaternion q1, quaternion q2, float t) + { + float dt = dot(q1, q2); + if (dt < 0.0f) + { + dt = -dt; + q2.value = -q2.value; + } + + if (dt < 0.9995f) + { + float angle = acos(dt); + float s = rsqrt(1.0f - dt * dt); // 1.0f / sin(angle) + float w1 = sin(angle * (1.0f - t)) * s; + float w2 = sin(angle * t) * s; + return quaternion(q1.value * w1 + q2.value * w2); + } + else + { + // if the angle is small, use linear interpolation + return nlerp(q1, q2, t); + } + } + + /// Returns a uint hash code of a quaternion. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(quaternion q) + { + return hash(q.value); + } + + /// + /// Returns a uint4 vector hash code of a quaternion. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 hashwide(quaternion q) + { + return hashwide(q.value); + } + + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 forward(quaternion q) { return mul(q, float3(0, 0, 1)); } // for compatibility + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/quaternion.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/quaternion.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..2f32afaf7b924f855e2e4bfa7d93eb61ef58ce4f --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/quaternion.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a8481bb868ae344e9b4a5551a11483d3 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/random.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/random.cs new file mode 100644 index 0000000000000000000000000000000000000000..d565fc16baf78a08a3a5541a1682656449867c49 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/random.cs @@ -0,0 +1,567 @@ +using System; +using System.Runtime.CompilerServices; +using static Unity.Mathematics.math; +using System.Diagnostics; + +namespace Unity.Mathematics +{ + /// + /// Random Number Generator based on xorshift. + /// Designed for minimal state (32bits) to be easily embeddable into components. + /// Core functionality is integer multiplication free to improve vectorization + /// on less capable SIMD instruction sets. + /// + [Serializable] + public partial struct Random + { + public uint state; + + /// + /// Constructs a Random instance with a given seed value. The seed must be non-zero. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public Random(uint seed) + { + state = seed; + CheckInitState(); + NextState(); + } + + /// + /// Initialized the state of the Random instance with a given seed value. The seed must be non-zero. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void InitState(uint seed = 0x6E624EB7u) + { + state = seed; + NextState(); + } + + /// Returns a uniformly random bool value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool NextBool() + { + return (NextState() & 1) == 1; + } + + /// Returns a uniformly random bool2 value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool2 NextBool2() + { + uint v = NextState(); + return (uint2(v) & uint2(1, 2)) == 0; + } + + /// Returns a uniformly random bool3 value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool3 NextBool3() + { + uint v = NextState(); + return (uint3(v) & uint3(1, 2, 4)) == 0; + } + + /// Returns a uniformly random bool4 value. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool4 NextBool4() + { + uint v = NextState(); + return (uint4(v) & uint4(1, 2, 4, 8)) == 0; + } + + + /// Returns a uniformly random int value in the interval [-2147483647, 2147483647]. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int NextInt() + { + return (int)NextState() ^ -2147483648; + } + + /// Returns a uniformly random int2 value with all components in the interval [-2147483647, 2147483647]. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2 NextInt2() + { + return int2((int)NextState(), (int)NextState()) ^ -2147483648; + } + + /// Returns a uniformly random int3 value with all components in the interval [-2147483647, 2147483647]. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3 NextInt3() + { + return int3((int)NextState(), (int)NextState(), (int)NextState()) ^ -2147483648; + } + + /// Returns a uniformly random int4 value with all components in the interval [-2147483647, 2147483647]. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4 NextInt4() + { + return int4((int)NextState(), (int)NextState(), (int)NextState(), (int)NextState()) ^ -2147483648; + } + + /// Returns a uniformly random int value in the interval [0, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int NextInt(int max) + { + CheckNextIntMax(max); + return (int)((NextState() * (ulong)max) >> 32); + } + + /// Returns a uniformly random int2 value with all components in the interval [0, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2 NextInt2(int2 max) + { + CheckNextIntMax(max.x); + CheckNextIntMax(max.y); + return int2((int)(NextState() * (ulong)max.x >> 32), + (int)(NextState() * (ulong)max.y >> 32)); + } + + /// Returns a uniformly random int3 value with all components in the interval [0, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3 NextInt3(int3 max) + { + CheckNextIntMax(max.x); + CheckNextIntMax(max.y); + CheckNextIntMax(max.z); + return int3((int)(NextState() * (ulong)max.x >> 32), + (int)(NextState() * (ulong)max.y >> 32), + (int)(NextState() * (ulong)max.z >> 32)); + } + + /// Returns a uniformly random int4 value with all components in the interval [0, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4 NextInt4(int4 max) + { + CheckNextIntMax(max.x); + CheckNextIntMax(max.y); + CheckNextIntMax(max.z); + CheckNextIntMax(max.w); + return int4((int)(NextState() * (ulong)max.x >> 32), + (int)(NextState() * (ulong)max.y >> 32), + (int)(NextState() * (ulong)max.z >> 32), + (int)(NextState() * (ulong)max.w >> 32)); + } + + /// Returns a uniformly random int value in the interval [min, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int NextInt(int min, int max) + { + CheckNextIntMinMax(min, max); + uint range = (uint)(max - min); + return (int)(NextState() * (ulong)range >> 32) + min; + } + + /// Returns a uniformly random int2 value with all components in the interval [min, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int2 NextInt2(int2 min, int2 max) + { + CheckNextIntMinMax(min.x, max.x); + CheckNextIntMinMax(min.y, max.y); + uint2 range = (uint2)(max - min); + return int2((int)(NextState() * (ulong)range.x >> 32), + (int)(NextState() * (ulong)range.y >> 32)) + min; + } + + /// Returns a uniformly random int3 value with all components in the interval [min, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int3 NextInt3(int3 min, int3 max) + { + CheckNextIntMinMax(min.x, max.x); + CheckNextIntMinMax(min.y, max.y); + CheckNextIntMinMax(min.z, max.z); + uint3 range = (uint3)(max - min); + return int3((int)(NextState() * (ulong)range.x >> 32), + (int)(NextState() * (ulong)range.y >> 32), + (int)(NextState() * (ulong)range.z >> 32)) + min; + } + + /// Returns a uniformly random int4 value with all components in the interval [min, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int4 NextInt4(int4 min, int4 max) + { + CheckNextIntMinMax(min.x, max.x); + CheckNextIntMinMax(min.y, max.y); + CheckNextIntMinMax(min.z, max.z); + CheckNextIntMinMax(min.w, max.w); + uint4 range = (uint4)(max - min); + return int4((int)(NextState() * (ulong)range.x >> 32), + (int)(NextState() * (ulong)range.y >> 32), + (int)(NextState() * (ulong)range.z >> 32), + (int)(NextState() * (ulong)range.w >> 32)) + min; + } + + /// Returns a uniformly random uint value in the interval [0, 4294967294]. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint NextUInt() + { + return NextState() - 1u; + } + + /// Returns a uniformly random uint2 value with all components in the interval [0, 4294967294]. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint2 NextUInt2() + { + return uint2(NextState(), NextState()) - 1u; + } + + /// Returns a uniformly random uint3 value with all components in the interval [0, 4294967294]. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3 NextUInt3() + { + return uint3(NextState(), NextState(), NextState()) - 1u; + } + + /// Returns a uniformly random uint4 value with all components in the interval [0, 4294967294]. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4 NextUInt4() + { + return uint4(NextState(), NextState(), NextState(), NextState()) - 1u; + } + + + /// Returns a uniformly random uint value in the interval [0, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint NextUInt(uint max) + { + return (uint)((NextState() * (ulong)max) >> 32); + } + + /// Returns a uniformly random uint2 value with all components in the interval [0, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint2 NextUInt2(uint2 max) + { + return uint2( (uint)(NextState() * (ulong)max.x >> 32), + (uint)(NextState() * (ulong)max.y >> 32)); + } + + /// Returns a uniformly random uint3 value with all components in the interval [0, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3 NextUInt3(uint3 max) + { + return uint3( (uint)(NextState() * (ulong)max.x >> 32), + (uint)(NextState() * (ulong)max.y >> 32), + (uint)(NextState() * (ulong)max.z >> 32)); + } + + /// Returns a uniformly random uint4 value with all components in the interval [0, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4 NextUInt4(uint4 max) + { + return uint4( (uint)(NextState() * (ulong)max.x >> 32), + (uint)(NextState() * (ulong)max.y >> 32), + (uint)(NextState() * (ulong)max.z >> 32), + (uint)(NextState() * (ulong)max.w >> 32)); + } + + /// Returns a uniformly random uint value in the interval [min, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint NextUInt(uint min, uint max) + { + CheckNextUIntMinMax(min, max); + uint range = max - min; + return (uint)(NextState() * (ulong)range >> 32) + min; + } + + /// Returns a uniformly random uint2 value with all components in the interval [min, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint2 NextUInt2(uint2 min, uint2 max) + { + CheckNextUIntMinMax(min.x, max.x); + CheckNextUIntMinMax(min.y, max.y); + uint2 range = max - min; + return uint2((uint)(NextState() * (ulong)range.x >> 32), + (uint)(NextState() * (ulong)range.y >> 32)) + min; + } + + /// Returns a uniformly random uint3 value with all components in the interval [min, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint3 NextUInt3(uint3 min, uint3 max) + { + CheckNextUIntMinMax(min.x, max.x); + CheckNextUIntMinMax(min.y, max.y); + CheckNextUIntMinMax(min.z, max.z); + uint3 range = max - min; + return uint3((uint)(NextState() * (ulong)range.x >> 32), + (uint)(NextState() * (ulong)range.y >> 32), + (uint)(NextState() * (ulong)range.z >> 32)) + min; + } + + /// Returns a uniformly random uint4 value with all components in the interval [min, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public uint4 NextUInt4(uint4 min, uint4 max) + { + CheckNextUIntMinMax(min.x, max.x); + CheckNextUIntMinMax(min.y, max.y); + CheckNextUIntMinMax(min.z, max.z); + CheckNextUIntMinMax(min.w, max.w); + uint4 range = (uint4)(max - min); + return uint4((uint)(NextState() * (ulong)range.x >> 32), + (uint)(NextState() * (ulong)range.y >> 32), + (uint)(NextState() * (ulong)range.z >> 32), + (uint)(NextState() * (ulong)range.w >> 32)) + min; + } + + /// Returns a uniformly random float value in the interval [0, 1). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float NextFloat() + { + return asfloat(0x3f800000 | (NextState() >> 9)) - 1.0f; + } + + /// Returns a uniformly random float2 value with all components in the interval [0, 1). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2 NextFloat2() + { + return asfloat(0x3f800000 | (uint2(NextState(), NextState()) >> 9)) - 1.0f; + } + + /// Returns a uniformly random float3 value with all components in the interval [0, 1). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3 NextFloat3() + { + return asfloat(0x3f800000 | (uint3(NextState(), NextState(), NextState()) >> 9)) - 1.0f; + } + + /// Returns a uniformly random float4 value with all components in the interval [0, 1). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4 NextFloat4() + { + return asfloat(0x3f800000 | (uint4(NextState(), NextState(), NextState(), NextState()) >> 9)) - 1.0f; + } + + + /// Returns a uniformly random float value in the interval [0, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float NextFloat(float max) { return NextFloat() * max; } + + /// Returns a uniformly random float2 value with all components in the interval [0, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2 NextFloat2(float2 max) { return NextFloat2() * max; } + + /// Returns a uniformly random float3 value with all components in the interval [0, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3 NextFloat3(float3 max) { return NextFloat3() * max; } + + /// Returns a uniformly random float4 value with all components in the interval [0, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4 NextFloat4(float4 max) { return NextFloat4() * max; } + + + /// Returns a uniformly random float value in the interval [min, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float NextFloat(float min, float max) { return NextFloat() * (max - min) + min; } + + /// Returns a uniformly random float2 value with all components in the interval [min, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2 NextFloat2(float2 min, float2 max) { return NextFloat2() * (max - min) + min; } + + /// Returns a uniformly random float3 value with all components in the interval [min, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3 NextFloat3(float3 min, float3 max) { return NextFloat3() * (max - min) + min; } + + /// Returns a uniformly random float4 value with all components in the interval [min, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float4 NextFloat4(float4 min, float4 max) { return NextFloat4() * (max - min) + min; } + + + + /// Returns a uniformly random double value in the interval [0, 1). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public double NextDouble() + { + ulong sx = ((ulong)NextState() << 20) ^ NextState(); + return asdouble(0x3ff0000000000000 | sx) - 1.0; + } + + /// Returns a uniformly random double2 value with all components in the interval [0, 1). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public double2 NextDouble2() + { + ulong sx = ((ulong)NextState() << 20) ^ NextState(); + ulong sy = ((ulong)NextState() << 20) ^ NextState(); + return double2(asdouble(0x3ff0000000000000 | sx), + asdouble(0x3ff0000000000000 | sy)) - 1.0; + } + + /// Returns a uniformly random double3 value with all components in the interval [0, 1). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public double3 NextDouble3() + { + ulong sx = ((ulong)NextState() << 20) ^ NextState(); + ulong sy = ((ulong)NextState() << 20) ^ NextState(); + ulong sz = ((ulong)NextState() << 20) ^ NextState(); + return double3(asdouble(0x3ff0000000000000 | sx), + asdouble(0x3ff0000000000000 | sy), + asdouble(0x3ff0000000000000 | sz)) - 1.0; + } + + /// Returns a uniformly random double4 value with all components in the interval [0, 1). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public double4 NextDouble4() + { + ulong sx = ((ulong)NextState() << 20) ^ NextState(); + ulong sy = ((ulong)NextState() << 20) ^ NextState(); + ulong sz = ((ulong)NextState() << 20) ^ NextState(); + ulong sw = ((ulong)NextState() << 20) ^ NextState(); + return double4(asdouble(0x3ff0000000000000 | sx), + asdouble(0x3ff0000000000000 | sy), + asdouble(0x3ff0000000000000 | sz), + asdouble(0x3ff0000000000000 | sw)) - 1.0; + } + + + /// Returns a uniformly random double value in the interval [0, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public double NextDouble(double max) { return NextDouble() * max; } + + /// Returns a uniformly random double2 value with all components in the interval [0, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public double2 NextDouble2(double2 max) { return NextDouble2() * max; } + + /// Returns a uniformly random double3 value with all components in the interval [0, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public double3 NextDouble3(double3 max) { return NextDouble3() * max; } + + /// Returns a uniformly random double4 value with all components in the interval [0, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public double4 NextDouble4(double4 max) { return NextDouble4() * max; } + + + /// Returns a uniformly random double value in the interval [min, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public double NextDouble(double min, double max) { return NextDouble() * (max - min) + min; } + + /// Returns a uniformly random double2 value with all components in the interval [min, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public double2 NextDouble2(double2 min, double2 max) { return NextDouble2() * (max - min) + min; } + + /// Returns a uniformly random double3 value with all components in the interval [min, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public double3 NextDouble3(double3 min, double3 max) { return NextDouble3() * (max - min) + min; } + + /// Returns a uniformly random double4 value with all components in the interval [min, max). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public double4 NextDouble4(double4 min, double4 max) { return NextDouble4() * (max - min) + min; } + + /// Returns a unit length float2 vector representing a uniformly random 2D direction. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float2 NextFloat2Direction() + { + float angle = NextFloat() * PI * 2.0f; + float s, c; + sincos(angle, out s, out c); + return float2(c, s); + } + + /// Returns a unit length double2 vector representing a uniformly random 2D direction. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public double2 NextDouble2Direction() + { + double angle = NextDouble() * PI_DBL * 2.0; + double s, c; + sincos(angle, out s, out c); + return double2(c, s); + } + + /// Returns a unit length float3 vector representing a uniformly random 3D direction. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public float3 NextFloat3Direction() + { + float2 rnd = NextFloat2(); + float z = rnd.x * 2.0f - 1.0f; + float r = sqrt(max(1.0f - z * z, 0.0f)); + float angle = rnd.y * PI * 2.0f; + float s, c; + sincos(angle, out s, out c); + return float3(c*r, s*r, z); + } + + /// Returns a unit length double3 vector representing a uniformly random 3D direction. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public double3 NextDouble3Direction() + { + double2 rnd = NextDouble2(); + double z = rnd.x * 2.0 - 1.0; + double r = sqrt(max(1.0 - z * z, 0.0)); + double angle = rnd.y * PI_DBL * 2.0; + double s, c; + sincos(angle, out s, out c); + return double3(c * r, s * r, z); + } + + /// Returns a unit length quaternion representing a uniformly 3D rotation. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public quaternion NextQuaternionRotation() + { + float3 rnd = NextFloat3(float3(2.0f * PI, 2.0f * PI, 1.0f)); + float u1 = rnd.z; + float2 theta_rho = rnd.xy; + + float i = sqrt(1.0f - u1); + float j = sqrt(u1); + + float2 sin_theta_rho; + float2 cos_theta_rho; + sincos(theta_rho, out sin_theta_rho, out cos_theta_rho); + + quaternion q = quaternion(i * sin_theta_rho.x, i * cos_theta_rho.x, j * sin_theta_rho.y, j * cos_theta_rho.y); + return quaternion(select(q.value, -q.value, q.value.w < 0.0f)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private uint NextState() + { + CheckState(); + uint t = state; + state ^= state << 13; + state ^= state >> 17; + state ^= state << 5; + return t; + } + + [Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")] + private void CheckInitState() + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if (state == 0) + throw new System.ArgumentException("Seed must be non-zero"); +#endif + } + + [Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")] + private void CheckState() + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if(state == 0) + throw new System.ArgumentException("Invalid state 0. Random object has not been properly initialized"); +#endif + } + + [Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")] + private void CheckNextIntMax(int max) + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if (max < 0) + throw new System.ArgumentException("max must be positive"); +#endif + } + + [Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")] + private void CheckNextIntMinMax(int min, int max) + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if (min > max) + throw new System.ArgumentException("min must be less than or equal to max"); +#endif + } + + [Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")] + private void CheckNextUIntMinMax(uint min, uint max) + { +#if ENABLE_UNITY_COLLECTIONS_CHECKS + if (min > max) + throw new System.ArgumentException("min must be less than or equal to max"); +#endif + } + + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/random.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/random.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..9c9463bc6b530024c52458ea50c73c2ce4b52921 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/random.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 897d0bd3ae806496b8724cb68e7d18c4 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/rigid_transform.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/rigid_transform.cs new file mode 100644 index 0000000000000000000000000000000000000000..4ff9c2d8ad125ac5a05d04d63320786dceaad8ec --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/rigid_transform.cs @@ -0,0 +1,339 @@ +using System; +using System.Runtime.CompilerServices; +using static Unity.Mathematics.math; + +namespace Unity.Mathematics +{ + public struct RigidTransform + { + public quaternion rot; + public float3 pos; + + /// A RigidTransform representing the identity transform. + public static readonly RigidTransform identity = new RigidTransform(new quaternion(0.0f, 0.0f, 0.0f, 1.0f), new float3(0.0f, 0.0f, 0.0f)); + + /// Constructs a RigidTransform from a rotation represented by a unit quaternion and a translation represented by a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public RigidTransform(quaternion rotation, float3 translation) + { + this.rot = rotation; + this.pos = translation; + } + + /// Constructs a RigidTransform from a rotation represented by a float3x3 matrix and a translation represented by a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public RigidTransform(float3x3 rotation, float3 translation) + { + this.rot = new quaternion(rotation); + this.pos = translation; + } + + /// Constructs a RigidTransform from a float4x4. Assumes the matrix is orthonormal. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public RigidTransform(float4x4 transform) + { + this.rot = new quaternion(transform); + this.pos = transform.c3.xyz; + } + + + /// + /// Returns a RigidTransform representing a rotation around a unit axis by an angle in radians. + /// The rotation direction is clockwise when looking along the rotation axis towards the origin. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static RigidTransform AxisAngle(float3 axis, float angle) { return new RigidTransform(quaternion.AxisAngle(axis, angle), float3.zero); } + + /// + /// Returns a RigidTransform constructed by first performing a rotation around the x-axis, then the y-axis and finally the z-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// A float3 vector containing the rotation angles around the x-, y- and z-axis measures in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static RigidTransform EulerXYZ(float3 xyz) { return new RigidTransform(quaternion.EulerXYZ(xyz), float3.zero); } + + /// + /// Returns a RigidTransform constructed by first performing a rotation around the x-axis, then the z-axis and finally the y-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// A float3 vector containing the rotation angles around the x-, y- and z-axis measures in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static RigidTransform EulerXZY(float3 xyz) { return new RigidTransform(quaternion.EulerXZY(xyz), float3.zero); } + + /// + /// Returns a RigidTransform constructed by first performing a rotation around the y-axis, then the x-axis and finally the z-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// A float3 vector containing the rotation angles around the x-, y- and z-axis measures in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static RigidTransform EulerYXZ(float3 xyz) { return new RigidTransform(quaternion.EulerYXZ(xyz), float3.zero); } + + /// + /// Returns a RigidTransform constructed by first performing a rotation around the y-axis, then the z-axis and finally the x-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// A float3 vector containing the rotation angles around the x-, y- and z-axis measures in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static RigidTransform EulerYZX(float3 xyz) { return new RigidTransform(quaternion.EulerYZX(xyz), float3.zero); } + + + /// + /// Returns a RigidTransform constructed by first performing a rotation around the z-axis, then the x-axis and finally the y-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// This is the default order rotation order in Unity. + /// + /// A float3 vector containing the rotation angles around the x-, y- and z-axis measures in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static RigidTransform EulerZXY(float3 xyz) { return new RigidTransform(quaternion.EulerZXY(xyz), float3.zero); } + + /// + /// Returns a RigidTransform constructed by first performing a rotation around the z-axis, then the y-axis and finally the x-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// A float3 vector containing the rotation angles around the x-, y- and z-axis measures in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static RigidTransform EulerZYX(float3 xyz) { return new RigidTransform(quaternion.EulerZYX(xyz), float3.zero); } + + /// + /// Returns a RigidTransform constructed by first performing a rotation around the x-axis, then the y-axis and finally the z-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// The rotation angle around the x-axis in radians. + /// The rotation angle around the y-axis in radians. + /// The rotation angle around the z-axis in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static RigidTransform EulerXYZ(float x, float y, float z) { return EulerXYZ(float3(x, y, z)); } + + /// + /// Returns a RigidTransform constructed by first performing a rotation around the x-axis, then the z-axis and finally the y-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// The rotation angle around the x-axis in radians. + /// The rotation angle around the y-axis in radians. + /// The rotation angle around the z-axis in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static RigidTransform EulerXZY(float x, float y, float z) { return EulerXZY(float3(x, y, z)); } + + /// + /// Returns a RigidTransform constructed by first performing a rotation around the y-axis, then the x-axis and finally the z-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// The rotation angle around the x-axis in radians. + /// The rotation angle around the y-axis in radians. + /// The rotation angle around the z-axis in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static RigidTransform EulerYXZ(float x, float y, float z) { return EulerYXZ(float3(x, y, z)); } + + /// + /// Returns a RigidTransform constructed by first performing a rotation around the y-axis, then the z-axis and finally the x-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// The rotation angle around the x-axis in radians. + /// The rotation angle around the y-axis in radians. + /// The rotation angle around the z-axis in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static RigidTransform EulerYZX(float x, float y, float z) { return EulerYZX(float3(x, y, z)); } + + /// + /// Returns a RigidTransform constructed by first performing a rotation around the z-axis, then the x-axis and finally the y-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// This is the default order rotation order in Unity. + /// + /// The rotation angle around the x-axis in radians. + /// The rotation angle around the y-axis in radians. + /// The rotation angle around the z-axis in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static RigidTransform EulerZXY(float x, float y, float z) { return EulerZXY(float3(x, y, z)); } + + /// + /// Returns a RigidTransform constructed by first performing a rotation around the z-axis, then the y-axis and finally the x-axis. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// + /// The rotation angle around the x-axis in radians. + /// The rotation angle around the y-axis in radians. + /// The rotation angle around the z-axis in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static RigidTransform EulerZYX(float x, float y, float z) { return EulerZYX(float3(x, y, z)); } + + /// + /// Returns a RigidTransform constructed by first performing 3 rotations around the principal axes in a given order. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// When the rotation order is known at compile time, it is recommended for performance reasons to use specific + /// Euler rotation constructors such as EulerZXY(...). + /// + /// A float3 vector containing the rotation angles around the x-, y- and z-axis measures in radians. + /// The order in which the rotations are applied. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static RigidTransform Euler(float3 xyz, RotationOrder order = RotationOrder.ZXY) + { + switch (order) + { + case RotationOrder.XYZ: + return EulerXYZ(xyz); + case RotationOrder.XZY: + return EulerXZY(xyz); + case RotationOrder.YXZ: + return EulerYXZ(xyz); + case RotationOrder.YZX: + return EulerYZX(xyz); + case RotationOrder.ZXY: + return EulerZXY(xyz); + case RotationOrder.ZYX: + return EulerZYX(xyz); + default: + return RigidTransform.identity; + } + } + + /// + /// Returns a RigidTransform constructed by first performing 3 rotations around the principal axes in a given order. + /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin. + /// When the rotation order is known at compile time, it is recommended for performance reasons to use specific + /// Euler rotation constructors such as EulerZXY(...). + /// + /// The rotation angle around the x-axis in radians. + /// The rotation angle around the y-axis in radians. + /// The rotation angle around the z-axis in radians. + /// The order in which the rotations are applied. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static RigidTransform Euler(float x, float y, float z, RotationOrder order = RotationOrder.Default) + { + return Euler(float3(x, y, z), order); + } + + /// Returns a float4x4 matrix that rotates around the x-axis by a given number of radians. + /// The clockwise rotation angle when looking along the x-axis towards the origin in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static RigidTransform RotateX(float angle) + { + return new RigidTransform(quaternion.RotateX(angle), float3.zero); + } + + /// Returns a float4x4 matrix that rotates around the y-axis by a given number of radians. + /// The clockwise rotation angle when looking along the y-axis towards the origin in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static RigidTransform RotateY(float angle) + { + return new RigidTransform(quaternion.RotateY(angle), float3.zero); + } + + /// Returns a float4x4 matrix that rotates around the z-axis by a given number of radians. + /// The clockwise rotation angle when looking along the z-axis towards the origin in radians. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static RigidTransform RotateZ(float angle) + { + return new RigidTransform(quaternion.RotateZ(angle), float3.zero); + } + + /// Returns a RigidTransform that translates by an amount specified by a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static RigidTransform Translate(float3 vector) + { + return new RigidTransform(quaternion.identity, vector); + } + + + /// Returns true if the RigidTransform is equal to a given RigidTransform, false otherwise. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool Equals(RigidTransform x) { return rot.Equals(x.rot) && pos.Equals(x.pos); } + + /// Returns true if the RigidTransform is equal to a given RigidTransform, false otherwise. + public override bool Equals(object x) { return Equals((RigidTransform)x); } + + /// Returns a hash code for the RigidTransform. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override int GetHashCode() { return (int)math.hash(this); } + + /// Returns a string representation of the RigidTransform. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public override string ToString() + { + return string.Format("RigidTransform(({0}f, {1}f, {2}f, {3}f), ({4}f, {5}f, {6}f))", + rot.value.x, rot.value.y, rot.value.z, rot.value.w, pos.x, pos.y, pos.z); + } + + /// Returns a string representation of the quaternion using a specified format and culture-specific format information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public string ToString(string format, IFormatProvider formatProvider) + { + return string.Format("float4x4(({0}f, {1}f, {2}f, {3}f), ({4}f, {5}f, {6}f))", + rot.value.x.ToString(format, formatProvider), + rot.value.y.ToString(format, formatProvider), + rot.value.z.ToString(format, formatProvider), + rot.value.w.ToString(format, formatProvider), + pos.x.ToString(format, formatProvider), + pos.y.ToString(format, formatProvider), + pos.z.ToString(format, formatProvider)); + } + } + + public static partial class math + { + /// Returns a RigidTransform constructed from a rotation represented by a unit quaternion and a translation represented by a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static RigidTransform RigidTransform(quaternion rot, float3 pos) { return new RigidTransform(rot, pos); } + + /// Returns a RigidTransform constructed from a rotation represented by a unit quaternion and a translation represented by a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static RigidTransform RigidTransform(float3x3 rotation, float3 translation) { return new RigidTransform(rotation, translation); } + + /// Returns a RigidTransform constructed from a rotation represented by a float3x3 matrix and a translation represented by a float3 vector. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static RigidTransform RigidTransform(float4x4 transform) { return new RigidTransform(transform); } + + /// Returns the inverse of a RigidTransform. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static RigidTransform inverse(RigidTransform t) + { + quaternion invRotation = inverse(t.rot); + float3 invTranslation = mul(invRotation, -t.pos); + return new RigidTransform(invRotation, invTranslation); + } + + /// Returns the result of transforming the RigidTransform b by the RigidTransform a. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static RigidTransform mul(RigidTransform a, RigidTransform b) + { + return new RigidTransform(mul(a.rot, b.rot), mul(a.rot, b.pos) + a.pos); + } + + /// Returns the result of transforming a float4 homogeneous coordinate by a RigidTransform. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float4 mul(RigidTransform a, float4 pos) + { + return float4(mul(a.rot, pos.xyz) + a.pos * pos.w, pos.w); + } + + /// Returns the result of rotating a float3 vector by a RigidTransform. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 rotate(RigidTransform a, float3 dir) + { + return mul(a.rot, dir); + } + + /// Returns the result of transforming a float3 point by a RigidTransform. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static float3 transform(RigidTransform a, float3 pos) + { + return mul(a.rot, pos) + a.pos; + } + + /// Returns a uint hash code of a RigidTransform. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint hash(RigidTransform t) + { + return hash(t.rot) + 0xC5C5394Bu * hash(t.pos); + } + + /// + /// Returns a uint4 vector hash code of a RigidTransform. + /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash + /// that are only reduced to a narrow uint hash at the very end instead of at every step. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint4 hashwide(RigidTransform t) + { + return hashwide(t.rot) + 0xC5C5394Bu * hashwide(t.pos).xyzz; + } + } +} \ No newline at end of file