diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md new file mode 100644 index 00000000..ff664441 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.md @@ -0,0 +1,27 @@ +--- +name: Bug report +about: Report a bug that should be fixed +title: '' +labels: '' +assignees: '' + +--- + +**Describe the bug** +A clear and concise description of what the bug is. + +**To Reproduce** +Steps to reproduce the behavior: +1. Go to '...' +2. Click on '....' +3. Scroll down to '....' +4. See error + +**Expected behavior** +A clear and concise description of what you expected to happen. + +**Screenshots** +If applicable, add screenshots to help explain your problem. + +**Additional context** +Add any other context about the problem here. \ No newline at end of file diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md new file mode 100644 index 00000000..23094e9d --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature_request.md @@ -0,0 +1,20 @@ +--- +name: Feature request +about: Suggest a feature for the project +title: '' +labels: '' +assignees: '' + +--- + +**Is your feature request related to a problem? Please describe.** +A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] + +**Describe the solution you'd like** +A clear and concise description of what you want to happen. + +**Describe alternatives you've considered** +A clear and concise description of any alternative solutions or features you've considered. + +**Additional context** +Add any other context or screenshots about the feature request here. \ No newline at end of file diff --git a/Assets/Models/HouseModular.gltf b/Assets/Models/HouseModular.gltf new file mode 100644 index 00000000..3e9e9a05 --- /dev/null +++ b/Assets/Models/HouseModular.gltf @@ -0,0 +1,1358 @@ +{ + "asset" : { + "generator" : "Khronos glTF Blender I/O v3.3.32", + "version" : "2.0" + }, + "scene" : 0, + "scenes" : [ + { + "name" : "Scene", + "nodes" : [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ] + } + ], + "nodes" : [ + { + "mesh" : 0, + "name" : "FloorLarge" + }, + { + "mesh" : 1, + "name" : "FloorSmall" + }, + { + "mesh" : 2, + "name" : "FloorLong" + }, + { + "mesh" : 3, + "name" : "Pillar" + }, + { + "mesh" : 4, + "name" : "WallEnd" + }, + { + "mesh" : 5, + "name" : "WallCorner" + }, + { + "mesh" : 6, + "name" : "WallDefault" + }, + { + "mesh" : 7, + "name" : "WallLarge" + }, + { + "mesh" : 8, + "name" : "WallDiagonal" + }, + { + "mesh" : 9, + "name" : "WallTBlock" + }, + { + "mesh" : 10, + "name" : "WindowLarge" + }, + { + "mesh" : 11, + "name" : "WindowSmallOpened" + }, + { + "mesh" : 12, + "name" : "WindowSmallClosed" + }, + { + "mesh" : 13, + "name" : "WindowLargeOpen" + }, + { + "mesh" : 14, + "name" : "WallDoorHole" + }, + { + "mesh" : 15, + "name" : "Door", + "translation" : [ + -0.4000000059604645, + 0, + 0.09999999403953552 + ] + }, + { + "mesh" : 16, + "name" : "DoorFrame" + } + ], + "materials" : [ + { + "doubleSided" : true, + "name" : "Material", + "pbrMetallicRoughness" : { + "baseColorFactor" : [ + 0.800000011920929, + 0.800000011920929, + 0.800000011920929, + 1 + ], + "metallicFactor" : 0, + "roughnessFactor" : 0.4000000059604645 + } + } + ], + "meshes" : [ + { + "name" : "Cube.013", + "primitives" : [ + { + "attributes" : { + "POSITION" : 0, + "NORMAL" : 1, + "TEXCOORD_0" : 2 + }, + "indices" : 3, + "material" : 0 + } + ] + }, + { + "name" : "Cube.015", + "primitives" : [ + { + "attributes" : { + "POSITION" : 4, + "NORMAL" : 5, + "TEXCOORD_0" : 6 + }, + "indices" : 7, + "material" : 0 + } + ] + }, + { + "name" : "Cube.014", + "primitives" : [ + { + "attributes" : { + "POSITION" : 8, + "NORMAL" : 9, + "TEXCOORD_0" : 10 + }, + "indices" : 11, + "material" : 0 + } + ] + }, + { + "name" : "Cube.043", + "primitives" : [ + { + "attributes" : { + "POSITION" : 12, + "NORMAL" : 13, + "TEXCOORD_0" : 14 + }, + "indices" : 15, + "material" : 0 + } + ] + }, + { + "name" : "Cube.001", + "primitives" : [ + { + "attributes" : { + "POSITION" : 16, + "NORMAL" : 17, + "TEXCOORD_0" : 18 + }, + "indices" : 19, + "material" : 0 + } + ] + }, + { + "name" : "Cube.009", + "primitives" : [ + { + "attributes" : { + "POSITION" : 20, + "NORMAL" : 21, + "TEXCOORD_0" : 22 + }, + "indices" : 23, + "material" : 0 + } + ] + }, + { + "name" : "Cube.002", + "primitives" : [ + { + "attributes" : { + "POSITION" : 24, + "NORMAL" : 25, + "TEXCOORD_0" : 26 + }, + "indices" : 27, + "material" : 0 + } + ] + }, + { + "name" : "Cube.003", + "primitives" : [ + { + "attributes" : { + "POSITION" : 28, + "NORMAL" : 29, + "TEXCOORD_0" : 30 + }, + "indices" : 31, + "material" : 0 + } + ] + }, + { + "name" : "Cube.008", + "primitives" : [ + { + "attributes" : { + "POSITION" : 32, + "NORMAL" : 33, + "TEXCOORD_0" : 34 + }, + "indices" : 35, + "material" : 0 + } + ] + }, + { + "name" : "Cube.011", + "primitives" : [ + { + "attributes" : { + "POSITION" : 36, + "NORMAL" : 37, + "TEXCOORD_0" : 38 + }, + "indices" : 39, + "material" : 0 + } + ] + }, + { + "name" : "Cube.034", + "primitives" : [ + { + "attributes" : { + "POSITION" : 40, + "NORMAL" : 41, + "TEXCOORD_0" : 42 + }, + "indices" : 43, + "material" : 0 + } + ] + }, + { + "name" : "Cube.007", + "primitives" : [ + { + "attributes" : { + "POSITION" : 44, + "NORMAL" : 45, + "TEXCOORD_0" : 46 + }, + "indices" : 47, + "material" : 0 + } + ] + }, + { + "name" : "Cube.016", + "primitives" : [ + { + "attributes" : { + "POSITION" : 48, + "NORMAL" : 49, + "TEXCOORD_0" : 50 + }, + "indices" : 51, + "material" : 0 + } + ] + }, + { + "name" : "Cube.025", + "primitives" : [ + { + "attributes" : { + "POSITION" : 52, + "NORMAL" : 53, + "TEXCOORD_0" : 54 + }, + "indices" : 55, + "material" : 0 + } + ] + }, + { + "name" : "Cube.006", + "primitives" : [ + { + "attributes" : { + "POSITION" : 56, + "NORMAL" : 57, + "TEXCOORD_0" : 58 + }, + "indices" : 59, + "material" : 0 + } + ] + }, + { + "name" : "Cube.005", + "primitives" : [ + { + "attributes" : { + "POSITION" : 60, + "NORMAL" : 61, + "TEXCOORD_0" : 62 + }, + "indices" : 63, + "material" : 0 + } + ] + }, + { + "name" : "Cube", + "primitives" : [ + { + "attributes" : { + "POSITION" : 64, + "NORMAL" : 65, + "TEXCOORD_0" : 66 + }, + "indices" : 67, + "material" : 0 + } + ] + } + ], + "accessors" : [ + { + "bufferView" : 0, + "componentType" : 5126, + "count" : 56, + "max" : [ + 1, + 0.009999998845160007, + 1 + ], + "min" : [ + -1, + -0.03999999910593033, + -1 + ], + "type" : "VEC3" + }, + { + "bufferView" : 1, + "componentType" : 5126, + "count" : 56, + "type" : "VEC3" + }, + { + "bufferView" : 2, + "componentType" : 5126, + "count" : 56, + "type" : "VEC2" + }, + { + "bufferView" : 3, + "componentType" : 5123, + "count" : 96, + "type" : "SCALAR" + }, + { + "bufferView" : 4, + "componentType" : 5126, + "count" : 24, + "max" : [ + 0.5, + 0.009999998845160007, + 0.5 + ], + "min" : [ + -0.5, + -0.03999999910593033, + -0.5 + ], + "type" : "VEC3" + }, + { + "bufferView" : 5, + "componentType" : 5126, + "count" : 24, + "type" : "VEC3" + }, + { + "bufferView" : 6, + "componentType" : 5126, + "count" : 24, + "type" : "VEC2" + }, + { + "bufferView" : 7, + "componentType" : 5123, + "count" : 36, + "type" : "SCALAR" + }, + { + "bufferView" : 8, + "componentType" : 5126, + "count" : 36, + "max" : [ + 1, + 0.009999998845160007, + 0.5 + ], + "min" : [ + -1, + -0.03999999910593033, + -0.5 + ], + "type" : "VEC3" + }, + { + "bufferView" : 9, + "componentType" : 5126, + "count" : 36, + "type" : "VEC3" + }, + { + "bufferView" : 10, + "componentType" : 5126, + "count" : 36, + "type" : "VEC2" + }, + { + "bufferView" : 11, + "componentType" : 5123, + "count" : 60, + "type" : "SCALAR" + }, + { + "bufferView" : 12, + "componentType" : 5126, + "count" : 66, + "max" : [ + 0.1199999749660492, + 2.200000047683716, + 0.125 + ], + "min" : [ + -0.1200004369020462, + 0, + -0.11499999463558197 + ], + "type" : "VEC3" + }, + { + "bufferView" : 13, + "componentType" : 5126, + "count" : 66, + "type" : "VEC3" + }, + { + "bufferView" : 14, + "componentType" : 5126, + "count" : 66, + "type" : "VEC2" + }, + { + "bufferView" : 15, + "componentType" : 5123, + "count" : 108, + "type" : "SCALAR" + }, + { + "bufferView" : 16, + "componentType" : 5126, + "count" : 68, + "max" : [ + 0.5199999809265137, + 2.200000047683716, + 0.11999999731779099 + ], + "min" : [ + -0.5, + 0, + -0.11999999731779099 + ], + "type" : "VEC3" + }, + { + "bufferView" : 17, + "componentType" : 5126, + "count" : 68, + "type" : "VEC3" + }, + { + "bufferView" : 18, + "componentType" : 5126, + "count" : 68, + "type" : "VEC2" + }, + { + "bufferView" : 19, + "componentType" : 5123, + "count" : 108, + "type" : "SCALAR" + }, + { + "bufferView" : 20, + "componentType" : 5126, + "count" : 134, + "max" : [ + 1, + 2.200000047683716, + 0.11999999731779099 + ], + "min" : [ + -0.12000006437301636, + 0, + -1 + ], + "type" : "VEC3" + }, + { + "bufferView" : 21, + "componentType" : 5126, + "count" : 134, + "type" : "VEC3" + }, + { + "bufferView" : 22, + "componentType" : 5126, + "count" : 134, + "type" : "VEC2" + }, + { + "bufferView" : 23, + "componentType" : 5123, + "count" : 240, + "type" : "SCALAR" + }, + { + "bufferView" : 24, + "componentType" : 5126, + "count" : 90, + "max" : [ + 0.5000000596046448, + 2.200000047683716, + 0.11999999731779099 + ], + "min" : [ + -0.4999999403953552, + 0, + -0.11999999731779099 + ], + "type" : "VEC3" + }, + { + "bufferView" : 25, + "componentType" : 5126, + "count" : 90, + "type" : "VEC3" + }, + { + "bufferView" : 26, + "componentType" : 5126, + "count" : 90, + "type" : "VEC2" + }, + { + "bufferView" : 27, + "componentType" : 5123, + "count" : 168, + "type" : "SCALAR" + }, + { + "bufferView" : 28, + "componentType" : 5126, + "count" : 128, + "max" : [ + 1, + 2.200000047683716, + 0.11999999731779099 + ], + "min" : [ + -0.9999999403953552, + 0, + -0.11999999731779099 + ], + "type" : "VEC3" + }, + { + "bufferView" : 29, + "componentType" : 5126, + "count" : 128, + "type" : "VEC3" + }, + { + "bufferView" : 30, + "componentType" : 5126, + "count" : 128, + "type" : "VEC2" + }, + { + "bufferView" : 31, + "componentType" : 5123, + "count" : 240, + "type" : "SCALAR" + }, + { + "bufferView" : 32, + "componentType" : 5126, + "count" : 96, + "max" : [ + 0.6200000047683716, + 2.200000047683716, + 0.619999885559082 + ], + "min" : [ + -0.5, + 0, + -0.5 + ], + "type" : "VEC3" + }, + { + "bufferView" : 33, + "componentType" : 5126, + "count" : 96, + "type" : "VEC3" + }, + { + "bufferView" : 34, + "componentType" : 5126, + "count" : 96, + "type" : "VEC2" + }, + { + "bufferView" : 35, + "componentType" : 5123, + "count" : 168, + "type" : "SCALAR" + }, + { + "bufferView" : 36, + "componentType" : 5126, + "count" : 200, + "max" : [ + 1, + 2.200000047683716, + 0.11999999731779099 + ], + "min" : [ + -1, + 0, + -1 + ], + "type" : "VEC3" + }, + { + "bufferView" : 37, + "componentType" : 5126, + "count" : 200, + "type" : "VEC3" + }, + { + "bufferView" : 38, + "componentType" : 5126, + "count" : 200, + "type" : "VEC2" + }, + { + "bufferView" : 39, + "componentType" : 5123, + "count" : 360, + "type" : "SCALAR" + }, + { + "bufferView" : 40, + "componentType" : 5126, + "count" : 973, + "max" : [ + 1.0000001192092896, + 2.200000286102295, + 0.11999999731779099 + ], + "min" : [ + -1, + 0, + -0.125 + ], + "type" : "VEC3" + }, + { + "bufferView" : 41, + "componentType" : 5126, + "count" : 973, + "type" : "VEC3" + }, + { + "bufferView" : 42, + "componentType" : 5126, + "count" : 973, + "type" : "VEC2" + }, + { + "bufferView" : 43, + "componentType" : 5123, + "count" : 1632, + "type" : "SCALAR" + }, + { + "bufferView" : 44, + "componentType" : 5126, + "count" : 613, + "max" : [ + 0.5000000596046448, + 2.200000286102295, + 0.33178770542144775 + ], + "min" : [ + -0.4999999403953552, + 0, + -0.125 + ], + "type" : "VEC3" + }, + { + "bufferView" : 45, + "componentType" : 5126, + "count" : 613, + "type" : "VEC3" + }, + { + "bufferView" : 46, + "componentType" : 5126, + "count" : 613, + "type" : "VEC2" + }, + { + "bufferView" : 47, + "componentType" : 5123, + "count" : 1068, + "type" : "SCALAR" + }, + { + "bufferView" : 48, + "componentType" : 5126, + "count" : 538, + "max" : [ + 0.5000000596046448, + 2.200000286102295, + 0.11999999731779099 + ], + "min" : [ + -0.4999999701976776, + 0, + -0.125 + ], + "type" : "VEC3" + }, + { + "bufferView" : 49, + "componentType" : 5126, + "count" : 538, + "type" : "VEC3" + }, + { + "bufferView" : 50, + "componentType" : 5126, + "count" : 538, + "type" : "VEC2" + }, + { + "bufferView" : 51, + "componentType" : 5123, + "count" : 924, + "type" : "SCALAR" + }, + { + "bufferView" : 52, + "componentType" : 5126, + "count" : 1067, + "max" : [ + 1.0000001192092896, + 2.200000286102295, + 0.47529903054237366 + ], + "min" : [ + -1, + 0, + -0.125 + ], + "type" : "VEC3" + }, + { + "bufferView" : 53, + "componentType" : 5126, + "count" : 1067, + "type" : "VEC3" + }, + { + "bufferView" : 54, + "componentType" : 5126, + "count" : 1067, + "type" : "VEC2" + }, + { + "bufferView" : 55, + "componentType" : 5123, + "count" : 1776, + "type" : "SCALAR" + }, + { + "bufferView" : 56, + "componentType" : 5126, + "count" : 202, + "max" : [ + 0.5, + 2.200000286102295, + 0.11999999731779099 + ], + "min" : [ + -0.5, + 0, + -0.11999999731779099 + ], + "type" : "VEC3" + }, + { + "bufferView" : 57, + "componentType" : 5126, + "count" : 202, + "type" : "VEC3" + }, + { + "bufferView" : 58, + "componentType" : 5126, + "count" : 202, + "type" : "VEC2" + }, + { + "bufferView" : 59, + "componentType" : 5123, + "count" : 384, + "type" : "SCALAR" + }, + { + "bufferView" : 60, + "componentType" : 5126, + "count" : 842, + "max" : [ + 0.7999999523162842, + 2.000326156616211, + 0.05949999764561653 + ], + "min" : [ + -0.018654286861419678, + 0.0003262758255004883, + -0.09449999779462814 + ], + "type" : "VEC3" + }, + { + "bufferView" : 61, + "componentType" : 5126, + "count" : 842, + "type" : "VEC3" + }, + { + "bufferView" : 62, + "componentType" : 5126, + "count" : 842, + "type" : "VEC2" + }, + { + "bufferView" : 63, + "componentType" : 5123, + "count" : 3324, + "type" : "SCALAR" + }, + { + "bufferView" : 64, + "componentType" : 5126, + "count" : 298, + "max" : [ + 0.4599999785423279, + 2.0799999237060547, + 0.11121083796024323 + ], + "min" : [ + -0.4599999785423279, + 0, + -0.1087893396615982 + ], + "type" : "VEC3" + }, + { + "bufferView" : 65, + "componentType" : 5126, + "count" : 298, + "type" : "VEC3" + }, + { + "bufferView" : 66, + "componentType" : 5126, + "count" : 298, + "type" : "VEC2" + }, + { + "bufferView" : 67, + "componentType" : 5123, + "count" : 486, + "type" : "SCALAR" + } + ], + "bufferViews" : [ + { + "buffer" : 0, + "byteLength" : 672, + "byteOffset" : 0, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 672, + "byteOffset" : 672, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 448, + "byteOffset" : 1344, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 192, + "byteOffset" : 1792, + "target" : 34963 + }, + { + "buffer" : 0, + "byteLength" : 288, + "byteOffset" : 1984, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 288, + "byteOffset" : 2272, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 192, + "byteOffset" : 2560, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 72, + "byteOffset" : 2752, + "target" : 34963 + }, + { + "buffer" : 0, + "byteLength" : 432, + "byteOffset" : 2824, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 432, + "byteOffset" : 3256, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 288, + "byteOffset" : 3688, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 120, + "byteOffset" : 3976, + "target" : 34963 + }, + { + "buffer" : 0, + "byteLength" : 792, + "byteOffset" : 4096, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 792, + "byteOffset" : 4888, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 528, + "byteOffset" : 5680, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 216, + "byteOffset" : 6208, + "target" : 34963 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 6424, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 816, + "byteOffset" : 7240, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 544, + "byteOffset" : 8056, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 216, + "byteOffset" : 8600, + "target" : 34963 + }, + { + "buffer" : 0, + "byteLength" : 1608, + "byteOffset" : 8816, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 1608, + "byteOffset" : 10424, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 1072, + "byteOffset" : 12032, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 480, + "byteOffset" : 13104, + "target" : 34963 + }, + { + "buffer" : 0, + "byteLength" : 1080, + "byteOffset" : 13584, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 1080, + "byteOffset" : 14664, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 720, + "byteOffset" : 15744, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 336, + "byteOffset" : 16464, + "target" : 34963 + }, + { + "buffer" : 0, + "byteLength" : 1536, + "byteOffset" : 16800, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 1536, + "byteOffset" : 18336, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 1024, + "byteOffset" : 19872, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 480, + "byteOffset" : 20896, + "target" : 34963 + }, + { + "buffer" : 0, + "byteLength" : 1152, + "byteOffset" : 21376, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 1152, + "byteOffset" : 22528, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 768, + "byteOffset" : 23680, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 336, + "byteOffset" : 24448, + "target" : 34963 + }, + { + "buffer" : 0, + "byteLength" : 2400, + "byteOffset" : 24784, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 2400, + "byteOffset" : 27184, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 1600, + "byteOffset" : 29584, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 720, + "byteOffset" : 31184, + "target" : 34963 + }, + { + "buffer" : 0, + "byteLength" : 11676, + "byteOffset" : 31904, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 11676, + "byteOffset" : 43580, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 7784, + "byteOffset" : 55256, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 3264, + "byteOffset" : 63040, + "target" : 34963 + }, + { + "buffer" : 0, + "byteLength" : 7356, + "byteOffset" : 66304, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 7356, + "byteOffset" : 73660, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 4904, + "byteOffset" : 81016, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 2136, + "byteOffset" : 85920, + "target" : 34963 + }, + { + "buffer" : 0, + "byteLength" : 6456, + "byteOffset" : 88056, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 6456, + "byteOffset" : 94512, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 4304, + "byteOffset" : 100968, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 1848, + "byteOffset" : 105272, + "target" : 34963 + }, + { + "buffer" : 0, + "byteLength" : 12804, + "byteOffset" : 107120, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 12804, + "byteOffset" : 119924, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 8536, + "byteOffset" : 132728, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 3552, + "byteOffset" : 141264, + "target" : 34963 + }, + { + "buffer" : 0, + "byteLength" : 2424, + "byteOffset" : 144816, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 2424, + "byteOffset" : 147240, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 1616, + "byteOffset" : 149664, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 768, + "byteOffset" : 151280, + "target" : 34963 + }, + { + "buffer" : 0, + "byteLength" : 10104, + "byteOffset" : 152048, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 10104, + "byteOffset" : 162152, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 6736, + "byteOffset" : 172256, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 6648, + "byteOffset" : 178992, + "target" : 34963 + }, + { + "buffer" : 0, + "byteLength" : 3576, + "byteOffset" : 185640, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 3576, + "byteOffset" : 189216, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 2384, + "byteOffset" : 192792, + "target" : 34962 + }, + { + "buffer" : 0, + "byteLength" : 972, + "byteOffset" : 195176, + "target" : 34963 + } + ], + "buffers" : [ + { + "byteLength" : 196148, + "uri" : "data:application/octet-stream;base64,AACAvwnXIzwAAIA/AACAvwnXIzwAAIA/AACAvwnXIzwAAIA/AACAvwrXI70AAIA/AACAvwrXI70AAIA/AACAvwrXI70AAIA/AACAvwnXIzwAAIC/AACAvwnXIzwAAIC/AACAvwnXIzwAAIC/AACAvwrXI70AAIC/AACAvwrXI70AAIC/AACAvwrXI70AAIC/AACAPwnXIzwAAIA/AACAPwnXIzwAAIA/AACAPwnXIzwAAIA/AACAPwrXI70AAIA/AACAPwrXI70AAIA/AACAPwrXI70AAIA/AACAPwnXIzwAAIC/AACAPwnXIzwAAIC/AACAPwnXIzwAAIC/AACAPwrXI70AAIC/AACAPwrXI70AAIC/AACAPwrXI70AAIC/AAAAAAnXIzwAAIC/AAAAAAnXIzwAAIC/AAAAAAnXIzwAAIC/AAAAAArXI70AAIC/AAAAAArXI70AAIC/AAAAAArXI70AAIC/AAAAAAnXIzwAAIA/AAAAAAnXIzwAAIA/AAAAAAnXIzwAAIA/AAAAAArXI70AAIA/AAAAAArXI70AAIA/AAAAAArXI70AAIA/AACAvwnXIzwAAACAAACAvwnXIzwAAACAAACAvwnXIzwAAACAAACAvwrXI70AAACAAACAvwrXI70AAACAAACAvwrXI70AAACAAACAPwnXIzwAAACAAACAPwnXIzwAAACAAACAPwnXIzwAAACAAACAPwrXI70AAACAAACAPwrXI70AAACAAACAPwrXI70AAACAAAAAAArXI70AAACAAAAAAArXI70AAACAAAAAAArXI70AAACAAAAAAArXI70AAACAAAAAAAnXIzwAAACAAAAAAAnXIzwAAACAAAAAAAnXIzwAAACAAAAAAAnXIzwAAACAAACAvwAAAAAAAACAAAAAAAAAAAAAAIA/AAAAAAAAgD8AAACAAACAvwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIA/AACAvwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAAAAAgD8AAACAAACAvwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AAAAAAAAAAAAAIA/AAAAAAAAgD8AAACAAACAPwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIA/AACAPwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAAAAAgD8AAACAAACAPwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AACAPwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAAAAAgD8AAACAAAAAAAAAgD8AAACAAAAAAAAAgL8AAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AAAAAAAAAAAAAIA/AAAAAAAAgD8AAACAAAAAAAAAgD8AAACAAAAAAAAAgL8AAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIA/AACAvwAAAAAAAACAAAAAAAAAgD8AAACAAAAAAAAAgD8AAACAAACAvwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAAAAgL8AAACAAAAAAAAAgD8AAACAAAAAAAAAgD8AAACAAACAPwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAAAAgL8AAACAAACAPwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAAAAgL8AAACAAAAAAAAAgL8AAACAAAAAAAAAgL8AAACAAAAAAAAAgD8AAACAAAAAAAAAgD8AAACAAAAAAAAAgD8AAACAAAAAAAAAgD8AAACAAMB/PwDAfz8AwH8/AMB/P5pC/T68Gf0+AMB/PwDAfz8U/Xc/vBn9PgDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/P5pC/T4AzTc8AMB/PwDAfz8U/Xc/AM03PADAfz8AwH8/AMB/PwDAfz8U/Xc/vBn9PgDAfz8AwH8/mkL9PrwZ/T4AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8U/Xc/AM03PADAfz8AwH8/mkL9PgDNNzwAwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz+aQv0+AM03PBT9dz8AzTc8mkL9PgDNNzwU/Xc/AM03PADAfz8AwH8/AMB/PwDAfz+aQv0+vBn9PhT9dz+8Gf0+mkL9PrwZ/T4U/Xc/vBn9PgDAfz8AwH8/AMB/PwDAfz+aQv0+AM03PJpC/T68Gf0+AMB/PwDAfz8U/Xc/AM03PBT9dz+8Gf0+FP13PwDNNzwU/Xc/vBn9PgDAfz8AwH8/mkL9PgDNNzyaQv0+vBn9PgDAfz8AwH8/mkL9PgDNNzyaQv0+vBn9PhT9dz8AzTc8FP13P7wZ/T6aQv0+AM03PJpC/T68Gf0+FP13PwDNNzwU/Xc/vBn9PiQABgAJACQACQAnABgAEgAWABgAFgAdACwADgARACwAEQAvAB4AAQAFAB4ABQAjADQAHwANADQADQAqADAAIQAEADAABAAoAC0ADwAiAC0AIgAyACUAAgAgACUAIAA2AAwAHgAjAAwAIwAQAAcAGAAdAAcAHQALAAgAJgA3AAgANwAaABUALgAzABUAMwAcABsAMQApABsAKQAKABkANQArABkAKwATABQALAAvABQALwAXAAAAJAAnAAAAJwADAAAAAL8J1yM8AAAAPwAAAL8J1yM8AAAAPwAAAL8J1yM8AAAAPwAAAL8K1yO9AAAAPwAAAL8K1yO9AAAAPwAAAL8K1yO9AAAAPwAAAL8J1yM8AAAAvwAAAL8J1yM8AAAAvwAAAL8J1yM8AAAAvwAAAL8K1yO9AAAAvwAAAL8K1yO9AAAAvwAAAL8K1yO9AAAAvwAAAD8J1yM8AAAAPwAAAD8J1yM8AAAAPwAAAD8J1yM8AAAAPwAAAD8K1yO9AAAAPwAAAD8K1yO9AAAAPwAAAD8K1yO9AAAAPwAAAD8J1yM8AAAAvwAAAD8J1yM8AAAAvwAAAD8J1yM8AAAAvwAAAD8K1yO9AAAAvwAAAD8K1yO9AAAAvwAAAD8K1yO9AAAAvwAAgL8AAAAAAAAAgAAAAAAAAAAAAACAPwAAAAAAAIA/AAAAgAAAgL8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAPwAAgL8AAAAAAAAAgAAAAAAAAAAAAACAvwAAAAAAAIA/AAAAgAAAgL8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAvwAAAAAAAAAAAACAPwAAAAAAAIA/AAAAgAAAgD8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAPwAAgD8AAAAAAAAAgAAAAAAAAAAAAACAvwAAAAAAAIA/AAAAgAAAgD8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAvwAAgD8AAAAAAAAAgADAfz8AwH8/AMB/PwDAfz+aQv0+vBn9PgDAfz8AwH8/FP13P7wZ/T4AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz+aQv0+AM03PADAfz8AwH8/FP13PwDNNzwAwH8/AMB/PwDAfz8AwH8/FP13P7wZ/T4AwH8/AMB/P5pC/T68Gf0+AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/FP13PwDNNzwAwH8/AMB/P5pC/T4AzTc8AMB/PwDAfz8AwH8/AMB/PwAABgAJAAAACQADAAcAEgAWAAcAFgALABQADgARABQAEQAXAAwAAQAFAAwABQAQAAgAAgANAAgADQATABUADwAEABUABAAKAAAAgL8J1yM8AAAAPwAAgL8J1yM8AAAAPwAAgL8J1yM8AAAAPwAAgL8K1yO9AAAAPwAAgL8K1yO9AAAAPwAAgL8K1yO9AAAAPwAAgL8J1yM8AAAAvwAAgL8J1yM8AAAAvwAAgL8J1yM8AAAAvwAAgL8K1yO9AAAAvwAAgL8K1yO9AAAAvwAAgL8K1yO9AAAAvwAAgD8J1yM8AAAAPwAAgD8J1yM8AAAAPwAAgD8J1yM8AAAAPwAAgD8K1yO9AAAAPwAAgD8K1yO9AAAAPwAAgD8K1yO9AAAAPwAAgD8J1yM8AAAAvwAAgD8J1yM8AAAAvwAAgD8J1yM8AAAAvwAAgD8K1yO9AAAAvwAAgD8K1yO9AAAAvwAAgD8K1yO9AAAAvwAAAAAJ1yM8AAAAvwAAAAAJ1yM8AAAAvwAAAAAJ1yM8AAAAvwAAAAAK1yO9AAAAvwAAAAAK1yO9AAAAvwAAAAAK1yO9AAAAvwAAAAAJ1yM8AAAAPwAAAAAJ1yM8AAAAPwAAAAAJ1yM8AAAAPwAAAAAK1yO9AAAAPwAAAAAK1yO9AAAAPwAAAAAK1yO9AAAAPwAAgL8AAAAAAAAAgAAAAAAAAAAAAACAPwAAAAAAAIA/AAAAgAAAgL8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAPwAAgL8AAAAAAAAAgAAAAAAAAAAAAACAvwAAAAAAAIA/AAAAgAAAgL8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAvwAAAAAAAAAAAACAPwAAAAAAAIA/AAAAgAAAgD8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAPwAAgD8AAAAAAAAAgAAAAAAAAAAAAACAvwAAAAAAAIA/AAAAgAAAgD8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAvwAAgD8AAAAAAAAAgAAAAAAAAAAAAACAvwAAAAAAAIA/AAAAgAAAAAAAAIA/AAAAgAAAAAAAAIC/AAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAvwAAAAAAAAAAAACAPwAAAAAAAIA/AAAAgAAAAAAAAIA/AAAAgAAAAAAAAIC/AAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAPwDAfz8AwH8/AMB/PwDAfz+aQv0+vBn9PgDAfz8AwH8/FP13P7wZ/T4AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz+aQv0+AM03PADAfz8AwH8/FP13PwDNNzwAwH8/AMB/PwDAfz8AwH8/FP13P7wZ/T4AwH8/AMB/P5pC/T68Gf0+AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/FP13PwDNNzwAwH8/AMB/P5pC/T4AzTc8AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/mkL9PgDNNzwU/Xc/AM03PJpC/T4AzTc8FP13PwDNNzwAwH8/AMB/PwDAfz8AwH8/mkL9PrwZ/T4U/Xc/vBn9PppC/T68Gf0+FP13P7wZ/T4AwH8/AMB/PwAABgAJAAAACQADABgAEgAWABgAFgAdABQADgARABQAEQAXAB4AAQAFAB4ABQAjABkAHwANABkADQATABsAIQAEABsABAAKABUADwAiABUAIgAcAAgAAgAgAAgAIAAaAAwAHgAjAAwAIwAQAAcAGAAdAAcAHQALAMrC9b0AAAAAAAAAPsrC9b0AAAAAAAAAPsrC9b0AAAAAAAAAPsrMzL3NzAxAPQrXPcrMzL3NzAxAPQrXPcrMzL3NzAxAPQrXPcrC9b0AAAAAHoXrvcrC9b0AAAAAHoXrvcrC9b0AAAAAHoXrvcrMzL3NzAxAXI/CvcrMzL3NzAxAXI/CvcrMzL3NzAxAXI/CvcrMzL2F6wFAPQrXPcrMzL2F6wFAPQrXPcrMzL2F6wFAXI/CvcrMzL2F6wFAXI/CvcrC9b2QwvU9HoXrvcrC9b2QwvU9HoXrvcrC9b2QwvU9HoXrvcrC9b2QwvU9HoXrvcrC9b2QwvU9AAAAPsrC9b2QwvU9AAAAPsrC9b2QwvU9AAAAPsrC9b2QwvU9AAAAPsrMzL24HgU+PQrXPcrMzL24HgU+PQrXPcrMzL24HgU+PQrXPcrMzL24HgU+PQrXPcrMzL24HgU+XI/CvcrMzL24HgU+XI/CvcrMzL24HgU+XI/CvcrMzL24HgU+XI/CvczMzD3NzAxAPQrXPczMzD3NzAxAPQrXPczMzD3NzAxAPQrXPYzC9T2QwvU9HoXrvYzC9T2QwvU9HoXrvYzC9T2QwvU9HoXrvYzC9T2QwvU9HoXrvczMzD24HgU+XI/CvczMzD24HgU+XI/CvczMzD24HgU+XI/CvczMzD24HgU+XI/CvczMzD2F6wFAPQrXPczMzD2F6wFAPQrXPczMzD2F6wFAPQrXPczMzD2F6wFAXI/CvczMzD2F6wFAXI/CvczMzD2F6wFAXI/Cvc7MzD3NzAxAXI/Cvc7MzD3NzAxAXI/Cvc7MzD3NzAxAXI/CvczMzD24HgU+PQrXPczMzD24HgU+PQrXPczMzD24HgU+PQrXPczMzD24HgU+PQrXPYzC9T2QwvU9AAAAPozC9T2QwvU9AAAAPozC9T2QwvU9AAAAPozC9T2QwvU9AAAAPozC9T0AAAAAAAAAPozC9T0AAAAAAAAAPozC9T0AAAAAAAAAPozC9T0AAAAAHoXrvYzC9T0AAAAAHoXrvYzC9T0AAAAAHoXrvQAAgL8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAPwAAgL8AAAAAAAAAgAAAAAAAAAAAAACAPwAAAAAAAIA/AAAAgAAAgL8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAvwAAgL8AAAAAAAAAgAAAAAAAAAAAAACAvwAAAAAAAIA/AAAAgAAAgL8AAAAAAAAAgAAAAAAAAAAAAACAPwAAgL8AAAAAAAAAgAAAAAAAAAAAAACAvwAAgL8AAAAAAAAAgP335L56+WQ/AAAAgAAAAAAAAAAAAACAvwAAAAAv+WQ/KfnkvgAAgL8AAAAAAAAAgP335L56+WQ/AAAAgAAAAAAAAAAAAACAPwAAAAAy+WQ/H/nkPgAAgL8AAAAAAAAAgP335L56+WQ/AAAAgAAAAAAAAAAAAACAPwAAAAAy+WQ/H/nkPgAAgL8AAAAAAAAAgP335L56+WQ/AAAAgAAAAAAAAAAAAACAvwAAAAAv+WQ/KfnkvgAAAAAAAAAAAACAPwAAAAAAAIA/AAAAgAAAgD8uPDyzOktrMwAAAAAAAAAAAACAvwAAAAAv+WQ/Kfnkvib55D4w+WQ/AAAAgAAAgD8AAAAAAAAAgAAAAAAAAAAAAACAvwAAAAAv+WQ/Kfnkvib55D4w+WQ/AAAAgAAAgD8AAAAAAAAAgAAAAAAAAAAAAACAPwAAgD8uPDyzOktrMwAAgD8AAAAAAAAAgAAAAAAAAAAAAACAvwAAgD8uPDyzOktrMwAAgD8AAAAAAAAAgAAAAAAAAAAAAACAvwAAAAAAAIA/AAAAgAAAgD8uPDyzOktrMwAAAAAAAAAAAACAPwAAAAAy+WQ/H/nkPib55D4w+WQ/AAAAgAAAgD8AAAAAAAAAgAAAAAAAAAAAAACAPwAAAAAy+WQ/H/nkPib55D4w+WQ/AAAAgAAAgD8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAPwAAgD8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAvwAAgD8AAAAAAAAAgIhd9j68324/AMB/PwDAfz/MJ88+vN9uP8ut9j6AQ0c8FbPPPoBDRzwAwH8/AMB/P8wnzz68324/AMB/PwDAfz+IXfY+vN9uPxWzzz6AQ0c8y632PoBDRzwAwH8/AMB/P8ut9j7ATrk9FbPPPsBOuT0Vs88+wE65Pcut9j7ATrk9zCfPPlP2Yj/MJ88+U/ZiP4hd9j5T9mI/iF32PlP2Yj+IXfY+U/ZiP4hd9j5T9mI/zCfPPlP2Yj/MJ88+U/ZiP8ut9j4UbEg/iF32PjNzYT8Vs88+FGxIP8wnzz40c2E/FbPPPhRsSD/MJ88+NHNhP8ut9j4UbEg/iF32PjNzYT/LrfY+gENHPADAfz8AwH8/FbPPPoBDRzzMJ88+U/ZiP8wnzz5T9mI/iF32PlP2Yj+IXfY+U/ZiPxWzzz4UbEg/zCfPPjRzYT+IXfY+M3NhP8ut9j4UbEg/y632PsBOuT0Vs88+wE65PRWzzz7ATrk9FbPPPsBOuT3LrfY+wE65Pcut9j7ATrk9FbPPPoBDRzwAwH8/AMB/P8ut9j6AQ0c8y632PhRsSD+IXfY+M3NhP8wnzz40c2E/FbPPPhRsSD+IXfY+U/ZiP4hd9j5T9mI/zCfPPlP2Yj/MJ88+U/ZiPwDAfz8AwH8/iF32Przfbj/MJ88+vN9uPwDAfz8AwH8/zCfPPrzfbj+IXfY+vN9uPwwAAwAJAAwACQAOAEAACAASAEAAEgAjACAABAANACAADQArAC4ADwAKAC4ACgAxADwAAQAHADwABwA/ACcAHgAPACcADwAuABgADAAOABgADgAcAAAAFAAQAAAAEAAGACsADQAaACsAGgA0ADgAFgACADgAAgA9ABUAGQAdABUAHQARADIACwAFADIABQAhADUAGwAXADUAFwA5ACQAEwAfACQAHwAoADYAOgAlADYAJQApADsAPgBBADsAQQAmACoAMAAtACoALQA3ACIALAAvACIALwAzAAAAAL8AAAAAj8L1PQAAAL8AAAAAj8L1PQAAAL8AAAAAj8L1Pf7//77NzAxAzMzMPf7//77NzAxAzMzMPf7//77NzAxAzMzMPf7//74AAAAAj8L1vf7//74AAAAAj8L1vf7//74AAAAAj8L1vf7//77NzAxAzMzMvf7//77NzAxAzMzMvf7//77NzAxAzMzMvf7//76F6wFAzMzMPf7//76F6wFAzMzMPf7//76F6wFAzMzMPf7//76F6wFAzMzMvf7//76F6wFAzMzMvf7//76F6wFAzMzMvf7//76QwvU9j8L1vf7//76QwvU9j8L1vf7//76QwvU9j8L1vf7//76QwvU9j8L1vf7//76QwvU9j8L1Pf7//76QwvU9j8L1Pf7//76QwvU9j8L1Pf7//76QwvU9j8L1Pf7//764HgU+zMzMPf7//764HgU+zMzMPf7//764HgU+zMzMPf7//764HgU+zMzMvf7//764HgU+zMzMvf7//764HgU+zMzMvQAAAD/NzAxAzMzMPQAAAD/NzAxAzMzMPQAAAD/NzAxAzMzMPbgeBT+QwvU9j8L1vbgeBT+QwvU9j8L1vbgeBT+QwvU9j8L1vbgeBT+QwvU9j8L1vQAAAD+4HgU+zMzMvQAAAD+4HgU+zMzMvQAAAD+4HgU+zMzMvQAAAD+4HgU+zMzMvQAAAD+F6wFAzMzMPQAAAD+F6wFAzMzMPQAAAD+F6wFAzMzMPQAAAD+F6wFAzMzMPQAAAD+F6wFAzMzMvQAAAD+F6wFAzMzMvQAAAD+F6wFAzMzMvQAAAD+F6wFAzMzMvQEAAD/NzAxAzMzMvQEAAD/NzAxAzMzMvQEAAD/NzAxAzMzMvQAAAD+4HgU+zMzMPQAAAD+4HgU+zMzMPQAAAD+4HgU+zMzMPQAAAD+4HgU+zMzMPbgeBT+QwvU9j8L1PbgeBT+QwvU9j8L1PbgeBT+QwvU9j8L1PbgeBT+QwvU9j8L1PbgeBT8AAAAAj8L1PbgeBT8AAAAAj8L1PbgeBT8AAAAAj8L1PbgeBT8AAAAAj8L1vbgeBT8AAAAAj8L1vbgeBT8AAAAAj8L1vQAAgL9VVYU0juMKtAAAAAAAAIC/AAAAgAAAAAANuIKz//9/PwAAgL8AAAAAAAAAgAAAAAAAAAAAAACAPwAAAAAAAIA/AAAAgAAAgL9VVYU0juMKtAAAAAAAAIC/AAAAgAAAAAAAAAAA//9/vwAAgL8AAAAAAAAAgAAAAAAAAAAAAACAvwAAAAAAAIA/AAAAgAAAgL8AAAAAAAAAgAAAAAAAAAAA//9/PwAAAAAAAAAAAACAPwAAgL8AAAAAAAAAgAAAAAAAAAAAAACAvwAAAAAAAAAA//9/vwAAgL8AAAAAAAAAgAAAgL9VVYU0juMKtAAAAAAAAAAA//9/vwAAAAAx+WQ/HvnkvgAAgL8AAAAAAAAAgAAAgL9VVYU0juMKtAAAAAANuIKz//9/PwAAAAAx+WQ/HvnkPgAAgL8AAAAAAAAAgAAAAAAAAAAA//9/PwAAAAAx+WQ/HvnkPgAAgL8AAAAAAAAAgAAAAAAAAAAA//9/vwAAAAAx+WQ/HvnkvgAAAAAAAAAAAACAPwAAAAAAAIA/AAAAgAAAgD8uPDy0AAAAgAAAAAAAAAAA//9/vwAAAAAx+WQ/Hvnkvir55D4v+WQ/AAAAgAAAgD8AAAAAAAAAgAAAAAAAAAAA//9/vwAAAAAx+WQ/Hvnkvir55D4v+WQ/AAAAgAAAgD8AAAAAAAAAgAAAAAAAAAAA//9/PwAAAAAAAAAAAACAPwAAgD8uPDy0AAAAgAAAgD8AAAAAAAAAgAAAAAAAAAAAAACAvwAAAAAAAAAA//9/vwAAgD8uPDy0AAAAgAAAgD8AAAAAAAAAgAAAAAAAAAAAAACAvwAAAAAAAIA/AAAAgAAAgD8uPDy0AAAAgAAAAAAAAAAA//9/PwAAAAAx+WQ/HvnkPir55D4v+WQ/AAAAgAAAgD8AAAAAAAAAgAAAAAANuIKz//9/PwAAAAAx+WQ/HvnkPir55D4v+WQ/AAAAgAAAgD8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAAAANuIKz//9/PwAAgD8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAA//9/vwAAgD8AAAAAAAAAgADAfz8AwH8/AMB/PwDAfz+grwA8CshuPwDAfz8AwH8/4Lj1OwBDRzwAwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz+m2ck+CshuPwDAfz8AwH8/HQDKPgDmTTwAwH8/AMB/PwDAfz8AwH8/4Lj1OxgFuT3guPU7GAW5PQDAfz8AwH8/HQDKPqjZuT0dAMo+qNm5PQDAfz8AwH8/AMB/PwDAfz+m2ck+6sliP6bZyT7qyWI/AMB/PwDAfz8AwH8/AMB/P6CvADzlyWI/oK8APOXJYj8AwH8/AMB/P+C49TvUWkg/oK8APE5eYT8AwH8/AMB/Px0Ayj5mdUg/ptnJPk5eYT8dAMo+AOZNPADAfz8AwH8/FbPPPoBDRzygrwA85cliP6CvADzlyWI/iF32PlP2Yj+IXfY+U/ZiP+C49TvUWkg/oK8APE5eYT+IXfY+M3NhP8ut9j4UbEg/HQDKPqjZuT0dAMo+qNm5PRWzzz7ATrk9FbPPPsBOuT3guPU7GAW5PeC49TsYBbk9y632PsBOuT3LrfY+wE65PeC49TsAQ0c8AMB/PwDAfz/LrfY+gENHPB0Ayj5mdUg/ptnJPk5eYT/MJ88+NHNhPxWzzz4UbEg/ptnJPurJYj+m2ck+6sliP8wnzz5T9mI/zCfPPlP2Yj8AwH8/AMB/P6bZyT4KyG4/zCfPPrzfbj8AwH8/AMB/P6CvADwKyG4/iF32Przfbj8MAAMACQAMAAkADwAqADIALgAqAC4AOQBCAAgAFABCABQAIwAgAAQADgAgAA4ALAAvABAACgAvAAoAMwA+AAEABwA+AAcAQQAnAB4AEQAnABEAMAA4ADwAJQA4ACUAKQAaAAwADwAaAA8AHQAAABcAEwAAABMABgArAA0AGwArABsANgBDACYAPQBDAD0AQAA6ABgAAgA6AAIAPwAWABoAHQAWAB0AEgA0AAsABQA0AAUAIQA3ABwAGQA3ABkAOwAkABUAHwAkAB8AKAAiAC0AMQAiADEANQCIwvU9AAAAAAAAgL+IwvU9AAAAAAAAgL+IwvU9AAAAAAAAgL+IwvU9mML1PQAAgL+IwvU9mML1PQAAgL+IwvU9mML1PQAAgL+PwvU9AAAAAJXC9b2PwvU9AAAAAJXC9b2PwvU9AAAAAJXC9b2PwvU9AAAAAJXC9b0AAICzAAAAAAAAgL8AAICzAAAAAAAAgL8AAICzmML1PQAAgL8AAAAAAAAAAAAAwLIAAAAAAAAAAAAAwLIAAIA/AAAAAAAAAIAAAIA/AAAAAAAAAIAAAIA/AAAAAI/C9b0AAIA/AAAAAI/C9b0AAIA/AAAAAI/C9b0AAIA/kML1PQAAAIAAAIA/kML1PY/C9b0AAIA/kML1PY/C9b0AAIA/kML1PY/C9b0AAIA/uB4FPgAAAIAAAIA/uB4FPszMzL0AAIA/uB4FPszMzL0AAIA/uB4FPszMzL0AAIA/hesBQAAAAIAAAIA/hesBQMzMzL0AAIA/hesBQMzMzL0AAIA/hesBQMzMzL0AAIA/zcwMQAAAAIAAAIA/zcwMQAAAAIAAAIA/zcwMQMzMzL0AAIA/zcwMQMzMzL0AAIA/zcwMQMzMzL0AAIAyzcwMQAAAcDQAAIAyzcwMQAAAcDTQzMw9zcwMQMHMzL3QzMw9zcwMQMHMzL3QzMw9zcwMQMHMzL3QzMw9zcwMQMHMzL0AAMCzzcwMQAAAgL8AAMCzzcwMQAAAgL/AzMw9zcwMQAAAgL/AzMw9zcwMQAAAgL/AzMw9zcwMQAAAgL8AAMCzhOsBQAAAgL/AzMw9hOsBQAAAgL/AzMw9hOsBQAAAgL/AzMw9hOsBQAAAgL8AAMCzvB4FPgAAgL/AzMw9vB4FPgAAgL/AzMw9vB4FPgAAgL/AzMw9vB4FPgAAgL/KzMw9uB4FPsfMzL3KzMw9uB4FPsfMzL3KzMw9uB4FPsfMzL3KzMw9uB4FPsfMzL2PwvU9kML1PZXC9b2PwvU9kML1PZXC9b2PwvU9kML1PZXC9b2PwvU9kML1PZXC9b3KzMw9hesBQMfMzL3KzMw9hesBQMfMzL3KzMw9hesBQMfMzL3KzMw9hesBQMfMzL2YwvW9AAAAAAAAgL+YwvW9AAAAAAAAgL+YwvW9AAAAAAAAgL/YzMy9zcwMQAAAgL/YzMy9zcwMQAAAgL/YzMy9zcwMQAAAgL8AAIA/AAAAAI/C9T0AAIA/AAAAAI/C9T0AAIA/AAAAAI/C9T0AAIA/zcwMQMzMzD0AAIA/zcwMQMzMzD0AAIA/zcwMQMzMzD3YzMy9hOsBQAAAgL/YzMy9hOsBQAAAgL/YzMy9hOsBQAAAgL8AAIA/hesBQMzMzD0AAIA/hesBQMzMzD0AAIA/hesBQMzMzD2YwvW9mML1PQAAgL+YwvW9mML1PQAAgL+YwvW9mML1PQAAgL8AAIA/kML1PY/C9T0AAIA/kML1PY/C9T0AAIA/kML1PY/C9T3YzMy9vB4FPgAAgL/YzMy9vB4FPgAAgL/YzMy9vB4FPgAAgL8AAIA/uB4FPszMzD0AAIA/uB4FPszMzD0AAIA/uB4FPszMzD3MzMy9zcwMQP3MzD3MzMy9zcwMQP3MzD3MzMy9zcwMQP3MzD3MzMy9zcwMQP3MzD3MzMy9hesBQP3MzD3MzMy9hesBQP3MzD3MzMy9hesBQP3MzD3MzMy9hesBQP3MzD3MzMy9uB4FPv3MzD3MzMy9uB4FPv3MzD3MzMy9uB4FPv3MzD3MzMy9uB4FPv3MzD2PwvW9kML1PY/C9T2PwvW9kML1PY/C9T2PwvW9kML1PY/C9T2PwvW9kML1PY/C9T2PwvW9AAAAAI/C9T2PwvW9AAAAAI/C9T2PwvW9AAAAAI/C9T0AAICzAAAAAAAAgL8AAICzAAAAAAAAgL8AAMCzzcwMQAAAgL8AAMCzzcwMQAAAgL8AAMCzhOsBQAAAgL8AAICzmML1PQAAgL8AAMCzvB4FPgAAgL8AAAAAAAAAAAAAwLIAAIA/AAAAAAAAAIAAAIA/AAAAAAAAAIAAAIAyzcwMQAAAcDQAAIAyzcwMQAAAcDQAAIA/zcwMQAAAAIAAAIA/zcwMQAAAAIAAAIA/uB4FPgAAAIAAAIA/kML1PQAAAIAAAIA/hesBQAAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgL8AAIA/AAAAAFl0kbMAAAAAAAAAAAAAgL8U+eQ+NPlkP/Ex8TIAAIA/AAAAAFl0kbMAAAAAAACAvwAAAIAAAAAA//9/vwAAAICLLlozAAAAAP//f78AAIA/AAAAAFl0kbMAAAAA//9/vwAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8AAAAAAACAvwAAAIAAAAAA//9/vwAAAIAAAAAAAACAvwAAAIAAAIA/AAAAAAAAAIAAAAAAAACAvwAAAICLLlozAAAAAP//f78AAIA/AAAAAAAAAIAAAIA/AAAAAAAAAIDayyAxNflkPwv55L6LLlozAAAAAP//f78AAIA/AAAAAAAAAIAAAIA/AAAAAAAAAIAcxzGzAAAAAAAAgL/ayyAxNflkPwv55L4AAIA/AAAAAAAAAIAAAIA/AAAAAAAAAIDjOI6z2NwcNAAAgL8cxzGzAAAAAAAAgL8AAIA/AAAAAAAAAIDEayi0AACAPwAAAIAAAIA/AAAAAAAAAIDEayi0AACAPwAAAIDjOI6z2NwcNAAAgL8AAIA/AAAAAAAAAIDEayi0AACAPwAAAIAAAAAAAACAPwAAAIDEayi0AACAPwAAAIDjOI6z2NwcNAAAgL8AAAAAAACAPwAAAIAAAIA/GS0NtChL67MAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIA/GS0NtChL67MAAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8AAIA/GS0NtChL67MAAIA/AAAAALOewrMAAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8U+eQ+NPlkP/Ex8TIAAIA/AAAAALOewrMcxzGzAAAAAAAAgL/ayyAxNflkPwv55L4U+eQ+NPlkP/Ex8TIAAIA/AAAAALOewrPayyAxNflkPwv55L6LLlozAAAAAP//f78U+eQ+NPlkP/Ex8TIAAIA/AAAAAFl0kbPjOI6z2NwcNAAAgL8cxzGzAAAAAAAAgL8AAIA/GS0NtChL67MAAIA/AAAAALOewrMAAIC/AAAAAF0YbjMAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAIC/AAAAAJVmrzMAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAIA/AAAAAAAAAICdJAm0//9/PwAAAICJLrI0AAAAAAAAgD8AAIA/AAAAAAAAAIAAAIC/AAAAAKGLrjMAAIC/AAAAAJVmrzMAAAAAAAAAAAAAgL+JLrI0AAAAAAAAgD+MLrI0AAAAAAAAgD8AAIA/AAAAAAAAAIAAAIC/AAAAAF0YbjMp+eS+LvlkPxGXpTMAAAAAAAAAAAAAgL8AAAAAAAAAAAAAgD/GKKEzFflkP5L55D4AAIA/AAAAAAAAAIAAAIC/AAAAAKGLrjMp+eS+LvlkPxGXpTMAAAAAAAAAAAAAgL/GKKEzFflkP5L55D6MLrI0AAAAAAAAgD8AAIA/AAAAAAAAAIAAAIC/AAAAAJVmrzOdJAm0//9/PwAAAIAAAAAAAACAPwAAAICJLrI0AAAAAAAAgD8AAIC/AAAAAKGLrjMAAIC/AAAAAJVmrzOJLrI0AAAAAAAAgD+MLrI0AAAAAAAAgD8AAIC/AAAAAKGLrjMp+eS+LvlkPxGXpTPGKKEzFflkP5L55D6MLrI0AAAAAAAAgD8AAIC/AAAAAF0YbjMp+eS+LvlkPxGXpTMAAAAAAAAAAAAAgD/GKKEzFflkP5L55D4AAIC/AAAAAF0YbjMAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8AAAAAAACAvwAAAIAAAAAAAACAvwAAAIAAAIA/AAAAAAAAAICdJAm0//9/PwAAAIAAAAAAAACAPwAAAICdJAm0//9/PwAAAIAAAIA/AAAAAAAAAIAAAIA/AAAAAAAAAIAAAIA/AAAAAAAAAIAAAIA/AAAAAAAAAIAAwH8/AMB/PwDAfz8AwH8/ptnJPgrIbj8AwH8/AMB/P6bZyT5stWI/ptnJPmy1Yj8AwH8/AMB/PwDAfz8AwH8/ptnJPgrIbj+grwA8CshuPwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz+grwA8CshuPwDAfz8AwH8/AMB/PwDAfz+grwA8Z7ViP6CvADxntWI/AMB/PwDAfz8AwH8/AMB/P+C49TvUWkg/oK8APE5eYT8AwH8/AMB/PwDAfz8AwH8/4Lj1OxgFuT3guPU7GAW5PQDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/4Lj1OwBDRzwAwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/Px0Ayj4A5k08AMB/PwDAfz/guPU7AENHPADAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/HQDKPgDmTTwAwH8/AMB/PwDAfz8AwH8/HQDKPqjZuT0dAMo+qNm5PQDAfz8AwH8/AMB/PwDAfz+m2ck+Tl5hPx0Ayj5mdUg/HQDKPmZ1SD+m2ck+Tl5hP6CvADxOXmE/4Lj1O9RaSD+m2ck+bLViP6bZyT5stWI/oK8APGe1Yj+grwA8Z7ViPx0Ayj6o2bk9HQDKPqjZuT3guPU7GAW5PeC49TsYBbk9oK8APArIbj8AwH8/AMB/PwDAfz8AwH8/4Lj1OwBDRzwAwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz+m2ck+CshuPwDAfz8AwH8/AMB/PwDAfz8dAMo+AOZNPADAfz8AwH8/4Lj1OxgFuT3guPU7GAW5PQDAfz8AwH8/HQDKPqjZuT0dAMo+qNm5PQDAfz8AwH8/oK8APGe1Yj+grwA8Z7ViPwDAfz8AwH8/ptnJPmy1Yj+m2ck+bLViPwDAfz8AwH8/4Lj1O9RaSD+grwA8Tl5hPwDAfz8AwH8/ptnJPk5eYT8dAMo+ZnVIPwDAfz8AwH8/HQDKPgDmTTwAwH8/AMB/PwDAfz8AwH8/4Lj1OwBDRzwdAMo+qNm5PR0Ayj6o2bk94Lj1OxgFuT3guPU7GAW5PR0Ayj5mdUg/ptnJPk5eYT+grwA8Tl5hP+C49TvUWkg/ptnJPmy1Yj+m2ck+bLViP6CvADxntWI/oK8APGe1Yj+m2ck+CshuPwDAfz8AwH8/oK8APArIbj8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/CwAMAAMACwADAAEACQACAAUACQAFAD8ADgAKAAAADgAAAAcADwANAAYADwAGABEAEwAXABQAEwAUABAAFwAbABgAFwAYABQAGwAfABwAGwAcABgAHwAkACEAHwAhABwAIgAnACUAIgAlACAAKQAuACwAKQAsACYAMAArAC0AMAAtADEANAAwADEANAAxADUADAA0ADUADAA1AAMAPgAEADYAPgA2ADoAOwA3ADMAOwAzAEMAGQA4AEEAGQBBAB4AFQA8ADkAFQA5ABoAQgAyAC8AQgAvACoAHQBAACgAHQAoACMAEgAIAD0AEgA9ABYAhQCCAE8AhQBPAFUAYgBHAFEAYgBRAGcAZgBQAFwAZgBcAGoAgwCFAFUAgwBVAGEAbgBWAEQAbgBEAHIAfgCEAFsAfgBbAEwAgAB4AEkAgABJAGQAawBdAFcAawBXAG8AhACDAGEAhABhAFsAXwBsAHEAXwBxAFoAgQB/AGMAgQBjAE0AWQBwAHQAWQB0AEsAVABpAG0AVABtAGAATgBlAGgATgBoAFMASgBzAHwASgB8AH0AWABeAHsAWAB7AHoARgBYAHoARgB6AHYAXgBSAHkAXgB5AHsAcwBFAHUAcwB1AHwAUgBIAHcAUgB3AHkA/v//vgAAAACPwvU9/v//vgAAAACPwvU9/v//vgAAAACPwvU9/v//vs3MDEDMzMw9/v//vs3MDEDMzMw9/v//vs3MDEDMzMw9/v//voXrAUDMzMw9/v//voXrAUDMzMw9/v//voXrAUDMzMw9/v//vpDC9T2PwvU9/v//vpDC9T2PwvU9/v//vpDC9T2PwvU9/v//vrgeBT7MzMw9/v//vrgeBT7MzMw9/v//vrgeBT7MzMw9AAAAP83MDEDMzMw9AAAAP83MDEDMzMw9AAAAP83MDEDMzMw9AAAAP4XrAUDMzMw9AAAAP4XrAUDMzMw9AAAAP4XrAUDMzMw9AAAAP7geBT7MzMw9AAAAP7geBT7MzMw9AAAAP7geBT7MzMw9AAAAP5DC9T2PwvU9AAAAP5DC9T2PwvU9AAAAP5DC9T2PwvU9AAAAPwAAAACPwvU9AAAAPwAAAACPwvU9AAAAPwAAAACPwvU9/v//vgAAAAAAAACA/v//vgAAAAAAAACA/v//vs3MDEAAAACA/v//vs3MDEAAAACA/v//voXrAUAAAACA/v//vpDC9T0AAACA/v//vrgeBT4AAACAAAAAPwAAAAAAAACAAAAAPwAAAAAAAACAAAAAP7geBT4AAACAAAAAP5DC9T0AAACAAAAAP4XrAUAAAACAAAAAP83MDEAAAACAAAAAP83MDEAAAACA/v//vgAAAACPwvW9/v//vgAAAACPwvW9/v//vgAAAACPwvW9/v//vpDC9T2PwvW9/v//vpDC9T2PwvW9/v//vpDC9T2PwvW9AAAAPwAAAACPwvW9AAAAPwAAAACPwvW9AAAAPwAAAACPwvW9/v//vgAAAAAAAACA/v//vgAAAAAAAACA/v//vpDC9T0AAACAAAAAPwAAAAAAAACAAAAAPwAAAAAAAACAAAAAP5DC9T0AAACAAAAAP5DC9T2PwvW9AAAAP5DC9T2PwvW9AAAAP5DC9T2PwvW9AAAAP7geBT4AAACAAAAAP4XrAUAAAACAAAAAP4XrAUAAAACAAAAAP7geBT7MzMy9AAAAP7geBT7MzMy9AAAAP7geBT7MzMy9/v//vrgeBT7MzMy9/v//vrgeBT7MzMy9/v//vrgeBT7MzMy9AAAAP4XrAUDMzMy9AAAAP4XrAUDMzMy9AAAAP4XrAUDMzMy9AAAAP4XrAUDMzMy9/v//voXrAUDMzMy9/v//voXrAUDMzMy9/v//voXrAUDMzMy9AQAAP83MDEDMzMy9AQAAP83MDEDMzMy9AQAAP83MDEDMzMy9/v//vs3MDEDMzMy9/v//vs3MDEDMzMy9/v//vs3MDEDMzMy9AAAAP83MDEAAAACAAAAAP83MDEAAAACA/v//vs3MDEAAAACA/v//vs3MDEAAAACA/v//voXrAUAAAACA/v//vrgeBT4AAACAAACAvwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIA/AACAvwAAAAAAAACAAAAAAAAAAAAAAIA/AAAAAP//fz8AAACAAACAvwAAAAAAAACAAAAAAAAAAAD//38/AAAAAAAAAAAAAIA/AACAvwAAAAAAAACAAAAAAAAAAAAAAIA/AAAAADL5ZD8h+eQ+AACAvwAAAAAAAACAAAAAAAAAAAD//38/AAAAADL5ZD8h+eQ+AAAAAAAAAAAAAIA/AAAAAP//fz8AAACAAACAPwAAAAAAAACAAAAAAAAAAAD//38/AAAAAAAAAAAAAIA/AACAPwAAAAAAAACAAAAAAAAAAAD//38/AAAAADL5ZD8h+eQ+AACAPwAAAAAAAACAAAAAAAAAAAAAAIA/AAAAADL5ZD8h+eQ+AACAPwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIA/AACAPwAAAAAAAACAAACAvwAAAAAAAACAAAAAAAAAgL8AAACAAACAvwAAAAAAAACAAAAAAP//fz8AAACAAACAvwAAAAAAAACAAACAvwAAAAAAAACAAACAvwAAAAAAAACAAAAAAAAAgL8AAACAAACAPwAAAAAAAACAAACAPwAAAAAAAACAAACAPwAAAAAAAACAAACAPwAAAAAAAACAAAAAAP//fz8AAACAAACAPwAAAAAAAACAAACAvwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AACAvwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAADL5ZD8h+eS+AAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AACAPwAAAAAAAACAAACAvwAAAAAAAACAAAAAAAAAgL8AAACAAACAvwAAAAAAAACAAAAAAAAAgL8AAACAAACAPwAAAAAAAACAAACAPwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAADL5ZD8h+eS+AACAPwAAAAAAAACAAACAPwAAAAAAAACAAACAPy48PLQAAACAAACAPwAAAAAAAACAAAAAAAAAAAD//3+/AAAAADL5ZD8h+eS+AACAPwAAAAAAAACAAACAvwAAAAAAAACAAAAAAAAAAAD//3+/AAAAADL5ZD8h+eS+AAAAAAAAAAAAAIC/AAAAAAAAAAD//3+/AACAPy48PLQAAACAAACAPwAAAAAAAACAAACAvwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAAAAAAAD//3+/AAAAAAAAAAAAAIC/AAAAAAAAgD8AAACAAACAPy48PLQAAACAAACAvwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAAAAAgD8AAACAAAAAAAAAgD8AAACAAACAPy48PLQAAACAAACAvwAAAAAAAACAAAAAAAAAgD8AAACAAACAvwAAAAAAAACAAACAvwAAAAAAAACAAMB/PwDAfz8AwH8/AMB/P6CvADwKyG4/AMB/PwDAfz/guPU7AENHPADAfz8AwH8/AMB/PwDAfz/guPU7GAW5PeC49TsYBbk9AMB/PwDAfz+grwA85cliP6CvADzlyWI/AMB/PwDAfz/guPU71FpIP6CvADxOXmE/HQDKPgDmTTwAwH8/AMB/PwDAfz8AwH8/HQDKPqjZuT0dAMo+qNm5PQDAfz8AwH8/HQDKPmZ1SD+m2ck+Tl5hPwDAfz8AwH8/ptnJPurJYj+m2ck+6sliPwDAfz8AwH8/AMB/PwDAfz+m2ck+CshuPwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz+m2ck+CshuPwDAfz8AwH8/ptnJPurJYj+m2ck+6sliPwDAfz8AwH8/oK8APArIbj8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/P6CvADzlyWI/oK8APOXJYj8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/P+C49TvUWkg/oK8APE5eYT8AwH8/AMB/PwDAfz8AwH8/HQDKPmZ1SD+m2ck+Tl5hP+C49TsYBbk94Lj1OxgFuT0AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8dAMo+qNm5PR0Ayj6o2bk94Lj1OwBDRzwAwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8dAMo+AOZNPADAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/DwAEAAgADwAIABMAEgAHAA0AEgANABUAGAAKAAIAGAACABwAKgAhAAUAKgAFABAAFgAOAAsAFgALABkAJwApABQAJwAUABcAEQAUACkAEQApACsAGgAdACYAGgAmACgAFwAaACgAFwAoACcACQAMACQACQAkACMAAAAJACMAAAAjAB4ADAAGACIADAAiACQAGwABAB8AGwAfACUABgADACAABgAgACIANQA3AC8ANQAvACwAMwAuADAAMwAwADsAOAA2AC0AOAAtADIAOgA5ADQAOgA0AD0APgA6AD0APgA9AEMAQwBKAEAAQwBAAD4APAAxAEYAPABGAEIAQQBFAE0AQQBNAEgARwBMAFIARwBSAE4AVQA/AEkAVQBJAFAATwBTAFcATwBXAFQAWABWAFEAWABRAEsAWQBYAEsAWQBLAEQANwBZAEQANwBEAC8A//9/vwAAAACPwvU9//9/vwAAAACPwvU9//9/vwAAAACPwvU9//9/v83MDEDMzMw9//9/v83MDEDMzMw9//9/v83MDEDMzMw9//9/v4XrAUDMzMw9//9/v4XrAUDMzMw9//9/v4XrAUDMzMw9//9/v5DC9T2PwvU9//9/v5DC9T2PwvU9//9/v5DC9T2PwvU9//9/v7geBT7MzMw9//9/v7geBT7MzMw9//9/v7geBT7MzMw9AACAP83MDEDMzMw9AACAP83MDEDMzMw9AACAP83MDEDMzMw9AACAP4XrAUDMzMw9AACAP4XrAUDMzMw9AACAP7geBT7MzMw9AACAP7geBT7MzMw9AACAP7geBT7MzMw9AACAP5DC9T2PwvU9AACAP5DC9T2PwvU9AACAP5DC9T2PwvU9AACAPwAAAACPwvU9AACAPwAAAACPwvU9AACAPwAAAACPwvU9AAAAAM3MDEDMzMw9AAAAAM3MDEDMzMw9AAAAAM3MDEDMzMw9AAAAAM3MDEDMzMw9AAAAAIXrAUDMzMw9AAAAAIXrAUDMzMw9AAAAAIXrAUDMzMw9AAAAALgeBT7MzMw9AAAAALgeBT7MzMw9AAAAALgeBT7MzMw9AAAAALgeBT7MzMw9AAAAAJDC9T2PwvU9AAAAAJDC9T2PwvU9AAAAAJDC9T2PwvU9AAAAAJDC9T2PwvU9AAAAAAAAAACPwvU9AAAAAAAAAACPwvU9AAAAAAAAAACPwvU9//9/vwAAAAAAAACA//9/vwAAAAAAAACA//9/v83MDEAAAACA//9/v83MDEAAAACA//9/v4XrAUAAAACA//9/v5DC9T0AAACA//9/v7geBT4AAACAAACAP83MDEAAAACAAACAP83MDEAAAACAAACAPwAAAAAAAACAAACAPwAAAAAAAACAAACAP7geBT4AAACAAACAP5DC9T0AAACAAAAAAAAAAAAAAACAAAAAAM3MDEAAAACAAAAAAM3MDEAAAACAAACAP4XrAUAAAACA//9/vwAAAACPwvW9//9/vwAAAACPwvW9//9/vwAAAACPwvW9//9/v5DC9T2PwvW9//9/v5DC9T2PwvW9//9/v5DC9T2PwvW9AAAAAAAAAACPwvW9AAAAAAAAAACPwvW9AAAAAAAAAACPwvW9//9/vwAAAAAAAACA//9/vwAAAAAAAACA//9/v5DC9T0AAACAAAAAAAAAAAAAAACAAACAPwAAAAAAAACAAACAPwAAAAAAAACAAACAPwAAAACPwvW9AACAPwAAAACPwvW9AACAPwAAAACPwvW9AACAP5DC9T0AAACAAACAP5DC9T2PwvW9AACAP5DC9T2PwvW9AACAP5DC9T2PwvW9AACAP7geBT4AAACAAACAP4XrAUAAAACAAACAP7geBT7MzMy9AACAP7geBT7MzMy9AACAP7geBT7MzMy9AACAP4XrAUDMzMy9AACAP4XrAUDMzMy9AAAAALgeBT7MzMy9AAAAALgeBT7MzMy9AAAAALgeBT7MzMy9AAAAALgeBT7MzMy9//9/v7geBT7MzMy9//9/v7geBT7MzMy9//9/v7geBT7MzMy9AAAAAJDC9T2PwvW9AAAAAJDC9T2PwvW9AAAAAJDC9T2PwvW9AAAAAJDC9T2PwvW9AAAAAIXrAUDMzMy9AAAAAIXrAUDMzMy9AAAAAIXrAUDMzMy9//9/v4XrAUDMzMy9//9/v4XrAUDMzMy9//9/v4XrAUDMzMy9AAAAAM3MDEDMzMy9AAAAAM3MDEDMzMy9AAAAAM3MDEDMzMy9AAAAAM3MDEDMzMy9AACAP83MDEDMzMy9AACAP83MDEDMzMy9AACAP83MDEDMzMy9//9/v83MDEDMzMy9//9/v83MDEDMzMy9//9/v83MDEDMzMy9AAAAAM3MDEAAAACAAAAAAM3MDEAAAACA//9/v83MDEAAAACA//9/v83MDEAAAACAAACAP83MDEAAAACAAACAP83MDEAAAACA//9/v4XrAUAAAACA//9/v7geBT4AAACAAACAvwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIA/AACAvwAAAAAAAACAAAAAAAAAAAAAAIA/AAAAAP//fz8AAACAAACAvwAAAAAAAACAAAAAAAAAAAD//38/AAAAAAAAAAAAAIA/AACAvwAAAAAAAACAAAAAAAAAAAAAAIA/AAAAADP5ZD8h+eQ+AACAvwAAAAAAAACAAAAAAAAAAAD//38/AAAAADP5ZD8h+eQ+AAAAAAAAAAAAAIA/AAAAAAAAgD8AAACAAACAPwAAAAAAAACAAAAAAAAAAAAAAIA/AACAPwAAAAAAAACAAAAAAAAAAAAAAIA/AAAAADL5ZD8h+eQ+AACAPwAAAAAAAACAAAAAAAAAAAAAAIA/AAAAADL5ZD8h+eQ+AACAPwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIA/AACAPwAAAAAAAACAAAAAAAAAAAAAAIA/AAAAAAAAAAAAAIA/AAAAAP//fz8AAACAAAAAAAAAgD8AAACAAAAAAAAAAAD//38/AAAAAAAAAAAAAIA/AAAAAAAAAAAAAIA/AAAAAAAAAAD//38/AAAAAAAAAAAAAIA/AAAAADL5ZD8h+eQ+AAAAADP5ZD8h+eQ+AAAAAAAAAAAAAIA/AAAAAAAAAAAAAIA/AAAAADL5ZD8h+eQ+AAAAADP5ZD8h+eQ+AAAAAAAAgL8AAACAAAAAAAAAAAAAAIA/AAAAAAAAAAAAAIA/AACAvwAAAAAAAACAAAAAAAAAgL8AAACAAACAvwAAAAAAAACAAAAAAP//fz8AAACAAACAvwAAAAAAAACAAACAvwAAAAAAAACAAACAvwAAAAAAAACAAAAAAAAAgD8AAACAAACAPwAAAAAAAACAAAAAAAAAgL8AAACAAACAPwAAAAAAAACAAACAPwAAAAAAAACAAACAPwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAP//fz8AAACAAAAAAAAAgD8AAACAAACAPwAAAAAAAACAAACAvwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AACAvwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAADP5ZD8h+eS+AAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AAAAAAAAAAAAAIC/AACAvwAAAAAAAACAAAAAAAAAgL8AAACAAACAvwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAAAAgL8AAACAAACAPwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AACAPwAAAAAAAACAAACAPwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAADL5ZD8h+eS+AACAPwAAAAAAAACAAACAPwAAAAAAAACAAACAPwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAADL5ZD8h+eS+AACAPwAAAAAAAACAAAAAAAAAAAAAAIC/AACAPwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAAAAAAAD//3+/AAAAADL5ZD8h+eS+AAAAADP5ZD8h+eS+AACAvwAAAAAAAACAAAAAAAAAAAD//3+/AAAAADP5ZD8h+eS+AAAAAAAAAAAAAIC/AAAAAAAAAAAAAIC/AAAAADL5ZD8h+eS+AAAAADP5ZD8h+eS+AAAAAAAAAAAAAIC/AAAAAAAAAAAAAIC/AAAAAAAAAAD//3+/AACAvwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAAAAAAAD//3+/AAAAAAAAAAAAAIC/AAAAAAAAAAAAAIC/AAAAAP//fz8AAACAAAAAAAAAgD8AAACAAAAAAAAAAAAAAIC/AAAAAAAAgD8AAACAAACAPwAAAAAAAACAAACAvwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAAP//fz8AAACAAAAAAP//fz8AAACAAAAAAAAAgD8AAACAAACAvwAAAAAAAACAAAAAAP//fz8AAACAAAAAAAAAgD8AAACAAACAPwAAAAAAAACAAACAvwAAAAAAAACAAACAvwAAAAAAAACAAMB/PwDAfz8AwH8/AMB/P6CvADwKyG4/AMB/PwDAfz/guPU7AENHPADAfz8AwH8/AMB/PwDAfz/guPU7GAW5PeC49TsYBbk9AMB/PwDAfz+grwA85cliP6CvADzlyWI/AMB/PwDAfz/guPU71FpIP6CvADxOXmE/HQDKPgDnTTwAwH8/AMB/PwDAfz8AwH8/HQDKPqjZuT0AwH8/AMB/Px0Ayj5mdUg/ptnJPk5eYT8AwH8/AMB/P6bZyT7oyWI/ptnJPujJYj8AwH8/AMB/PwDAfz8AwH8/ptnJPgrIbj8AwH8/AMB/P+C49TsAQ0c8HQDKPgDnTTwAwH8/AMB/PwDAfz8AwH8/HQDKPqjZuT3guPU7GAW5PR0Ayj6o2bk9HQDKPmZ1SD/guPU71FpIP6CvADxOXmE/ptnJPk5eYT+grwA85cliP6bZyT7oyWI/oK8APOXJYj+m2ck+6MliPwDAfz8AwH8/oK8APArIbj+m2ck+CshuPwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/ptnJPgrIbj8AwH8/AMB/P6bZyT7oyWI/ptnJPujJYj8AwH8/AMB/P6CvADwKyG4/ptnJPgrIbj8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/P6CvADwKyG4/AMB/PwDAfz8AwH8/AMB/P6CvADzlyWI/oK8APOXJYj8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz/guPU71FpIP6CvADxOXmE/AMB/PwDAfz/guPU7GAW5PQDAfz8AwH8/HQDKPmZ1SD/guPU71FpIP6bZyT5OXmE/oK8APE5eYT8AwH8/AMB/Px0Ayj5mdUg/ptnJPk5eYT+grwA85cliP6bZyT7oyWI/ptnJPujJYj+grwA85cliP+C49TsYBbk9HQDKPqjZuT3guPU7GAW5PQDAfz8AwH8/HQDKPqjZuT0dAMo+qNm5PeC49TsAQ0c8HQDKPgDnTTwAwH8/AMB/PwDAfz8AwH8/4Lj1OwBDRzwAwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8dAMo+AOdNPADAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/Px4ABAAIAB4ACAAjACEABwANACEADQAkACkACgACACkAAgAuAD0AMgAFAD0ABQAfACcADgALACcACwArADoAPwATADoAEwAWABUAJgAqABUAKgAYADYAPgAgADYAIAAQABcAKAAtABcALQAbABIAIgAlABIAJQAUAA8AHQAiAA8AIgASABoALAA8ABoAPAA4ABEAEwA/ABEAPwA3ABkAHAA5ABkAOQA7ABYAGQA7ABYAOwA6AAkADAA1AAkANQA0AAAACQA0AAAANAAvAAwABgAzAAwAMwA1ACwAAQAwACwAMAA8AAYAAwAxAAYAMQAzAEkASwBDAEkAQwBAAEcAQgBEAEcARABkAEwASgBBAEwAQQBGAE0ATABGAE0ARgBPAFIATgBRAFIAUQBVAFYAUgBVAFYAVQBaAFoAXABXAFoAVwBWAFQAZgBfAFQAXwBZAFgAXQBpAFgAaQBbAGcARQBjAGcAYwBgAF4AYgBtAF4AbQBqAGgAbAB2AGgAdgBuAFsAaQBvAFsAbwByAHMAcQB5AHMAeQB8AHAAdwB7AHAAewB4AH0AVwBcAH0AXAB0AH4AegB1AH4AdQBrAH8AfgBrAH8AawBhAEsAfwBhAEsAYQBDAFAASABlAFAAZQBTAAAAAL8AAAAAULgePwAAAL8AAAAAULgePwAAAL8AAAAAULgePwAAAL/NzAxAmJkZPwAAAL/NzAxAmJkZPwAAAL/NzAxAmJkZP1K4Hj8AAAAAAAAAv1K4Hj8AAAAAAAAAv1K4Hj8AAAAAAAAAv5mZGT/NzAxAAAAAv5mZGT/NzAxAAAAAv5mZGT/NzAxAAAAAvwAAAL+E6wFAmJkZPwAAAL+E6wFAmJkZPwAAAL+E6wFAmJkZPwAAAL+E6wFAmJkZP5mZGT+F6wFAAAAAv5mZGT+F6wFAAAAAv5mZGT+F6wFAAAAAvwAAAL+YwvU9ULgePwAAAL+YwvU9ULgePwAAAL+YwvU9ULgeP1K4Hj+QwvU9AAAAv1K4Hj+QwvU9AAAAv1K4Hj+QwvU9AAAAvwAAAL+8HgU+mJkZPwAAAL+8HgU+mJkZPwAAAL+8HgU+mJkZPwAAAL+8HgU+mJkZP5mZGT+4HgU+AAAAv5mZGT+4HgU+AAAAv5mZGT+4HgU+AAAAvwAAAL/NzAxA/P//PgAAAL/NzAxA/P//PgAAAD8AAAAAAAAAvwAAAD8AAAAAAAAAvwAAAL+E6wFA/P//PgAAAL+E6wFA/P//PgAAAL+YwvU9/P//PgAAAL+8HgU+/P//PgAAAL+8HgU+/P//PpDP/z64HgU+AAAAvwAAAD+QwvU9AAAAvwAAAD/NzAxAAAAAvwAAAD/NzAxAAAAAvwAAAL8AAAAA/P//PgAAAL8AAAAA/P//PgAAAD+F6wFAAAAAvwAAAL8AAAAAWI/CPgAAAL8AAAAAWI/CPgAAAL8AAAAAWI/CPgAAAL+YwvU9WI/CPgAAAL+YwvU9WI/CPgAAAL+YwvU9WI/CPlyPwj4AAAAAAAAAv1yPwj4AAAAAAAAAv1yPwj4AAAAAAAAAvwAAAL8AAAAA/P//PgAAAL8AAAAA/P//PgAAAL+YwvU9/P//PgAAAD8AAAAAAAAAvwAAAD8AAAAAAAAAvwAAAD+QwvU9AAAAv1yPwj6QwvU9AAAAv1yPwj6QwvU9AAAAv1yPwj6QwvU9AAAAv5DP/z64HgU+AAAAv8zMzD64HgU+AAAAv8zMzD64HgU+AAAAv8zMzD64HgU+AAAAvwAAAD+F6wFAAAAAv8zMzD6F6wFAAAAAv8zMzD6F6wFAAAAAv8zMzD6F6wFAAAAAvwAAAD/NzAxAAAAAvwAAAD/NzAxAAAAAv8zMzD7NzAxAAAAAv8zMzD7NzAxAAAAAv8zMzD7NzAxAAAAAvwAAAL/NzAxA/P//PgAAAL/NzAxA/P//PgAAAL+E6wFA/P//PgAAAL+E6wFA/P//PgAAAL/NzAxAyMzMPgAAAL/NzAxAyMzMPgAAAL/NzAxAyMzMPgAAAL+E6wFAyMzMPgAAAL+E6wFAyMzMPgAAAL+E6wFAyMzMPgAAAL+E6wFAyMzMPgAAAL+8HgU+yMzMPgAAAL+8HgU+yMzMPgAAAL+8HgU+yMzMPgAAAL+8HgU+yMzMPgAAAL+8HgU+/P//PgAAAL+8HgU+/P//PgAAgL8AAAAAAAAAgAAAAAAAAIC/AAAAgPMENT8AAAAA9AQ1PwAAgL8AAAAAAAAAgAAAAAAAAIA/AAAAgPUENT8AAAAA8gQ1PwAAAAAAAIC/AAAAgAAAAAAAAAAAAACAv/MENT8AAAAA9AQ1PwAAAAAAAAAAAACAvwAAAAAAAIA/AAAAgPUENT8AAAAA8gQ1PwAAgL8AAAAAAAAAgP//f78AAAAAAAAAgPMENT8AAAAA9AQ1P/UENT8AAAAA8gQ1PwAAAAAAAAAAAACAv/MENT8AAAAA9AQ1P/UENT8AAAAA8gQ1PwAAgL8AAAAAAAAAgOEF0T7yBVE/2wXRPvMENT8AAAAA9AQ1PwAAAAAAAAAAAACAv+EF0T7yBVE/2wXRPvMENT8AAAAA9AQ1PwAAgL8AAAAAAAAAgP//f78AAAAAAAAAgOEF0T7yBVE/2wXRPvMENT8AAAAA9AQ1PwAAAAAAAAAAAACAv+EF0T7yBVE/2wXRPvMENT8AAAAA9AQ1PwAAgL8AAAAAAAAAgAAAAAAAAIA/AAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAvwAAgL8AAAAAAAAAgP//f78AAAAAAAAAgAAAgL8AAAAAAAAAgAAAgL8AAAAAAAAAgP//f78AAAAAAAAAgAAAAAAAAAAAAACAvwAAAAAAAAAAAACAvwAAAAAAAAAAAACAvwAAAAAAAIA/AAAAgAAAgL8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAvwAAgL8AAAAAAAAAgPMENb8AAAAA9QQ1vwAAAAD//3+/AAAAgAAAgL8AAAAAAAAAgPMENb8AAAAA9QQ1v+wF0b7sBVE/6QXRvvMENb8AAAAA9QQ1vwAAAAD//3+/AAAAgAAAAAAAAAAAAACAvwAAgL8AAAAAAAAAgAAAAAD//3+/AAAAgAAAgL8AAAAAAAAAgAAAAAD//3+/AAAAgAAAAAAAAAAAAACAvwAAAAAAAAAAAACAv/MENb8AAAAA9QQ1v+wF0b7sBVE/6QXRvgAAAAAAAAAAAACAvwAAAAAAAAAAAACAv/IENb8AAAAA9AQ1v+wF0b7sBVE/6QXRvgAAAAAAAAAAAACAvwAAAAAAAAAAAACAv/sENb8AAAAA7QQ1v/IENb8AAAAA9AQ1vwAAAAAAAAAAAACAvwAAAAAAAAAAAACAvwAAAAAAAIA/AAAAgPsENb8AAAAA7QQ1vwAAAAAAAAAAAACAvwAAAAAAAIA/AAAAgAAAgL8AAAAAAAAAgAAAAAAAAIA/AAAAgAAAgL8AAAAAAAAAgP//f78AAAAAAAAAgAAAgL8AAAAAAAAAgPsENb8AAAAA7QQ1vwAAAAAAAIA/AAAAgAAAgL8AAAAAAAAAgP//f78AAAAAAAAAgPsENb8AAAAA7QQ1v/IENb8AAAAA9AQ1vwAAgL8AAAAAAAAAgP//f78AAAAAAAAAgPIENb8AAAAA9AQ1v+wF0b7sBVE/6QXRvgAAgL8AAAAAAAAAgP//f78AAAAAAAAAgADAfz8AwH8/AMB/PwDAfz+grwA8CshuPwDAfz8AwH8/AMB/PwDAfz/guPU7AENHPADAfz8AwH8/AMB/PwDAfz+m2ck+CshuPwDAfz8AwH8/AMB/PwDAfz8dAMo+AOZNPADAfz8AwH8/AMB/PwDAfz/guPU7GAW5PeC49TsYBbk9AMB/PwDAfz8dAMo+qNm5PR0Ayj6o2bk9AMB/PwDAfz+grwA8Z7ViP6CvADxntWI/AMB/PwDAfz+m2ck+bLViP6bZyT5stWI/AMB/PwDAfz8AwH8/AMB/P6CvADxOXmE/4Lj1O9RaSD8AwH8/AMB/P6bZyT5OXmE/HQDKPmZ1SD8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/ptnJPgrIbj8AwH8/AMB/PwDAfz8AwH8/ptnJPmy1Yj+m2ck+bLViP6CvADwKyG4/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/P6CvADxntWI/oK8APGe1Yj8AwH8/AMB/PwDAfz8AwH8/4Lj1O9RaSD+grwA8Tl5hPwDAfz8AwH8/AMB/PwDAfz/guPU7GAW5PeC49TsYBbk9AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/4Lj1OwBDRzwAwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/Px0Ayj4A5k08AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/HQDKPqjZuT0dAMo+qNm5PQDAfz8AwH8/AMB/PwDAfz8dAMo+ZnVIP6bZyT5OXmE/AMB/PwDAfz8AwH8/AMB/Py8AKwAJAC8ACQAQAAsABQAPAAsADwASACkALwAQACkAEAAdABEADgAcABEAHAAfACMAKgAWACMAFgAHABgAFQACABgAAgAIACwAIQAEACwABAAKACoAKQAdACoAHQAWAB4AGwAUAB4AFAAXABMAGQAnABMAJwAmAAAAEwAmAAAAJgAtABoADQAlABoAJQAoAAYAAQAuAAYALgAiAAwAAwAgAAwAIAAkADkAOwAzADkAMwAwADYAMQA0ADYANAA/ADwAOgAyADwAMgA3ADgAQQA+ADgAPgA9AEEARQBCAEEAQgA+AEUASQBGAEUARgBCAEkATQBKAEkASgBGAE4AVQBQAE4AUABLAFEATwBTAFEAUwBWAEcAWABUAEcAVABMAF8AUgBXAF8AVwBbAEMAXABZAEMAWQBIAEAANQBdAEAAXQBEADsAXgBaADsAWgAzAAAAgD8AAAAAj8L1PQAAgD8AAAAAj8L1PQAAgD8AAAAAj8L1PQAAgD+F6wFAzMzMPQAAgD+F6wFAzMzMPQAAgD+F6wFAzMzMPQAAgD+QwvU9j8L1PQAAgD+QwvU9j8L1PQAAgD+QwvU9j8L1PQAAgD+4HgU+zMzMPQAAgD+4HgU+zMzMPQAAgD+4HgU+zMzMPQAAAACF6wFA/czMPQAAAACF6wFA/czMPQAAAACF6wFA/czMPQAAAACF6wFA/czMPQAAAAC4HgU+/czMPQAAAAC4HgU+/czMPQAAAAC4HgU+/czMPQAAAAC4HgU+/czMPQAAAACQwvU9j8L1PQAAAACQwvU9j8L1PQAAAACQwvU9j8L1PQAAAACQwvU9j8L1PQAAgL8AAAAAj8L1PQAAgL8AAAAAj8L1PQAAgL8AAAAAj8L1PQAAgL+F6wFAzMzMPQAAgL+F6wFAzMzMPQAAgL+F6wFAzMzMPQAAgL+QwvU9j8L1PQAAgL+QwvU9j8L1PQAAgL+QwvU9j8L1PQAAgD/NzAxAzMzMPQAAgD/NzAxAzMzMPQAAgD/NzAxAzMzMPQAAAADNzAxA9MzMPQAAAADNzAxA9MzMPQAAAADNzAxA9MzMPQAAAADNzAxA9MzMPQAAAAAAAAAAj8L1PQAAAAAAAAAAj8L1PQAAAAAAAAAAj8L1PQAAgL/NzAxAzMzMPQAAgL/NzAxAzMzMPQAAgL/NzAxAzMzMPQAAgL+4HgU+zMzMPQAAgL+4HgU+zMzMPQAAgL+4HgU+zMzMPQAAgL8AAAAAAAAAgAAAgL8AAAAAAAAAgAAAgL/NzAxAAAAAgAAAgL/NzAxAAAAAgAAAAAAAAAAAAADAsgAAAADNzAxAAABINAAAAADNzAxAAABINAAAgL+QwvU9AAAAgAAAgL+4HgU+AAAAgAAAgL+F6wFAAAAAgAAAgD8AAAAAAAAAgAAAgD8AAAAAAAAAgAAAgD/NzAxAAAAAgAAAgD/NzAxAAAAAgAAAgD+4HgU+AAAAgAAAgD+QwvU9AAAAgAAAgD+F6wFAAAAAgAAAgD+F6wFAzMzMvQAAgD+F6wFAzMzMvQAAgD+F6wFAzMzMvcrMzD2F6wFAx8zMvcrMzD2F6wFAx8zMvcrMzD2F6wFAx8zMvcrMzD2F6wFAx8zMvQAAgD/NzAxAzMzMvQAAgD/NzAxAzMzMvQAAgD/NzAxAzMzMvQAAgD+4HgU+zMzMvQAAgD+4HgU+zMzMvQAAgD+4HgU+zMzMvQAAgD+F6wFAAAAAgAAAgD/NzAxAAAAAgAAAgD/NzAxAAAAAgAAAgD+4HgU+AAAAgAAAgD+QwvU9AAAAgAAAgD+QwvU9j8L1vQAAgD+QwvU9j8L1vQAAgD+QwvU9j8L1vQAAgD8AAAAAAAAAgAAAgD8AAAAAAAAAgAAAgD8AAAAAj8L1vQAAgD8AAAAAj8L1vQAAgD8AAAAAj8L1vQAAAAAAAAAAAADAso/C9T0AAAAAlcL1vY/C9T0AAAAAlcL1vY/C9T0AAAAAlcL1vQAAAAAAAAAAAACAvwAAAAAAAAAAAACAvwAAAACYwvU9AACAv4jC9T0AAAAAAACAv4jC9T0AAAAAAACAv4jC9T0AAAAAAACAv4jC9T2YwvU9AACAv4jC9T2YwvU9AACAv4jC9T2YwvU9AACAv4/C9T2QwvU9lcL1vY/C9T2QwvU9lcL1vY/C9T2QwvU9lcL1vY/C9T2QwvU9lcL1vcDMzD28HgU+AACAv8DMzD28HgU+AACAv8DMzD28HgU+AACAv8rMzD24HgU+x8zMvcrMzD24HgU+x8zMvcrMzD24HgU+x8zMvcrMzD24HgU+x8zMvcDMzD2E6wFAAACAv8DMzD2E6wFAAACAv8DMzD2E6wFAAACAvwAAAAC8HgU+AACAvwAAAACE6wFAAACAvwAAAADNzAxAAACAvwAAAADNzAxAAACAv8DMzD3NzAxAAACAv8DMzD3NzAxAAACAv8DMzD3NzAxAAACAvwAAAADNzAxAAABINAAAAADNzAxAAABINNDMzD3NzAxAwczMvdDMzD3NzAxAwczMvdDMzD3NzAxAwczMvdDMzD3NzAxAwczMvcDMzL3NzAxAAACAv8DMzL3NzAxAAACAv8DMzL3NzAxAAACAv9DMzL3NzAxAwczMvdDMzL3NzAxAwczMvdDMzL3NzAxAwczMvdDMzL3NzAxAwczMvcDMzL2E6wFAAACAv8DMzL2E6wFAAACAv8DMzL2E6wFAAACAvwAAAADNzAxAAACAvwAAAADNzAxAAACAvwAAAADNzAxAAABINAAAAADNzAxAAABINAAAAACE6wFAAACAvwAAAAC8HgU+AACAvwAAAACYwvU9AACAv8DMzL28HgU+AACAv8DMzL28HgU+AACAv8DMzL28HgU+AACAv8rMzL24HgU+x8zMvcrMzL24HgU+x8zMvcrMzL24HgU+x8zMvcrMzL24HgU+x8zMvYjC9b2YwvU9AACAv4jC9b2YwvU9AACAv4jC9b2YwvU9AACAv4/C9b2QwvU9lcL1vY/C9b2QwvU9lcL1vY/C9b2QwvU9lcL1vY/C9b2QwvU9lcL1vYjC9b0AAAAAAACAv4jC9b0AAAAAAACAv4jC9b0AAAAAAACAv4/C9b0AAAAAlcL1vY/C9b0AAAAAlcL1vY/C9b0AAAAAlcL1vY/C9b0AAAAAlcL1vQAAAAAAAAAAAACAvwAAAAAAAAAAAACAvwAAAAAAAAAAAADAsgAAAAAAAAAAAADAsgAAgL8AAAAAAAAAgAAAgL8AAAAAAAAAgAAAgL8AAAAAj8L1vQAAgL8AAAAAj8L1vQAAgL8AAAAAj8L1vQAAgL+QwvU9AAAAgAAAgL+QwvU9j8L1vQAAgL+QwvU9j8L1vQAAgL+QwvU9j8L1vQAAgL+4HgU+AAAAgAAAgL+4HgU+zMzMvQAAgL+4HgU+zMzMvQAAgL+4HgU+zMzMvQAAgL+F6wFAAAAAgAAAgL+F6wFAzMzMvQAAgL+F6wFAzMzMvQAAgL+F6wFAzMzMvQAAgL/NzAxAAAAAgAAAgL/NzAxAAAAAgAAAgL/NzAxAzMzMvQAAgL/NzAxAzMzMvQAAgL/NzAxAzMzMvcrMzL2F6wFAx8zMvcrMzL2F6wFAx8zMvcrMzL2F6wFAx8zMvcrMzL2F6wFAx8zMvQAAAAAAAIC/AAAAgAAAAAAAAAAAAACAPwAAgD8AAAAAAAAAgP//sTQ3PDw0AACAPwAAxDQAAAAAAACAPwAAgD8AAAAAAAAAgAAAAAAAAAAAAACAPwHjsjMX+WQ/jfnkPgAAgD8AAAAAAAAAgAHjsjMX+WQ/jfnkPgAAxDQAAAAAAACAPwAAgD8AAAAAAAAAgAAAxLQAAAAAAACAP/n/sbQ3PDw0AACAP///sTQ3PDw0AACAPwAAxDQAAAAAAACAPwAAxLQAAAAAAACAPwHjsrMX+WQ/jfnkPgHjsjMX+WQ/jfnkPgAAxDQAAAAAAACAPwHjsrMX+WQ/jfnkPgAAAAAAAAAAAACAPwAAAAAAAAAAAACAPwHjsjMX+WQ/jfnkPgAAgL8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAPwAAgL8AAAAAAAAAgAAAxLQAAAAAAACAP/n/sbQ3PDw0AACAPwAAgL8AAAAAAAAAgAHjsrMX+WQ/jfnkPgAAAAAAAAAAAACAP/r/n7P//38/AAAAgP//sTQ3PDw0AACAPwAAgD8AAAAAAAAAgPn/sbQ3PDw0AACAP/r/n7P//38/AAAAgAAAAAD//38/AAAAgP//sTQ3PDw0AACAPwAAAAAAAIC/AAAAgAAAAAAAAAAAAACAPwAAAAAAAAAAAACAPwAAgL8AAAAAAAAAgPn/sbQ3PDw0AACAPwAAAAD//38/AAAAgAAAgL8AAAAAAAAAgAAAxLQAAAAAAACAPwHjsrMX+WQ/jfnkPgAAgL8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAgL8AAAAAAAAAgAAAAAD//38/AAAAgAAAAAAAAIC/AAAAgPr/n7P//38/AAAAgAAAAAD//38/AAAAgAAAgL8AAAAAAAAAgAAAgL8AAAAAAAAAgAAAgL8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAgD8AAAAAAAAAgPr/n7P//38/AAAAgAAAgD8AAAAAAAAAgAAAgD8AAAAAAAAAgAAAgD8AAAAAAAAAgAAAgD8AAAAAAAAAgOM4jrPY3Bw0AACAvxzHMbMAAAAAAACAvwAAgD8AAAAAAAAAgOM4jrPY3Bw0AACAvxzHMbMAAAAAAACAvwAAgD8ZLQ20KEvrswAAgD8AAAAAs57Cs+M4jrPY3Bw0AACAv8G8hjIAAIA/AAAAgAAAgD8AAAAAAAAAgBzHMbMAAAAAAACAv9rLIDE1+WQ/C/nkvgAAgD8AAAAAAAAAgAAAgD8AAAAAAAAAgMG8hjIAAIA/AAAAgAAAgD8AAAAAAAAAgAAAgD8AAAAAAAAAgAAAgD8AAAAAAAAAgNrLIDE1+WQ/C/nkvosuWjMAAAAA//9/vwAAgD8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAgD8AAAAAAAAAgAAAAAAAAIC/AAAAgIsuWjMAAAAA//9/vwAAgD8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAAAAAAIC/AAAAgIsuWjMAAAAA//9/vwAAgD8AAAAAWXSRswAAAAAAAIC/AAAAgAAAAAAAAAAAAACAvwAAAAAAAAAAAACAvwAAAAAAAIC/AAAAgAAAAAAAAAAAAACAvwAAgD8AAAAAWXSRswAAAAAAAAAAAACAvxT55D40+WQ/8THxMgAAgD8AAAAAWXSRs9rLIDE1+WQ/C/nkvosuWjMAAAAA//9/vxT55D40+WQ/8THxMgAAgD8AAAAAWXSRswAAAAAAAAAAAACAvxT55D40+WQ/8THxMgAAgD8AAAAAs57CsxzHMbMAAAAAAACAv9rLIDE1+WQ/C/nkvhT55D40+WQ/8THxMgAAgD8AAAAAs57CswAAAAAAAAAAAACAvwAAgD8ZLQ20KEvrswAAgD8AAAAAs57CswAAAAAAAAAAAACAvwAAAAAAAAAAAACAvwAAAAAAAAAAAACAvwAAAAAAAIA/AAAAgAAAAAAAAAAAAACAvwAAAAAAAIA/AAAAgAAAgD8ZLQ20KEvrswAAAAAAAIA/AAAAgMG8hjIAAIA/AAAAgOM4jrPY3Bw0AACAvwAAAAAAAIA/AAAAgMG8hjIAAIA/AAAAgAAAgD8ZLQ20KEvrswAAgL8ZLQ20KEvrswAAAAAAAAAAAACAvwAAAAAAAIA/AAAAgAAAgL8ZLQ20KEvrswAAAAAAAIA/AAAAgOM4jjMYxzE0AACAv8ZrKDQAAIA/AAAAgAAAgL8ZLQ20KEvrswAAgL8AAAAAcSK7swAAAAAAAAAAAACAvwAAAAAAAAAAAACAvwAAAAAAAIA/AAAAgAAAAAAAAIA/AAAAgMZrKDQAAIA/AAAAgAAAAAAAAAAAAACAvwAAAAAAAAAAAACAvwAAAAAAAAAAAACAvwAAgL8AAAAAcSK7sxT55L40+WQ/Sj77MgAAAAAAAAAAAACAvwAAgL8AAAAAcSK7sxT55L40+WQ/Sj77MgAAAAA3+WQ/C/nkvhzHMTMAAAAAAACAvwAAgL8AAAAA34OXsxT55L40+WQ/Sj77MgAAAAAAAAAAAACAvwAAgL8AAAAA34OXsxT55L40+WQ/Sj77MosuWrMAAAAA//9/vwAAAAA3+WQ/C/nkvgAAgL8AAAAA34OXswAAAAAAAIC/AAAAgAAAAAAAAAAAAACAvwAAgL8AAAAA34OXs4suWrMAAAAA//9/vwAAAAAAAIC/AAAAgAAAAAD//3+/AAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAvwAAAAAAAIC/AAAAgAAAAAD//3+/AAAAgAAAgL8AAAAAAAAAgAAAAAD//3+/AAAAgAAAgL8AAAAAAAAAgIsuWrMAAAAA//9/vwAAAAD//3+/AAAAgAAAgL8AAAAAAAAAgAAAgL8AAAAAAAAAgIsuWrMAAAAA//9/vwAAAAA3+WQ/C/nkvgAAgL8AAAAAAAAAgAAAgL8AAAAAAAAAgAAAAAA3+WQ/C/nkvhzHMTMAAAAAAACAvwAAgL8AAAAAAAAAgAAAgL8AAAAAAAAAgBzHMTMAAAAAAACAv+M4jjMYxzE0AACAvwAAgL8AAAAAAAAAgMZrKDQAAIA/AAAAgAAAgL8AAAAAAAAAgOM4jjMYxzE0AACAv8ZrKDQAAIA/AAAAgAAAgL8ZLQ20KEvrswAAgL8AAAAAcSK7sxzHMTMAAAAAAACAv+M4jjMYxzE0AACAvwDAfz8AwH8/ptnJPgrIbj8AwH8/AMB/Px0Ayj6o2bk9HQDKPqjZuT0AwH8/AMB/P6bZyT5stWI/ptnJPmy1Yj8AwH8/AMB/P6bZyT5OXmE/HQDKPmZ1SD8AwH8/AMB/PxwAyj4YBbk9HADKPhgFuT3guPU7GAW5PeC49TsYBbk9HADKPtRaSD+D0ck+Tl5hP6CvADxOXmE/4Lj1O9RaSD+D0ck+Z7ViP6CvADxntWI/g9HJPme1Yj+grwA8Z7ViPwDAfz8AwH8/AMB/PwDAfz+AVv87CshuPwDAfz8AwH8/wLj1O6jZuT3AuPU7qNm5PQDAfz8AwH8/gFb/O2y1Yj+AVv87bLViPwDAfz8AwH8/HQDKPgDmTTwAwH8/AMB/PxwAyj4AQ0c8AMB/PwDAfz8AwH8/AMB/P+C49TsAQ0c8AMB/PwDAfz+grwA8CshuP4PRyT4KyG4/AMB/PwDAfz/AuPU7AOZNPADAfz8AwH8/AMB/PwDAfz/AuPU7ZnVIP4BW/ztOXmE/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/P+C49TsYBbk94Lj1OxgFuT0AwH8/AMB/Px0Ayj6o2bk9HQDKPqjZuT3guPU7GAW5PeC49TsYBbk94Lj1OwBDRzwAwH8/AMB/PwDAfz8AwH8/4Lj1O9RaSD+grwA8Tl5hPwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/P6CvADxntWI/oK8APGe1Yj8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/P6CvADwKyG4/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/ptnJPgrIbj+grwA8CshuPwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz+m2ck+CshuPwDAfz8AwH8/ptnJPmy1Yj+m2ck+bLViP6bZyT5stWI/ptnJPmy1Yj+grwA8Z7ViP6CvADxntWI/AMB/PwDAfz+m2ck+Tl5hPx0Ayj5mdUg/HQDKPmZ1SD+m2ck+Tl5hP6CvADxOXmE/4Lj1O9RaSD8AwH8/AMB/Px0Ayj6o2bk9HQDKPqjZuT0AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8dAMo+AOZNPADAfz8AwH8/AMB/PwDAfz8dAMo+AOZNPADAfz8AwH8/AMB/PwDAfz/guPU7AENHPB0Ayj4A5k08AMB/PwDAfz8AwH8/AMB/P+C49TsAQ0c8AMB/PwDAfz8dAMo+AOZNPADAfz8AwH8/HQDKPqjZuT0dAMo+qNm5PQDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8dAMo+ZnVIP6bZyT5OXmE/AMB/PwDAfz/guPU71FpIP6CvADxOXmE/ptnJPk5eYT8dAMo+ZnVIP6bZyT5stWI/ptnJPmy1Yj8AwH8/AMB/P6CvADxntWI/oK8APGe1Yj+m2ck+bLViP6bZyT5stWI/ptnJPgrIbj8AwH8/AMB/PwDAfz8AwH8/oK8APArIbj+m2ck+CshuPwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/P6CvADwKyG4/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/oK8APGe1Yj+grwA8Z7ViPwDAfz8AwH8/AMB/PwDAfz+grwA8Tl5hP+C49TvUWkg/AMB/PwDAfz8AwH8/AMB/P+C49TsYBbk94Lj1OxgFuT0AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz/guPU7AENHPADAfz8AwH8/4Lj1OxgFuT3guPU7GAW5PR0Ayj6o2bk9HQDKPqjZuT0JABIAFwAJABcABwAGABUAKQAGACkAAQAEAA8AEwAEABMACgAiACcADgAiAA4AAwAwAB8AFAAwABQAEQAgABoAKgAgACoAFgAcAC8AEAAcABAADAAsAB0ADQAsAA0AJABBAD4AIwBBACMABQA/AEEABQA/AAUACwA8AEAACAA8AAgAAgBAAD8ACwBAAAsACAA6ABsAKwA6ACsAMwA5AC4AGwA5ABsAOgAxABgAHgAxAB4AOAA4AB4ALgA4AC4AOQA0AC0AJgA0ACYANwAZADIANQAZADUAKAAoADUAOwAoADsAAAAlACEAPQAlAD0ANgBCAEUAgABCAIAASQBMAHAARgBMAEYAQwBEAEsAUQBEAFEATwBOAEQATwBOAE8AUgBWAE4AUgBWAFIAUwBbAFYAUwBbAFMAWABcAF0AWQBcAFkAVwBcAGAAYwBcAGMAXQBkAGEAYgBkAGIAZgBfAGUAaABfAGgAbABrAGcAbgBrAG4AcgBmAGIAdwBmAHcAbQBzAG8AdgBzAHYASABtAHcAeABtAHgAdAB0AHgAeQB0AHkAewB6AH4AgQB6AIEAfAB/AFAASgB/AEoAggBHAHUAfQBHAH0AgwBUAGkAcQBUAHEATQBaAF4AagBaAGoAVQCQAI8AhgCQAIYAiADEAIcAhADEAIQAiwCSAI0AhQCSAIUAjgCTAJcAjQCTAI0AkgCUAJ4AlwCUAJcAkwCgAJkAlgCgAJYAnQCYAMUAjACYAIwAlQCmAJ8AnACmAJwAowCrAKUAngCrAJ4AlACqAKwAqACqAKgApACvALIAqQCvAKkArQCwAK4AswCwALMAtAC0ALMAtwC0ALcAuAC4ALcAuwC4ALsAvAC8ALsAvwC8AL8AwQDDAMAAkQDDAJEAigC+AMIAiQC+AIkAxwC6AL0AxgC6AMYAmwC2ALkAmgC2AJoAogCxALUAoQCxAKEApwBCi2y/pHBdPx6F6z1Ci2y/pHBdPx6F6z1Ci2y/pHBdPx6F6z1Ci2y/pHBdPwAAAL5Ci2y/pHBdPwAAAL5Ci2y/pHBdPwAAAL5Ci2y/cD1qPx6F6z1Ci2y/cD1qPx6F6z1Ci2y/cD1qPx6F6z1Ci2w/pHBdPx6F6z1Ci2w/pHBdPx6F6z1Ci2w/pHBdPx6F6z1Ci2w/pHBdPwAAAL5Ci2w/pHBdPwAAAL5Ci2w/pHBdPwAAAL5Ci2w/cD1qPx6F6z1Ci2w/cD1qPx6F6z1Ci2w/cD1qPx6F6z1Ci2w/cD1qPwAAAL5Ci2w/cD1qPwAAAL5Ci2w/cD1qPwAAAL5Ci2y/cD1qPwAAAL5Ci2y/cD1qPwAAAL5Ci2y/cD1qPwAAAL4AAAAApHBdPx6F6z0AAAAApHBdPx6F6z0AAAAApHBdPx6F6z0AAAAApHBdPx6F6z0AAAAAcD1qPx6F6z0AAAAAcD1qPx6F6z0AAAAAcD1qPx6F6z0AAAAAcD1qPx6F6z0AAAAAcD1qPwAAAL4AAAAAcD1qPwAAAL4AAAAAcD1qPwAAAL4AAAAAcD1qPwAAAL4AAAAApHBdPwAAAL4AAAAApHBdPwAAAL4AAAAApHBdPwAAAL4AAAAApHBdPwAAAL7+/3+/AAAAAI/C9T3+/3+/AAAAAI/C9T3+/3+/AAAAAI/C9T3+/3+/zcwMQMzMzD3+/3+/zcwMQMzMzD3+/3+/zcwMQMzMzD3+/3+/hesBQMzMzD3+/3+/hesBQMzMzD3+/3+/hesBQMzMzD3+/3+/hesBQMzMzD3+/3+/kML1PY/C9T3+/3+/kML1PY/C9T3+/3+/kML1PY/C9T3+/3+/kML1PY/C9T3+/3+/uB4FPszMzD3+/3+/uB4FPszMzD3+/3+/uB4FPszMzD3+/3+/uB4FPszMzD0AAIA/zcwMQMzMzD0AAIA/zcwMQMzMzD0AAIA/zcwMQMzMzD0AAIA/hesBQMzMzD0AAIA/hesBQMzMzD0AAIA/hesBQMzMzD0AAIA/uB4FPszMzD0AAIA/uB4FPszMzD0AAIA/uB4FPszMzD0AAIA/kML1PY/C9T0AAIA/kML1PY/C9T0AAIA/kML1PY/C9T0AAIA/AAAAAI/C9T0AAIA/AAAAAI/C9T0AAIA/AAAAAI/C9T21HmW/zcwMQMzMzD21HmW/zcwMQMzMzD24HmU/zcwMQMzMzD24HmU/zcwMQMzMzD24HmU/hesBQMzMzD24HmU/hesBQMzMzD24HmU/hesBQMzMzD24HmU/hesBQMzMzD21HmW/hesBQMzMzD21HmW/hesBQMzMzD21HmW/hesBQMzMzD21HmW/hesBQMzMzD24HmU/uB4FPszMzD24HmU/uB4FPszMzD24HmU/uB4FPszMzD24HmU/uB4FPszMzD21HmW/uB4FPszMzD21HmW/uB4FPszMzD21HmW/uB4FPszMzD21HmW/uB4FPszMzD21HmW/kML1PY/C9T21HmW/kML1PY/C9T21HmW/kML1PY/C9T21HmW/kML1PY/C9T24HmU/kML1PY/C9T24HmU/kML1PY/C9T24HmU/kML1PY/C9T24HmU/kML1PY/C9T21HmW/AAAAAI/C9T21HmW/AAAAAI/C9T21HmW/AAAAAI/C9T24HmU/AAAAAI/C9T24HmU/AAAAAI/C9T24HmU/AAAAAI/C9T0AAIC/ZmZmP8zMzD0AAIC/ZmZmP8zMzD0AAIC/ZmZmP8zMzD0AAIC/ZmZmP8zMzD0AAIA/ZmZmP8zMzD0AAIA/ZmZmP8zMzD0AAIA/ZmZmP8zMzD21HmW/ZmZmP1WjzD21HmW/ZmZmP1WjzD21HmW/ZmZmP1WjzD21HmW/ZmZmP1WjzD21HmW/ZmZmP1WjzD24HmU/ZmZmP1WjzD24HmU/ZmZmP1WjzD24HmU/ZmZmP1WjzD24HmU/ZmZmP1WjzD24HmU/ZmZmP1WjzD0AAAAAzcwMQMzMzD0AAAAAzcwMQMzMzD0AAAAAzcwMQMzMzD0AAAAAhesBQMzMzD0AAAAAhesBQMzMzD0AAAAAhesBQMzMzD0AAAAAhesBQMzMzD0AAAAAuB4FPszMzD0AAAAAuB4FPszMzD0AAAAAuB4FPszMzD0AAAAAuB4FPszMzD0AAAAAkML1PY/C9T0AAAAAkML1PY/C9T0AAAAAkML1PY/C9T0AAAAAkML1PY/C9T0AAAAAAAAAAI/C9T0AAAAAAAAAAI/C9T0AAAAAAAAAAI/C9T0AAIAzZmZmP1WjzD0AAIAzZmZmP1WjzD0AAIAzZmZmP1WjzD0AAIAzZmZmP1WjzD0vHGe/6iUCQPz8Zj3zKFy/Urj+P/z8Zj3zKFy/Urj+P/z8Zj3zKFy/Urj+P/z8Zj0vHGc/6iUCQP38Zj0vHGc/6iUCQP38Zj0vHGe/6iUCQGH5h70vHGe/6iUCQGH5h70wHGe/0nxlP/z8Zj3zKFy/16NwP/z8Zj3zKFy/16NwP/z8Zj3zKFy/16NwP/z8Zj0uHGc/0nxlP/38Zj0uHGc/0nxlP/38Zj0wHGe/0nxlP2H5h73zKFy/16NwP2H5h73zKFy/16NwP2H5h73zKFy/16NwP2H5h70uHGc/0nxlP2H5h70vHGc/6iUCQGH5h73yKFw/16NwP2H5h73yKFw/16NwP2H5h73yKFw/16NwP2H5h73zKFw/Urj+P2H5h73zKFw/Urj+P2H5h73zKFw/Urj+P2H5h73yKFw/16NwP8aQ+bzyKFw/16NwP8aQ+bzyKFw/16NwP8aQ+bzyKFw/16NwP8aQ+bzzKFy/16NwP8aQ+bzzKFy/16NwP8aQ+bzzKFy/16NwP8aQ+bzyKFw/16NwP0Klp7zyKFw/16NwP0Klp7zyKFw/16NwP0Klp7zzKFw/Urj+P8aQ+bzzKFw/Urj+P8aQ+bzzKFw/Urj+P8aQ+bzzKFw/Urj+P8aQ+byYxGA/16NwP8aQ+byYxGA/16NwP8aQ+byYxGA/16NwP8aQ+byYxGA/16NwP0Klp7yYxGA/16NwP0Klp7yYxGA/16NwP0Klp7yYxGA/Urj+P8aQ+byYxGA/Urj+P8aQ+byYxGA/Urj+P8aQ+byYxGA/Urj+P0Klp7yYxGA/Urj+P0Klp7yYxGA/Urj+P0Klp7zzKFw/Urj+P0Klp7zzKFw/Urj+P0Klp7zzKFw/Urj+P0Klp7zzKFw/Urj+P0Klp7zzKFy/Urj+P0Klp7zzKFy/Urj+P0Klp7zzKFy/Urj+P0Klp7zzKFy/Urj+P0Klp7zzKFw/Urj+P25zKzzzKFw/Urj+P25zKzzzKFw/Urj+P25zKzzyKFw/16NwP25zKzzyKFw/16NwP25zKzzyKFw/16NwP25zKzzzKFw/Urj+PzylpzzzKFw/Urj+PzylpzzzKFw/Urj+PzylpzzzKFy/Urj+P25zKzzzKFy/Urj+P25zKzzzKFy/Urj+P25zKzyYxGA/Urj+P25zKzyYxGA/Urj+P25zKzyYxGA/Urj+P25zKzyYxGA/16NwP25zKzyYxGA/16NwP25zKzyYxGA/16NwP25zKzyYxGA/Urj+PzylpzyYxGA/Urj+PzylpzyYxGA/Urj+PzylpzyYxGA/16NwPzylpzyYxGA/16NwPzylpzyYxGA/16NwPzylpzzyKFw/16NwPzylpzzyKFw/16NwPzylpzzyKFw/16NwPzylpzzzKFy/16NwPzylpzzzKFy/16NwPzylpzzzKFy/16NwPzylpzzzKFy/16NwPzylpzzyKFw/16NwP/38Zj3yKFw/16NwP/38Zj3yKFw/16NwP/38Zj3yKFw/16NwP/38Zj3zKFw/Urj+P/38Zj3zKFw/Urj+P/38Zj3zKFw/Urj+P/38Zj3zKFw/Urj+P/38Zj3zKFy/16NwP25zKzzzKFy/16NwP25zKzzzKFy/16NwP25zKzzzKFy/Urj+PzylpzzzKFy/Urj+PzylpzzzKFy/Urj+PzylpzyZxGC/16NwPzylpzyZxGC/16NwPzylpzyZxGC/16NwPzylpzyZxGC/16NwP25zKzyZxGC/16NwP25zKzyZxGC/16NwP25zKzyYxGC/Urj+PzylpzyYxGC/Urj+PzylpzyYxGC/Urj+PzylpzyYxGC/Urj+P25zKzyYxGC/Urj+P25zKzyYxGC/Urj+P25zKzzzKFy/16NwP0Klp7zzKFy/16NwP0Klp7zzKFy/16NwP0Klp7yZxGC/16NwP0Klp7yZxGC/16NwP0Klp7yZxGC/16NwP0Klp7yZxGC/16NwP8aQ+byZxGC/16NwP8aQ+byZxGC/16NwP8aQ+byYxGC/Urj+P0Klp7yYxGC/Urj+P0Klp7yYxGC/Urj+P0Klp7yYxGC/Urj+P8aQ+byYxGC/Urj+P8aQ+byYxGC/Urj+P8aQ+bzzKFy/Urj+P8aQ+bzzKFy/Urj+P8aQ+bzzKFy/Urj+P8aQ+bzzKFy/Urj+P8aQ+bzzKFy/Urj+P2H5h73zKFy/Urj+P2H5h73zKFy/Urj+P2H5h73zKFy/Urj+P2H5h70AAAAA6iUCQPz8Zj0AAAAA6iUCQPz8Zj0AAAAAUrj+P0Klp7wAAAAAUrj+P25zKzwAAAAAUrj+P/z8Zj0AAAAAUrj+P/z8Zj0AAAAAUrj+P/z8Zj0AAAAAUrj+PzylpzwAAAAAUrj+P8aQ+bwAAAAAUrj+P8aQ+bwAAAAAUrj+P2H5h70AAAAAUrj+P2H5h70AAAAAUrj+P2H5h70AAAAA6iUCQGH5h70AAAAA6iUCQGH5h70AAICz0nxlP/z8Zj0AAICz0nxlP/z8Zj0AAICz0nxlP2H5h70AAICz16NwP2H5h70AAICz16NwP2H5h70AAICz16NwP2H5h70AAICz16NwP8aQ+bwAAICz16NwP8aQ+bwAAICz16NwPzylpzwAAICz16NwPzylpzwAAICz16NwP/z8Zj0AAICz16NwP/z8Zj0AAICz16NwP/z8Zj0AAICz16NwP/z8Zj0AAICz16NwP25zKzwAAICz16NwP0Klp7x+JV2/1BYAQE5127t+JV2/1BYAQE5127t+JV2/1BYAQE5127t+JV2/1BYAQE5127uUB1W/E/H6P05127uUB1W/E/H6P05127uUB1W/E/H6P05127uUB1W/E/H6P05127t+JV2/1BYAQBleMb1+JV2/1BYAQBleMb1+JV2/1BYAQBleMb1+JV2/1BYAQBleMb1+JV2/JNm4P05127t+JV2/JNm4P05127t+JV2/JNm4P05127t+JV2/JNm4P05127sGiJO+1BYAQE5127sGiJO+1BYAQE5127sGiJO+1BYAQE5127sGiJO+1BYAQE5127vaw6O+E/H6P05127vaw6O+E/H6P05127vaw6O+E/H6P05127vaw6O+E/H6P05127sGiJO+1BYAQBleMb0GiJO+1BYAQBleMb0GiJO+1BYAQBleMb0GiJO+1BYAQBleMb0HiJO+JNm4P05127sHiJO+JNm4P05127sHiJO+JNm4P05127sHiJO+JNm4P05127vaw6O+uhW+P05127vaw6O+uhW+P05127vaw6O+uhW+P05127vaw6O+uhW+P05127sHiJO+JNm4PxleMb0HiJO+JNm4PxleMb0HiJO+JNm4PxleMb0HiJO+JNm4PxleMb3aw6O+uhW+PxleMb3aw6O+uhW+PxleMb3aw6O+uhW+PxleMb3aw6O+uhW+PxleMb1+JV2/JNm4PxleMb1+JV2/JNm4PxleMb1+JV2/JNm4PxleMb1+JV2/JNm4PxleMb2UB1W/uhW+PxleMb2UB1W/uhW+PxleMb2UB1W/uhW+PxleMb2UB1W/uhW+PxleMb2UB1W/uhW+P05127uUB1W/uhW+P05127uUB1W/uhW+P05127uUB1W/uhW+P05127uUB1W/E/H6PxleMb2UB1W/E/H6PxleMb2UB1W/E/H6PxleMb2UB1W/E/H6PxleMb3aw6O+E/H6PxleMb3aw6O+E/H6PxleMb3aw6O+E/H6PxleMb3aw6O+E/H6PxleMb1+JV2/pI29P2doCD1+JV2/pI29P2doCD1+JV2/pI29P2doCD2UB1W/D1G4P2doCD2UB1W/D1G4P2doCD2UB1W/D1G4P2doCD1+JV2/pI29P5RwWLt+JV2/pI29P5RwWLt+JV2/pI29P5RwWLt+JV2/pI29P5RwWLt+JV2/QHJsP2doCD1+JV2/QHJsP2doCD1+JV2/QHJsP2doCD1+JV2/QHJsP2doCD2UB1W/D1G4P5RwWLuUB1W/D1G4P5RwWLuUB1W/D1G4P5RwWLuUB1W/D1G4P5RwWLuUB1W/bOt2P5RwWLuUB1W/bOt2P5RwWLuUB1W/bOt2P5RwWLuUB1W/bOt2P5RwWLt+JV2/QHJsP5RwWLt+JV2/QHJsP5RwWLt+JV2/QHJsP5RwWLt+JV2/QHJsP5RwWLuUB1W/bOt2P2doCD2UB1W/bOt2P2doCD2UB1W/bOt2P2doCD2UB1W/bOt2P2doCD0HiJO+QHJsP2doCD0HiJO+QHJsP2doCD0HiJO+QHJsP2doCD0HiJO+QHJsP2doCD0GiJO+pI29P2doCD0GiJO+pI29P2doCD0GiJO+pI29P2doCD0GiJO+pI29P2doCD3aw6O+bOt2P2doCD3aw6O+bOt2P2doCD3aw6O+bOt2P2doCD3aw6O+bOt2P2doCD0HiJO+QHJsP5RwWLsHiJO+QHJsP5RwWLsHiJO+QHJsP5RwWLsHiJO+QHJsP5RwWLsGiJO+pI29P5RwWLsGiJO+pI29P5RwWLsGiJO+pI29P5RwWLsGiJO+pI29P5RwWLvaw6O+bOt2P5RwWLvaw6O+bOt2P5RwWLvaw6O+bOt2P5RwWLvaw6O+bOt2P5RwWLvaw6O+D1G4P5RwWLvaw6O+D1G4P5RwWLvaw6O+D1G4P5RwWLvaw6O+D1G4P5RwWLvaw6O+D1G4P2doCD3aw6O+D1G4P2doCD3aw6O+D1G4P2doCD3aw6O+D1G4P2doCD0yyRa/4xK6P1TF9DwyyRa/4xK6P1TF9DwyyRa/4xK6P4Bn/TgyyRa/4xK6P4Bn/ThPIBC/4xK6P4Bn/ThPIBC/4xK6P4Bn/TgyyRa/xGdzP4Bn/TgyyRa/xGdzP4Bn/ThPIBC/xGdzP4Bn/ThPIBC/xGdzP4Bn/TgyyRa/xGdzP1TF9DwyyRa/xGdzP1TF9DxPIBC/xGdzP1TF9DxPIBC/xGdzP1TF9DxPIBC/4xK6P1TF9DxPIBC/4xK6P1TF9DyDYZO+1BYAQE5127uDYZO+1BYAQE5127uDYZO+1BYAQE5127uDYZO+1BYAQE5127uwJYO+E/H6P05127uwJYO+E/H6P05127uwJYO+E/H6P05127uwJYO+E/H6P05127uDYZO+1BYAQBleMb2DYZO+1BYAQBleMb2DYZO+1BYAQBleMb2DYZO+1BYAQBleMb2DYZO+JNm4P05127uDYZO+JNm4P05127uDYZO+JNm4P05127uDYZO+JNm4P05127txYZM+1BYAQE5127txYZM+1BYAQE5127txYZM+1BYAQE5127txYZM+1BYAQE5127ueJYM+E/H6P05127ueJYM+E/H6P05127ueJYM+E/H6P05127ueJYM+E/H6P05127txYZM+1BYAQBleMb1xYZM+1BYAQBleMb1xYZM+1BYAQBleMb1xYZM+1BYAQBleMb1xYZM+JNm4P05127txYZM+JNm4P05127txYZM+JNm4P05127txYZM+JNm4P05127ueJYM+uhW+P05127ueJYM+uhW+P05127ueJYM+uhW+P05127ueJYM+uhW+P05127txYZM+JNm4PxleMb1xYZM+JNm4PxleMb1xYZM+JNm4PxleMb1xYZM+JNm4PxleMb2eJYM+uhW+PxleMb2eJYM+uhW+PxleMb2eJYM+uhW+PxleMb2eJYM+uhW+PxleMb2DYZO+JNm4PxleMb2DYZO+JNm4PxleMb2DYZO+JNm4PxleMb2DYZO+JNm4PxleMb2wJYO+uhW+PxleMb2wJYO+uhW+PxleMb2wJYO+uhW+PxleMb2wJYO+uhW+PxleMb2wJYO+uhW+P05127uwJYO+uhW+P05127uwJYO+uhW+P05127uwJYO+uhW+P05127uwJYO+E/H6PxleMb2wJYO+E/H6PxleMb2wJYO+E/H6PxleMb2wJYO+E/H6PxleMb2eJYM+E/H6PxleMb2eJYM+E/H6PxleMb2eJYM+E/H6PxleMb2eJYM+E/H6PxleMb2DYZO+pI29P2doCD2DYZO+pI29P2doCD2DYZO+pI29P2doCD2DYZO+pI29P2doCD2wJYO+D1G4P2doCD2wJYO+D1G4P2doCD2wJYO+D1G4P2doCD2wJYO+D1G4P2doCD2DYZO+pI29P5RwWLuDYZO+pI29P5RwWLuDYZO+pI29P5RwWLuDYZO+pI29P5RwWLuDYZO+QHJsP2doCD2DYZO+QHJsP2doCD2DYZO+QHJsP2doCD2DYZO+QHJsP2doCD2wJYO+D1G4P5RwWLuwJYO+D1G4P5RwWLuwJYO+D1G4P5RwWLuwJYO+D1G4P5RwWLuwJYO+bOt2P5RwWLuwJYO+bOt2P5RwWLuwJYO+bOt2P5RwWLuwJYO+bOt2P5RwWLuDYZO+QHJsP5RwWLuDYZO+QHJsP5RwWLuDYZO+QHJsP5RwWLuDYZO+QHJsP5RwWLuwJYO+bOt2P2doCD2wJYO+bOt2P2doCD2wJYO+bOt2P2doCD2wJYO+bOt2P2doCD1xYZM+QHJsP2doCD1xYZM+QHJsP2doCD1xYZM+QHJsP2doCD1xYZM+QHJsP2doCD1xYZM+pI29P2doCD1xYZM+pI29P2doCD1xYZM+pI29P2doCD1xYZM+pI29P2doCD2eJYM+bOt2P2doCD2eJYM+bOt2P2doCD2eJYM+bOt2P2doCD2eJYM+bOt2P2doCD1xYZM+QHJsP5RwWLtxYZM+QHJsP5RwWLtxYZM+QHJsP5RwWLtxYZM+QHJsP5RwWLtxYZM+pI29P5RwWLtxYZM+pI29P5RwWLtxYZM+pI29P5RwWLtxYZM+pI29P5RwWLueJYM+bOt2P5RwWLueJYM+bOt2P5RwWLueJYM+bOt2P5RwWLueJYM+bOt2P5RwWLueJYM+D1G4P5RwWLueJYM+D1G4P5RwWLueJYM+D1G4P5RwWLueJYM+D1G4P5RwWLueJYM+D1G4P2doCD2eJYM+D1G4P2doCD2eJYM+D1G4P2doCD2eJYM+D1G4P2doCD1mHVW84xK6P1TF9DxmHVW84xK6P1TF9DxmHVW84xK6P4Bn/ThmHVW84xK6P4Bn/ThmG1U84xK6P4Bn/ThmG1U84xK6P4Bn/ThmHVW8xGdzP4Bn/ThmHVW8xGdzP4Bn/ThmG1U8xGdzP4Bn/ThmG1U8xGdzP4Bn/ThmHVW8xGdzP1TF9DxmHVW8xGdzP1TF9DxmG1U8xGdzP1TF9DxmG1U8xGdzP1TF9DxmG1U84xK6P1TF9DxmG1U84xK6P1TF9Dzxh5M+1BYAQE5127vxh5M+1BYAQE5127vxh5M+1BYAQE5127vxh5M+1BYAQE5127vFw6M+E/H6P05127vFw6M+E/H6P05127vFw6M+E/H6P05127vFw6M+E/H6P05127vxh5M+1BYAQBleMb3xh5M+1BYAQBleMb3xh5M+1BYAQBleMb3xh5M+1BYAQBleMb3xh5M+JNm4P05127vxh5M+JNm4P05127vxh5M+JNm4P05127vxh5M+JNm4P05127tzJV0/1BYAQE5127tzJV0/1BYAQE5127tzJV0/1BYAQE5127tzJV0/1BYAQE5127uJB1U/E/H6P05127uJB1U/E/H6P05127uJB1U/E/H6P05127uJB1U/E/H6P05127tzJV0/1BYAQBleMb1zJV0/1BYAQBleMb1zJV0/1BYAQBleMb1zJV0/1BYAQBleMb1zJV0/JNm4P05127tzJV0/JNm4P05127tzJV0/JNm4P05127tzJV0/JNm4P05127uJB1U/uhW+P05127uJB1U/uhW+P05127uJB1U/uhW+P05127uJB1U/uhW+P05127tzJV0/JNm4PxleMb1zJV0/JNm4PxleMb1zJV0/JNm4PxleMb1zJV0/JNm4PxleMb2JB1U/uhW+PxleMb2JB1U/uhW+PxleMb2JB1U/uhW+PxleMb2JB1U/uhW+PxleMb3xh5M+JNm4PxleMb3xh5M+JNm4PxleMb3xh5M+JNm4PxleMb3xh5M+JNm4PxleMb3Bw6M+uhW+PxleMb3Bw6M+uhW+PxleMb3Bw6M+uhW+PxleMb3Bw6M+uhW+PxleMb3Bw6M+uhW+P05127vBw6M+uhW+P05127vBw6M+uhW+P05127vBw6M+uhW+P05127vFw6M+E/H6PxleMb3Fw6M+E/H6PxleMb3Fw6M+E/H6PxleMb3Fw6M+E/H6PxleMb2JB1U/E/H6PxleMb2JB1U/E/H6PxleMb2JB1U/E/H6PxleMb2JB1U/E/H6PxleMb3xh5M+pI29P2doCD3xh5M+pI29P2doCD3xh5M+pI29P2doCD3xh5M+pI29P2doCD3Fw6M+D1G4P2doCD3Fw6M+D1G4P2doCD3Fw6M+D1G4P2doCD3Fw6M+D1G4P2doCD3xh5M+pI29P5RwWLvxh5M+pI29P5RwWLvxh5M+pI29P5RwWLvxh5M+pI29P5RwWLvxh5M+QHJsP2doCD3xh5M+QHJsP2doCD3xh5M+QHJsP2doCD3Fw6M+D1G4P5RwWLvFw6M+D1G4P5RwWLvFw6M+D1G4P5RwWLvFw6M+D1G4P5RwWLvBw6M+bOt2P5RwWLvBw6M+bOt2P5RwWLvBw6M+bOt2P5RwWLvBw6M+bOt2P5RwWLvxh5M+QHJsP5RwWLvxh5M+QHJsP5RwWLvxh5M+QHJsP5RwWLvxh5M+QHJsP5RwWLvBw6M+bOt2P2doCD3Bw6M+bOt2P2doCD3Bw6M+bOt2P2doCD1zJV0/QHJsP2doCD1zJV0/QHJsP2doCD1zJV0/QHJsP2doCD1zJV0/pI29P2doCD1zJV0/pI29P2doCD1zJV0/pI29P2doCD1zJV0/pI29P2doCD2JB1U/bOt2P2doCD2JB1U/bOt2P2doCD2JB1U/bOt2P2doCD1zJV0/QHJsP5RwWLtzJV0/QHJsP5RwWLtzJV0/QHJsP5RwWLtzJV0/QHJsP5RwWLtzJV0/pI29P5RwWLtzJV0/pI29P5RwWLtzJV0/pI29P5RwWLtzJV0/pI29P5RwWLuJB1U/bOt2P5RwWLuJB1U/bOt2P5RwWLuJB1U/bOt2P5RwWLuJB1U/bOt2P5RwWLuJB1U/D1G4P5RwWLuJB1U/D1G4P5RwWLuJB1U/D1G4P5RwWLuJB1U/D1G4P5RwWLuJB1U/D1G4P2doCD2JB1U/D1G4P2doCD2JB1U/D1G4P2doCD2JB1U/D1G4P2doCD1EIBA/4xK6P1TF9DxEIBA/4xK6P1TF9DxEIBA/4xK6P4Bn/ThEIBA/4xK6P4Bn/TgnyRY/4xK6P4Bn/TgnyRY/4xK6P4Bn/ThEIBA/xGdzP4Bn/ThEIBA/xGdzP4Bn/TgnyRY/xGdzP4Bn/TgnyRY/xGdzP4Bn/ThEIBA/xGdzP1TF9DxEIBA/xGdzP1TF9DwnyRY/xGdzP1TF9DwnyRY/xGdzP1TF9DwnyRY/4xK6P1TF9DwnyRY/4xK6P1TF9DwyyRa/d1j8P63RJbwyyRa/d1j8P63RJbwyyRa/d1j8P2FYI70yyRa/d1j8P2FYI71PIBC/d1j8P2FYI71PIBC/d1j8P2FYI70yyRa/dvm7P2FYI70yyRa/dvm7P2FYI71PIBC/dvm7P2FYI71PIBC/dvm7P2FYI70yyRa/dvm7P63RJbwyyRa/dvm7P63RJbxPIBC/dvm7P63RJbxPIBC/dvm7P63RJbxPIBC/d1j8P63RJbxPIBC/d1j8P63RJbxmHVW8d1j8P63RJbxmHVW8d1j8P63RJbxmHVW8d1j8P2FYI71mHVW8d1j8P2FYI71mG1U8d1j8P2FYI71mG1U8d1j8P2FYI71mHVW8dvm7P2FYI71mHVW8dvm7P2FYI71mG1U8dvm7P2FYI71mG1U8dvm7P2FYI71mHVW8dvm7P63RJbxmHVW8dvm7P63RJbxmG1U8dvm7P63RJbxmG1U8dvm7P63RJbxmG1U8d1j8P63RJbxmG1U8d1j8P63RJbxEIBA/d1j8P63RJbxEIBA/d1j8P63RJbxEIBA/d1j8P2FYI71EIBA/d1j8P2FYI70nyRY/d1j8P2FYI70nyRY/d1j8P2FYI71EIBA/dvm7P2FYI71EIBA/dvm7P2FYI70nyRY/dvm7P2FYI70nyRY/dvm7P2FYI71EIBA/dvm7P63RJbxEIBA/dvm7P63RJbwnyRY/dvm7P63RJbwnyRY/dvm7P63RJbwnyRY/d1j8P63RJbwnyRY/d1j8P63RJbz+/3+/AAAAAAAAAID+/3+/AAAAAAAAAID+/3+/zcwMQAAAAID+/3+/zcwMQAAAAID+/3+/hesBQAAAAID+/3+/hesBQAAAAID+/3+/kML1PQDcpbj+/3+/kML1PQDcpbj+/3+/uB4FPgAAAID+/3+/uB4FPgAAAIAAAIA/zcwMQAAAAIAAAIA/zcwMQAAAAIAAAIA/AAAAAAAAAIAAAIA/AAAAAAAAAIAAAIA/uB4FPgAAAIAAAIA/kML1PQAAAIAAAIA/hesBQAAAAIC1HmW/zcwMQAAAAIC5HmU/zcwMQAAAAIC1HmW/AAAAAAAAAIC4HmU/AAAAAAAAAIAAAIA/ZmZmPwDcpbj+/3+/ZmZmPwAAAID+/3+/ZmZmPwAAAIAAAAAAzcwMQAAAAIAAAAAAAAAAAAAAAIC4HmU/hesBQAAAAIC4HmU/hesBQAAAAIC4HmU/ZmZmPwAAAIC4HmU/ZmZmPwAAAIC1HmW/ZmZmPwAAAIC1HmW/ZmZmPwAAAIC1HmW/hesBQAAAAIC1HmW/hesBQAAAAIAAAIAzhesBQAAAAIAAAIAzhesBQAAAAIAAAIAzZmZmPwAAAIAAAIAzZmZmPwAAAID+/3+/AAAAAI7C9b3+/3+/AAAAAI7C9b3+/3+/AAAAAI7C9b3+/3+/zswMQMzMzL3+/3+/zswMQMzMzL3+/3+/zswMQMzMzL3+/3+/hesBQMzMzL3+/3+/hesBQMzMzL3+/3+/hesBQMzMzL3+/3+/kML1PY7C9b3+/3+/kML1PY7C9b3+/3+/kML1PY7C9b3+/3+/kML1PY7C9b3+/3+/uB4FPszMzL3+/3+/uB4FPszMzL3+/3+/uB4FPszMzL0AAIA/kML1PY7C9b0AAIA/kML1PY7C9b0AAIA/kML1PY7C9b0AAIA/kML1PY7C9b0AAIA/uB4FPszMzL0AAIA/uB4FPszMzL0AAIA/uB4FPszMzL0AAIA/hesBQMzMzL0AAIA/hesBQMzMzL0AAIA/hesBQMzMzL0BAIA/zswMQMzMzL0BAIA/zswMQMzMzL0BAIA/zswMQMzMzL0AAIA/AAAAAI7C9b0AAIA/AAAAAI7C9b0AAIA/AAAAAI7C9b24HmU/kML1PY7C9b24HmU/kML1PY7C9b24HmU/kML1PY7C9b24HmU/kML1PY7C9b21HmW/kML1PY7C9b21HmW/kML1PY7C9b21HmW/kML1PY7C9b21HmW/kML1PY7C9b21HmW/uB4FPszMzL21HmW/uB4FPszMzL21HmW/uB4FPszMzL21HmW/uB4FPszMzL24HmU/uB4FPszMzL24HmU/uB4FPszMzL24HmU/uB4FPszMzL21HmW/hesBQMzMzL21HmW/hesBQMzMzL21HmW/hesBQMzMzL21HmW/hesBQMzMzL24HmU/hesBQMzMzL24HmU/hesBQMzMzL24HmU/hesBQMzMzL24HmU/hesBQMzMzL21HmW/AAAAAI7C9b21HmW/AAAAAI7C9b21HmW/AAAAAI7C9b24HmU/AAAAAI7C9b24HmU/AAAAAI7C9b24HmU/AAAAAI7C9b26HmU/zswMQMzMzL26HmU/zswMQMzMzL26HmU/zswMQMzMzL21HmW/zswMQMzMzL21HmW/zswMQMzMzL21HmW/zswMQMzMzL21HmW/zswMQMzMzL3+/3+/ZmZmP8zMzL3+/3+/ZmZmP8zMzL3+/3+/ZmZmP8zMzL0AAIA/ZmZmP8zMzL0AAIA/ZmZmP8zMzL0AAIA/ZmZmP8zMzL21HmW/ZmZmP8zMzL21HmW/ZmZmP8zMzL21HmW/ZmZmP8zMzL21HmW/ZmZmP8zMzL24HmU/ZmZmP8zMzL24HmU/ZmZmP8zMzL24HmU/ZmZmP8zMzL0AAACmzswMQMzMzL0AAACmzswMQMzMzL0AAACmzswMQMzMzL0AAACmhesBQMzMzL0AAACmhesBQMzMzL0AAACmhesBQMzMzL0AAACmhesBQMzMzL0AAACmkML1PY7C9b0AAACmkML1PY7C9b0AAACmkML1PY7C9b0AAACmkML1PY7C9b0AAACmuB4FPszMzL0AAACmuB4FPszMzL0AAACmuB4FPszMzL0AAACmuB4FPszMzL0AAACmAAAAAI7C9b0AAACmAAAAAI7C9b0AAACmAAAAAI7C9b0AAACmZmZmP8zMzL0AAACmZmZmP8zMzL0AAACmZmZmP8zMzL0AAACmZmZmP8zMzL3+/3+/AAAAAAAAAC/+/3+/AAAAAAAAAC/+/3+/zswMQACAB7H+/3+/zswMQACAB7H+/3+/hesBQAAAAC/+/3+/hesBQAAAAC/+/3+/kML1PQAAAC/+/3+/kML1PQAAAC/+/3+/uB4FPgAAAC8AAIA/zswMQAAAAC8AAIA/zswMQAAAAC8AAIA/AAAAAAAAAC8AAIA/AAAAAAAAAC8AAIA/uB4FPgAAAC8AAIA/kML1PQAAAC8AAIA/kML1PQAAAC8AAIA/hesBQAAAAC8AAIA/hesBQAAAAC+1HmW/zswMQAAAAC+1HmW/zswMQAAAAC+5HmU/zswMQAAAAC+1HmW/AAAAAAAAAC+4HmU/AAAAAAAAAC8AAIA/ZmZmPwAAAC8AAIA/ZmZmPwAAAC/+/3+/ZmZmPwAAAC/+/3+/ZmZmPwAAAC8AAACmzswMQAAAAIAAAACmAAAAAAAAAIC4HmU/hesBQAAAAIC4HmU/hesBQAAAAIC4HmU/ZmZmPwAAAIC4HmU/ZmZmPwAAAIC1HmW/ZmZmPwAAAIC1HmW/ZmZmPwAAAIC1HmW/hesBQAAAAIC1HmW/hesBQAAAAIAAAACmhesBQAAAAIAAAACmhesBQAAAAIAAAACmZmZmPwAAAIAAAACmZmZmPwAAAIAAAIC/AAAAAAAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgD8AAIC/AAAAAAAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgL8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAA//9/PwAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAA//9/PwAAAIAAAIA/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAA//9/PwAAAIAAAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAA//9/PwAAAIAAAAAA//9/vwAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAA//9/PwAAAIAAAAAA//9/PwAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8AAAAA//9/PwAAAIAAAAAA//9/PwAAAIAAAAAA//9/vwAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL///3+/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIC/AAAAAAAAAID//3+/doxiMwAAAIAAAAAAAAAAAAAAgD+Sc8U5GM0SuP7/fz8AAIC/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAMvlkPyX55D4AAIC/2Tums9DKT7UAAIC/AAAAAAAAAIAAAAAAMvlkPyX55D6Vc8U5eG9XOP//fz8AAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAICSc8W5GM0SuP7/fz8AAAAAAAAAAAAAgD8AAIA/AAAAAAAAAICec8W5gm9XOP7/fz8AAAAAMflkPyT55D4AAIA/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAMflkPyT55D4AAIA/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIC/AAAAAAAAAICSc8W5GM0SuP7/fz8AAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAAAAAACAvwAAAIAAAAAAAAAAAAAAgD+Sc8U5GM0SuP7/fz8AAIA/AAAAAAAAAICec8W5gm9XOP7/fz8AAAAAMmrXOAAAgD8AAAAAMflkPyT55D4AAAAAMvlkPyX55D4AAAAAPWPXOP//fz8AAAAAMvlkPyL55D4AAAAAMvlkPyX55D6Vc8U5eG9XOP//fz8AAAAAAAAAAP//fz8AAAAAAAAAAAAAgD8AAAAAMvlkPyL55D4AAAAAMvlkPyX55D4AAAAAAAAAAP//fz8AAAAAAAAAAAAAgD8AAAAAMflkPyT55D4AAAAAMvlkPyX55D4AAAAAAACAvwAAAIAAAAAAAAAAAP//fz8AAAAAAAAAAAAAgD8AAAAAAACAvwAAAIAAAAAAAAAAAP//fz8AAAAAAAAAAAAAgD8AAIC/2Tums9DKT7X//3+/doxiMwAAAICSc8U5GM0SuP7/fz+Vc8U5eG9XOP//fz+ec8W5gm9XOP7/fz+Sc8W5GM0SuP7/fz8AAIA/AAAAAAAAAIAAAAAAPWPXOP//fz8AAAAA//9/PwAAAICSc8U5GM0SuP7/fz+Vc8U5eG9XOP//fz8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAICec8W5gm9XOP7/fz+Sc8W5GM0SuP7/fz8AAAAAMmrXOAAAgD8AAAAA//9/PwAAAIAAAAAAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAAAAAACAvwAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAPWPXOP//fz8AAAAAMmrXOAAAgD8AAAAAMvlkPyL55D4AAAAAMvlkPyX55D4AAAAAAAAAAP//fz8AAAAAAAAAAP//fz8AAAAAMvlkPyL55D4AAAAAMvlkPyX55D4AAAAAAACAvwAAAIAAAAAAAAAAAP//fz8AAAAAAAAAAP//fz8AAAAAPWPXOP//fz8AAAAAMmrXOAAAgD8AAAAA//9/PwAAAIAAAAAA//9/PwAAAIAAAAAAAAAAAAAAgD8AAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIDGOZGxAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAxVnQsgAAgL8AAAAAAAAAAAAAgL8AAAAAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAA//9/PwAAAIAAAIA/AAAAAAAAAIDFOZGxAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8AAIC/Pc9zMwAAAIAAAAAAAAAAAAAAgL8AAAAA//9/PwAAAIAAAIC/Pc9zMwAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgL8AAIC/Pc9zMwAAAIAAAAAAAAAAAAAAgD8AAAAA//9/PwAAAIAAAAAAAACAPwAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAIC/Ps9zMwAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIC/Pc9zMwAAAIAAAAAAAACAvwAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgD8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIC/AAAAAAAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgD8AAIC/AAAAAAAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgL8AAIC/Ps9zMwAAAIAAAAAAAACAvwAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgL8AAAAAAACAvwAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIAAAIC/Ps9zMwAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAIC/Ps9zMwAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIC/Pc9zMwAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIC/Pc9zMwAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAAAAAAAAAAAAgL8AAAAA//9/PwAAAIAAAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAIC/Pc9zMwAAAIDFOZGxAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIC/Pc9zMwAAAIDGOZGxAAAAAAAAgD8AAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIA/Pc9zswAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIA/Pc9zswAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAIA/Pc9zswAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAIA/Pc9zswAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIA/Pc9zswAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIA/Pc9zswAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgL8AAIA/Pc9zswAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgD8AAIA/Pc9zswAAAIAAAAAAAACAvwAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAAAA//9/vwAAAIAAAAAAxVnQsgAAgL8AAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIDGOZGxAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAAACAvwAAAIAAAAAAAACAvwAAAIDGOZGxAAAAAAAAgD8AAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAAAAAACAvwAAAIAAAAAAAACAvwAAAIAAAAAA//9/vwAAAIAAAAAA//9/vwAAAIAAAAAAxVnQsgAAgL8AAAAAAAAAAAAAgL8AAAAAxVnQsgAAgL8AAAAAAAAAAAAAgL/FOZGxAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8AAAAA//9/PwAAAIAAAAAAAACAPwAAAIAAAAAA//9/PwAAAIAAAAAAAACAPwAAAIAAAAAA//9/PwAAAIAAAAAAAACAPwAAAIDFOZGxAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAA//9/PwAAAIAAAAAAAACAPwAAAIAAAAAAAACAPwAAAIAAAAAAAACAPwAAAIAAAIC/AAAAAAAAAIAAAAAAPqngsQAAgD8AAAAAAAAAAAAAgD8AAAAA//9/PwAAAIAAAAAAAACAvwAAAIAAAAAAPqngsQAAgD8AAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAmLozMgAAgL8AAAAA//9/PwAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAAAAfwcSMgAAgD8AAAAAPqngsQAAgD8AAAAAkFJ0sAAAgD8AAAAA//9/PwAAAIAAAIA/TbFlswAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAPqngsQAAgD8AAAAAkFJ0sAAAgD8AAAAAAAAAAAAAgL8AAAAAmLozMgAAgL8AAAAA//9/PwAAAIAAAIA/TbFlswAAAIAAAAAAAACAvwAAAIAAAAAAkFJ0sAAAgD8AAAAAfwcSMgAAgD8AAIA/TbFlswAAAIAAAIC/AAAAAAAAAIAAAAAAkFJ0sAAAgD8AAAAAfwcSMgAAgD8AAAAAAACAPwAAAIAAAAAAAACAvwAAAIAAAAAAJkMdswAAgL8AAAAAAAAAAAAAgL8AAIA/TbFlswAAAIAAAIC/AAAAAAAAAIAAAAAAJkMdswAAgL8AAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAJkMdswAAgL8AAAAAAAAAAAAAgL8AAAAAJkMdswAAgL8AAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAfwcSMgAAgD8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAAAAmLozMgAAgL8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAAAAmLozMgAAgL8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAA6zFKsQAAgL8AAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIC/AAAAAAAAAIAAAAAA//9/vwAAAIAAAAAAdbqzswAAgD8AAAAAAAAAAAAAgD8AAAAAAACAvwAAAIAAAAAA6zFKsQAAgL8AAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAJkMdMQAAgL8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgL8AAAAAJkMdMQAAgL8AAAAAdbqzswAAgD8AAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAAAA//9/vwAAAIAAAAAAdbqzswAAgD8AAAAAkFL0MQAAgD8AAIA/SrFlswAAAIAAAAAAAAAAAAAAgD8AAAAAkFL0MQAAgD8AAAAAAACAPwAAAIAAAIA/SrFlswAAAIAAAIC/AAAAAAAAAIAAAAAAdbqzswAAgD8AAAAAkFL0MQAAgD8AAAAAAACAPwAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgL8AAAAAJkMdMQAAgL8AAIA/SrFlswAAAIAAAAAA6zFKsQAAgL8AAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIA/SrFlswAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAJkMdMQAAgL8AAAAAAACAPwAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAA6zFKsQAAgL8AAAAAAAAAAAAAgL8AAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAAAAkFL0MQAAgD8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAA8ssGMQAAgD8AAAAAAACAPwAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAAAA8ssGMQAAgD8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAA6zFKswAAgL8AAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAA2MsGsQAAgD8AAAAAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAA8ssGMQAAgD8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAAAA8ssGMQAAgD8AAAAA6zFKswAAgL8AAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAA2MsGsQAAgD8AAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAA2MsGsQAAgD8AAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAAAAxDFKMwAAgL8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAxDFKMwAAgL8AAAAAAACAPwAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAAAAxDFKMwAAgL8AAAAAAAAAAAAAgL8AAAAAxDFKMwAAgL8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAAAA2MsGsQAAgD8AAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAA6zFKswAAgL8AAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAA6zFKswAAgL8AAAAAAAAAAAAAgL8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAmLqzMwAAgD8AAAAA//9/PwAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAAAAmLqzMwAAgD8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAARUMdsQAAgL8AAAAAAAAAAAAAgL8AAAAA//9/PwAAAIAAAIC/AAAAAAAAAIAAAAAA//9/vwAAAIAAAAAAdbqzswAAgD8AAAAAAAAAAAAAgD8AAAAAAACAvwAAAIAAAAAARUMdsQAAgL8AAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAJkMdMQAAgL8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgL8AAAAAJkMdMQAAgL8AAAAAdbqzswAAgD8AAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAAAA//9/vwAAAIAAAAAAdbqzswAAgD8AAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAmLqzMwAAgD8AAAAA//9/PwAAAIAAAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAdbqzswAAgD8AAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgL8AAAAAJkMdMQAAgL8AAIA/AAAAAAAAAIAAAAAARUMdsQAAgL8AAAAAAAAAAAAAgL8AAAAA//9/PwAAAIAAAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAJkMdMQAAgL8AAAAAAACAPwAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAARUMdsQAAgL8AAAAAAAAAAAAAgL8AAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAAAAmLqzMwAAgD8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAulJ0sAAAgD8AAAAA8suGMQAAgD8AAAAAAACAPwAAAIAAAAAAAACAvwAAAIAAAAAAulJ0sAAAgD8AAAAA8suGMQAAgD8AAIA/bJyGtAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAmLozMgAAgL8AAAAAAACAPwAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAA18uGsQAAgD8AAAAAulJ0sAAAgD8AAAAAAAAAAAAAgD8AAAAA8suGMQAAgD8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAAAA8suGMQAAgD8AAAAAAAAAAAAAgL8AAAAAmLozMgAAgL8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAA18uGsQAAgD8AAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAA18uGsQAAgD8AAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAAAAAACAvwAAAIAAAAAAdLozsgAAgL8AAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAdLozsgAAgL8AAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAdLozsgAAgL8AAAAAAAAAAAAAgL8AAAAAdLozsgAAgL8AAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIA/bJyGtAAAAIAAAAAA18uGsQAAgD8AAAAAulJ0sAAAgD8AAAAAAACAPwAAAIAAAIA/bJyGtAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAAAAmLozMgAAgL8AAIA/bJyGtAAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAAAAmLozMgAAgL8AAIC/AAAAAAAAAIAAAAAAmLqzswAAgD8AAAAAAAAAAAAAgD8AAAAA//9/PwAAAIAAAAAAAACAvwAAAIAAAAAAmLqzswAAgD8AAAAAAAAAAAAAgD8AAIA/bZyGtAAAAIAAAIC/AAAAAAAAAIAAAAAA6zFKsQAAgL8AAAAAAAAAAAAAgL8AAAAA//9/PwAAAIAAAIC/AAAAAAAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgD8AAAAAAACAvwAAAIAAAAAA6zFKsQAAgL8AAAAAAAAAAAAAgL8AAIA/bZyGtAAAAIAAAAAAAAAAAAAAgL8AAAAAwjFKMQAAgL8AAAAAAACAPwAAAIAAAIA/bZyGtAAAAIAAAIC/AAAAAAAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgL8AAAAAwjFKMQAAgL8AAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIA/bZyGtAAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAAAAmLqzswAAgD8AAAAAAAAAAAAAgD8AAAAA//9/PwAAAIAAAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgL8AAAAAwjFKMQAAgL8AAIA/AAAAAAAAAIAAAAAA6zFKsQAAgL8AAAAAAAAAAAAAgL8AAAAA//9/PwAAAIAAAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAwjFKMQAAgL8AAAAAAACAPwAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAA6zFKsQAAgL8AAAAAAAAAAAAAgL8AAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAmLqzswAAgD8AAAAAAAAAAAAAgD8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAIA/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAAACAvwAAAIAAAIC/AAAAAAAAAIAAAAAAAACAPwAAAIAAAIC/AAAAAAAAAID//3+/doxiMwAAAIAAAIC/AAAAAAAAAID//3+/AAAAAAAAAIAAAIC/2Tums9DKT7UAAIC/AAAAAAAAAIAAAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAAAAAACAvwAAAIAAAIA/AAAAAAAAAIAAAIA/AAAAAAAAAIAAAIA/AAAAAAAAAIAAAIA/AAAAAAAAAIAAAAAAAACAPwAAAIAAAAAAAACAPwAAAIAAAAAAAACAvwAAAIAAAAAAAACAvwAAAIAAAIA/AAAAAAAAAIAAAIC/2Tums9DKT7X//3+/doxiMwAAAIAAAAAAAACAPwAAAIAAAAAAAACAvwAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAIC/AAAAAAAAAIAAAAAA//9/PwAAAIAAAAAA//9/PwAAAIAAAIA/AAAAAAAAAIAAAAAAAACAvwAAAIAAAIA/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAACAvwAAAIAAAAAA//9/PwAAAIAAAAAA//9/PwAAAID//3+/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL9N5eo0AACAPwAAAIAAAIC/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAIC/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAMPlkPyn55L4AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAMPlkPyn55L4AAAAAAAAAAAAAgL8AAAAAMPlkPyn55L7//38/AAAAAAAAAIAAAIA/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAMPlkPyn55L4AAIA/AAAAAAAAAIAAAAAAAAAAAAAAgL///38/AAAAAAAAAIAAAIA/Ijy8tAAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIA/Ijy8tAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL///38/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAAAAL/lkPyj55L4AAAAAMPlkPyn55L4AAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAAAAMPlkPyn55L4AAAAAMvlkPyL55L4AAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAAAAMPlkPyn55L4AAAAAMvlkPyL55L4AAAAAAAAAAAAAgL8AAAAAL/lkPyj55L4AAAAAMPlkPyn55L4AAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAP//f7///38/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAAAAymH8Mv//f78AAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAAAAAAAAAAAAgL8AAAAAymH8Mv//f78AAAAAAACAPwAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAAAAAACAPwAAAIBN5eo0AACAPwAAAIAAAIC/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL///38/AAAAAAAAAIAAAIA/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAAAAAACAPwAAAID//38/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAAAAAAAAAP//f78AAAAAymH8Mv//f78AAAAAAACAPwAAAIAAAAAAAACAvwAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAP//f78AAAAAymH8Mv//f78AAAAAAAAAAP//f78AAAAAAAAAAP//f78AAAAAL/lkPyj55L4AAAAAMvlkPyL55L4AAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAAAAL/lkPyj55L4AAAAAMvlkPyL55L4AAAAAAACAvwAAAIAAAAAAAAAAAP//f78AAAAAAAAAAP//f78AAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAAAAAACAPwAAAIAAAAAAAACAPwAAAID//3+/AAAAAAAAAIAAAAAAAACAvwAAAIAAAIC/AAAAAAAAAIBN5eo0AACAPwAAAIAAAIC/AAAAAAAAAID//3+/AAAAAAAAAIAAAIC/AAAAAAAAAID//3+/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAACAPwAAAIAAAIA/Ijy8tAAAAIAAAAAAAACAvwAAAID//38/AAAAAAAAAIAAAIA/AAAAAAAAAID//38/AAAAAAAAAIAAAIA/AAAAAAAAAID//38/AAAAAAAAAIAAAIA/Ijy8tAAAAIAAAAAAAACAPwAAAIBN5eo0AACAPwAAAIAAAAAAAACAPwAAAIAAAAAAAACAvwAAAIAAAAAAAACAvwAAAID//38/AAAAAAAAAIAAAIA/AAAAAAAAAIAAAIC/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAAACAPwAAAIAAAAAAAACAvwAAAID//3+/AAAAAAAAAIAAAAAAAACAvwAAAID//3+/AAAAAAAAAIAAAAAAAACAPwAAAIAAAAAAAACAPwAAAID//38/AAAAAAAAAIAAAAAAAACAvwAAAID//38/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAACAvwAAAIAAAAAAAACAPwAAAIAAAAAAAACAPwAAAIA1uwg/d/g8PwgFFz/jrRI/HaQIP+OtEj9GexY/d/g8P+afCz/jrRI/HaQIPwUxOz81uwg/S3lAP2oBCz/jrRI/5p8LP+OtEj8IBRc/BTE7Px2kCD8FMTs/RnsWP3f4PD/mnws/BTE7Px2kCD/jrRI/NbsIP3f4PD9qAQs/BTE7P+afCz8FMTs/tWsWP0t5QD9qAQs/460SPwgFFz8FMTs/NbsIP0t5QD+1axY/S3lAP2oBCz8FMTs/CAUXP+OtEj8IBRc/460SPwgFFz8FMTs/HaQIP+OtEj8dpAg/BTE7P2oBCz/jrRI/agELPwUxOz/mnws/460SP+afCz8FMTs/agELP+OtEj9qAQs/BTE7PwgFFz/jrRI/CAUXPwUxOz/mnws/460SP+afCz8FMTs/HaQIP+OtEj8dpAg/BTE7PwDAfz8AwH8/AMB/PwDAfz+grwA8CshuPwDAfz8AwH8/4Lj1O0AnRzwAwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz/guPU7GAW5PeC49TsYBbk9AMB/PwDAfz8AwH8/AMB/P6CvADyTyGI/oK8APJPIYj8AwH8/AMB/PwDAfz8AwH8/oK8APE5eYT/guPU71FpIPx0Ayj7Ay008AMB/PwDAfz8AwH8/AMB/Px0Ayj6o2bk9HQDKPqjZuT0AwH8/AMB/Px0Ayj5mdUg/ptnJPk5eYT8AwH8/AMB/P6bZyT6QyGI/ptnJPpDIYj8AwH8/AMB/PwDAfz8AwH8/ptnJPgrIbj8AwH8/AMB/PzDrOT1AJ0c8AMB/PwDAfz/kVLc+QCdHPADAfz8AwH8/y632PiB9uD3yVLc+GAW5Pfvx3T7uEUo/8lS3PhgFuT0o3m097hFKPzDrOT0YBbk9MOs5PRgFuT0Vs88+IH24Pf1Utz7UWkg//VS3PtRaSD+M56E+Tl5hP4znoT5OXmE/MOs5PdRaSD9Apa49Tl5hP0Clrj1OXmE/MOs5PdRaSD9Apa49k8hiP0Clrj2TyGI/QKWuPZPIYj9Apa49k8hiP4znoT6QyGI/jOehPpDIYj+M56E+kMhiP4znoT6QyGI/AMB/PwDAfz9Apa49CshuP0Clrj0KyG4/AMB/PwDAfz+M56E+CshuP4znoT4KyG4/AMB/PwDAfz8AwH8/AMB/P+C49TtsY/8+4Lj1O2xj/z4dAMo+kJj/Ph0Ayj6QmP8+AMB/PwDAfz8w6zk9bGP/PniSVD3m518/MOs5PWxj/z4w6zk9bGP/PhWzzz5sY/8+y632Pmxj/z71VLc+bGP/PvVUtz5sY/8+9VS3Pmxj/z778d0+5udfP+C49TtAJ0c8HQDKPsDLTTwAwH8/AMB/PwAD/DvuEUo/eVDzPu4RSj/guPU7GAW5PR0Ayj6o2bk9HQDKPmZ1SD/guPU71FpIP6bZyT5OXmE/oK8APE5eYT+grwA8kMhiP6bZyT6QyGI/ptnJPpDIYj+grwA8kMhiPwDAfz8AwH8/oK8APArIbj+m2ck+CshuPx0Ayj6QmP8+4Lj1O2xj/z4AA/w75udfPwvY9T7m518/K3c3P0msAT+mpzI/mTcJPzRPNT+yvAM/IZgtP/sIRz8rdzc/wThRPyt3Nz/BOFE/KXc3P744UT8pdzc/vjhRPz9e/j42rAE/G1cBP6S8Az/zpjI/gsYFPyGYLT8mEBI/LV7+PsY4UT8tXv4+xjhRPzte/j7GOFE/GVcBP1YoTz+jpzI/mTcJP/MIIz8wFBI/MF7+PjesAT8rdzc/PawBPyGYLT8mEBI/FlcBP6e8Az/skgM/lzcJPyGYLT/7CEc/PpIDP4LGBT8tTzU/p7wDP6DPKz8mEBI/oM8rPyYQEj/skgM/HEAIP+ySAz8cQAg/dtEkPzIUEj+jpzI/H0AIP3bRJD8yFBI/BhUpPysSEj8GFSk/KxISP5SSAz+P6Qc/mc8rP/oIRz8+kgM//L0GPz6SAz/8vQY/mc8rP/oIRz+55io/OBASP7nmKj84EBI/ROQCP6xACD/l/Sk/GhISP+X9KT8aEhI/6+MCPx3qBz+55io/EQlHP5fjAj+LvgY/ueYqPxEJRz/i/Sk/8gpHP/HjAj8XFQc/4v0pP/IKRz8DFSk/AQtHP5iSAz+KFAc/mJIDP4oUBz8DFSk/AQtHP06nMj+MFAc/TqcyP4wUBz8HjCc/AQtHPweMJz8BC0c/B4wnPwELRz+YkgM/kukHPweMJz8BC0c/DownPysSEj8OjCc/KxISP5SSAz+GFAc/bdEkPwcNRz/wkgM/H0AIP23RJD8HDUc/TqcyP5TpBz8DFSk/AQtHPwMVKT8BC0c/JqMmPxQLRz/x4wI/H+oHPyajJj8UC0c/LqMmPzoSEj8uoyY/OhISP+vjAj8WFQc/TrolP/QMRz9G5AI/sEAIP066JT/0DEc/VbolPxwUEj9VuiU/HBQSP5bjAj+HvgY/dtEkPzAUEj920SQ/MBQSPzuSAz/6vQY/oM8rPyYQEj/zpjI/+r0GP/OmMj/6vQY/oM8rPyYQEj/zCCM/MBQSPxRXAT9aKE8/FFcBP1ooTz87kgM/gsYFP+oIIz8HDUc/LU81P1QoTz/wkgM/mTcJPy1PNT9UKE8/BhUpPywSEj9OpzI/ihQHPwYVKT8sEhI/pqcyPyBACD+bzys/+ghHP5vPKz/6CEc/ueYqPzgQEj+aVTM/a70GP7nmKj84EBI/5f0pPxoSEj/zVTM/+xMHP+X9KT8aEhI/TlYzP5M/CD+55io/EQlHP7nmKj8RCUc/9lUzPwbpBz/j/Sk/8gpHP+P9KT/yCkc/DownPywSEj9OpzI/kukHPw6MJz8sEhI/LqMmPz4SEj/zVTM/AukHPy6jJj8+EhI/VbolPxwUEj9OVjM/kT8IP1W6JT8cFBI/9lUzP/4TBz8moyY/FAtHPyajJj8UC0c/nVUzP229Bj9OuiU/9AxHP066JT/0DEc/+KYyP/29Bj/4pjI//b0GP23RJD8HDUc/bdEkPwcNRz/4pjI/g8YFPzBPNT9SKE8/ME81P1IoTz/qCCM/Bw1HPyt3Nz9uDCk/K3c3P24MKT+bXBs/ixQHP5tcGz+T6Qc/Mk81P2wMKT/0XBs/mTcJPzJPNT9sDCk/9FwbPyBACD9FXBs//L0GP0VcGz/8vQY/RVwbP4LGBT8wTzU/ZgwpPzBPNT9mDCk/K3c3P2gMKT8rdzc/aAwpPzJe/j5oDCk/Ml7+PmgMKT8yXv4+aAwpPxZXAT9oDCk/8VwbP5g3CT/xXBs/mDcJP/FcGz8eQAg/8VwbPx5ACD9AXBs/+r0GP0BcGz/6vQY/FlcBP2kMKT8WVwE/aQwpP0BcGz+CxgU/QFwbP4LGBT+ZXBs/iBQHP5lcGz+Q6Qc/6OAuP1N4az/8ogM/UZNXP/yiAz9Rk1c/6OAuPyM4aD+hBy8/6YtuP38+Bj/0xlk/fz4GP/TGWT/o4C4/AS1oP+jgLj8jOGg/YPsyP1GTVz9g+zI/UZNXP+jgLj9TeGs/rs0HP1N4az/o4C4/U3hrP/yiAz/KkHU//KIDP8qQdT9g+zI/UZNXP2D7Mj9Rk1c/rs0HPyM4aD/o4C4/6ThoP+jgLj89hGs/7QAIP+mLbj/cXzA/9MZZP9xfMD/0xlk//KIDP1GTVz/8ogM/UZNXP67NBz9TeGs/6OAuPxp5az+uzQc/U3hrP2D7Mj/HkHU/YPsyP8eQdT+uzQc/6ThoP67NBz89hGs/3F8wPyNdcz/cXzA/I11zP+0ACD8wm2w/rs0HPyM4aD/8ogM/ypB1P/yiAz/KkHU/rs0HPxp5az+uzQc/AS1oP38+Bj8jXXM/fz4GPyNdcz/tAAg/6YtuP67NBz8jOGg/6OAuPyM4aD9g+zI/x5B1P2D7Mj/HkHU/3F8wPyNdcz/cXzA/I11zP6EHLz/pi24/rs0HPz2Eaz9/PgY/I11zP38+Bj8jXXM/oQcvPzCbbD+uzQc/AS1oP6EHLz8wm2w/3F8wP/TGWT/cXzA/9MZZP+jgLj89hGs/6OAuPwEtaD/tAAg/MJtsP38+Bj/0xlk/fz4GP/TGWT+hBy8/BPFxP/yiAz9Rk1c/oQcvP29Wbz+hBy8/6YtuP38+Bj/0xlk/6OAuPwEtaD+hBy8/b1ZvP2D7Mj9Rk1c/YPsyP1GTVz+hBy8/BPFxP+0ACD8E8XE/oQcvPwTxcT/8ogM/ypB1P/yiAz/KkHU/oQcvPzCbbD/cXzA/9MZZP9xfMD/0xlk/6OAuPz2Eaz/cXzA/I11zP9xfMD8jXXM/oQcvP+mLbj+uzQc/PYRrP+0ACD9sVm8/oQcvP29Wbz9g+zI/x5B1P2D7Mj/HkHU/fz4GPyNdcz9/PgY/I11zP6EHLz8wm2w/rs0HPwEtaD/tAAg/BPFxP2D7Mj/HkHU/YPsyP8eQdT/tAAg/b1ZvP2D7Mj9Rk1c/YPsyP1GTVz/tAAg/b1ZvP6EHLz9vVm8/rs0HPz2Eaz/cXzA/I11zP9xfMD8jXXM/7QAIPzCbbD/tAAg/bFZvP/yiAz/KkHU//KIDP8qQdT/tAAg/BPFxP/yiAz9Rk1c//KIDP1GTVz/tAAg/BPFxP6EHLz8E8XE/rs0HPwEtaD9/PgY/I11zP38+Bj8jXXM/7QAIP+mLbj/o4C4/AS1oP+0ACD8wm2w/fz4GP/TGWT9/PgY/9MZZP+jgLj89hGs/7QAIP+mLbj/cXzA/9MZZP9xfMD/0xlk/oQcvP+mLbj+hBy8/MJtsP6EHLz8wm2w/oQcvP+mLbj+hBy8/MJtsP6EHLz/pi24/7QAIPzCbbD/tAAg/6YtuP+0ACD8wm2w/7QAIP+mLbj/tAAg/6YtuP+0ACD8wm2w/7QAIP+mLbj/tAAg/MJtsP6EHLz/pi24/oQcvPzCbbD/o4C4/U3hrP/yiAz9Rk1c//KIDP1GTVz/o4C4/IzhoP6EHLz/pi24/fz4GP/TGWT9/PgY/9MZZP+jgLj8BLWg/6OAuPyM4aD9g+zI/UZNXP2D7Mj9Rk1c/6OAuP1N4az+uzQc/U3hrP+jgLj9TeGs//KIDP8qQdT/8ogM/ypB1P2D7Mj9Rk1c/YPsyP1GTVz+uzQc/IzhoP+jgLj/pOGg/6OAuPz2Eaz/tAAg/6YtuP9xfMD/0xlk/3F8wP/TGWT/8ogM/UZNXP/yiAz9Rk1c/rs0HP1N4az/o4C4/GnlrP67NBz9TeGs/YPsyP8eQdT9g+zI/x5B1P67NBz/pOGg/rs0HPz2Eaz/cXzA/I11zP9xfMD8jXXM/7QAIPzCbbD+uzQc/IzhoP/yiAz/KkHU//KIDP8qQdT+uzQc/GnlrP67NBz8BLWg/fz4GPyNdcz9/PgY/I11zP+0ACD/pi24/rs0HPyM4aD/o4C4/IzhoP2D7Mj/HkHU/YPsyP8eQdT/cXzA/I11zP9xfMD8jXXM/oQcvP+mLbj+uzQc/PYRrP38+Bj8jXXM/fz4GPyNdcz+hBy8/MJtsP67NBz8BLWg/oQcvPzCbbD/cXzA/9MZZP9xfMD/0xlk/6OAuPz2Eaz/o4C4/AS1oP+0ACD8wm2w/fz4GP/TGWT9/PgY/9MZZP6EHLz8E8XE//KIDP1GTVz/8ogM/UZNXP6EHLz9vVm8/oQcvP+mLbj9/PgY/9MZZP38+Bj/0xlk/6OAuPwEtaD+hBy8/b1ZvP2D7Mj9Rk1c/YPsyP1GTVz+hBy8/BPFxP+0ACD8E8XE/oQcvPwTxcT/8ogM/ypB1P/yiAz/KkHU/oQcvPzCbbD/cXzA/9MZZP9xfMD/0xlk/6OAuPz2Eaz/cXzA/I11zP9xfMD8jXXM/oQcvP+mLbj+uzQc/PYRrP+0ACD9sVm8/oQcvP29Wbz9g+zI/x5B1P2D7Mj/HkHU/fz4GPyNdcz9/PgY/I11zP6EHLz8wm2w/rs0HPwEtaD/tAAg/BPFxP2D7Mj/HkHU/YPsyP8eQdT/tAAg/b1ZvP2D7Mj9Rk1c/YPsyP1GTVz/tAAg/b1ZvP6EHLz9vVm8/rs0HPz2Eaz/cXzA/I11zP9xfMD8jXXM/7QAIPzCbbD/tAAg/bFZvP/yiAz/KkHU//KIDP8qQdT/tAAg/BPFxP/yiAz9Rk1c//KIDP1GTVz/tAAg/BPFxP6EHLz8E8XE/rs0HPwEtaD9/PgY/I11zP38+Bj8jXXM/7QAIP+mLbj/o4C4/AS1oP+0ACD8wm2w/fz4GP/TGWT9/PgY/9MZZP+jgLj89hGs/7QAIP+mLbj/cXzA/9MZZP9xfMD/0xlk/oQcvP+mLbj+hBy8/MJtsP6EHLz8wm2w/oQcvP+mLbj+hBy8/MJtsP6EHLz/pi24/7QAIPzCbbD/tAAg/6YtuP+0ACD8wm2w/7QAIP+mLbj/tAAg/6YtuP+0ACD8wm2w/7QAIP+mLbj/tAAg/MJtsP6EHLz/pi24/oQcvPzCbbD/o4C4/U3hrP/yiAz9Rk1c//KIDP1GTVz/o4C4/IzhoP6EHLz/pi24/fz4GP/TGWT9/PgY/9MZZP+jgLj8BLWg/6OAuPyM4aD9g+zI/UZNXP2D7Mj9Rk1c/6OAuP1N4az+uzQc/U3hrP+jgLj9TeGs//KIDP8qQdT/8ogM/ypB1P2D7Mj9Rk1c/YPsyP1GTVz+uzQc/IzhoP+jgLj/pOGg/6OAuPz2Eaz/tAAg/6YtuP9xfMD/0xlk/3F8wP/TGWT/8ogM/UZNXP/yiAz9Rk1c/rs0HP1N4az/o4C4/GnlrP67NBz9TeGs/YPsyP8eQdT9g+zI/x5B1P67NBz/pOGg/rs0HPz2Eaz/cXzA/I11zP9xfMD8jXXM/7QAIPzCbbD+uzQc/IzhoP/yiAz/KkHU//KIDP8qQdT+uzQc/GnlrP67NBz8BLWg/fz4GPyNdcz9/PgY/I11zP+0ACD/pi24/rs0HPyM4aD/o4C4/IzhoP2D7Mj/HkHU/YPsyP8eQdT/cXzA/I11zP9xfMD8jXXM/oQcvP+mLbj+uzQc/PYRrP38+Bj8jXXM/fz4GPyNdcz+hBy8/MJtsP67NBz8BLWg/oQcvPzCbbD/cXzA/9MZZP9xfMD/0xlk/6OAuPz2Eaz/o4C4/AS1oP+0ACD8wm2w/fz4GP/TGWT9/PgY/9MZZP6EHLz8E8XE//KIDP1GTVz/8ogM/UZNXP6EHLz9vVm8/oQcvP+mLbj9/PgY/9MZZP38+Bj/0xlk/6OAuPwEtaD+hBy8/b1ZvP2D7Mj9Rk1c/YPsyP1GTVz+hBy8/BPFxP+0ACD8E8XE/oQcvPwTxcT/8ogM/ypB1P6EHLz8wm2w/3F8wP/TGWT/cXzA/9MZZP+jgLj89hGs/3F8wPyNdcz/cXzA/I11zP6EHLz/pi24/rs0HPz2Eaz/tAAg/bFZvP6EHLz9vVm8/YPsyP8eQdT9g+zI/x5B1P38+Bj8jXXM/oQcvPzCbbD+uzQc/AS1oP+0ACD8E8XE/YPsyP8eQdT/tAAg/b1ZvP2D7Mj9Rk1c/YPsyP1GTVz/tAAg/b1ZvP6EHLz9vVm8/rs0HPz2Eaz/cXzA/I11zP+0ACD8wm2w/7QAIP2xWbz/8ogM/ypB1P/yiAz/KkHU/7QAIPwTxcT/8ogM/UZNXP/yiAz9Rk1c/7QAIPwTxcT+hBy8/BPFxP67NBz8BLWg/fz4GPyNdcz9/PgY/I11zP+0ACD/pi24/6OAuPwEtaD/tAAg/MJtsP38+Bj/0xlk/fz4GP/TGWT/o4C4/PYRrP+0ACD/pi24/3F8wP/TGWT/cXzA/9MZZP6EHLz/pi24/oQcvPzCbbD+hBy8/MJtsP6EHLz/pi24/oQcvPzCbbD+hBy8/6YtuP+0ACD8wm2w/7QAIP+mLbj/tAAg/MJtsP+0ACD/pi24/7QAIP+mLbj/tAAg/MJtsP+0ACD/pi24/7QAIPzCbbD+hBy8/6YtuP6EHLz8wm2w/oQcvP+mLbj+hBy8/MJtsP6EHLz8wm2w/oQcvP+mLbj+hBy8/MJtsP6EHLz/pi24/7QAIPzCbbD/tAAg/6YtuP+0ACD8wm2w/7QAIP+mLbj/tAAg/6YtuP+0ACD8wm2w/7QAIP+mLbj/tAAg/MJtsP6EHLz/pi24/oQcvPzCbbD+hBy8/6YtuP6EHLz8wm2w/oQcvPzCbbD+hBy8/6YtuP6EHLz8wm2w/oQcvP+mLbj/tAAg/MJtsP+0ACD/pi24/7QAIPzCbbD/tAAg/6YtuP+0ACD/pi24/7QAIPzCbbD/tAAg/6YtuP+0ACD8wm2w/oQcvP+mLbj+hBy8/MJtsP6EHLz/pi24/oQcvPzCbbD+hBy8/MJtsP6EHLz/pi24/oQcvPzCbbD+hBy8/6YtuP+0ACD8wm2w/7QAIP+mLbj/tAAg/MJtsP+0ACD/pi24/7QAIP+mLbj/tAAg/MJtsP+0ACD/pi24/7QAIPzCbbD+hBy8/6YtuP6EHLz8wm2w/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/P3Aw4z4gfbg9+/HdPur8VD9wMOM+bGP/Pvvx3T7q/FQ/eJJUPer8VD9wMOM+bGP/PijebT3q/FQ/cDDjPiB9uD0AA/w76vxUP3lQ8z7q/FQ/AAP8O+r8VD8L2PU+6vxUPwDAfz8AwH8/AMB/PwDAfz+m2ck+CshuPwDAfz8AwH8/HQDKPkDMTTwAwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8dAMo+qNm5PQDAfz8AwH8/AMB/PwDAfz+m2ck+kMhiP6bZyT6QyGI/AMB/PwDAfz8dAMo+ZnVIP6bZyT5OXmE/oK8API7IYj+grwA8jshiPwDAfz8AwH8/AMB/PwDAfz/guPU71FpIP6CvADxOXmE/AMB/PwDAfz/guPU7GAW5PQDAfz8AwH8/AMB/PwDAfz/guPU7wCdHPADAfz8AwH8/AMB/PwDAfz8AwH8/AMB/P6CvADwKyG4/AMB/PwDAfz+Wpa49jshiP5alrj2OyGI/lqWuPY7IYj+Wpa49jshiP5znoT6QyGI/nOehPpDIYj+c56E+kMhiP5znoT6QyGI/5FS3PtRaSD/kVLc+1FpIP5znoT5OXmE/nOehPk5eYT9E6zk91FpIP5alrj1OXmE/lqWuPU5eYT8o3m095udfP/VUtz4YBbk99VS3PhgFuT3LrfY+IH24PRWzzz4gfbg9+/HdPubnXz+s6jk9GAW5PazqOT0YBbk9AMB/PwDAfz+c56E+CshuP5znoT4KyG4/AMB/PwDAfz+Wpa49CshuP5alrj0KyG4/rOo5PcAnRzys6jk9wCdHPADAfz8AwH8/9VS3PsAnRzz1VLc+wCdHPADAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/HQDKPpCY/z7guPU7bGP/PgDAfz8AwH8/AMB/PwDAfz/sVLc+bGP/PuxUtz5sY/8+eJJUPe4RSj/LrfY+bGP/PhWzzz5sY/8+FOs5PWxj/z778d0+7hFKP+C49TvAJ0c8HQDKPkDMTTwAwH8/AMB/PwAD/Dvm518/eVDzPubnXz/guPU7GAW5PR0Ayj6o2bk9oK8APJDIYj+m2ck+kMhiP6bZyT6QyGI/oK8APJDIYj8dAMo+ZnVIP+C49TvUWkg/ptnJPk5eYT+grwA8Tl5hPwDAfz8AwH8/oK8APArIbj+m2ck+CshuPx0Ayj6QmP8+4Lj1O2xj/z4AA/w77hFKPwvY9T7uEUo/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/P3Aw4z4gfbg9+/HdPur8VD9wMOM+bGP/Pvvx3T7q/FQ/eJJUPer8VD9wMOM+bGP/PijebT3q/FQ/cDDjPiB9uD0AA/w76vxUP3lQ8z7q/FQ/AAP8O+r8VD8L2PU+6vxUPyQADAAJACQACQAYAAAABgAVAAAAFQADABsAHQAHABsABwACAA4AFAARAA4AEQALACMAFwAIACMACAAfACcAIQASACcAEgANAAUAFgAgAAUAIAAmABMAIgAeABMAHgAQAAoADwAcAAoAHAAaAAQAJQAZAAQAGQABACEDKQNMACEDTAA7AG8AeABVAG8AVQBAAEMAYgBqAEMAagBHADoASwBQADoAUAA+AEEAVwBjAEEAYwBEACwDJwM/ACwDPwBxAF4ANAAqAF4AKgBnAHUAbgA5AHUAOQBcAFsAOAA1AFsANQBgAEkALAAwAEkAMABSAIYAigBkAIYAZABYAC8DfgBMAC8DTAApA4cAjABpAIcAaQBhAI8AhABWAI8AVgB6ADwDNQNzADwDcwCRAHwAgQBQAHwAUABLACgDGgMtACgDLQBKADEDMwN3ADEDdwBNAFMAMQBtAFMAbQB0ACUDLANxACUDcQBCAD0ATgB5AD0AeQBwADYDOANUADYDVAB2ADkDMgNPADkDTwB/ADcDOgOAADcDgABRAEkAUgCCAEkAggB9ACgDSgB+ACgDfgAvAzQDOwOQADQDkAB7AHIAWQCDAHIAgwCOAF0AZgCNAF0AjQCIAFoAXwCJAFoAiQCFAJQAkgCaAJQAmgCbAB8BkgCUAB8BlAAkAS4BOAGbAC4BmwCaAC8BoAChAC8BoQAwAZkAHAGhAJkAoQCgAKsApQCkAKsApACnADMBrgCoADMBqAAxAawAtgCpAKwAqQCmADQBPAG1ADQBtQCvALUAvwC8ALUAvACvAK0AuwDCAK0AwgC5ALoAvQDDALoAwwDAALgAwQDEALgAxADIAMkAxQC+AMkAvgC0ACYBIAHKACYBygAWAdEAzgDGANEAxgCzACEBIAHHACEBxwDPANIA3gDcANIA3ADQAM8A2wDhAM8A4QDVACEBJQH4ACEB+ADXAN0A4wDgAN0A4ADaANYA4gDkANYA5ADnAOgA5QDfAOgA3wDTADsBNgHoADsB6ADTADoB8ADoADoB6AA2Ae0A8QDUAO0A1ADmAJcA9ADvAJcA7wCfACMBJQHVACMB1QDzAPYA/wD8APYA/ADrAOkA+wACAekAAgH5APoAlQCdAPoAnQDsAP0AAAEGAf0ABgEDAfgAAQEEAfgABAHXANgABQH+ANgA/gD1ADsB0wC1ADsBtQA8Ac0A2QD3AM0A9wAJAbEADgELAbEACwEIAQcBCgERAQcBEQHMAAwBDwEVAQwBFQESAcsAEAETAcsAEwEXARgBFAENARgBDQGwACcBKAGqACcBqgC4AB0BGQGyAB0BsgCjACsBKQEbASsBGwGYAKUAqwAqAaUAKgEsARcBGgEoARcBKAEnAZMA+AAlAZMAJQEjAc8A1QAlAc8AJQEhAdcAygAgAdcAIAEhAbcAxwAgAbcAIAEmAZYAHgEiAZYAIgHyAPYAOwE8AfYAPAEIAZwAOQE1AZwANQHqAPYA6wA2AfYANgE7AbEACAE8AbEAPAE0AbEANAEyAbEAMgGiAKQALwEwAaQAMAGnAJ4A7gA3AZ4ANwEtAT4BQgFTAT4BUwFNAUMBPwFLAUMBSwFxAU8BVwFIAU8BSAFAAUkBPQFFAUkBRQFpAU4BVAFeAU4BXgFaAVgBUAFcAVgBXAFkAXIBTAFbAXIBWwFfAWEBWQFKAWEBSgFqAXsBVQFjAXsBYwFnAWsBbQFmAWsBZgFiAUYBdgFuAUYBbgFsAW8BcwFgAW8BYAFoAXgBRAF0AXgBdAFwAXcBRwFWAXcBVgF8AXoBUgFBAXoBQQF1AV0BUQF5AV0BeQFlAYEBfgGKAYEBigGYAYcBfQGDAYcBgwGTAacBmwGIAacBiAGUAZkBpgGyAZkBsgGRAYUBjQGPAYUBjwGVAY4BggGaAY4BmgGSAZ8BfgGBAZ8BgQG5AYkBnAGkAYkBpAGXAa4BogGeAa4BngGqAaABugGlAaABpQGdAbYBrAGoAbYBqAGwAa0BhgF/Aa0BfwGhAaMBtwGzAaMBswGvAZYBkAGxAZYBsQGpAasBtQGMAasBjAGEAbgBgAGLAbgBiwG0AcIBvgG/AcIBvwHDAcUBuwG9AcUBvQHBAccByQG8AccBvAHGAcQBwAHKAcQBygHIAc0B0QHiAc0B4gHcAdABzAHaAdAB2gEAAt0B5QHWAd0B1gHOAdcBywHTAdcB0wH3AdsB4QHtAdsB7QHpAeYB3gHqAeYB6gHyAf8B2QHoAf8B6AHsAe8B5wHYAe8B2AH4AQoC5AHwAQoC8AH0AfoB/AH1AfoB9QHxAdUBBQL7AdUB+wH5Af0BAQLuAf0B7gH2AQYC0gECAgYCAgL+AQQC1AHjAQQC4wEJAggC4AHPAQgCzwEDAusB3wEHAusBBwLzARACDAIaAhACGgIoAhcCCwITAhcCEwIjAjcCKwIYAjcCGAIkAikCNgJCAikCQgIhAhUCHQIfAhUCHwIlAh4CEgIqAh4CKgIiAjACDQIRAjACEQJKAhkCLAI0AhkCNAInAj4CMgIuAj4CLgI6Ai8CSQI1Ai8CNQItAkYCPAI4AkYCOAJAAj0CFgIOAj0CDgIxAjMCRwJDAjMCQwI/AiYCIAJBAiYCQQI5AjsCRQIcAjsCHAIUAkgCDwIbAkgCGwJEAlICTgJPAlICTwJTAlUCSwJNAlUCTQJRAlcCWQJMAlcCTAJWAlQCUAJaAlQCWgJYAl0CYQJyAl0CcgJsAmACXAJqAmACagKQAm0CdQJmAm0CZgJeAmcCWwJjAmcCYwKHAmsCcQJ9AmsCfQJ5AnYCbgJ6AnYCegKCAo8CaQJ4Ao8CeAJ8An8CdwJoAn8CaAKIApkCcwKBApkCgQKFAokCiwKEAokChAKAAmQClAKMAmQCjAKKAo0CkQJ+Ao0CfgKGApYCYgKSApYCkgKOApUCZQJ0ApUCdAKaApgCcAJfApgCXwKTAnsCbwKXAnsClwKDAqECnQKpAqECqQK2AqcCmwKjAqcCowKyAsMCuQKoAsMCqAKzArcCwgLOArcCzgKwAqUCrAKuAqUCrgK0Aq0CogK4Aq0CuAKxArwCnAKgArwCoALVAqkCugLBAqkCwQK2AsoCvwK7AsoCuwLGAr0C1gLBAr0CwQK6AtICyALEAtICxALMAskCpgKeAskCngK+AsAC0wLPAsACzwLLArUCrwLNArUCzQLFAscC0QKrAscCqwKkAtQCnwKqAtQCqgLQAt4C2gLbAt4C2wLfAuEC1wLZAuEC2QLdAuMC5QLYAuMC2ALiAuAC3ALmAuAC5gLkAu4C6gLrAu4C6wLvAvEC5wLpAvEC6QLtAvMC9QLoAvMC6ALyAvAC7AL2AvAC9gL0Av4C+gL7Av4C+wL/AgED9wL5AgED+QL9AgMDBQP4AgMD+AICAwAD/AIGAwADBgMEAw4DCgMLAw4DCwMPAxEDBwMJAxEDCQMNAxMDFQMIAxMDCAMSAxADDAMWAxADFgMUA2UAKgMwA2UAMAOLADYAawAtAzYALQMfA4sAMAMrA4sAKwNoAGUAKQAYA2UAGAMqAzwAPwAnAzwAJwMiA0UASAAkA0UAJAMmA0IARQAmA0IAJgMlAzIANwAgAzIAIAMdAygAMwAeAygAHgMXA2wALwAcA2wAHAMuA0YAaAArA0YAKwMjAy4AKwAZAy4AGQMbA6gDpgNAA6gDQANDA4cDgwNFA4cDRQNtA1QDcgN6A1QDegNXA68DugN3A68DdwNaA4QDjANyA4QDcgNUA74DqQNEA74DRAOCA6QDqwNHA6QDRwM9A6oDrANKA6oDSgNGA1sDeANdA1sDXQNNA7EDswNQA7EDUANTA7IDsANcA7IDXANPA64DtQNWA64DVgNZA3UDPwNIA3UDSANhA2MDSQNMA2MDTANnA7kDpQM+A7kDPgN0A20DRQNBA20DQQN9A04DYANrA04DawNSA5cDmwNqA5cDagNfA8ADnQN3A8ADdwO6A5QDjwN7A5QDewNzA58DlgNeA58DXgN5A5kDoAOMA5kDjANpA6wDvQOBA6wDgQNKA1EDaQOMA1EDjAOEA2UDSwODA2UDgwOHA24DfgOOA24DjgOTA2YDiAOhA2YDoQOaA3YDYgOVA3YDlQOeA7kDdAOdA7kDnQPAA2QDaAOcA2QDnAOYA38DtgO/A38DvwOQA1MDhgO8A1MDvAOxA4ADQgOnA4ADpwO3A5ADvwO4A5ADuAN8A4UDVQO0A4UDtAO7A1gDfAO4A1gDuAOtA40DogPLA40DywPEA2wDkgPKA2wDygPHA5EDcQPCA5EDwgPJA4oDbwPIA4oDyAPGA3ADiwPDA3ADwwPBA6MDiQPFA6MDxQPMA/7//74AAAAAj8L1Pf7//74AAAAAj8L1Pf7//74AAAAAj8L1Pf7//77OzAxANcrMPf7//77OzAxANcrMPf7//77OzAxANcrMPf7//76F6wFANcrMPf7//76F6wFANcrMPf7//76QwvU9j8L1Pf7//76QwvU9j8L1Pf7//76QwvU9j8L1Pf7//764HgU+rPPMPf7//764HgU+rPPMPf7//764HgU+rPPMPQAAAD/OzAxANcrMPQAAAD/OzAxANcrMPQAAAD/OzAxANcrMPQAAAD+F6wFANcrMPQAAAD+F6wFANcrMPQAAAD+4HgU+NcrMPQAAAD+4HgU+NcrMPQAAAD+4HgU+NcrMPQAAAD+QwvU9j8L1PQAAAD+QwvU9j8L1PQAAAD+QwvU9j8L1PQAAAD8AAAAAj8L1PQAAAD8AAAAAj8L1PQAAAD8AAAAAj8L1PcvMzL7OzAxANcrMPcvMzL7OzAxANcrMPc3MzD7OzAxANcrMPc3MzD7OzAxANcrMPc3MzD6F6wFANcrMPc3MzD6F6wFANcrMPc3MzD6F6wFANcrMPcvMzL6F6wFANcrMPcvMzL6F6wFANcrMPcvMzL6F6wFANcrMPc3MzD64HgU+NcrMPc3MzD64HgU+NcrMPc3MzD64HgU+NcrMPcvMzL64HgU+NcrMPcvMzL64HgU+NcrMPcvMzL64HgU+NcrMPcvMzL64HgU+NcrMPcvMzL6QwvU9j8L1PcvMzL6QwvU9j8L1PcvMzL6QwvU9j8L1Pc3MzD6QwvU9j8L1Pc3MzD6QwvU9j8L1Pc3MzD6QwvU9j8L1PcvMzL4AAAAAj8L1PcvMzL4AAAAAj8L1Pc3MzD4AAAAAj8L1Pc3MzD4AAAAAj8L1Pf7//75mZmY/NcrMPf7//75mZmY/NcrMPf7//75mZmY/NcrMPQAAAD9mZmY/NcrMPQAAAD9mZmY/NcrMPcvMzL5mZmY/NcrMPcvMzL5mZmY/NcrMPcvMzL5mZmY/NcrMPcvMzL5mZmY/NcrMPc3MzD5mZmY/NcrMPc3MzD5mZmY/NcrMPc3MzD5mZmY/NcrMPV44zr7qJQJA/PxmPV44zr7qJQJA/PxmPeZRuL5SuP4//PxmPeZRuL5SuP4//PxmPeZRuL5SuP4//PxmPeZRuL5SuP4//PxmPV44zj7qJQJA/fxmPV44zj7qJQJA/fxmPV44zr7qJQJAYfmHvV44zr7qJQJAYfmHvV84zr7SfGU//PxmPV84zr7SfGU//PxmPedRuL7Xo3A//PxmPedRuL7Xo3A//PxmPedRuL7Xo3A//PxmPedRuL7Xo3A//PxmPV04zj7SfGU//fxmPV04zj7SfGU//fxmPV84zr7SfGU/YfmHvV84zr7SfGU/YfmHvedRuL7Xo3A/YfmHvedRuL7Xo3A/YfmHvedRuL7Xo3A/YfmHvedRuL7Xo3A/YfmHvV04zj7SfGU/YfmHvV04zj7SfGU/YfmHvV44zj7qJQJAYfmHvV44zj7qJQJAYfmHveVRuD7Xo3A/YfmHveVRuD7Xo3A/YfmHveVRuD7Xo3A/YfmHveVRuD7Xo3A/YfmHveZRuD5SuP4/YfmHveZRuD5SuP4/YfmHveZRuD5SuP4/YfmHveZRuD5SuP4/YfmHveVRuD7Xo3A/xpD5vOVRuD7Xo3A/xpD5vOVRuD7Xo3A/xpD5vOVRuD7Xo3A/xpD5vOdRuL7Xo3A/xpD5vOdRuL7Xo3A/xpD5vOdRuL7Xo3A/xpD5vOdRuL7Xo3A/xpD5vOVRuD7Xo3A/QqWnvOVRuD7Xo3A/QqWnvOVRuD7Xo3A/QqWnvOVRuD7Xo3A/QqWnvOZRuD5SuP4/xpD5vOZRuD5SuP4/xpD5vOZRuD5SuP4/xpD5vOZRuD5SuP4/xpD5vDCJwT7Xo3A/xpD5vDCJwT7Xo3A/xpD5vDCJwT7Xo3A/xpD5vDCJwT7Xo3A/QqWnvDCJwT7Xo3A/QqWnvDCJwT7Xo3A/QqWnvDGJwT5SuP4/xpD5vDGJwT5SuP4/xpD5vDGJwT5SuP4/xpD5vDGJwT5SuP4/QqWnvDGJwT5SuP4/QqWnvDGJwT5SuP4/QqWnvOZRuD5SuP4/QqWnvOZRuD5SuP4/QqWnvOZRuD5SuP4/QqWnvOZRuD5SuP4/QqWnvOZRuL5SuP4/QqWnvOZRuL5SuP4/QqWnvOZRuL5SuP4/QqWnvOZRuL5SuP4/QqWnvOZRuD5SuP4/bnMrPOZRuD5SuP4/bnMrPOZRuD5SuP4/bnMrPOZRuD5SuP4/bnMrPOVRuD7Xo3A/bnMrPOVRuD7Xo3A/bnMrPOVRuD7Xo3A/bnMrPOVRuD7Xo3A/bnMrPOZRuD5SuP4/PKWnPOZRuD5SuP4/PKWnPOZRuD5SuP4/PKWnPOZRuD5SuP4/PKWnPOZRuL5SuP4/bnMrPOZRuL5SuP4/bnMrPOZRuL5SuP4/bnMrPOZRuL5SuP4/bnMrPDGJwT5SuP4/bnMrPDGJwT5SuP4/bnMrPDGJwT5SuP4/bnMrPDCJwT7Xo3A/bnMrPDCJwT7Xo3A/bnMrPDCJwT7Xo3A/bnMrPDGJwT5SuP4/PKWnPDGJwT5SuP4/PKWnPDGJwT5SuP4/PKWnPDCJwT7Xo3A/PKWnPDCJwT7Xo3A/PKWnPDCJwT7Xo3A/PKWnPOVRuD7Xo3A/PKWnPOVRuD7Xo3A/PKWnPOVRuD7Xo3A/PKWnPOVRuD7Xo3A/PKWnPOdRuL7Xo3A/PKWnPOdRuL7Xo3A/PKWnPOdRuL7Xo3A/PKWnPOdRuL7Xo3A/PKWnPOVRuD7Xo3A//fxmPeVRuD7Xo3A//fxmPeVRuD7Xo3A//fxmPeVRuD7Xo3A//fxmPeZRuD5SuP4//fxmPeZRuD5SuP4//fxmPeZRuD5SuP4//fxmPeZRuD5SuP4//fxmPedRuL7Xo3A/bnMrPOdRuL7Xo3A/bnMrPOdRuL7Xo3A/bnMrPOdRuL7Xo3A/bnMrPOZRuL5SuP4/PKWnPOZRuL5SuP4/PKWnPOZRuL5SuP4/PKWnPOZRuL5SuP4/PKWnPDKJwb7Xo3A/PKWnPDKJwb7Xo3A/PKWnPDKJwb7Xo3A/PKWnPDKJwb7Xo3A/bnMrPDKJwb7Xo3A/bnMrPDKJwb7Xo3A/bnMrPDGJwb5SuP4/PKWnPDGJwb5SuP4/PKWnPDGJwb5SuP4/PKWnPDGJwb5SuP4/bnMrPDGJwb5SuP4/bnMrPDGJwb5SuP4/bnMrPOdRuL7Xo3A/QqWnvOdRuL7Xo3A/QqWnvOdRuL7Xo3A/QqWnvOdRuL7Xo3A/QqWnvDKJwb7Xo3A/QqWnvDKJwb7Xo3A/QqWnvDKJwb7Xo3A/QqWnvDKJwb7Xo3A/xpD5vDKJwb7Xo3A/xpD5vDKJwb7Xo3A/xpD5vDGJwb5SuP4/QqWnvDGJwb5SuP4/QqWnvDGJwb5SuP4/QqWnvDGJwb5SuP4/xpD5vDGJwb5SuP4/xpD5vDGJwb5SuP4/xpD5vOZRuL5SuP4/xpD5vOZRuL5SuP4/xpD5vOZRuL5SuP4/xpD5vOZRuL5SuP4/xpD5vOZRuL5SuP4/YfmHveZRuL5SuP4/YfmHveZRuL5SuP4/YfmHveZRuL5SuP4/YfmHvd05uL6Zff4/cL8Kvd05uL6Zff4/cL8Kvd05uL6Zff4/cL8Kvd05uL6Zff4/cL8KvRXvo74mPPo/AGUkvBXvo74mPPo/AGUkvBXvo74mPPo/AGUkvBXvo74mPPo/AGUkvN05uL6gwvs/OEyCvd05uL6gwvs/OEyCvd05uL6gwvs/OEyCvd05uL6gwvs/OEyCvd05uL7chcQ/p+uUPt05uL7chcQ/p+uUPt05uL7chcQ/p+uUPt05uL7chcQ/p+uUPtc5uD6Zff4/dL8Kvdc5uD6Zff4/dL8Kvdc5uD6Zff4/dL8Kvdc5uD6Zff4/dL8KvQ/voz4mPPo/EGUkvA/voz4mPPo/EGUkvA/voz4mPPo/EGUkvA/voz4mPPo/EGUkvNc5uD6gwvs/OEyCvdc5uD6gwvs/OEyCvdc5uD6gwvs/OEyCvdc5uD6gwvs/OEyCvdY5uD7chcQ/p+uUPtY5uD7chcQ/p+uUPtY5uD7chcQ/p+uUPtY5uD7chcQ/p+uUPg7voz5Qx8g/3raIPg7voz5Qx8g/3raIPg7voz5Qx8g/3raIPg7voz5Qx8g/3raIPtY5uD7kysE/iLCFPtY5uD7kysE/iLCFPtY5uD7kysE/iLCFPtY5uD7kysE/iLCFPg7voz5XDMY/fvdyPg7voz5XDMY/fvdyPg7voz5XDMY/fvdyPg7voz5XDMY/fvdyPt05uL7kysE/iLCFPt05uL7kysE/iLCFPt05uL7kysE/iLCFPt05uL7kysE/iLCFPhbvo75XDMY/fvdyPhbvo75XDMY/fvdyPhbvo75XDMY/fvdyPhbvo75XDMY/fvdyPhbvo75Qx8g/37aIPhbvo75Qx8g/37aIPhbvo75Qx8g/37aIPhbvo75Qx8g/37aIPhXvo74tgfc/QPIivRXvo74tgfc/QPIivRXvo74tgfc/QPIivRXvo74tgfc/QPIivQ/voz4tgfc/QPIivQ/voz4tgfc/QPIivQ/voz4tgfc/QPIivQ/voz4tgfc/QPIivd05uL6Jef8/uB/nO905uL6Jef8/uB/nO905uL6Jef8/uB/nO905uL6Jef8/uB/nOxXvo74VOPs/bhT9PBXvo74VOPs/bhT9PBXvo74VOPs/bhT9PBXvo74VOPs/bhT9PN05uL6Qvvw/Euq5vN05uL6Qvvw/Euq5vN05uL6Qvvw/Euq5vN05uL6Qvvw/Euq5vN05uL7MgcU/FOCpPt05uL7MgcU/FOCpPt05uL7MgcU/FOCpPt05uL7MgcU/FOCpPhXvo74dffg/YCeWOhXvo74dffg/YCeWOhXvo74dffg/YCeWOhXvo74dffg/YCeWOhbvo75HCMc/LHCOPhbvo75HCMc/LHCOPhbvo75HCMc/LHCOPhbvo75HCMc/LHCOPt05uL7UxsI/9KSaPt05uL7UxsI/9KSaPt05uL7UxsI/9KSaPt05uL7UxsI/9KSaPhbvo75Aw8k/TKudPhbvo75Aw8k/TKudPhbvo75Aw8k/TKudPhbvo75Aw8k/TKudPtY5uD7NgcU/E+CpPtY5uD7NgcU/E+CpPtY5uD7NgcU/E+CpPtY5uD7NgcU/E+CpPtc5uD6Jef8/uB/nO9c5uD6Jef8/uB/nO9c5uD6Jef8/uB/nO9c5uD6Jef8/uB/nOw7voz5Aw8k/TKudPg7voz5Aw8k/TKudPg7voz5Aw8k/TKudPg7voz5Aw8k/TKudPtY5uD7UxsI/9KSaPtY5uD7UxsI/9KSaPtY5uD7UxsI/9KSaPtY5uD7UxsI/9KSaPtc5uD6Qvvw/Euq5vNc5uD6Qvvw/Euq5vNc5uD6Qvvw/Euq5vNc5uD6Qvvw/Euq5vA7voz5ICMc/LHCOPg7voz5ICMc/LHCOPg7voz5ICMc/LHCOPg7voz5ICMc/LHCOPg/voz4dffg/ICeWOg/voz4dffg/ICeWOg/voz4dffg/ICeWOg/voz4dffg/ICeWOg/voz4WOPs/bhT9PA/voz4WOPs/bhT9PA/voz4WOPs/bhT9PA/voz4WOPs/bhT9POExhbxGZPw/wsGkPOExhbxGZPw/wsGkPOExhbwLLPo/qGyFu+ExhbwLLPo/qGyFu6AxhTwLLPo/qGyFu6AxhTwLLPo/qGyFu+cxhbwX3MU/V/WTPucxhbwX3MU/V/WTPpoxhTwX3MU/V/WTPpoxhTwX3MU/V/WTPucxhbxSFMg/JVegPucxhbxSFMg/JVegPpoxhTxSFMg/JVegPpoxhTxSFMg/JVegPqAxhTxGZPw/wsGkPKAxhTxGZPw/wsGkPDwK176kcF0/HoXrPTwK176kcF0/HoXrPTwK176kcF0/HoXrPTwK176kcF0/AAAAvjwK176kcF0/AAAAvjwK176kcF0/AAAAvjwK175wPWo/HoXrPTwK175wPWo/HoXrPTwK175wPWo/HoXrPTwK1z6kcF0/HoXrPTwK1z6kcF0/HoXrPTwK1z6kcF0/HoXrPTwK1z6kcF0/AAAAvjwK1z6kcF0/AAAAvjwK1z6kcF0/AAAAvjwK1z5wPWo/HoXrPTwK1z5wPWo/HoXrPTwK1z5wPWo/HoXrPTwK1z5wPWo/AAAAvjwK1z5wPWo/AAAAvjwK1z5wPWo/AAAAvjwK175wPWo/AAAAvjwK175wPWo/AAAAvjwK175wPWo/AAAAvui8rL7/vMU/5DiRPui8rL7/vMU/5DiRPui8rL47z8g/pDaIPui8rL47z8g/pDaIPliGtr7/vMU/5DiRPliGtr7/vMU/5DiRPliGtr47z8g/pDaIPliGtr47z8g/pDaIPui8rL4Pf6w/AC9xPOi8rL4Pf6w/AC9xPOi8rL4Pf6w/AC9xPOi8rL5Kka8/AGQ8u+i8rL5Kka8/AGQ8u+i8rL5Kka8/AGQ8u1iGtr4Pf6w/AC9xPFiGtr4Pf6w/AC9xPFiGtr4Pf6w/AC9xPFiGtr5Kka8/AGQ8u1iGtr5Kka8/AGQ8u1iGtr5Kka8/AGQ8u+i8rL4dRsc/xLeMPui8rL4dRsc/xLeMPliGtr4dRsc/xLeMPliGtr4dRsc/xLeMPliGtr4a+6w/AKmou1iGtr4a+6w/AKmou1iGtr4a+6w/AKmou1iGtr4a+6w/AKmou+i8rL4a+6w/AKmou+i8rL4a+6w/AKmou+i8rL4a+6w/AKmou+i8rL4a+6w/AKmou6Chsb7/vMU/5DiRPqChsb7/vMU/5DiRPqChsb47z8g/pDaIPqChsb47z8g/pDaIPqChsb4Pf6w/AC9xPKChsb4Pf6w/AC9xPKChsb4Pf6w/AC9xPKChsb5Kka8/AGQ8u6Chsb5Kka8/AGQ8u6Chsb5Kka8/AGQ8u6Chsb4a+6w/AKmou6Chsb4a+6w/AKmou+bBtj7/vMU/5DiRPubBtj7/vMU/5DiRPubBtj47z8g/pDaIPubBtj47z8g/pDaIPnb4rD7/vMU/5DiRPnb4rD7/vMU/5DiRPnb4rD47z8g/pDaIPnb4rD47z8g/pDaIPubBtj4Pf6w/AC9xPObBtj4Pf6w/AC9xPObBtj4Pf6w/AC9xPObBtj5Kka8/AGQ8u+bBtj5Kka8/AGQ8u+bBtj5Kka8/AGQ8u3b4rD4Pf6w/AC9xPHb4rD4Pf6w/AC9xPHb4rD4Pf6w/AC9xPHb4rD5Kka8/AGQ8u3b4rD5Kka8/AGQ8u3b4rD5Kka8/AGQ8u+bBtj4dRsc/xLeMPubBtj4dRsc/xLeMPnb4rD4dRsc/xLeMPnb4rD4dRsc/xLeMPnb4rD4a+6w/AKmou3b4rD4a+6w/AKmou3b4rD4a+6w/AKmou3b4rD4a+6w/AKmou+bBtj4a+6w/AKmou+bBtj4a+6w/AKmou+bBtj4a+6w/AKmou+bBtj4a+6w/AKmouy7dsT7/vMU/5DiRPi7dsT7/vMU/5DiRPi7dsT47z8g/pDaIPi7dsT47z8g/pDaIPi7dsT4Pf6w/AC9xPC7dsT4Pf6w/AC9xPC7dsT4Pf6w/AC9xPC7dsT4Pf6w/AC9xPC7dsT5Kka8/AGQ8uy7dsT5Kka8/AGQ8uy7dsT5Kka8/AGQ8uy7dsT5Kka8/AGQ8uy7dsT4a+6w/AKmouy7dsT4a+6w/AKmouy7dsT4a+6w/AKmouy7dsT4a+6w/AKmou83MzD6F6wFAAAAAgM3MzD6F6wFAAAAAgMvMzL6F6wFAAAAAgMvMzL6F6wFAAAAAgMvMzL5mZmY/AAAAgMvMzL5mZmY/AAAAgM3MzD5mZmY/AAAAgM3MzD5mZmY/AAAAgP7//74AAAAAANgltv7//74AAAAAANgltv7//77OzAxAANgltv7//77OzAxAANgltv7//76F6wFAANgltv7//76QwvU9ANgltv7//764HgU+gHobOAAAAD/OzAxAANgltgAAAD/OzAxAANgltgAAAD8AAAAAANgltgAAAD8AAAAAANgltgAAAD+4HgU+ANgltgAAAD+QwvU9ANgltgAAAD+F6wFAANgltsrMzL7OzAxAANglts7MzD7OzAxAANgltsvMzL4AAAAAANglts3MzD4AAAAAANgltgAAAD9mZmY/ANgltv7//75mZmY/ANgltv7//74AAAAAjsL1vf7//74AAAAAjsL1vf7//74AAAAAjsL1vf7//77OzAxAzszMvf7//77OzAxAzszMvf7//77OzAxAzszMvf7//76F6wFAzszMvf7//76F6wFAzszMvf7//76QwvU9jsL1vf7//76QwvU9jsL1vf7//76QwvU9jsL1vf7//764HgU+zszMvf7//764HgU+zszMvf7//764HgU+zszMvQAAAD+QwvU9jsL1vQAAAD+QwvU9jsL1vQAAAD+QwvU9jsL1vQAAAD+4HgU+zszMvQAAAD+4HgU+zszMvQAAAD+4HgU+zszMvQAAAD+F6wFAzszMvQAAAD+F6wFAzszMvQAAAD+F6wFAzszMvQEAAD/OzAxAzszMvQEAAD/OzAxAzszMvQEAAD/OzAxAzszMvQAAAD8AAAAAjsL1vQAAAD8AAAAAjsL1vQAAAD8AAAAAjsL1vc3MzD6QwvU9jsL1vc3MzD6QwvU9jsL1vc3MzD6QwvU9jsL1vcvMzL6QwvU9jsL1vcvMzL6QwvU9jsL1vcvMzL6QwvU9jsL1vcvMzL64HgU+zszMvcvMzL64HgU+zszMvcvMzL64HgU+zszMvc3MzD64HgU+zszMvc3MzD64HgU+zszMvc3MzD64HgU+zszMvcvMzL6F6wFAzszMvcvMzL6F6wFAzszMvcvMzL6F6wFAzszMvcvMzL6F6wFAzszMvc3MzD6F6wFAzszMvc3MzD6F6wFAzszMvc3MzD6F6wFAzszMvc3MzD6F6wFAzszMvcvMzL4AAAAAjsL1vcvMzL4AAAAAjsL1vc3MzD4AAAAAjsL1vc3MzD4AAAAAjsL1vc7MzD7OzAxAzszMvc7MzD7OzAxAzszMvc7MzD7OzAxAzszMvcrMzL7OzAxAzszMvcrMzL7OzAxAzszMvcrMzL7OzAxAzszMvf7//75mZmY/zszMvf7//75mZmY/zszMvQAAAD9mZmY/zszMvQAAAD9mZmY/zszMvcvMzL5mZmY/zszMvcvMzL5mZmY/zszMvcvMzL5mZmY/zszMvc3MzD5mZmY/zszMvc3MzD5mZmY/zszMvc3MzD5mZmY/zszMvc3MzD6F6wFAAAAAgM3MzD6F6wFAAAAAgM3MzD5mZmY/AAAAgM3MzD5mZmY/AAAAgMvMzL5mZmY/AAAAgMvMzL5mZmY/AAAAgMvMzL6F6wFAAAAAgMvMzL6F6wFAAAAAgP7//74AAAAAANgltv7//74AAAAAANgltv7//77OzAxAANgltv7//77OzAxAANgltv7//76F6wFAANgltv7//76QwvU9ANgltv7//764HgU+gHobOAAAAD/OzAxAANgltgAAAD/OzAxAANgltgAAAD8AAAAAANgltgAAAD8AAAAAANgltgAAAD+4HgU+ANgltgAAAD+QwvU9ANgltgAAAD+F6wFAANgltgAAAD+F6wFAANgltsrMzL7OzAxAANglts7MzD7OzAxAANgltsvMzL4AAAAAANglts3MzD4AAAAAANgltgAAAD9mZmY/ANgltv7//75mZmY/ANgltgAAgL8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAPwAAgL8AAAAAAAAAgAAAAAAAAAAAAACAPwAAAAAAAIA/AAAAgAAAgL8AAAAAAAAAgAAAAAAAAAAAAACAPwAAgL8AAAAAAAAAgAAAAAAAAAAAAACAP06mOTne5GQ/W0rlPgAAgL8AAAAAAAAAgE6mOTne5GQ/W0rlPv9SzznfWVc4/v9/PwAAAAAAAAAAAACAPwAAAAAAAIA/AAAAgAAAgD8AAAAAAAAAgAAAAAAAAAAAAACAPwAAgD8AAAAAAAAAgAAAAAAAAAAAAACAPwAAAAAX/GQ/i+3kPgAAgD8AAAAAAAAAgAAAAAAAAAAAAACAPwAAAAAX/GQ/i+3kPgAAgD8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAPwAAgD8AAAAAAAAAgAAAAAAAAAAAAACAPwAAAAAAAIA/AAAAgAAAAAAAAAAAAACAPwAAAAAAAIA/AAAAgP//f78AAAAAAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAPwAAAAAAAIC/AAAAgAAAAAAAAAAAAACAP///fz8AAAAAAAAAgAAAAAAAAAAAAACAPwAAAAAX/GQ/i+3kPgAAAAAX/GQ/j+3kPgAAAAAAAAAAAACAPwAAAAAX/GQ/j+3kPk6mOTne5GQ/W0rlPv9SzznfWVc4/v9/PwAAAAAAAAAAAACAPwAAAAAX/GQ/j+3kPk6mOTne5GQ/W0rlPgAAAAAAAAAAAACAPwAAAAAX/GQ/i+3kPgAAAAAX/GQ/j+3kPgAAAAAAAIC/AAAAgAAAAAAAAAAAAACAPwAAAAAAAIC/AAAAgAAAAAAAAAAAAACAPwAAgL8AAAAAAAAAgAAAAAAAAAAAAACAP/9SzznfWVc4/v9/PwAAAAAAAAAAAACAPwAAgD8AAAAAAAAAgAAAAAAAAAAAAACAPwAAAAAAAIA/AAAAgP9SzznfWVc4/v9/P///fz8AAAAAAAAAgP//f78AAAAAAAAAgAAAAAAAAAAAAACAPwAAAAAAAIA/AAAAgALPp7EAAAAAAACAPwAAAAAAAAAA//9/PwLPp7EAAAAAAACAPwAAAAAAAIC/AAAAgAAAAAAAAAAA//9/PwAAgD89z/OyAAAAgALPp7EAAAAAAACAPwAAAAAAAAAAAACAPwAAAAAAAAAA//9/vwAAAADxj7QzAACAvwPPp7HXv3CyAACAPwAAAAAAAAAA//9/PwPPp7HXv3CyAACAPwAAAAAAAAAA//9/PwAAAAAAAIA/AAAAgAAAgD89z/OyAAAAgAPPp7HXv3CyAACAPwAAAAAAAAAAAACAPwAAAADXv/CzAACAvwAAAAAAAAAA//9/vwAAAADXv/CzAACAvwAAAAAAAAAA//9/vwAAAAAAAIA/AAAAgAAAgD89z/OyAAAAgAAAAADXv/CzAACAvwAAAAAAAAAAAACAvwAAAAAAAAAAAACAvwAAAADxj7QzAACAvwAAgL89z/MyAAAAgAAAAADXv/CzAACAvwAAAAAAAAAAAACAvwAAAAAAAIA/AAAAgAAAgL89z/MyAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAvwAAAADxj7QzAACAvwAAgL89z/MyAAAAgAAAAAAAAAAAAACAPwAAAAD//38/AAAAgAAAAAAAAIA/AAAAgAAAAAAAAAAAAACAPwAAAAD//38/AAAAgAAAAAAAAIA/AAAAgAAAgD89z/OyAAAAgAAAgL8+z/MyAAAAgAAAAAAAAAAAAACAvwAAAAD//38/AAAAgAAAAAAAAIA/AAAAgAAAgL89z/MyAAAAgAAAAAAAAIC/AAAAgAAAAAD//3+/AAAAgAAAAAAAAAAAAACAPwAAgL89z/MyAAAAgAAAAAAAAAAAAACAPwAAAAAAAIA/AAAAgAAAgL89z/MyAAAAgAAAAAAAAAAAAACAvwAAAAAAAIA/AAAAgAAAgL89z/MyAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAPwAAgL89z/MyAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAvwAAgL8+z/MyAAAAgAAAAAAAAIC/AAAAgAAAAAD//3+/AAAAgAAAAAAAAAAAAACAvwAAAAAAAIC/AAAAgAAAAAD//3+/AAAAgAAAAAAAAAAAAACAvwAAgD8+z/OyAAAAgAAAgL8+z/MyAAAAgAAAAAAAAIC/AAAAgAAAAAD//3+/AAAAgAAAAAAAAAAAAACAPwAAgL8+z/MyAAAAgAAAAAAAAAAAAACAPwAAAAD//38/AAAAgAAAAAAAAIA/AAAAgAAAgL89z/MyAAAAgAAAAAAAAIC/AAAAgAAAAAD//3+/AAAAgAAAAAAAAAAAAACAvwAAAAAAAIC/AAAAgAAAAAD//3+/AAAAgAAAAAAAAAAAAACAPwAAgD8+z/OyAAAAgAAAgL89z/MyAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAPwAAgL89z/MyAAAAgAAAAAAAAAAAAACAPwAAAAAAAIA/AAAAgAAAgL89z/MyAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAvwAAgL89z/MyAAAAgAAAAAAAAAAAAACAvwAAAAAAAIA/AAAAgAAAgL89z/MyAAAAgAAAAAAAAAAAAACAvwAAAAD//38/AAAAgAAAAAAAAIA/AAAAgAAAAAAAAAAAAACAvwAAAAD//38/AAAAgAAAAAAAAIA/AAAAgAAAgD89z/OyAAAAgAAAgL89z/MyAAAAgAPPp7HXv3CyAACAPwAAAAAAAAAAAACAPwAAAAAAAIA/AAAAgAAAgL89z/MyAAAAgALPp7EAAAAAAACAPwAAAAAAAIC/AAAAgAAAAAAAAAAAAACAPwAAAAAAAAAAAACAPwAAAAD//38/AAAAgAAAAAAAAIA/AAAAgAAAgD8+z/OyAAAAgAAAAAAAAIC/AAAAgAAAAAD//3+/AAAAgAAAAAAAAAAAAACAvwAAgD89z/OyAAAAgAAAAAAAAAAAAACAvwAAAAAAAIA/AAAAgAAAgD89z/OyAAAAgAAAAAAAAAAAAACAPwAAAAAAAIA/AAAAgAAAgD89z/OyAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAvwAAgD89z/OyAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAPwAAgD89z/OyAAAAgAAAAAAAAAAAAACAvwAAAAD//38/AAAAgAAAAAAAAIA/AAAAgAAAgD8+z/OyAAAAgAAAAAAAAAAAAACAvwAAAAAAAIA/AAAAgAAAgD89z/OyAAAAgAAAAAAAAAAAAACAPwAAAAAAAIA/AAAAgAAAgD89z/OyAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAvwAAgD89z/OyAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAPwAAgD89z/OyAAAAgAAAAAAAAIC/AAAAgAAAAAD//3+/AAAAgAAAAAAAAAAAAACAPwAAgD89z/OyAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAA//9/vwAAAADxj7QzAACAvwAAgD89z/OyAAAAgAAAgL8AAAAAAAAAgFx1Q7SfLRU//QpQPwAAAACSLRU/BwtQPwAAAAD2ClA/qi0Vv1x1Q7SfLRU//QpQPwAAAAD2ClC/qS0VPwAAAACSLRU/BwtQPwAAgD+xyVqzlqUPtAAAgL8AAAAAAAAAgAAAAACSLRW/BwtQvwAAAAD2ClA/qi0Vv1t1wzSfLRW//wpQvwAAgL8AAAAAAAAAgFx1Q7SfLRU//QpQPwAAAAAOC1C/ii0VP03IDzSaLRU/AwtQP/yXErWaLRU/AgtQPwAAAACSLRU/BwtQPwAAAAD2ClA/qi0VvwAAgD/UqTqzmM+GNAAAgL+2yVozAAAAgPyXErWaLRU/AgtQPwAAAAD2ClC/qS0VPwAAAACSLRU/BwtQP1B1w7SbLRW//wpQvwAAAACSLRW/BwtQvwAAAAD2ClA/qi0VvwAAgD/UqTqzmM+GNPyXErWaLRU/AgtQPwAAAAAOC1C/ii0VP03IDzSaLRU/AwtQPwAAgD/UqTqzmM+GNAAAgL+2yVozAAAAgPyXErWaLRU/AgtQPwAAAADyClA/ri0Vv03IDzSaLRU/AwtQP1B1w7SbLRW//wpQvwAAAAAOC1C/ii0VPwAAAACyLRW/7wpQvwAAgD/UqTqzmM+GNAAAgL+2yVozAAAAgFB1w7SbLRW//wpQvwAAAACyLRW/7wpQvwAAAADyClA/ri0VvwAAgL8AAAAAAAAAgAAAAAAOC1C/ii0VPwAAAACyLRW/7wpQv1t1wzSfLRW//wpQvwAAAACyLRW/7wpQvwAAAADyClA/ri0Vv1t1wzSfLRW//wpQvwAAgD+xyVqzlqUPtFx1Q7SfLRU//QpQPwAAAADyClA/ri0Vv03IDzSaLRU/AwtQPwAAgD+xyVqzlqUPtAAAAAD2ClC/qS0VPwAAAACSLRW/BwtQv1t1wzSfLRW//wpQvwAAgD+xyVqzlqUPtAAAgL+2yVozAAAAgFB1w7SbLRW//wpQvwAAAAD2ClC/qS0VPwAAAACSLRW/BwtQvwAAgL8AAAAAAAAAgF11Q7WfLRU//gpQPwAAAACWLRU/AgtQPwAAAAD3ClA/qC0Vv111Q7WfLRU//gpQPwAAAACWLRU/AgtQP3erPjQCC1C/ly0VPwAAgD/uyVqzHgOeNAAAgL8AAAAAAAAAgFx1w7WeLRW/AAtQvwAAAACmLRW/+gpQvwAAAAD3ClA/qC0VvwAAgL8AAAAAAAAAgF11Q7WfLRU//gpQPwAAAAADC1C/li0VPwAAAACbLRU/AQtQP1x1w7WeLRW/AAtQvwAAAACmLRW/+gpQv3erPjQCC1C/ly0VPwAAgD/uyVqzHgOeNFx1w7WeLRW/AAtQvwAAAACYLRW/BAtQvwAAAAAEC1A/ly0VvwAAgD/uyVqzHgOeNAAAgL8AAAAAAAAAgFx1w7WeLRW/AAtQvwAAAAADC1C/li0VPwAAAACYLRW/BAtQv111Q7WfLRU//gpQPwAAAACbLRU/AQtQPwAAAAAEC1A/ly0VvwAAgD/uyVqzHgOeNAAAAAADC1C/li0VPwAAAACaLRU/AQtQPwAAAACbLRU/AQtQPwAAgD/jqTqzTdW3NAAAAACWLRU/AgtQPwAAAACaLRU/AQtQPwAAAAD3ClA/qC0VvwAAgD/jqTqzTdW3NAAAgL+9yVozytXltAAAAACaLRU/AQtQPwAAAACbLRU/AQtQPwAAAAAEC1A/ly0VvwAAAAADC1C/li0VPwAAAACYLRW/BAtQv1B1wzWZLRW/AgtQvwAAgD/jqTqzTdW3NAAAAACmLRW/+gpQvwAAAAD3ClA/qC0Vv1B1wzWZLRW/AgtQvwAAgD/jqTqzTdW3NAAAgL+9yVozytXltAAAAACYLRW/BAtQvwAAAAAEC1A/ly0Vv1B1wzWZLRW/AgtQvwAAgL+9yVozytXltAAAAACmLRW/+gpQv3erPjQCC1C/ly0VP1B1wzWZLRW/AgtQvwAAgL+9yVozytXltAAAAACWLRU/AgtQPwAAAACaLRU/AQtQP3erPjQCC1C/ly0VPwAAgL8AIpsyAAAAgAAAAACZLRU/AQtQPwAAgL8AIpsyAAAAgAAAAACaLRW/AQtQvwAAAACaLRW/AQtQvwAAgD8pIpuyAAAAgAAAgL8AIpsyAAAAgAAAAACaLRW/AQtQvwAAAACaLRW/AQtQvwAAgD8pIpuyAAAAgAAAgL8AIpsyAAAAgAAAAACZLRU/AQtQPwAAAACZLRU/AQtQPwAAgD8pIpuyAAAAgAAAAACZLRU/AQtQPwAAgD8pIpuyAAAAgAAAgL8AAAAAAAAAgAAAAAD//3+/AAAAgAAAAAAAAAAAAACAPwAAgL8AAAAAAAAAgAAAAAD//3+/AAAAgAAAAAAAAAAAAACAvwAAgL8AAAAAAAAAgAAAAAAAAAAAAACAPwAAAAD//38/AAAAgAAAAAD//3+/AAAAgAAAAAAAAAAAAACAPwAAgD8AAAAAAAAAgAAAAAD//3+/AAAAgAAAAAAAAAAAAACAvwAAgD8AAAAAAAAAgAAAAAAAAAAAAACAPwAAAAD//38/AAAAgAAAgD8AAAAAAAAAgAAAAAAAAAAAAACAvwAAAAD//38/AAAAgAAAgD8AAAAAAAAAgAAAgL8AAAAAAAAAgAAAAAAAAAAAAACAvwAAAAD//38/AAAAgAAAAADYcE6/NmMXPwAAgD8AAAAAu5q5NQAAAADHcE4/UWMXvwAAgD8AAAAA+f/EswAAgL8AAAAAOQSFtQAAAADGcE6/UGMXPwAAgL8AAAAAAAAAgAAAAADYcE4/N2MXvwAAAADaeXu/vqg/vgAAAADYcE6/NmMXPwAAgD8AAAAAu5q5NQAAAABr3OQ9g2V+vwAAAADHcE4/UWMXvwAAgD8AAAAA+f/EswAAgL8AAAAAOQSFtQAAAADaeXu/vqg/vgAAAADGcE6/UGMXPwAAgL8AAAAAAAAAgAAAAABr3OQ9g2V+vwAAAADYcE4/N2MXvwAAgD8AAAAA+f/EswAAgD8AAAAAu5q5NQAAgL8AAAAAOQSFtQAAgL8AAAAAAAAAgAAAgL8AAAAAOQSFtQAAgL8AAAAAAAAAgAAAAADaeXu/vqg/vgAAAABr3OQ9g2V+vwAAAADaeXu/vqg/vgAAAABr3OQ9g2V+vwAAgD8AAAAA+f/EswAAgD8AAAAAu5q5NQAAAADYcE6/NmMXPwAAAADGcE6/UGMXPwAAAADHcE4/UWMXvwAAAADYcE4/N2MXvwAAAADaeXu/vqg/vgAAAADYcE6/NmMXPwAAAADGcE6/UGMXPwAAAABr3OQ9g2V+vwAAAADHcE4/UWMXvwAAAADYcE4/N2MXvwAAAADaeXu/vqg/vgAAAABr3OQ9g2V+vwAAAADYcE6/NmMXPwAAgD8AAAAA+Xh3tQAAAADHcE4/UWMXvwAAgD8AAAAA+78TNQAAgL8AAAAAyXuUNQAAAADGcE6/UGMXPwAAgL8AAAAA5v9EtQAAAADYcE4/N2MXvwAAAADceXu/lqg/vgAAAADYcE6/NmMXPwAAgD8AAAAA+Xh3tQAAAABJ3OQ9hWV+vwAAAADHcE4/UWMXvwAAgD8AAAAA+78TNQAAgL8AAAAAyXuUNQAAAADaeXu/vqg/vgAAAADGcE6/UGMXPwAAgL8AAAAA5v9EtQAAAABr3OQ9g2V+vwAAAADYcE4/N2MXvwAAgD8AAAAA+Xh3tQAAgD8AAAAA+78TNQAAgL8AAAAA5v9EtQAAgL8AAAAAyXuUNQAAgL8AAAAA5v9EtQAAgL8AAAAAyXuUNQAAAADaeXu/vqg/vgAAAABr3OQ9g2V+vwAAAADceXu/lqg/vgAAAABJ3OQ9hWV+vwAAgD8AAAAA+Xh3tQAAgD8AAAAA+78TNQAAAADYcE6/NmMXPwAAAADGcE6/UGMXPwAAAADHcE4/UWMXvwAAAADYcE4/N2MXvwAAAADceXu/lqg/vgAAAADaeXu/vqg/vgAAAADYcE6/NmMXPwAAAADGcE6/UGMXPwAAAABJ3OQ9hWV+vwAAAABr3OQ9g2V+vwAAAADHcE4/UWMXvwAAAADYcE4/N2MXvwAAAADceXu/lqg/vgAAAADaeXu/vqg/vgAAAABJ3OQ9hWV+vwAAAABr3OQ9g2V+v///f78AAAAAAAAAgAAAAAAAAIC/AAAAgAAAAAAAAIC/AAAAgP//fz8AAAAAAAAAgAAAAAAAAIA/AAAAgP//fz8AAAAAAAAAgP//f78AAAAAAAAAgAAAAAAAAIA/AAAAgAAAgL8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAgL8AAAAAAAAAgAAAAAAAAIA/AAAAgAAAgL8AAAAAAAAAgAAAgL8AAAAAAAAAgAAAgL8AAAAAAAAAgAAAAAAAAIA/AAAAgAAAgD8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAgD8AAAAAAAAAgAAAgD8AAAAAAAAAgAAAgD8AAAAAAAAAgAAAgD8AAAAAAAAAgAAAAAAAAIA/AAAAgAAAAAAAAIA/AAAAgAAAAAAAAIC/AAAAgAAAAAAAAIC/AAAAgAAAgD8AAAAAAAAAgAAAgL8AAAAAAAAAgAAAgL8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAvwAAgL8AAAAAAAAAgAAAAAAAAAAAAACAvwAAAAAAAIA/AAAAgAAAgL8AAAAAAAAAgAAAAAAAAAAAAACAvwAAgL8AAAAAAAAAgAAAAAAAAAAAAACAvwAAAAAt+WQ/NPnkvgAAgL8AAAAAAAAAgAAAAAAAAAAAAACAvwAAAAAt+WQ/NPnkvgAAAAAAAAAAAACAvwAAAAAu+WQ/LvnkvgAAgD8AAAAAAAAAgAAAAAAAAAAAAACAvwAAAAAu+WQ/LvnkvgAAgD8AAAAAAAAAgAAAAAAAAAAAAACAvwAAgD8iPDy0AAAAgAAAgD8AAAAAAAAAgAAAAAAAAAAAAACAvwAAAAAAAIA/AAAAgAAAgD8iPDy0AAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAvwAAgD8AAAAAAAAAgAAAAAAAAAAAAACAvwAAAAAu+WQ/MvnkvgAAAAAu+WQ/LvnkvgAAAAAAAAAAAACAvwAAAAAt+WQ/NPnkvgAAAAAu+WQ/MvnkvgAAAAAAAAAAAACAvwAAAAAt+WQ/NPnkvgAAAAAu+WQ/MvnkvgAAAAAAAAAAAACAvwAAAAAu+WQ/MvnkvgAAAAAu+WQ/LvnkvgAAAAAAAIC/AAAAgAAAAAAAAAAAAACAvwAAAAAnPLwyAACAvwAAgD8AAAAAAAAAgAAAgL8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAAAAAAAAAAACAvwAAAAAnPLwyAACAvwAAAAAAAIC/AAAAgAAAAAAAAAAAAACAvwAAAAAAAIC/AAAAgAAAAAAAAAAAAACAvwAAAAAAAAAAAACAvwAAAAAnPLwyAACAvwAAAAAAAIA/AAAAgAAAAAAAAAAAAACAvwAAAAAnPLwyAACAvwAAAAAAAIA/AAAAgAAAgL8AAAAAAAAAgAAAAAAAAAAAAACAvwAAAAAAAAAAAACAvwAAgD8AAAAAAAAAgAAAAAAAAAAAAACAvwAAAAAAAIA/AAAAgAAAgD8AAAAAAAAAgAAAgL8AAAAAAAAAgAAAAAAAAAAAAACAvwAAAAAAAIA/AAAAgAAAgL8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAgL8AAAAAAAAAgAAAAAAAAIA/AAAAgAAAAAAAAIA/AAAAgAAAgD8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAgD8AAAAAAAAAgAAAgL8AAAAAAAAAgAAAAAAAAIC/AAAAgAAAgL8AAAAAAAAAgAAAAAAAAIA/AAAAgAAAgL8AAAAAAAAAgAAAgL8AAAAAAAAAgAAAgL8AAAAAAAAAgAAAAAAAAIA/AAAAgAAAgD8iPDy0AAAAgAAAAAAAAIC/AAAAgAAAgD8AAAAAAAAAgAAAgD8AAAAAAAAAgAAAgD8AAAAAAAAAgAAAgD8iPDy0AAAAgAAAgD8AAAAAAAAAgAAAAAAAAIA/AAAAgAAAAAAAAIA/AAAAgAAAAAAAAIC/AAAAgAAAAAAAAIC/AAAAgAAAgD8AAAAAAAAAgAAAgL8AAAAAAAAAgADAfz8AwH8/AMB/PwDAfz+grwA8CshuPwDAfz8AwH8/4Lj1O0AnRzwAwH8/AMB/PwDAfz8AwH8/4Lj1OxgFuT0AwH8/AMB/P6CvADyTyGI/oK8APJPIYj8AwH8/AMB/P6CvADxOXmE/4Lj1O9RaSD8dAMo+wMtNPADAfz8AwH8/AMB/PwDAfz8dAMo+qNm5PQDAfz8AwH8/HQDKPmZ1SD+m2ck+Tl5hPwDAfz8AwH8/ptnJPpDIYj+m2ck+kMhiPwDAfz8AwH8/AMB/PwDAfz+m2ck+CshuPwDAfz8AwH8/AE83PUAnRzwAwH8/AMB/P6z2tD5AJ0c8AMB/PwDAfz/LrfY+IH24PafD2z7uEUo/sva0PhgFuT14klQ97hFKPwBPNz0YBbk9FbPPPiB9uD249rQ+1FpIP9ButT5OXmE/0G61Pk5eYT8ATzc91FpIP1R1Pj1OXmE/VHU+PU5eYT8ATzc91FpIP1R1Pj2TyGI/VHU+PZPIYj9UdT49k8hiP9ButT6QyGI/0G61PpDIYj/QbrU+kMhiPwDAfz8AwH8/VHU+PQrIbj8AwH8/AMB/P9ButT4KyG4/AMB/PwDAfz/guPU7bGP/PuC49TtsY/8+HQDKPpCY/z4AwH8/AMB/PwBPNz1sY/8+RHRKPebnXz8ATzc9bGP/PhWzzz5sY/8+y632Pmxj/z629rQ+bGP/PnEH3T7m518/ZDkyP1JVTT9kOTI/UlVNP7jALz/30Eo/3yQhPwTfEj+4wC8/99BKPyGYLT/7CEc/Sq4DP1JVTT9KrgM/UlVNP06uAz9QVU0/Tq4DP1BVTT95OTI/taELP3k5Mj+1oQs/xsAvPxUmDj/GwC8/FSYOP/T4GD+w4BI/IZgtPyYQEj9DrgM/rKELP0OuAz+soQs/Ra4DP7OhCz9FrgM/s6ELP/kmBj8RJg4/+SYGPxEmDj/fJCE/Dd8SP/MIIz8wFBI/eTkyP66hCz95OTI/rqELP3I5Mj9SVU0/cjkyP1JVTT8hmC0/JhASP8TALz8QJg4/xMAvPxAmDj/eJCE/821GPyGYLT/7CEc/9PgYP41vRj/EwC8/8dBKP8TALz/x0Eo/oM8rPyYQEj+gzys/JhASP0nZHj/zbUY/SdkeP/NtRj920SQ/MhQSP1DZHj8N3xI/UNkePw3fEj920SQ/MhQSPwYVKT8rEhI/BhUpPysSEj/KCx4/w25GP8oLHj/DbkY/mc8rP/oIRz+GRBs/jW9GP4ZEGz+Nb0Y/mc8rP/oIRz+55io/OBASP7nmKj84EBI/oNoeP50MSD/l/Sk/GhISP+X9KT8aEhI/Gg0eP3ENSD+55io/EQlHP9pFGz87Dkg/ueYqPxEJRz/i/Sk/8gpHP1cTHD9nDUg/4v0pP/IKRz8DFSk/AQtHPwYSHD+7bkY/BhIcP7tuRj8DFSk/AQtHPwkSHD/b3xI/CRIcP9vfEj8HjCc/AQtHPweMJz8BC0c/B4wnPwELRz/PCx4/u25GP88LHj+7bkY/B4wnPwELRz8OjCc/KxISPw6MJz8rEhI/ABIcP8NuRj8AEhw/w25GP23RJD8HDUc/UtkeP+htRj9S2R4/6G1GP23RJD8HDUc/1AseP9vfEj/UCx4/298SPwMVKT8BC0c/AxUpPwELRz8moyY/FAtHPx4NHj9nDUg/JqMmPxQLRz8uoyY/OhISPy6jJj86EhI/VBMcP3ENSD9OuiU/9AxHP6XaHj+bDEg/TrolP/QMRz9VuiU/HBQSP1W6JT8cFBI/0UUbPz0OSD920SQ/MBQSP3bRJD8wFBI/gkQbP5ZvRj+CRBs/lm9GP6DPKz8mEBI/hEQbP7DgEj+ERBs/sOASP6DPKz8mEBI/8wgjPzAUEj/zJgY/DiYOP/MmBj8OJg4/9PgYP5ZvRj/qCCM/Bw1HP/omBj/x0Eo/3yQhP+htRj/6JgY/8dBKPwYVKT8sEhI/BhIcP9vfEj8GEhw/298SPwYVKT8sEhI/UtkePwTfEj9S2R4/BN8SP5vPKz/6CEc/m88rP/oIRz+55io/OBASPy1DGz8HQhE/ueYqPzgQEj/l/Sk/GhISP7UQHD81QRE/5f0pPxoSEj8D2B4/XEARP7nmKj8RCUc/ueYqPxEJRz+ECh4/LUERP+P9KT/yCkc/4/0pP/IKRz8OjCc/LBISP88LHj/b3xI/zwseP9vfEj8OjCc/LBISPy6jJj8+EhI/fAoePzVBET8uoyY/PhISP1W6JT8cFBI/+tceP15AET9VuiU/HBQSP7oQHD8tQRE/JqMmPxQLRz8moyY/FAtHPzNDGz//QRE/TrolP/QMRz9OuiU/9AxHP4tEGz+m4BI/i0QbP6bgEj9t0SQ/Bw1HP23RJD8HDUc/+PgYP6bgEj//JgY/9NBKP/8mBj/00Eo/6ggjPwcNRz8AAC8/KKFmP8LE/j5yfVI/wsT+PnJ9Uj8AAC8/bq9iP2R6Aj/8rlU/AAAvP+xeXT9kegI//K5VPwAALz/toWI/AAAvP26vYj/ljjc/cn1SPwAALz8ooWY/5Y43P3J9Uj/VNwg/KKFmP8jE/j5m/X0/AAAvPyihZj/IxP4+Zv19P+WONz9yfVI/5Y43P3J9Uj/VNwg/bq9iPwAALz9gsGI/AAAvP5yvZj/kdjQ//K5VP9U3CD/sXl0/5HY0P/yuVT/CxP4+cn1SP8LE/j5yfVI/1TcIPyihZj8AAC8/GqJmP+WONz9h/X0/1TcIPyihZj/ljjc/Yf19P9U3CD9gsGI/1TcIP5uvZj/kdjQ/2Mt6P9U3CD96A1s/5HY0P9jLej/IxP4+Zv19P9U3CD9ur2I/yMT+Pmb9fT/VNwg/GqJmP9U3CD/toWI/ZHoCP9jLej9kegI/2Mt6P9U3CD/sXl0/1TcIP26vYj8AAC8/bq9iP+WONz9h/X0/5Y43P2H9fT/kdjQ/2Mt6PwAALz/sXl0/5HY0P9jLej/VNwg/m69mP2R6Aj/Yy3o/AAAvP3oDWz9kegI/2Mt6P9U3CD/toWI/AAAvP3oDWz/kdjQ//K5VP+R2ND/8rlU/AAAvP5yvZj8AAC8/7aFiP2R6Aj/8rlU/1TcIP3oDWz9kegI//K5VPwAALz/CfmE/wsT+PnJ9Uj/CxP4+cn1SPwAALz/2VF4/ZHoCP/yuVT9kegI//K5VPwAALz/sXl0/AAAvP+2hYj8AAC8/9lReP+WONz9yfVI/5Y43P3J9Uj8AAC8/wn5hP9U3CD/CfmE/yMT+Pmb9fT8AAC8/wn5hP8jE/j5m/X0/5HY0P/yuVT/kdjQ//K5VPwAALz96A1s/AAAvP5yvZj/kdjQ/2Mt6P+R2ND/Yy3o/AAAvP+xeXT/VNwg/m69mP9U3CD/0VF4/5Y43P2H9fT8AAC8/9lReP+WONz9h/X0/ZHoCP9jLej9kegI/2Mt6PwAALz96A1s/1TcIP+2hYj/VNwg/wn5hP+WONz9h/X0/5Y43P2H9fT/VNwg/9lReP+WONz9yfVI/5Y43P3J9Uj/VNwg/9lRePwAALz/2VF4/1TcIP5uvZj/kdjQ/2Mt6P+R2ND/Yy3o/1TcIP3oDWz/VNwg/9FReP8jE/j5m/X0/yMT+Pmb9fT/VNwg/wn5hP8LE/j5yfVI/1TcIP8J+YT/CxP4+cn1SPwAALz/CfmE/1TcIP+2hYj9kegI/2Mt6P9U3CD/sXl0/ZHoCP9jLej8AAC8/7aFiP2R6Aj/8rlU/1TcIP3oDWz9kegI//K5VPwAALz+cr2Y/5HY0P/yuVT/kdjQ//K5VP9U3CD/sXl0/AAAvP+xeXT8AAC8/egNbPwAALz96A1s/AAAvP+xeXT8AAC8/egNbPwAALz/sXl0/1TcIP3oDWz/VNwg/7F5dP9U3CD96A1s/1TcIP+xeXT/VNwg/7F5dP9U3CD96A1s/1TcIP+xeXT/VNwg/eQNbPwAALz/sXl0/AAAvP3oDWz81uwg/d/g8PwgFFz/jrRI/HaQIP+OtEj9GexY/d/g8P+afCz/jrRI/HaQIPwUxOz81uwg/S3lAP2oBCz/jrRI/5p8LP+OtEj8IBRc/BTE7Px2kCD8FMTs/tWsWP3f4PD/mnws/BTE7Px2kCD/jrRI/570IP3f4PD9qAQs/BTE7P+afCz8FMTs/tWsWP0t5QD9qAQs/460SPwgFFz8FMTs/570IP0t5QD9GexY/S3lAP2oBCz8FMTs/CAUXP+OtEj+01xY/ljREP7TXFj+WNEQ/TNoWP82NRT9M2hY/zY1FPxjYFj/tZkM/GNgWP+1mQz/m2RY/fFtGP+bZFj98W0Y/zBMKP7ooRD/MEwo/uihEP8wTCj+6KEQ/FiAKPw2QRT8WIAo/DZBFPxYgCj8NkEU/rhwKP0RpQz+uHAo/RGlDP64cCj9EaUM/LhcKP5RPRj8uFwo/lE9GPy4XCj+UT0Y/7tgWPybhRD/L1RY/JuFEP7/WFj9lukI/+tcWPygIRz+dvwg/TOlCP+zbCD/1z0Y/nb8IP0zpQj/s2wg/9c9GP7zbCD8AqEQ/or8IPwMPRT+ivwg/Aw9FP7zbCD8AqEQ/GNgWP5jUQz8Y2BY/mNRDP0zaFj+G+0U/TNoWP4b7RT+hDgo/KMlDP6EOCj8oyUM/oQ4KPyjJQz8HEgo/9+9FPwcSCj/370U/BxIKP/fvRT/eqAg/qMlDP96oCD9m8EU/tNcWP5Y0RD+01xY/ljREP0zaFj/NjUU/TNoWP82NRT8Y2BY/7WZDPxjYFj/tZkM/5tkWP3xbRj/m2RY/fFtGP8wTCj+6KEQ/zBMKP7ooRD/MEwo/uihEPxYgCj8NkEU/FiAKPw2QRT8WIAo/DZBFP64cCj9EaUM/rhwKP0RpQz+uHAo/RGlDPy4XCj+UT0Y/LhcKP5RPRj8uFwo/lE9GP8vVFj8m4UQ/7tgWPybhRD/61xY/KAhHP7/WFj9lukI/7NsIP/XPRj+dvwg/TOlCP52/CD9M6UI/7NsIP/XPRj+82wg/AKhEP6K/CD8DD0U/vNsIPwCoRD+ivwg/Aw9FPxjYFj+Y1EM/GNgWP5jUQz9M2hY/hvtFP0zaFj+G+0U/oQ4KPyjJQz+hDgo/KMlDP6EOCj8oyUM/oQ4KPyjJQz8HEgo/9+9FPwcSCj/370U/BxIKP/fvRT8HEgo/9+9FP96oCD+oyUM/3qgIP6jJQz/eqAg/ZvBFP96oCD9m8EU/cDDjPiB9uD2nw9s+6vxUP3iSVD3q/FQ/cDDjPiB9uD00dEo96vxUP3Aw4z5sY/8+cDDjPmxj/z5xB90+6vxUPwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/ptnJPgrIbj8AwH8/AMB/Px0Ayj5AzE08AMB/PwDAfz8AwH8/AMB/Px0Ayj6o2bk9AMB/PwDAfz+m2ck+kMhiP6bZyT6QyGI/AMB/PwDAfz8dAMo+ZnVIP6bZyT5OXmE/oK8API7IYj+grwA8jshiPwDAfz8AwH8/4Lj1O9RaSD+grwA8Tl5hPwDAfz8AwH8/4Lj1OxgFuT0AwH8/AMB/PwDAfz8AwH8/4Lj1O8AnRzwAwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz+grwA8CshuPwDAfz8AwH8/rHU+PY7IYj+sdT49jshiP6x1Pj2OyGI/2G61PpDIYj/YbrU+kMhiP9hutT6QyGI/rPa0PtRaSD/YbrU+Tl5hP9hutT5OXmE/EE83PdRaSD+sdT49Tl5hP6x1Pj1OXmE/eJJUPebnXz+29rQ+GAW5Pbb2tD4YBbk9y632PiB9uD0Vs88+IH24PafD2z7m518/xE43PRgFuT3ETjc9GAW5PQDAfz8AwH8/2G61PgrIbj8AwH8/AMB/P6x1Pj0KyG4/xE43PcAnRzzETjc9wCdHPADAfz8AwH8/tva0PsAnRzy29rQ+wCdHPADAfz8AwH8/AMB/PwDAfz8dAMo+kJj/PuC49TtsY/8+AMB/PwDAfz+w9rQ+bGP/PiR0Sj3uEUo/y632Pmxj/z4Vs88+bGP/PvRONz1sY/8+cQfdPu4RSj9wMOM+IH24PafD2z7q/FQ/cDDjPmxj/z5xB90+6vxUPzR0Sj3q/FQ/cDDjPmxj/z54klQ96vxUP3Aw4z4gfbg9AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/9gH+AR8A9gEfAA8AOgBBACYAOgAmABMAFgAwADYAFgA2ABoADgAeACIADgAiABEAFAAnADEAFAAxABcAAQL8ARIAAQISADsALQAJAAIALQACADQAPgA5AA0APgANACwAKwAMAAoAKwAKAC8AHAAEAAcAHAAHACQAKgAuADIAKgAyACgA/QEdAB8A/QEfAP4BLQA0ADYALQA2ADAAPAApACYAPAAmAEEA7gHrAT0A7gE9AEIAHAAkACIAHAAiAB4A/QHyAQUA/QEFAB0A5wHtAUAA5wFAACAAJAAHADgAJAA4ADwA+gEBAjsA+gE7ABUAEQAiAEEAEQBBADoA7AHqASUA7AElAD8A6QHoASEA6QEhACMARwBEAE4ARwBOAFAASQBDAEUASQBFALQAUwCwAE8AUwBPAE0AWwBVAFcAWwBXAGAASwDgAFgASwBYAFYAZQBdAFwAZQBcAGEAbQBqAGIAbQBiAFkAZwBzAGMAZwBjAF8AbADMAHEAbABxAGkAcgB8AHkAcgB5AGoAaAB4AH8AaAB/AHYAdwB6AIAAdwCAAH0AdAB+AIEAdACBAIQAhgCCAHsAhgB7AHAAdQCFAIgAdQCIANwAjwCLAIMAjwCDAG8AlwCHAIQAlwCEAIwAkACfAJ0AkACdAI4AjACcAKIAjACiAJQAjQCVALwAjQC8AJgAngCkAKEAngChAJsAlgCjAKUAlgClAKgAqgCmAKAAqgCgAJIAuACsAKkAuACpAJEAUQCyAKoAUQCqAK0ArwCzAJMArwCTAKcASgC2ALEASgCxAFQARgC7AJQARgCUALUAuQDDAMAAuQDAAK0AqwC/AMYAqwDGAL0AvgBIAFIAvgBSAK4AwQDEAMoAwQDKAMcAuwDFAMgAuwDIAJcAmQDJAMIAmQDCALcAuQCSAHIAuQByAM0AigCaALoAigC6AM4AbQDTANAAbQDQAM0AywDPANYAywDWAIkA0QDUANoA0QDaANcAhwDVANgAhwDYANsA3QDZANIA3QDSAGsA2wDfAGQA2wBkAHQA4gDeAG4A4gBuAFoAXgBmAOEAXgDhAEwA5QDpAPoA5QD6APQA5wDkAPAA5wDwABcB9QD9AO0A9QDtAOYA7wDjAOsA7wDrAA8B8wD4AAQB8wAEAf8A/gD2AAIB/gACAQoBGQHyAAEBGQEBAQYBCAEAAfEACAHxABABIAH7AAcBIAEHAQwBEQETAQ0BEQENAQkB7gAdARUB7gAVARIBFAEYAQUBFAEFAQ4BHgHqABoBHgEaARYBHAHsAPwAHAH8ACIBIQH5AOgAIQHoABsBAwH3AB8BAwEfAQsBJwEkATABJwEwAT8BLwEjASsBLwErATsBTwFDATEBTwExAT0BQQFOAVkBQQFZATkBLAEzATcBLAE3ATwBNgEqAUIBNgFCAToBRwElASgBRwEoAWABMgFFAU0BMgFNAUABVgFKAUYBVgFGAVIBSAFhAUwBSAFMAUQBXgFVAVEBXgFRAVoBVAEuASYBVAEmAUkBSwFfAVsBSwFbAVcBPgE4AVgBPgFYAVABUwFcATQBUwE0AS0BYgEpATUBYgE1AV0BagFmAWcBagFnAWsBbQFjAWUBbQFlAWkBbwFxAWQBbwFkAW4BbAFoAXIBbAFyAXABdwF/AXwBdwF8AXQBcwF5AYgBcwGIAXYBfQGCAXoBfQF6AXUBgQGHAYQBgQGEAX4BhgGKAXsBhgF7AYMBeAGJAYUBeAGFAYABogGRAZwBogGcAaQBtgGyAZYBtgGWAagBqQGYAY4BqQGOAZ8BqwGwAZQBqwGUAYsBswGtAY0BswGNAZcBlQGqAaABlQGgAYwBrwG1AacBrwGnAZMBjwGhAaMBjwGjAZkBmgGlAbUBmgG1Aa8BngGSAa4BngGuAbQBkAGbAbEBkAGxAawBpgGdAbIBpgGyAbYBzQG9AcgBzQHIAc8B5QHfAcIB5QHCAdQB1gHEAboB1gG6AcwB1wHdAcAB1wHAAbcB4QHZAbkB4QG5AcMBwQHVAcsBwQHLAbgB2wHjAdMB2wHTAb8BuwHOAdABuwHQAcUBxgHRAeQBxgHkAdwBygG+AdoBygHaAeIBvAHHAd4BvAHeAdgB0gHJAeAB0gHgAeYBCwA3AAICCwACAvUBMwD/AQACMwAAAjUAMwABAPABMwDwAf8BEAASAPwBEAD8AfcBGAAbAPkBGAD5AfsBFQAYAPsBFQD7AfoBCAALAPUBCAD1AfQBAAAIAPQBAAD0Ae8BNwAGAPMBNwDzAQICGQA1AAACGQAAAvgBBgADAPEBBgDxAfMBVAJSAgYCVAIGAgkCQgI/AgoCQgIKAi0CFwIyAjgCFwI4AhoCWQJiAjYCWQI2Ah0CQAJGAjICQAIyAhcCZAJUAgkCZAIJAj4CUAJVAgsCUAILAgMCVQJWAg4CVQIOAgsCHgI3AiACHgIgAhECWwJcAhMCWwITAhYCXAJaAh8CXAIfAhMCWAJdAhgCWAIYAhwCNQIFAgwCNQIMAiMCJAINAhACJAIQAicCYQJRAgQCYQIEAjQCLQIKAgcCLQIHAjsCEgIiAisCEgIrAhUCJQIoAioCJQIqAiECYQI0AjYCYQI2AmICLgI8AjkCLgI5AjMCNQIjAiACNQIgAjcCJgJCAkYCJgJGAikCVgJkAj4CVgI+Ag4CFAIpAkYCFAJGAkACJgIPAj8CJgI/AkICLAIxAkkCLAJJAk4CRAIvAk8CRAJPAk0CMAJFAkoCMAJKAkgCRwJDAkwCRwJMAksCFgJBAmMCFgJjAlsCPQIIAlMCPQJTAl8CPQJfAmACPQJgAjoCQQIZAl4CQQJeAmMCGwI6AmACGwJgAlcC/v//vgAAAACPwvU9/v//vgAAAACPwvU9/v//vgAAAACPwvU9////vs7MDEDKzMw9////vs7MDEDKzMw9////vs7MDEDKzMw9////voXrAUDKzMw9////voXrAUDKzMw9/v//vpDC9T2PwvU9/v//vpDC9T2PwvU9/v//vpDC9T2PwvU9/v//vpDC9T2PwvU9////vrgeBT7KzMw9////vrgeBT7KzMw9////vrgeBT7KzMw9////vrgeBT7KzMw9////Ps7MDEDKzMw9////Ps7MDEDKzMw9////Ps7MDEDKzMw9////PoXrAUDKzMw9////PoXrAUDKzMw9////PoXrAUDKzMw9////PrgeBT7KzMw9////PrgeBT7KzMw9////PrgeBT7KzMw9////PrgeBT7KzMw9AAAAP5DC9T2PwvU9AAAAP5DC9T2PwvU9AAAAP5DC9T2PwvU9AAAAP5DC9T2PwvU9AAAAPwAAAACPwvU9AAAAPwAAAACPwvU9AAAAPwAAAACPwvU9zMzMvs7MDEDKzMw9zMzMvs7MDEDKzMw9zMzMPs7MDEDKzMw9zMzMPs7MDEDKzMw9zMzMPs7MDEDKzMw9zMzMPoXrAUDKzMw9zMzMPoXrAUDKzMw9zMzMPoXrAUDKzMw9zMzMvoXrAUDKzMw9zMzMvoXrAUDKzMw9zMzMvoXrAUDKzMw9zMzMPrgeBT7KzMw9zMzMPrgeBT7KzMw9zMzMvrgeBT7KzMw9zMzMvrgeBT7KzMw9zMzMvrgeBT7KzMw9y8zMvpDC9T2PwvU9y8zMvpDC9T2PwvU9y8zMvpDC9T2PwvU9zczMPpDC9T2PwvU9zczMPpDC9T2PwvU9y8zMvgAAAACPwvU9y8zMvgAAAACPwvU9zczMPgAAAACPwvU9zczMPgAAAACPwvU9////vmZmZj/KzMw9////vmZmZj/KzMw9////vmZmZj/KzMw9////PmZmZj/KzMw9////PmZmZj/KzMw9////PmZmZj/KzMw9zMzMvmZmZj/KzMw9zMzMvmZmZj/KzMw9zMzMvmZmZj/KzMw9zMzMPmZmZj/KzMw9zMzMPmZmZj/KzMw9zMzMPmZmZj/KzMw9XjjOvuolAkD8/GY9XjjOvuolAkD8/GY95lG4vlK4/j/8/GY95lG4vlK4/j/8/GY95lG4vlK4/j/8/GY95lG4vlK4/j/8/GY9XjjOPuolAkD9/GY9XjjOPuolAkD9/GY9XjjOvuolAkBh+Ye9XjjOvuolAkBh+Ye9XzjOvtJ8ZT/8/GY9XzjOvtJ8ZT/8/GY951G4vtejcD/8/GY951G4vtejcD/8/GY951G4vtejcD/8/GY951G4vtejcD/8/GY9XTjOPtJ8ZT/9/GY9XTjOPtJ8ZT/9/GY9XzjOvtJ8ZT9h+Ye9XzjOvtJ8ZT9h+Ye951G4vtejcD9h+Ye951G4vtejcD9h+Ye951G4vtejcD9h+Ye951G4vtejcD9h+Ye9XTjOPtJ8ZT9h+Ye9XTjOPtJ8ZT9h+Ye9XjjOPuolAkBh+Ye9XjjOPuolAkBh+Ye95VG4PtejcD9h+Ye95VG4PtejcD9h+Ye95VG4PtejcD9h+Ye95VG4PtejcD9h+Ye95lG4PlK4/j9h+Ye95lG4PlK4/j9h+Ye95lG4PlK4/j9h+Ye95lG4PlK4/j9h+Ye95VG4PtejcD/GkPm85VG4PtejcD/GkPm85VG4PtejcD/GkPm85VG4PtejcD/GkPm851G4vtejcD/GkPm851G4vtejcD/GkPm851G4vtejcD/GkPm851G4vtejcD/GkPm85VG4PtejcD9Cpae85VG4PtejcD9Cpae85VG4PtejcD9Cpae85VG4PtejcD9Cpae85lG4PlK4/j/GkPm85lG4PlK4/j/GkPm85lG4PlK4/j/GkPm85lG4PlK4/j/GkPm8MInBPtejcD/GkPm8MInBPtejcD/GkPm8MInBPtejcD/GkPm8MInBPtejcD9Cpae8MInBPtejcD9Cpae8MInBPtejcD9Cpae8MYnBPlK4/j/GkPm8MYnBPlK4/j/GkPm8MYnBPlK4/j/GkPm8MYnBPlK4/j9Cpae8MYnBPlK4/j9Cpae8MYnBPlK4/j9Cpae85lG4PlK4/j9Cpae85lG4PlK4/j9Cpae85lG4PlK4/j9Cpae85lG4PlK4/j9Cpae85lG4vlK4/j9Cpae85lG4vlK4/j9Cpae85lG4vlK4/j9Cpae85lG4vlK4/j9Cpae85lG4PlK4/j9ucys85lG4PlK4/j9ucys85lG4PlK4/j9ucys85lG4PlK4/j9ucys85VG4PtejcD9ucys85VG4PtejcD9ucys85VG4PtejcD9ucys85VG4PtejcD9ucys85lG4PlK4/j88pac85lG4PlK4/j88pac85lG4PlK4/j88pac85lG4PlK4/j88pac85lG4vlK4/j9ucys85lG4vlK4/j9ucys85lG4vlK4/j9ucys85lG4vlK4/j9ucys8MYnBPlK4/j9ucys8MYnBPlK4/j9ucys8MYnBPlK4/j9ucys8MInBPtejcD9ucys8MInBPtejcD9ucys8MInBPtejcD9ucys8MYnBPlK4/j88pac8MYnBPlK4/j88pac8MYnBPlK4/j88pac8MInBPtejcD88pac8MInBPtejcD88pac8MInBPtejcD88pac85VG4PtejcD88pac85VG4PtejcD88pac85VG4PtejcD88pac85VG4PtejcD88pac851G4vtejcD88pac851G4vtejcD88pac851G4vtejcD88pac851G4vtejcD88pac85VG4PtejcD/9/GY95VG4PtejcD/9/GY95VG4PtejcD/9/GY95VG4PtejcD/9/GY95lG4PlK4/j/9/GY95lG4PlK4/j/9/GY95lG4PlK4/j/9/GY95lG4PlK4/j/9/GY951G4vtejcD9ucys851G4vtejcD9ucys851G4vtejcD9ucys851G4vtejcD9ucys85lG4vlK4/j88pac85lG4vlK4/j88pac85lG4vlK4/j88pac85lG4vlK4/j88pac8MonBvtejcD88pac8MonBvtejcD88pac8MonBvtejcD88pac8MonBvtejcD9ucys8MonBvtejcD9ucys8MonBvtejcD9ucys8MYnBvlK4/j88pac8MYnBvlK4/j88pac8MYnBvlK4/j88pac8MYnBvlK4/j9ucys8MYnBvlK4/j9ucys8MYnBvlK4/j9ucys851G4vtejcD9Cpae851G4vtejcD9Cpae851G4vtejcD9Cpae851G4vtejcD9Cpae8MonBvtejcD9Cpae8MonBvtejcD9Cpae8MonBvtejcD9Cpae8MonBvtejcD/GkPm8MonBvtejcD/GkPm8MonBvtejcD/GkPm8MYnBvlK4/j9Cpae8MYnBvlK4/j9Cpae8MYnBvlK4/j9Cpae8MYnBvlK4/j/GkPm8MYnBvlK4/j/GkPm8MYnBvlK4/j/GkPm85lG4vlK4/j/GkPm85lG4vlK4/j/GkPm85lG4vlK4/j/GkPm85lG4vlK4/j/GkPm85lG4vlK4/j9h+Ye95lG4vlK4/j9h+Ye95lG4vlK4/j9h+Ye95lG4vlK4/j9h+Ye93Tm4vtQWAEBOddu73Tm4vtQWAEBOddu73Tm4vtQWAEBOddu73Tm4vtQWAEBOddu7Fe+jvhPx+j9Oddu7Fe+jvhPx+j9Oddu7Fe+jvhPx+j9Oddu7Fe+jvhPx+j9Oddu73Tm4vtQWAEAZXjG93Tm4vtQWAEAZXjG93Tm4vtQWAEAZXjG93Tm4vtQWAEAZXjG93Tm4viTZuD9Oddu73Tm4viTZuD9Oddu73Tm4viTZuD9Oddu73Tm4viTZuD9Oddu71zm4PtQWAEBOddu71zm4PtQWAEBOddu71zm4PtQWAEBOddu71zm4PtQWAEBOddu7D++jPhPx+j9Oddu7D++jPhPx+j9Oddu7D++jPhPx+j9Oddu7D++jPhPx+j9Oddu71zm4PtQWAEAZXjG91zm4PtQWAEAZXjG91zm4PtQWAEAZXjG91zm4PtQWAEAZXjG91jm4PiTZuD9Oddu71jm4PiTZuD9Oddu71jm4PiTZuD9Oddu71jm4PiTZuD9Oddu7Du+jProVvj9Oddu7Du+jProVvj9Oddu7Du+jProVvj9Oddu7Du+jProVvj9Oddu71jm4PiTZuD8ZXjG91jm4PiTZuD8ZXjG91jm4PiTZuD8ZXjG91jm4PiTZuD8ZXjG9Du+jProVvj8ZXjG9Du+jProVvj8ZXjG9Du+jProVvj8ZXjG9Du+jProVvj8ZXjG93Tm4viTZuD8ZXjG93Tm4viTZuD8ZXjG93Tm4viTZuD8ZXjG93Tm4viTZuD8ZXjG9Fu+jvroVvj8ZXjG9Fu+jvroVvj8ZXjG9Fu+jvroVvj8ZXjG9Fu+jvroVvj8ZXjG9Fu+jvroVvj9Oddu7Fu+jvroVvj9Oddu7Fu+jvroVvj9Oddu7Fu+jvroVvj9Oddu7Fe+jvhPx+j8ZXjG9Fe+jvhPx+j8ZXjG9Fe+jvhPx+j8ZXjG9Fe+jvhPx+j8ZXjG9D++jPhPx+j8ZXjG9D++jPhPx+j8ZXjG9D++jPhPx+j8ZXjG9D++jPhPx+j8ZXjG93Tm4vqSNvT9naAg93Tm4vqSNvT9naAg93Tm4vqSNvT9naAg93Tm4vqSNvT9naAg9Fe+jvg9RuD9naAg9Fe+jvg9RuD9naAg9Fe+jvg9RuD9naAg9Fe+jvg9RuD9naAg93Tm4vqSNvT+UcFi73Tm4vqSNvT+UcFi73Tm4vqSNvT+UcFi73Tm4vqSNvT+UcFi73Tm4vkBybD9naAg93Tm4vkBybD9naAg93Tm4vkBybD9naAg93Tm4vkBybD9naAg9Fe+jvg9RuD+UcFi7Fe+jvg9RuD+UcFi7Fe+jvg9RuD+UcFi7Fe+jvg9RuD+UcFi7Fu+jvmzrdj+UcFi7Fu+jvmzrdj+UcFi7Fu+jvmzrdj+UcFi7Fu+jvmzrdj+UcFi73Tm4vkBybD+UcFi73Tm4vkBybD+UcFi73Tm4vkBybD+UcFi73Tm4vkBybD+UcFi7Fu+jvmzrdj9naAg9Fu+jvmzrdj9naAg9Fu+jvmzrdj9naAg9Fu+jvmzrdj9naAg91jm4PkBybD9naAg91jm4PkBybD9naAg91jm4PkBybD9naAg91jm4PkBybD9naAg91zm4PqSNvT9naAg91zm4PqSNvT9naAg91zm4PqSNvT9naAg91zm4PqSNvT9naAg9Du+jPmzrdj9naAg9Du+jPmzrdj9naAg9Du+jPmzrdj9naAg9Du+jPmzrdj9naAg91jm4PkBybD+UcFi71jm4PkBybD+UcFi71jm4PkBybD+UcFi71jm4PkBybD+UcFi71zm4PqSNvT+UcFi71zm4PqSNvT+UcFi71zm4PqSNvT+UcFi71zm4PqSNvT+UcFi7Du+jPmzrdj+UcFi7Du+jPmzrdj+UcFi7Du+jPmzrdj+UcFi7Du+jPmzrdj+UcFi7D++jPg9RuD+UcFi7D++jPg9RuD+UcFi7D++jPg9RuD+UcFi7D++jPg9RuD+UcFi7D++jPg9RuD9naAg9D++jPg9RuD9naAg9D++jPg9RuD9naAg9D++jPg9RuD9naAg94TGFvOMSuj9UxfQ84TGFvOMSuj9UxfQ84TGFvOMSuj+AZ/044TGFvOMSuj+AZ/04oDGFPOMSuj+AZ/04oDGFPOMSuj+AZ/047jGFvMRncz+AZ/047jGFvMRncz+AZ/04kzGFPMRncz+AZ/04kzGFPMRncz+AZ/047jGFvMRncz9UxfQ87jGFvMRncz9UxfQ8kzGFPMRncz9UxfQ8kzGFPMRncz9UxfQ8oDGFPOMSuj9UxfQ8oDGFPOMSuj9UxfQ8PArXvqRwXT8ehes9PArXvqRwXT8ehes9PArXvqRwXT8ehes9PArXvqRwXT8AAAC+PArXvqRwXT8AAAC+PArXvqRwXT8AAAC+PArXvnA9aj8ehes9PArXvnA9aj8ehes9PArXvnA9aj8ehes9PArXPqRwXT8ehes9PArXPqRwXT8ehes9PArXPqRwXT8ehes9PArXPqRwXT8AAAC+PArXPqRwXT8AAAC+PArXPqRwXT8AAAC+PArXPnA9aj8ehes9PArXPnA9aj8ehes9PArXPnA9aj8ehes9PArXPnA9aj8AAAC+PArXPnA9aj8AAAC+PArXPnA9aj8AAAC+PArXvnA9aj8AAAC+PArXvnA9aj8AAAC+PArXvnA9aj8AAAC+/v//vgAAAAAAAICt/v//vgAAAAAAAICt/v//vs7MDEAAAICt/v//vs7MDEAAAICt/v//voXrAUAAAICt/v//vpDC9T0AAICt/v//vpDC9T0AAICt/v//vrgeBT4AAACA/v//vrgeBT4AAACAAAAAP87MDEAAAICtAAAAP87MDEAAAICtAAAAPwAAAAAAAICtAAAAPwAAAAAAAICtAAAAP7geBT4AAICtAAAAP7geBT4AAICtAAAAP5DC9T0AAICtAAAAP5DC9T0AAICtAAAAP4XrAUAAAICtAAAAP4XrAUAAAICtyszMvs7MDEAAAICtzszMPs7MDEAAAICtzszMPs7MDEAAAICty8zMvgAAAAAAAICtzczMPgAAAAAAAICtAAAAP2ZmZj8AAICtAAAAP2ZmZj8AAICt/v//vmZmZj8AAICt/v//vmZmZj8AAICtzMzMPoXrAUAAAACAzMzMPoXrAUAAAACAzMzMPmZmZj8AAACAzMzMPmZmZj8AAACAzMzMvmZmZj8AAACAzMzMvmZmZj8AAACAzMzMvoXrAUAAAACAzMzMvoXrAUAAAACA/v//vgAAAACOwvW9/v//vgAAAACOwvW9/v//vgAAAACOwvW9/v//vs7MDEDOzMy9/v//vs7MDEDOzMy9/v//vs7MDEDOzMy9/v//voXrAUDOzMy9/v//voXrAUDOzMy9/v//vpDC9T2OwvW9/v//vpDC9T2OwvW9/v//vpDC9T2OwvW9/v//vpDC9T2OwvW9/v//vrgeBT7OzMy9/v//vrgeBT7OzMy9/v//vrgeBT7OzMy9AAAAP5DC9T2OwvW9AAAAP5DC9T2OwvW9AAAAP5DC9T2OwvW9AAAAP5DC9T2OwvW9AAAAP7geBT7OzMy9AAAAP7geBT7OzMy9AAAAP7geBT7OzMy9AAAAP4XrAUDOzMy9AAAAP4XrAUDOzMy9AAAAP4XrAUDOzMy9AQAAP87MDEDOzMy9AQAAP87MDEDOzMy9AQAAP87MDEDOzMy9AAAAPwAAAACOwvW9AAAAPwAAAACOwvW9AAAAPwAAAACOwvW9zczMPpDC9T2OwvW9zczMPpDC9T2OwvW9zczMPpDC9T2OwvW9y8zMvpDC9T2OwvW9y8zMvpDC9T2OwvW9y8zMvpDC9T2OwvW9y8zMvrgeBT7OzMy9y8zMvrgeBT7OzMy9y8zMvrgeBT7OzMy9zczMPrgeBT7OzMy9zczMPrgeBT7OzMy9zczMPrgeBT7OzMy9y8zMvoXrAUDOzMy9y8zMvoXrAUDOzMy9y8zMvoXrAUDOzMy9y8zMvoXrAUDOzMy9zczMPoXrAUDOzMy9zczMPoXrAUDOzMy9zczMPoXrAUDOzMy9zczMPoXrAUDOzMy9y8zMvgAAAACOwvW9y8zMvgAAAACOwvW9zczMPgAAAACOwvW9zczMPgAAAACOwvW9zszMPs7MDEDOzMy9zszMPs7MDEDOzMy9zszMPs7MDEDOzMy9yszMvs7MDEDOzMy9yszMvs7MDEDOzMy9yszMvs7MDEDOzMy9yszMvs7MDEDOzMy9/v//vmZmZj/OzMy9/v//vmZmZj/OzMy9AAAAP2ZmZj/OzMy9AAAAP2ZmZj/OzMy9y8zMvmZmZj/OzMy9y8zMvmZmZj/OzMy9y8zMvmZmZj/OzMy9zczMPmZmZj/OzMy9zczMPmZmZj/OzMy9zczMPmZmZj/OzMy9/v//vgAAAAAAAICt/v//vgAAAAAAAICt/v//vs7MDEAAAICt/v//vs7MDEAAAICt/v//voXrAUAAAICt/v//vpDC9T0AAICt/v//vpDC9T0AAICt/v//vrgeBT4AAACAAAAAP87MDEAAAICtAAAAP87MDEAAAICtAAAAPwAAAAAAAICtAAAAPwAAAAAAAICtAAAAP7geBT4AAICtAAAAP5DC9T0AAICtAAAAP5DC9T0AAICtAAAAP4XrAUAAAICtAAAAP4XrAUAAAICtyszMvs7MDEAAAICtyszMvs7MDEAAAICtzszMPs7MDEAAAICty8zMvgAAAAAAAICtzczMPgAAAAAAAICtAAAAP2ZmZj8AAICt/v//vmZmZj8AAICtzMzMPoXrAUAAAACAzMzMPoXrAUAAAACAzMzMPmZmZj8AAACAzMzMPmZmZj8AAACAzMzMvmZmZj8AAACAzMzMvmZmZj8AAACAzMzMvoXrAUAAAACAzMzMvoXrAUAAAACAAACAvwAAAAAAAACAAAAAAP//f78AAACAAAAAAAAAAAAAAIA/AACAvwAAAAAAAACAAAAAAAAAAAAAAIA/AAAAAAAAgD8AAACAAACAvwAAAAAAAACAAAAAAAAAAAAAAIA/AACAv6Mu2rUAAACAAACAvwAAAAAAAACAAAAAAAAAAAAAAIA/AAAAADX5ZD8S+eQ+AACAv6Mu2rUAAACAAACAvwAAAADRys+0AAAAAAAAAAAAAIA/AAAAADX5ZD8S+eQ+AAAAAAAAAAAAAIA/AAAAAP//fz8AAACAAACAPwAAAAAsS+s0AAAAAAAAAAAAAIA/AACAPwAAAAAsS+s0AACAPwAAAADMlw01AAAAAAAAAAAAAIA/AAAAADP5ZD8X+eQ+AACAPwAAAADRys80AACAP6Mu2jUAAACAAAAAAAAAAAAAAIA/AAAAADP5ZD8X+eQ+AACAPwAAAAAAAACAAACAP6Mu2jUAAACAAAAAAP//f78AAACAAAAAAAAAAAAAAIA/AACAPwAAAAAAAACAAAAAAAAAAAAAAIA/AAAAAAAAgD8AAACAAAAAAAAAAAAAAIA/AAAAAP//fz8AAACAAAAAAAAAgD8AAACAAACAvwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIA/AAAAAAAAgL8AAACAAAAAAAAAAAAAAIA/AACAPwAAAAAAAACAAAAAAAAAAAAAAIA/AAAAADP5ZD8X+eQ+AAAAAAAAAAAAAIA/AAAAADP5ZD8X+eQ+AAAAADX5ZD8S+eQ+AAAAAAAAAAAAAIA/AAAAADP5ZD8X+eQ+AAAAADX5ZD8S+eQ+AAAAAAAAAAAAAIA/AAAAADP5ZD8X+eQ+AAAAAP//f78AAACAAAAAAAAAAAAAAIA/AAAAAP//f78AAACAAAAAAAAAAAAAAIA/AACAvwAAAADRys+0AACAvwAAAAAAAACAAAAAAAAAAAAAAIA/AAAAAAAAAAAAAIA/AACAPwAAAADRys80AACAPwAAAADMlw01AAAAAAAAAAAAAIA/AAAAAAAAgD8AAACAAACAPwAAAAAAAACAAACAvwAAAAAAAACAAAAAAAAAAAAAAIA/AAAAAAAAgD8AAACAAs+nsQAAAAAAAIA/AAAAAAAAAAD//38/As+nsQAAAAAAAIA/AAAAAAAAgL8AAACAAAAAAAAAAAD//38/AACAPz3P87IAAACAAs+nsQAAAAAAAIA/AAAAAAAAAAAAAIA/AAAAAAAAAAD//3+/AAAAAPGPtDMAAIC/A8+nsde/cLIAAIA/AAAAAAAAAAD//38/A8+nsde/cLIAAIA/AAAAAAAAAAD//38/AAAAAAAAgD8AAACAAACAPz3P87IAAACAA8+nsde/cLIAAIA/AAAAAAAAAAAAAIA/AAAAANe/8LMAAIC/AAAAAAAAAAD//3+/AAAAANe/8LMAAIC/AAAAAAAAAAD//3+/AAAAAAAAgD8AAACAAACAPz3P87IAAACAAAAAANe/8LMAAIC/AAAAAAAAAAAAAIC/AAAAAAAAAAAAAIC/AAAAAPGPtDMAAIC/AACAvz3P8zIAAACAAAAAANe/8LMAAIC/AAAAAAAAAAAAAIC/AAAAAAAAgD8AAACAAACAvz3P8zIAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AAAAAPGPtDMAAIC/AACAvz3P8zIAAACAAAAAAAAAAAAAAIA/AAAAAP//fz8AAACAAAAAAAAAgD8AAACAAAAAAAAAAAAAAIA/AAAAAP//fz8AAACAAAAAAAAAgD8AAACAAACAPz3P87IAAACAAACAvz7P8zIAAACAAAAAAAAAAAAAAIC/AAAAAP//fz8AAACAAAAAAAAAgD8AAACAAACAvz3P8zIAAACAAAAAAAAAgL8AAACAAAAAAP//f78AAACAAAAAAAAAAAAAAIA/AACAvz3P8zIAAACAAAAAAAAAAAAAAIA/AAAAAAAAgD8AAACAAACAvz3P8zIAAACAAAAAAAAAAAAAAIC/AAAAAAAAgD8AAACAAACAvz3P8zIAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIA/AACAvz3P8zIAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AACAvz7P8zIAAACAAAAAAAAAgL8AAACAAAAAAP//f78AAACAAAAAAAAAAAAAAIC/AAAAAAAAgL8AAACAAAAAAP//f78AAACAAAAAAAAAAAAAAIC/AACAPz7P87IAAACAAACAvz7P8zIAAACAAAAAAAAAgL8AAACAAAAAAP//f78AAACAAAAAAAAAAAAAAIA/AACAvz7P8zIAAACAAAAAAAAAAAAAAIA/AAAAAP//fz8AAACAAAAAAAAAgD8AAACAAACAvz3P8zIAAACAAAAAAAAAgL8AAACAAAAAAP//f78AAACAAAAAAAAAAAAAAIC/AAAAAAAAgL8AAACAAAAAAP//f78AAACAAAAAAAAAAAAAAIA/AACAPz7P87IAAACAAACAvz3P8zIAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIA/AACAvz3P8zIAAACAAAAAAAAAAAAAAIA/AAAAAAAAgD8AAACAAACAvz3P8zIAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AACAvz3P8zIAAACAAAAAAAAAAAAAAIC/AAAAAAAAgD8AAACAAACAvz3P8zIAAACAAAAAAAAAAAAAAIC/AAAAAP//fz8AAACAAAAAAAAAgD8AAACAAAAAAAAAAAAAAIC/AAAAAP//fz8AAACAAAAAAAAAgD8AAACAAACAPz3P87IAAACAAACAvz3P8zIAAACAA8+nsde/cLIAAIA/AAAAAAAAAAAAAIA/AAAAAAAAgD8AAACAAACAvz3P8zIAAACAAs+nsQAAAAAAAIA/AAAAAAAAgL8AAACAAAAAAAAAAAAAAIA/AAAAAAAAAAAAAIA/AAAAAP//fz8AAACAAAAAAAAAgD8AAACAAACAPz7P87IAAACAAAAAAAAAgL8AAACAAAAAAP//f78AAACAAAAAAAAAAAAAAIC/AACAPz3P87IAAACAAAAAAAAAAAAAAIC/AAAAAAAAgD8AAACAAACAPz3P87IAAACAAAAAAAAAAAAAAIA/AAAAAAAAgD8AAACAAACAPz3P87IAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AACAPz3P87IAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIA/AACAPz3P87IAAACAAAAAAAAAAAAAAIC/AAAAAP//fz8AAACAAAAAAAAAgD8AAACAAACAPz7P87IAAACAAAAAAAAAAAAAAIC/AAAAAAAAgD8AAACAAACAPz3P87IAAACAAAAAAAAAAAAAAIA/AAAAAAAAgD8AAACAAACAPz3P87IAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AACAPz3P87IAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIA/AACAPz3P87IAAACAAAAAAAAAgL8AAACAAAAAAP//f78AAACAAAAAAAAAAAAAAIA/AACAPz3P87IAAACAAAAAAAAAgL8AAACAAAAAAAAAAAD//3+/AAAAAPGPtDMAAIC/AACAPz3P87IAAACAAACAvwAAAAAAAACAAAAAALSsV7L//38/AAAAAAAAAAAAAIA/AAAAAAAAgD8AAACAAAAAAP//f78AAACAAAAAALSsV7L//38/AAAAAAAAAAAAAIA/AACAP2ychrMAAACAAACAvwAAAAAAAACAAAAAAHjIj7L//3+/AAAAAF11w7EAAIC/AAAAAAAAgD8AAACAAACAvwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAF3Ij7EAAIA/AAAAAAAAAAAAAIA/AAAAALSsV7L//38/AAAAAAAAAAAAAIA/AAAAAAAAgD8AAACAAACAP02xZbMAAACAAACAv2ychjMAAACAAAAAAP//f78AAACAAAAAALSsV7L//38/AAAAAAAAAAAAAIA/AAAAAHjIj7L//3+/AAAAAAAAAAAAAIC/AAAAAAAAgD8AAACAAACAP02xZbMAAACAAAAAAAAAgL8AAACAAAAAAF3Ij7EAAIA/AAAAAAAAAAAAAIA/AACAP02xZbMAAACAAACAv2ychjMAAACAAAAAAF3Ij7EAAIA/AAAAAAAAAAAAAIA/AAAAAP//fz8AAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AAAAAHS6szMAAIC/AACAP02xZbMAAACAAACAv2ychjMAAACAAAAAAAAAAAAAAIC/AAAAAHS6szMAAIC/AAAAAP//fz8AAACAAACAvwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAF11w7EAAIC/AAAAAHS6szMAAIC/AAAAAF11w7EAAIC/AAAAAHS6szMAAIC/AAAAAP//fz8AAACAAACAP2ychrMAAACAAAAAAF3Ij7EAAIA/AAAAAAAAAAAAAIA/AAAAAP//fz8AAACAAACAP2ychrMAAACAAAAAAP//f78AAACAAAAAAHjIj7L//3+/AAAAAF11w7EAAIC/AACAP2ychrMAAACAAACAv2ychjMAAACAAAAAAP//f78AAACAAAAAAHjIj7L//3+/AAAAAAAAAAAAAIC/AACAvwAAAAAAAACAAAAAAAAAAAD//38/AAAAAAAAAAAAAIA/AAAAAAAAgD8AAACAAAAAAAAAgL8AAACAAAAAAAAAAAD//38/AAAAAAAAAAAAAIA/AACAP22chrMAAACAAACAvwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAAJa6szH//3+/AAAAAAAAgD8AAACAAACAvwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIA/AAAAAF3IjzMAAIA/AAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AAAAAJa6szH//3+/AACAP22chrMAAACAAAAAAAAAAAAAAIC/AAAAAIysVzEAAIC/AAAAAAAAgD8AAACAAACAP22chrMAAACAAACAvwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AAAAAIysVzEAAIC/AAAAAAAAAAAAAIA/AAAAAF3IjzMAAIA/AAAAAAAAgD8AAACAAACAP22chrMAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIA/AAAAAF3IjzMAAIA/AACAP0qxZbMAAACAAAAAAAAAAAD//38/AAAAAAAAAAAAAIA/AAAAAAAAgD8AAACAAACAP0qxZbMAAACAAACAv22chjMAAACAAAAAAAAAAAAAAIA/AAAAAF3IjzMAAIA/AAAAAAAAgD8AAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AAAAAIysVzEAAIC/AACAP0qxZbMAAACAAAAAAAAAAAAAAIC/AAAAAJa6szH//3+/AAAAAAAAgD8AAACAAACAP0qxZbMAAACAAACAv22chjMAAACAAAAAAAAAAAAAAIC/AAAAAIysVzEAAIC/AAAAAAAAgD8AAACAAACAv22chjMAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AAAAAJa6szH//3+/AACAv22chjMAAACAAAAAAAAAgL8AAACAAAAAAAAAAAD//38/AAAAAAAAAAAAAIA/AACAvwTNTjMAAACAAAAAAJ490rAAAIA/AACAvwTNTjMAAACAAAAAAF1bVK0AAIC/AAAAAF1bVK0AAIC/AACAPwTNTrMAAACAAACAvwTNTjMAAACAAAAAAF1bVK0AAIC/AAAAAF1bVK0AAIC/AACAPwTNTrMAAACAAACAvwTNTjMAAACAAAAAAJ490rAAAIA/AAAAAJ490rAAAIA/AACAPwTNTrMAAACAAAAAAJ490rAAAIA/AACAPwTNTrMAAACAAACAvwAAAAAAAACAAAAAAP//f78AAACAAAAAAAAAAAAAAIA/AACAvwAAAAAAAACAAAAAAP//f78AAACAAAAAAAAAAAAAAIC/AACAvwAAAAAAAACAAAAAAAAAAAAAAIA/AAAAAP//fz8AAACAAAAAAP//f78AAACAAAAAAAAAAAAAAIA/AACAPwAAAAAAAACAAAAAAP//f78AAACAAAAAAAAAAAAAAIC/AACAPwAAAAAAAACAAAAAAAAAAAAAAIA/AAAAAP//fz8AAACAAACAPwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAAP//fz8AAACAAACAPwAAAAAAAACAAACAvwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAAP//fz8AAACAAACAvwAAAAAAAACAAAAAAP//f78AAACAAACAvwAAAAAAAACAAAAAAAAAgD8AAACAAACAvwAAAAAAAACAAACAv6Mu2rUAAACAAACAvwAAAAAAAACAAACAv6Mu2rUAAACAAACAvwAAAADRys+0AAAAAP//fz8AAACAAACAPwAAAAAsS+s0AAAAAP//f78AAACAAACAPwAAAAAAAACAAACAPwAAAADRys80AACAP6Mu2jUAAACAAACAPwAAAAAAAACAAACAP6Mu2jUAAACAAACAPwAAAAAsS+s0AACAPwAAAADMlw01AAAAAAAAgD8AAACAAAAAAP//fz8AAACAAAAAAAAAgD8AAACAAAAAAP//f78AAACAAAAAAP//f78AAACAAACAPwAAAADRys80AACAPwAAAADMlw01AACAvwAAAADRys+0AACAvwAAAAAAAACAAACAvwAAAAAAAACAAAAAAAAAgL8AAACAAACAvwAAAAAAAACAAAAAAAAAgD8AAACAAAAAAAAAgD8AAACAAACAPwAAAAAAAACAAAAAAAAAgL8AAACAAACAPwAAAAAAAACA//9/vwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AACAvwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAAP//fz8AAACAAACAvwAAAAAAAACAAAAAAAAAAAAAAIC/AACAvwAAAAAAAACA//9/vwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAAC35ZD80+eS+AACAvwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAAC35ZD80+eS+AAAAAAAAAAAAAIC/AAAAAC75ZD8u+eS+//9/PwAAAAAAAACAAACAPwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAAC75ZD8u+eS+AACAPwAAAAAAAACAAAAAAAAAAAAAAIC/AACAPyQ8PLQAAACAAACAPwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAAAAAgD8AAACAAACAPyQ8PLQAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIC///9/PwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAAC75ZD8y+eS+AAAAAC75ZD8u+eS+AAAAAAAAAAAAAIC/AAAAAC35ZD80+eS+AAAAAC75ZD8y+eS+AAAAAAAAAAAAAIC/AAAAAC35ZD80+eS+AAAAAC75ZD8y+eS+AAAAAAAAAAAAAIC/AAAAAC75ZD8y+eS+AAAAAC75ZD8u+eS+AAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AAAAACc8vDIAAIC/AACAPwAAAADJl400AACAvwAAAADJl420AAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AAAAACc8vDIAAIC/AAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AAAAAAAAAAAAAIC/AAAAACc8vDIAAIC/AAAAAAAAgD8AAACAAAAAAAAAAAAAAIC/AAAAACc8vDIAAIC/AAAAAP//fz8AAACAAAAAAAAAgD8AAACAAACAvwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAAAAAAAAAAIC/AACAPwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAAAAAgD8AAACAAACAPwAAAADJl400AACAvwAAAADJl420AAAAAAAAAAAAAIC/AAAAAAAAgD8AAACA//9/vwAAAAAAAACAAAAAAAAAgL8AAACAAACAvwAAAAAAAACAAAAAAP//fz8AAACAAACAvwAAAAAAAACAAACAvwAAAAAAAACA//9/vwAAAAAAAACAAACAvwAAAAAAAACAAAAAAAAAgD8AAACAAACAPyQ8PLQAAACAAAAAAAAAgL8AAACA//9/PwAAAAAAAACAAACAPwAAAAAAAACA//9/PwAAAAAAAACAAACAPwAAAAAAAACAAACAPyQ8PLQAAACAAACAPwAAAAAAAACAAAAAAP//fz8AAACAAAAAAAAAgD8AAACAAAAAAAAAgD8AAACAAAAAAAAAgL8AAACAAAAAAAAAgL8AAACAAACAPwAAAAAAAACAAACAvwAAAAAAAACAAACAvwAAAADJl420AAAAAAAAgL8AAACAAACAvwAAAADJl420AAAAAAAAgD8AAACAAAAAAAAAgD8AAACAAACAPwAAAADJl400AAAAAAAAgL8AAACAAACAPwAAAADJl400AMB/PwDAfz8AwH8/AMB/P6CvADwKyG4/AMB/PwDAfz/guPU7QCdHPADAfz8AwH8/AMB/PwDAfz/guPU7GAW5PQDAfz8AwH8/AMB/PwDAfz+grwA8k8hiP6CvADyTyGI/AMB/PwDAfz8AwH8/AMB/P+C49TvUWkg/oK8APE5eYT8dAMo+wMtNPADAfz8AwH8/AMB/PwDAfz8dAMo+qNm5PQDAfz8AwH8/AMB/PwDAfz8dAMo+ZnVIP6bZyT5OXmE/AMB/PwDAfz8AwH8/AMB/P6bZyT6QyGI/ptnJPpDIYj8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz+m2ck+CshuPwDAfz8AwH8/AE83PUAnRzwAwH8/AMB/P6z2tD5AJ0c8AMB/PwDAfz8AwH8/AMB/P8ut9j4gfbg9p8PbPu4RSj+y9rQ+GAW5PXiSVD3uEUo/AE83PRgFuT0Vs88+IH24Pbj2tD7UWkg/0G61Pk5eYT8ATzc91FpIP1R1Pj1OXmE/VHU+PU5eYT9UdT49k8hiP1R1Pj2TyGI/VHU+PZPIYj/QbrU+kMhiP9ButT6QyGI/AMB/PwDAfz9UdT49CshuPwDAfz8AwH8/0G61PgrIbj8AwH8/AMB/PwDAfz8AwH8/4Lj1O2xj/z4dAMo+kJj/PgDAfz8AwH8/AMB/PwDAfz8ATzc9bGP/PkR0Sj3m518/FbPPPmxj/z7LrfY+bGP/Prb2tD5sY/8+cQfdPubnXz9kOTI/UlVNP2Q5Mj9SVU0/uMAvP/fQSj/fJCE/BN8SP7jALz/30Eo/IZgtP/sIRz9KrgM/UlVNP0quAz9SVU0/Tq4DP1BVTT9OrgM/UFVNP3k5Mj+1oQs/eTkyP7WhCz/GwC8/FSYOP8bALz8VJg4/9PgYP7DgEj8hmC0/JhASP0OuAz+soQs/Q64DP6yhCz9FrgM/s6ELP0WuAz+zoQs/+SYGPxEmDj/5JgY/ESYOP98kIT8N3xI/8wgjPzAUEj95OTI/rqELP3k5Mj+uoQs/cjkyP1JVTT9yOTI/UlVNPyGYLT8mEBI/xMAvPxAmDj/EwC8/ECYOP94kIT/zbUY/IZgtP/sIRz/0+Bg/jW9GP8TALz/x0Eo/xMAvP/HQSj+gzys/JhASP6DPKz8mEBI/SdkeP/NtRj9J2R4/821GP3bRJD8yFBI/UNkePw3fEj9Q2R4/Dd8SP3bRJD8yFBI/BhUpPysSEj8GFSk/KxISP8oLHj/DbkY/ygseP8NuRj+Zzys/+ghHP4ZEGz+Nb0Y/hkQbP41vRj+Zzys/+ghHP7nmKj84EBI/ueYqPzgQEj+g2h4/nQxIP+X9KT8aEhI/5f0pPxoSEj8aDR4/cQ1IP7nmKj8RCUc/2kUbPzsOSD+55io/EQlHP+L9KT/yCkc/VxMcP2cNSD/i/Sk/8gpHPwMVKT8BC0c/BhIcP7tuRj8GEhw/u25GPwMVKT8BC0c/CRIcP9vfEj8JEhw/298SPweMJz8BC0c/B4wnPwELRz8HjCc/AQtHP88LHj+7bkY/zwseP7tuRj8HjCc/AQtHPw6MJz8rEhI/DownPysSEj8AEhw/w25GPwASHD/DbkY/bdEkPwcNRz9S2R4/6G1GP1LZHj/obUY/bdEkPwcNRz/UCx4/298SP9QLHj/b3xI/AxUpPwELRz8DFSk/AQtHPyajJj8UC0c/Hg0eP2cNSD8moyY/FAtHPy6jJj86EhI/LqMmPzoSEj9UExw/cQ1IP066JT/0DEc/pdoeP5sMSD9OuiU/9AxHP1W6JT8cFBI/VbolPxwUEj/RRRs/PQ5IP3bRJD8wFBI/dtEkPzAUEj+CRBs/lm9GP4JEGz+Wb0Y/oM8rPyYQEj+ERBs/sOASP4REGz+w4BI/oM8rPyYQEj/zCCM/MBQSP/MmBj8OJg4/8yYGPw4mDj/0+Bg/lm9GP+oIIz8HDUc/+iYGP/HQSj/fJCE/6G1GP/omBj/x0Eo/BhUpPywSEj8GEhw/298SPwYSHD/b3xI/BhUpPywSEj9S2R4/BN8SP1LZHj8E3xI/m88rP/oIRz+bzys/+ghHP7nmKj84EBI/LUMbPwdCET+55io/OBASP+X9KT8aEhI/tRAcPzVBET/l/Sk/GhISPwPYHj9cQBE/ueYqPxEJRz+55io/EQlHP4QKHj8tQRE/4/0pP/IKRz/j/Sk/8gpHPw6MJz8sEhI/zwseP9vfEj/PCx4/298SPw6MJz8sEhI/LqMmPz4SEj98Ch4/NUERPy6jJj8+EhI/VbolPxwUEj/61x4/XkARP1W6JT8cFBI/uhAcPy1BET8moyY/FAtHPyajJj8UC0c/M0MbP/9BET9OuiU/9AxHP066JT/0DEc/i0QbP6bgEj+LRBs/puASP23RJD8HDUc/bdEkPwcNRz/4+Bg/puASP/8mBj/00Eo//yYGP/TQSj/qCCM/Bw1HPwAALz8ooWY/wsT+PnJ9Uj/CxP4+cn1SPwAALz9ur2I/AAAvP+xeXT9kegI//K5VP2R6Aj/8rlU/AAAvP+2hYj8AAC8/bq9iP+WONz9yfVI/5Y43P3J9Uj8AAC8/KKFmP9U3CD8ooWY/AAAvPyihZj/IxP4+Zv19P8jE/j5m/X0/5Y43P3J9Uj/ljjc/cn1SP9U3CD9ur2I/AAAvP2CwYj8AAC8/nK9mP9U3CD/sXl0/5HY0P/yuVT/kdjQ//K5VP8LE/j5yfVI/wsT+PnJ9Uj/VNwg/KKFmPwAALz8aomY/1TcIPyihZj/ljjc/Yf19P+WONz9h/X0/1TcIP2CwYj/VNwg/m69mP+R2ND/Yy3o/5HY0P9jLej/VNwg/egNbP9U3CD9ur2I/yMT+Pmb9fT/IxP4+Zv19P9U3CD8aomY/1TcIP+2hYj9kegI/2Mt6P2R6Aj/Yy3o/1TcIP+xeXT/VNwg/bq9iPwAALz9ur2I/5Y43P2H9fT/ljjc/Yf19P+R2ND/Yy3o/5HY0P9jLej8AAC8/7F5dP9U3CD+br2Y/ZHoCP9jLej9kegI/2Mt6PwAALz96A1s/1TcIP+2hYj8AAC8/egNbP+R2ND/8rlU/5HY0P/yuVT8AAC8/nK9mPwAALz/toWI/1TcIP3oDWz9kegI//K5VP2R6Aj/8rlU/AAAvP8J+YT/CxP4+cn1SP8LE/j5yfVI/AAAvP/ZUXj8AAC8/7F5dP2R6Aj/8rlU/ZHoCP/yuVT8AAC8/7aFiPwAALz/2VF4/5Y43P3J9Uj/ljjc/cn1SPwAALz/CfmE/1TcIP8J+YT8AAC8/wn5hP8jE/j5m/X0/yMT+Pmb9fT8AAC8/egNbP+R2ND/8rlU/5HY0P/yuVT8AAC8/nK9mP+R2ND/Yy3o/5HY0P9jLej8AAC8/7F5dP9U3CD+br2Y/1TcIP/RUXj8AAC8/9lReP+WONz9h/X0/5Y43P2H9fT9kegI/2Mt6P2R6Aj/Yy3o/AAAvP3oDWz/VNwg/7aFiP9U3CD/CfmE/5Y43P2H9fT/ljjc/Yf19P9U3CD/2VF4/5Y43P3J9Uj/ljjc/cn1SP9U3CD/2VF4/AAAvP/ZUXj/VNwg/m69mP+R2ND/Yy3o/5HY0P9jLej/VNwg/egNbP9U3CD/0VF4/yMT+Pmb9fT/IxP4+Zv19P9U3CD/CfmE/wsT+PnJ9Uj/CxP4+cn1SP9U3CD/CfmE/AAAvP8J+YT/VNwg/7aFiP2R6Aj/Yy3o/ZHoCP9jLej/VNwg/7F5dPwAALz/toWI/1TcIP3oDWz9kegI//K5VP2R6Aj/8rlU/AAAvP5yvZj/VNwg/7F5dP+R2ND/8rlU/5HY0P/yuVT8AAC8/7F5dPwAALz96A1s/AAAvP3oDWz8AAC8/7F5dPwAALz96A1s/AAAvP+xeXT/VNwg/egNbP9U3CD/sXl0/1TcIP3oDWz/VNwg/7F5dP9U3CD/sXl0/1TcIP3oDWz/VNwg/7F5dP9U3CD95A1s/AAAvP+xeXT8AAC8/egNbPzW7CD93+Dw/CAUXP+OtEj8dpAg/460SP0Z7Fj93+Dw/5p8LP+OtEj8dpAg/BTE7PzW7CD9LeUA/agELP+OtEj/mnws/460SPwgFFz8FMTs/HaQIPwUxOz+1axY/d/g8P+afCz8FMTs/HaQIP+OtEj/nvQg/d/g8P2oBCz8FMTs/5p8LPwUxOz+1axY/S3lAP2oBCz/jrRI/CAUXPwUxOz/nvQg/S3lAP0Z7Fj9LeUA/agELPwUxOz8IBRc/460SPwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/cDDjPiB9uD2nw9s+6vxUP3Aw4z5sY/8+cQfdPur8VD80dEo96vxUP3Aw4z5sY/8+eJJUPer8VD9wMOM+IH24PQDAfz8AwH8/AMB/PwDAfz+m2ck+CshuPwDAfz8AwH8/HQDKPkDMTTwAwH8/AMB/PwDAfz8AwH8/HQDKPqjZuT0AwH8/AMB/PwDAfz8AwH8/ptnJPpDIYj+m2ck+kMhiPwDAfz8AwH8/HQDKPmZ1SD+m2ck+Tl5hP6CvADyOyGI/oK8API7IYj8AwH8/AMB/PwDAfz8AwH8/4Lj1O9RaSD+grwA8Tl5hPwDAfz8AwH8/4Lj1OxgFuT0AwH8/AMB/PwDAfz8AwH8/4Lj1O8AnRzwAwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz+grwA8CshuPwDAfz8AwH8/rHU+PY7IYj+sdT49jshiP6x1Pj2OyGI/2G61PpDIYj/YbrU+kMhiP9hutT6QyGI/rPa0PtRaSD/YbrU+Tl5hP9hutT5OXmE/EE83PdRaSD+sdT49Tl5hP6x1Pj1OXmE/eJJUPebnXz+29rQ+GAW5Pbb2tD4YBbk9y632PiB9uD0Vs88+IH24PafD2z7m518/xE43PRgFuT3ETjc9GAW5PQDAfz8AwH8/2G61PgrIbj8AwH8/AMB/P6x1Pj0KyG4/xE43PcAnRzzETjc9wCdHPADAfz8AwH8/tva0PsAnRzy29rQ+wCdHPADAfz8AwH8/AMB/PwDAfz8AwH8/AMB/Px0Ayj6QmP8+4Lj1O2xj/z4AwH8/AMB/P7D2tD5sY/8+JHRKPe4RSj/LrfY+bGP/PhWzzz5sY/8+9E43PWxj/z5xB90+7hFKPwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/P3Aw4z4gfbg9p8PbPur8VD9wMOM+bGP/PnEH3T7q/FQ/NHRKPer8VD9wMOM+bGP/PniSVD3q/FQ/cDDjPiB9uD2XAaIBJACXASQAEQA9AEQALAA9ACwAFgAaADQAOQAaADkAHwAQACMAKAAQACgAEwAXAC0ANQAXADUAGwCnAaABFQCnARUAPwAxAAoAAgAxAAIANwBAADwADgBAAA4ALgAwAA8ACwAwAAsAMwAhAAQABwAhAAcAKgAvADIANQAvADUALQChASIAJQChASUAowExADcAOQAxADkANABAAC4ALABAACwARACtAa4BQQCtAUEARQAhACoAKAAhACgAIwChAZEBBQChAQUAIgCqAawBQwCqAUMAJgAqAAcAPAAqADwAQACbAaYBPgCbAT4AGAATACgARAATAEQAPQCvAbEBKwCvASsAQgCwAasBJwCwAScAKQBKAEcAUQBKAFEAUwBMAEYASABMAEgAtwBWALMAUgBWAFIAUABeAFgAWgBeAFoAYwBOAOMAWwBOAFsAWQBoAGAAXwBoAF8AZABwAG0AZQBwAGUAXABqAHYAZgBqAGYAYgBvAM8AdABvAHQAbAB1AH8AfAB1AHwAbQBrAHsAggBrAIIAeQB6AH0AgwB6AIMAgAB3AIEAhAB3AIQAhwCJAIUAfgCJAH4AcwB4AIgAiwB4AIsA3wCSAI4AhgCSAIYAcgCaAIoAhwCaAIcAjwCTAKIAoACTAKAAkQCPAJ8ApQCPAKUAlwCQAJgAvwCQAL8AmwChAKcApAChAKQAngCZAKYAqACZAKgAqwCtAKkAowCtAKMAlQC7AK8ArAC7AKwAlABUALUArQBUAK0AsACyALYAlgCyAJYAqgBNALkAtABNALQAVwBJAL4AlwBJAJcAuAC8AMYAwwC8AMMAsACuAMIAyQCuAMkAwADBAEsAVQDBAFUAsQDEAMcAzQDEAM0AygC+AMgAywC+AMsAmgCcAMwAxQCcAMUAugC8AJUAdQC8AHUA0ACNAJ0AvQCNAL0A0QBwANYA0wBwANMA0ADOANIA2QDOANkAjADUANcA3QDUAN0A2gCKANgA2wCKANsA3gDgANwA1QDgANUAbgDeAOIAZwDeAGcAdwDlAOEAcQDlAHEAXQBhAGkA5ABhAOQATwDnAOsA/ADnAPwA9gDsAOgA9QDsAPUAGwH4AAAB8QD4APEA6QDyAOYA7gDyAO4AEgH3AP0ACAH3AAgBBAEBAfkABQEBAQUBDQEaAfQAAwEaAQMBBwEKAQIB8wAKAfMAEwElAf8ACwElAQsBDwEVARcBEAEVARABDAHwACABFgHwABYBFAEYARwBCQEYAQkBEQEhAe0AHQEhAR0BGQEfAe8A/gAfAf4AJAEjAfsA6gAjAeoAHgEGAfoAIgEGASIBDgEsASgBNAEsATQBQgEyASYBLgEyAS4BPgFSAUYBMwFSATMBPwFEAVEBXQFEAV0BPAEvATcBOgEvAToBQAE5AS0BRQE5AUUBPQFKAScBKwFKASsBZAE1AUgBUAE1AVABQwFZAU0BSQFZAUkBVQFLAWUBTwFLAU8BRwFgAVYBUwFgAVMBWwFYATEBKQFYASkBTAFOAWIBXgFOAV4BWgFBATsBXAFBAVwBVAFXAWEBOAFXATgBMAFjASoBNgFjATYBXwFtAWkBagFtAWoBbgFwAWYBaAFwAWgBbAFyAXQBZwFyAWcBcQFvAWsBdQFvAXUBcwF6AYIBfwF6AX8BdwF2AXwBiwF2AYsBeQGAAYUBfQGAAX0BeAGEAYoBhwGEAYcBgQGJAY0BfgGJAX4BhgF7AYwBiAF7AYgBgwENADoAqAENAKgBlgE2AKQBpQE2AKUBOAA2AAEAjwE2AI8BpAESABQAnwESAJ8BmAEcACAAmgEcAJoBnQEZAB0AngEZAJ4BnAEIAAwAlQEIAJUBkwEAAAkAlAEAAJQBjgE7AAYAkgE7AJIBqQEeADgApQEeAKUBmQEGAAMAkAEGAJABkgH+AfwBtQH+AbUBuAH0AfEBuQH0AbkB3gHIAeMB6QHIAekBywEEAg8C5wEEAucBzgHyAfgB4wHyAeMByAERAv4BuAERArgB8AH6AQACuwH6AbsBsgH/AQECvgH/Ab4BugHPAegB0QHPAdEBwQEGAggCxAEGAsQBxwEHAgUC0AEHAtABwwEDAgkCyQEDAskBzQHmAbQBvAHmAbwB1AHVAb0BwAHVAcAB2AEOAvsBswEOArMB5QHeAbkBtgHeAbYB7AHCAdMB3AHCAdwBxgHWAdkB2wHWAdsB0gEOAuUB5wEOAucBDwLfAe0B6gHfAeoB5AHmAdQB0QHmAdEB6AHXAfQB+AHXAfgB2gEBAhEC8AEBAvABvgHFAdoB+AHFAfgB8gHXAb8B8QHXAfEB9AHHAfMBEALHARACBgLuAbcB/QHuAf0BCwLvAQwCDQLvAQ0C6wHzAcoBCgLzAQoCEALMAesBDQLMAQ0CAgLdAeIBEwLdARMCGAL2AeABGQL2ARkCFwLhAfcBFALhARQCEgL5AfUBFgL5ARYCFQJCi2y/pHBdPx6F6z1Ci2y/pHBdPx6F6z1Ci2y/pHBdPx6F6z1Ci2y/pHBdPwAAAL5Ci2y/pHBdPwAAAL5Ci2y/pHBdPwAAAL5Ci2y/cD1qPx6F6z1Ci2y/cD1qPx6F6z1Ci2y/cD1qPx6F6z1Ci2w/pHBdPx6F6z1Ci2w/pHBdPx6F6z1Ci2w/pHBdPx6F6z1Ci2w/pHBdPwAAAL5Ci2w/pHBdPwAAAL5Ci2w/pHBdPwAAAL5Ci2w/cD1qPx6F6z1Ci2w/cD1qPx6F6z1Ci2w/cD1qPx6F6z1Ci2w/cD1qPwAAAL5Ci2w/cD1qPwAAAL5Ci2w/cD1qPwAAAL5Ci2y/cD1qPwAAAL5Ci2y/cD1qPwAAAL5Ci2y/cD1qPwAAAL4AAAAApHBdPx6F6z0AAAAApHBdPx6F6z0AAAAApHBdPx6F6z0AAAAApHBdPx6F6z0AAAAAcD1qPx6F6z0AAAAAcD1qPx6F6z0AAAAAcD1qPx6F6z0AAAAAcD1qPx6F6z0AAAAAcD1qPwAAAL4AAAAAcD1qPwAAAL4AAAAAcD1qPwAAAL4AAAAAcD1qPwAAAL4AAAAApHBdPwAAAL4AAAAApHBdPwAAAL4AAAAApHBdPwAAAL4AAAAApHBdPwAAAL7+/3+/AAAAAI/C9T3+/3+/AAAAAI/C9T3+/3+/AAAAAI/C9T3+/3+/zcwMQMzMzD3+/3+/zcwMQMzMzD3+/3+/zcwMQMzMzD3+/3+/hesBQMzMzD3+/3+/hesBQMzMzD3+/3+/hesBQMzMzD3+/3+/hesBQMzMzD3+/3+/kML1PY/C9T3+/3+/kML1PY/C9T3+/3+/kML1PY/C9T3+/3+/kML1PY/C9T3+/3+/uB4FPszMzD3+/3+/uB4FPszMzD3+/3+/uB4FPszMzD3+/3+/uB4FPszMzD0AAIA/zcwMQMzMzD0AAIA/zcwMQMzMzD0AAIA/zcwMQMzMzD0AAIA/hesBQMzMzD0AAIA/hesBQMzMzD0AAIA/hesBQMzMzD0AAIA/uB4FPszMzD0AAIA/uB4FPszMzD0AAIA/uB4FPszMzD0AAIA/kML1PY/C9T0AAIA/kML1PY/C9T0AAIA/kML1PY/C9T0AAIA/AAAAAI/C9T0AAIA/AAAAAI/C9T0AAIA/AAAAAI/C9T21HmW/zcwMQMzMzD21HmW/zcwMQMzMzD24HmU/zcwMQMzMzD24HmU/zcwMQMzMzD24HmU/hesBQMzMzD24HmU/hesBQMzMzD24HmU/hesBQMzMzD24HmU/hesBQMzMzD21HmW/hesBQMzMzD21HmW/hesBQMzMzD21HmW/hesBQMzMzD21HmW/hesBQMzMzD24HmU/uB4FPszMzD24HmU/uB4FPszMzD24HmU/uB4FPszMzD24HmU/uB4FPszMzD21HmW/uB4FPszMzD21HmW/uB4FPszMzD21HmW/uB4FPszMzD21HmW/uB4FPszMzD21HmW/kML1PY/C9T21HmW/kML1PY/C9T21HmW/kML1PY/C9T21HmW/kML1PY/C9T24HmU/kML1PY/C9T24HmU/kML1PY/C9T24HmU/kML1PY/C9T24HmU/kML1PY/C9T21HmW/AAAAAI/C9T21HmW/AAAAAI/C9T21HmW/AAAAAI/C9T24HmU/AAAAAI/C9T24HmU/AAAAAI/C9T24HmU/AAAAAI/C9T0AAIC/ZmZmP8zMzD0AAIC/ZmZmP8zMzD0AAIC/ZmZmP8zMzD0AAIC/ZmZmP8zMzD0AAIA/ZmZmP8zMzD0AAIA/ZmZmP8zMzD0AAIA/ZmZmP8zMzD21HmW/ZmZmP1WjzD21HmW/ZmZmP1WjzD21HmW/ZmZmP1WjzD21HmW/ZmZmP1WjzD21HmW/ZmZmP1WjzD24HmU/ZmZmP1WjzD24HmU/ZmZmP1WjzD24HmU/ZmZmP1WjzD24HmU/ZmZmP1WjzD24HmU/ZmZmP1WjzD0AAAAAzcwMQMzMzD0AAAAAzcwMQMzMzD0AAAAAzcwMQMzMzD0AAAAAhesBQMzMzD0AAAAAhesBQMzMzD0AAAAAhesBQMzMzD0AAAAAhesBQMzMzD0AAAAAuB4FPszMzD0AAAAAuB4FPszMzD0AAAAAuB4FPszMzD0AAAAAuB4FPszMzD0AAAAAkML1PY/C9T0AAAAAkML1PY/C9T0AAAAAkML1PY/C9T0AAAAAkML1PY/C9T0AAAAAAAAAAI/C9T0AAAAAAAAAAI/C9T0AAAAAAAAAAI/C9T0AAIAzZmZmP1WjzD0AAIAzZmZmP1WjzD0AAIAzZmZmP1WjzD0AAIAzZmZmP1WjzD0vHGe/6iUCQPz8Zj3zKFy/Urj+P/z8Zj3zKFy/Urj+P/z8Zj3zKFy/Urj+P/z8Zj0vHGc/6iUCQP38Zj0vHGc/6iUCQP38Zj0vHGe/6iUCQGH5h70vHGe/6iUCQGH5h70wHGe/0nxlP/z8Zj3zKFy/16NwP/z8Zj3zKFy/16NwP/z8Zj3zKFy/16NwP/z8Zj0uHGc/0nxlP/38Zj0uHGc/0nxlP/38Zj0wHGe/0nxlP2H5h73zKFy/16NwP2H5h73zKFy/16NwP2H5h73zKFy/16NwP2H5h70uHGc/0nxlP2H5h70vHGc/6iUCQGH5h73yKFw/16NwP2H5h73yKFw/16NwP2H5h73yKFw/16NwP2H5h73zKFw/Urj+P2H5h73zKFw/Urj+P2H5h73zKFw/Urj+P2H5h73yKFw/16NwP8aQ+bzyKFw/16NwP8aQ+bzyKFw/16NwP8aQ+bzyKFw/16NwP8aQ+bzzKFy/16NwP8aQ+bzzKFy/16NwP8aQ+bzzKFy/16NwP8aQ+bzyKFw/16NwP0Klp7zyKFw/16NwP0Klp7zyKFw/16NwP0Klp7zzKFw/Urj+P8aQ+bzzKFw/Urj+P8aQ+bzzKFw/Urj+P8aQ+bzzKFw/Urj+P8aQ+byYxGA/16NwP8aQ+byYxGA/16NwP8aQ+byYxGA/16NwP8aQ+byYxGA/16NwP0Klp7yYxGA/16NwP0Klp7yYxGA/16NwP0Klp7yYxGA/Urj+P8aQ+byYxGA/Urj+P8aQ+byYxGA/Urj+P8aQ+byYxGA/Urj+P0Klp7yYxGA/Urj+P0Klp7yYxGA/Urj+P0Klp7zzKFw/Urj+P0Klp7zzKFw/Urj+P0Klp7zzKFw/Urj+P0Klp7zzKFw/Urj+P0Klp7zzKFy/Urj+P0Klp7zzKFy/Urj+P0Klp7zzKFy/Urj+P0Klp7zzKFy/Urj+P0Klp7zzKFw/Urj+P25zKzzzKFw/Urj+P25zKzzzKFw/Urj+P25zKzzyKFw/16NwP25zKzzyKFw/16NwP25zKzzyKFw/16NwP25zKzzzKFw/Urj+PzylpzzzKFw/Urj+PzylpzzzKFw/Urj+PzylpzzzKFy/Urj+P25zKzzzKFy/Urj+P25zKzzzKFy/Urj+P25zKzyYxGA/Urj+P25zKzyYxGA/Urj+P25zKzyYxGA/Urj+P25zKzyYxGA/16NwP25zKzyYxGA/16NwP25zKzyYxGA/16NwP25zKzyYxGA/Urj+PzylpzyYxGA/Urj+PzylpzyYxGA/Urj+PzylpzyYxGA/16NwPzylpzyYxGA/16NwPzylpzyYxGA/16NwPzylpzzyKFw/16NwPzylpzzyKFw/16NwPzylpzzyKFw/16NwPzylpzzzKFy/16NwPzylpzzzKFy/16NwPzylpzzzKFy/16NwPzylpzzzKFy/16NwPzylpzzyKFw/16NwP/38Zj3yKFw/16NwP/38Zj3yKFw/16NwP/38Zj3yKFw/16NwP/38Zj3zKFw/Urj+P/38Zj3zKFw/Urj+P/38Zj3zKFw/Urj+P/38Zj3zKFw/Urj+P/38Zj3zKFy/16NwP25zKzzzKFy/16NwP25zKzzzKFy/16NwP25zKzzzKFy/Urj+PzylpzzzKFy/Urj+PzylpzzzKFy/Urj+PzylpzyZxGC/16NwPzylpzyZxGC/16NwPzylpzyZxGC/16NwPzylpzyZxGC/16NwP25zKzyZxGC/16NwP25zKzyZxGC/16NwP25zKzyYxGC/Urj+PzylpzyYxGC/Urj+PzylpzyYxGC/Urj+PzylpzyYxGC/Urj+P25zKzyYxGC/Urj+P25zKzyYxGC/Urj+P25zKzzzKFy/16NwP0Klp7zzKFy/16NwP0Klp7zzKFy/16NwP0Klp7yZxGC/16NwP0Klp7yZxGC/16NwP0Klp7yZxGC/16NwP0Klp7yZxGC/16NwP8aQ+byZxGC/16NwP8aQ+byZxGC/16NwP8aQ+byYxGC/Urj+P0Klp7yYxGC/Urj+P0Klp7yYxGC/Urj+P0Klp7yYxGC/Urj+P8aQ+byYxGC/Urj+P8aQ+byYxGC/Urj+P8aQ+bzzKFy/Urj+P8aQ+bzzKFy/Urj+P8aQ+bzzKFy/Urj+P8aQ+bzzKFy/Urj+P8aQ+bzzKFy/Urj+P2H5h73zKFy/Urj+P2H5h73zKFy/Urj+P2H5h73zKFy/Urj+P2H5h70AAAAA6iUCQPz8Zj0AAAAA6iUCQPz8Zj0AAAAAUrj+P0Klp7wAAAAAUrj+P25zKzwAAAAAUrj+P/z8Zj0AAAAAUrj+P/z8Zj0AAAAAUrj+P/z8Zj0AAAAAUrj+PzylpzwAAAAAUrj+P8aQ+bwAAAAAUrj+P8aQ+bwAAAAAUrj+P2H5h70AAAAAUrj+P2H5h70AAAAAUrj+P2H5h70AAAAA6iUCQGH5h70AAAAA6iUCQGH5h70AAICz0nxlP/z8Zj0AAICz0nxlP/z8Zj0AAICz0nxlP2H5h70AAICz16NwP2H5h70AAICz16NwP2H5h70AAICz16NwP2H5h70AAICz16NwP8aQ+bwAAICz16NwP8aQ+bwAAICz16NwPzylpzwAAICz16NwPzylpzwAAICz16NwP/z8Zj0AAICz16NwP/z8Zj0AAICz16NwP/z8Zj0AAICz16NwP/z8Zj0AAICz16NwP25zKzwAAICz16NwP0Klp7x+JV2/sc/6P5SFFb1+JV2/sc/6P5SFFb1+JV2/sc/6P5SFFb1+JV2/sc/6P5SFFb2UB1W/uMH3P0CSVruUB1W/uMH3P0CSVruUB1W/uMH3P0CSVruUB1W/uMH3P0CSVrt+JV2/aQH3P/T6bL1+JV2/aQH3P/T6bL1+JV2/aQH3P/T6bL1+JV2/aQH3P/T6bL1+JV2/LzTRP8gP1T5+JV2/LzTRP8gP1T5+JV2/LzTRP8gP1T5+JV2/LzTRP8gP1T4GiJO+sc/6P5SFFb0GiJO+sc/6P5SFFb0GiJO+sc/6P5SFFb0GiJO+sc/6P5SFFb3aw6O+uMH3P0CSVrvaw6O+uMH3P0CSVrvaw6O+uMH3P0CSVrvaw6O+uMH3P0CSVrsGiJO+aQH3P/T6bL0GiJO+aQH3P/T6bL0GiJO+aQH3P/T6bL0GiJO+aQH3P/T6bL0HiJO+LzTRP8gP1T4HiJO+LzTRP8gP1T4HiJO+LzTRP8gP1T4HiJO+LzTRP8gP1T7aw6O+KULUPzgMxD7aw6O+KULUPzgMxD7aw6O+KULUPzgMxD7aw6O+KULUPzgMxD4HiJO+52XNPx0hyj4HiJO+52XNPx0hyj4HiJO+52XNPx0hyj4HiJO+52XNPx0hyj7aw6O+4XPQP4wduT7aw6O+4XPQP4wduT7aw6O+4XPQP4wduT7aw6O+4XPQP4wduT5+JV2/52XNPx0hyj5+JV2/52XNPx0hyj5+JV2/52XNPx0hyj5+JV2/52XNPx0hyj6UB1W/4XPQP4wduT6UB1W/4XPQP4wduT6UB1W/4XPQP4wduT6UB1W/4XPQP4wduT6UB1W/KULUPzgMxD6UB1W/KULUPzgMxD6UB1W/KULUPzgMxD6UB1W/KULUPzgMxD6UB1W/cPPzPwC9ybyUB1W/cPPzPwC9ybyUB1W/cPPzPwC9ybyUB1W/cPPzPwC9ybzaw6O+cPPzPwC9ybzaw6O+cPPzPwC9ybzaw6O+cPPzPwC9ybzaw6O+cPPzPwC9ybx+JV2/RuT7P4eeuTx+JV2/RuT7P4eeuTx+JV2/RuT7P4eeuTx+JV2/RuT7P4eeuTyUB1W/Tdb4P5zrZD2UB1W/Tdb4P5zrZD2UB1W/Tdb4P5zrZD2UB1W/Tdb4P5zrZD1+JV2//hX4P3A8qzp+JV2//hX4P3A8qzp+JV2//hX4P3A8qzp+JV2//hX4P3A8qzp+JV2/xEjSP2Va8z5+JV2/xEjSP2Va8z5+JV2/xEjSP2Va8z5+JV2/xEjSP2Va8z6UB1W/BQj1Pzx2DT2UB1W/BQj1Pzx2DT2UB1W/BQj1Pzx2DT2UB1W/BQj1Pzx2DT2UB1W/dYjRPydo1z6UB1W/dYjRPydo1z6UB1W/dYjRPydo1z6UB1W/dYjRPydo1z5+JV2/fHrOP7lr6D5+JV2/fHrOP7lr6D5+JV2/fHrOP7lr6D5+JV2/fHrOP7lr6D6UB1W/vVbVP9NW4j6UB1W/vVbVP9NW4j6UB1W/vVbVP9NW4j6UB1W/vVbVP9NW4j4HiJO+xEjSP2Va8z4HiJO+xEjSP2Va8z4HiJO+xEjSP2Va8z4HiJO+xEjSP2Va8z4GiJO+RuT7P4eeuTwGiJO+RuT7P4eeuTwGiJO+RuT7P4eeuTwGiJO+RuT7P4eeuTzaw6O+vVbVP9NW4j7aw6O+vVbVP9NW4j7aw6O+vVbVP9NW4j7aw6O+vVbVP9NW4j4HiJO+fHrOP7lr6D4HiJO+fHrOP7lr6D4HiJO+fHrOP7lr6D4HiJO+fHrOP7lr6D4GiJO+/hX4P3A8qzoGiJO+/hX4P3A8qzoGiJO+/hX4P3A8qzoGiJO+/hX4P3A8qzraw6O+dYjRPydo1z7aw6O+dYjRPydo1z7aw6O+dYjRPydo1z7aw6O+dYjRPydo1z7aw6O+BQj1Pzx2DT3aw6O+BQj1Pzx2DT3aw6O+BQj1Pzx2DT3aw6O+BQj1Pzx2DT3aw6O+Tdb4P5zrZD3aw6O+Tdb4P5zrZD3aw6O+Tdb4P5zrZD3aw6O+Tdb4P5zrZD0yyRa/k4H5P7wRLz0yyRa/k4H5P7wRLz0yyRa/h2n2P3fwzzwyyRa/h2n2P3fwzzxPIBC/h2n2P3fwzzxPIBC/h2n2P3fwzzwyyRa/MN3QP2Mj3j4yyRa/MN3QP2Mj3j5PIBC/MN3QP2Mj3j5PIBC/MN3QP2Mj3j4yyRa/PPXTP5MG5z4yyRa/PPXTP5MG5z5PIBC/PPXTP5MG5z5PIBC/PPXTP5MG5z5PIBC/k4H5P7wRLz1PIBC/k4H5P7wRLz2DYZO+sc/6P5SFFb2DYZO+sc/6P5SFFb2DYZO+sc/6P5SFFb2DYZO+sc/6P5SFFb2wJYO+uMH3P0CSVruwJYO+uMH3P0CSVruwJYO+uMH3P0CSVruwJYO+uMH3P0CSVruDYZO+aQH3P/T6bL2DYZO+aQH3P/T6bL2DYZO+aQH3P/T6bL2DYZO+aQH3P/T6bL2DYZO+LzTRP8gP1T6DYZO+LzTRP8gP1T6DYZO+LzTRP8gP1T6DYZO+LzTRP8gP1T5xYZM+sc/6P5SFFb1xYZM+sc/6P5SFFb1xYZM+sc/6P5SFFb1xYZM+sc/6P5SFFb2eJYM+uMH3P0CSVrueJYM+uMH3P0CSVrueJYM+uMH3P0CSVrueJYM+uMH3P0CSVrtxYZM+aQH3P/T6bL1xYZM+aQH3P/T6bL1xYZM+aQH3P/T6bL1xYZM+aQH3P/T6bL1xYZM+LzTRP8gP1T5xYZM+LzTRP8gP1T5xYZM+LzTRP8gP1T5xYZM+LzTRP8gP1T6eJYM+KULUPzgMxD6eJYM+KULUPzgMxD6eJYM+KULUPzgMxD6eJYM+KULUPzgMxD5xYZM+52XNPx0hyj5xYZM+52XNPx0hyj5xYZM+52XNPx0hyj5xYZM+52XNPx0hyj6eJYM+4XPQP4wduT6eJYM+4XPQP4wduT6eJYM+4XPQP4wduT6eJYM+4XPQP4wduT6DYZO+52XNPx0hyj6DYZO+52XNPx0hyj6DYZO+52XNPx0hyj6DYZO+52XNPx0hyj6wJYO+4XPQP4wduT6wJYO+4XPQP4wduT6wJYO+4XPQP4wduT6wJYO+4XPQP4wduT6wJYO+KULUPzgMxD6wJYO+KULUPzgMxD6wJYO+KULUPzgMxD6wJYO+KULUPzgMxD6wJYO+cPPzPwC9ybywJYO+cPPzPwC9ybywJYO+cPPzPwC9ybywJYO+cPPzPwC9ybyeJYM+cPPzPwC9ybyeJYM+cPPzPwC9ybyeJYM+cPPzPwC9ybyeJYM+cPPzPwC9ybyDYZO+RuT7P4eeuTyDYZO+RuT7P4eeuTyDYZO+RuT7P4eeuTyDYZO+RuT7P4eeuTywJYO+Tdb4P5zrZD2wJYO+Tdb4P5zrZD2wJYO+Tdb4P5zrZD2wJYO+Tdb4P5zrZD2DYZO+/hX4P3A8qzqDYZO+/hX4P3A8qzqDYZO+/hX4P3A8qzqDYZO+/hX4P3A8qzqDYZO+xEjSP2Va8z6DYZO+xEjSP2Va8z6DYZO+xEjSP2Va8z6DYZO+xEjSP2Va8z6wJYO+BQj1Pzx2DT2wJYO+BQj1Pzx2DT2wJYO+BQj1Pzx2DT2wJYO+BQj1Pzx2DT2wJYO+dYjRPydo1z6wJYO+dYjRPydo1z6wJYO+dYjRPydo1z6wJYO+dYjRPydo1z6DYZO+fHrOP7lr6D6DYZO+fHrOP7lr6D6DYZO+fHrOP7lr6D6DYZO+fHrOP7lr6D6wJYO+vVbVP9NW4j6wJYO+vVbVP9NW4j6wJYO+vVbVP9NW4j6wJYO+vVbVP9NW4j5xYZM+xEjSP2Va8z5xYZM+xEjSP2Va8z5xYZM+xEjSP2Va8z5xYZM+xEjSP2Va8z5xYZM+RuT7P4eeuTxxYZM+RuT7P4eeuTxxYZM+RuT7P4eeuTxxYZM+RuT7P4eeuTyeJYM+vVbVP9NW4j6eJYM+vVbVP9NW4j6eJYM+vVbVP9NW4j6eJYM+vVbVP9NW4j5xYZM+fHrOP7lr6D5xYZM+fHrOP7lr6D5xYZM+fHrOP7lr6D5xYZM+fHrOP7lr6D5xYZM+/hX4P3A8qzpxYZM+/hX4P3A8qzpxYZM+/hX4P3A8qzpxYZM+/hX4P3A8qzqeJYM+dYjRPydo1z6eJYM+dYjRPydo1z6eJYM+dYjRPydo1z6eJYM+dYjRPydo1z6eJYM+BQj1Pzx2DT2eJYM+BQj1Pzx2DT2eJYM+BQj1Pzx2DT2eJYM+BQj1Pzx2DT2eJYM+Tdb4P5zrZD2eJYM+Tdb4P5zrZD2eJYM+Tdb4P5zrZD2eJYM+Tdb4P5zrZD1mHVW8k4H5P7wRLz1mHVW8k4H5P7wRLz1mHVW8h2n2P3fwzzxmHVW8h2n2P3fwzzxmG1U8h2n2P3fwzzxmG1U8h2n2P3fwzzxmHVW8MN3QP2Mj3j5mHVW8MN3QP2Mj3j5mG1U8MN3QP2Mj3j5mG1U8MN3QP2Mj3j5mHVW8PPXTP5MG5z5mHVW8PPXTP5MG5z5mG1U8PPXTP5MG5z5mG1U8PPXTP5MG5z5mG1U8k4H5P7wRLz1mG1U8k4H5P7wRLz3xh5M+sc/6P5SFFb3xh5M+sc/6P5SFFb3xh5M+sc/6P5SFFb3xh5M+sc/6P5SFFb3Fw6M+uMH3P0CSVrvFw6M+uMH3P0CSVrvFw6M+uMH3P0CSVrvFw6M+uMH3P0CSVrvxh5M+aQH3P/T6bL3xh5M+aQH3P/T6bL3xh5M+aQH3P/T6bL3xh5M+aQH3P/T6bL3xh5M+LzTRP8gP1T7xh5M+LzTRP8gP1T7xh5M+LzTRP8gP1T7xh5M+LzTRP8gP1T5zJV0/sc/6P5SFFb1zJV0/sc/6P5SFFb1zJV0/sc/6P5SFFb1zJV0/sc/6P5SFFb2JB1U/uMH3P0CSVruJB1U/uMH3P0CSVruJB1U/uMH3P0CSVruJB1U/uMH3P0CSVrtzJV0/aQH3P/T6bL1zJV0/aQH3P/T6bL1zJV0/aQH3P/T6bL1zJV0/aQH3P/T6bL1zJV0/LzTRP8gP1T5zJV0/LzTRP8gP1T5zJV0/LzTRP8gP1T5zJV0/LzTRP8gP1T6JB1U/KULUPzgMxD6JB1U/KULUPzgMxD6JB1U/KULUPzgMxD6JB1U/KULUPzgMxD5zJV0/52XNPx0hyj5zJV0/52XNPx0hyj5zJV0/52XNPx0hyj5zJV0/52XNPx0hyj6JB1U/4XPQP4wduT6JB1U/4XPQP4wduT6JB1U/4XPQP4wduT6JB1U/4XPQP4wduT7xh5M+52XNPx0hyj7xh5M+52XNPx0hyj7xh5M+52XNPx0hyj7xh5M+52XNPx0hyj7Bw6M+4XPQP4wduT7Bw6M+4XPQP4wduT7Bw6M+4XPQP4wduT7Bw6M+4XPQP4wduT7Bw6M+KULUPzgMxD7Bw6M+KULUPzgMxD7Bw6M+KULUPzgMxD7Bw6M+KULUPzgMxD7Fw6M+cPPzPwC9ybzFw6M+cPPzPwC9ybzFw6M+cPPzPwC9ybzFw6M+cPPzPwC9ybyJB1U/cPPzPwC9ybyJB1U/cPPzPwC9ybyJB1U/cPPzPwC9ybyJB1U/cPPzPwC9ybzxh5M+RuT7P4eeuTzxh5M+RuT7P4eeuTzxh5M+RuT7P4eeuTzxh5M+RuT7P4eeuTzFw6M+Tdb4P5zrZD3Fw6M+Tdb4P5zrZD3Fw6M+Tdb4P5zrZD3Fw6M+Tdb4P5zrZD3xh5M+/hX4P3A8qzrxh5M+/hX4P3A8qzrxh5M+/hX4P3A8qzrxh5M+/hX4P3A8qzrxh5M+xEjSP2Va8z7xh5M+xEjSP2Va8z7xh5M+xEjSP2Va8z7xh5M+xEjSP2Va8z7Fw6M+BQj1Pzx2DT3Fw6M+BQj1Pzx2DT3Fw6M+BQj1Pzx2DT3Fw6M+BQj1Pzx2DT3Bw6M+dYjRPydo1z7Bw6M+dYjRPydo1z7Bw6M+dYjRPydo1z7Bw6M+dYjRPydo1z7xh5M+fHrOP7lr6D7xh5M+fHrOP7lr6D7xh5M+fHrOP7lr6D7xh5M+fHrOP7lr6D7Bw6M+vVbVP9NW4j7Bw6M+vVbVP9NW4j7Bw6M+vVbVP9NW4j7Bw6M+vVbVP9NW4j5zJV0/xEjSP2Va8z5zJV0/xEjSP2Va8z5zJV0/xEjSP2Va8z5zJV0/xEjSP2Va8z5zJV0/RuT7P4eeuTxzJV0/RuT7P4eeuTxzJV0/RuT7P4eeuTxzJV0/RuT7P4eeuTyJB1U/vVbVP9NW4j6JB1U/vVbVP9NW4j6JB1U/vVbVP9NW4j6JB1U/vVbVP9NW4j5zJV0/fHrOP7lr6D5zJV0/fHrOP7lr6D5zJV0/fHrOP7lr6D5zJV0/fHrOP7lr6D5zJV0//hX4P3A8qzpzJV0//hX4P3A8qzpzJV0//hX4P3A8qzpzJV0//hX4P3A8qzqJB1U/dYjRPydo1z6JB1U/dYjRPydo1z6JB1U/dYjRPydo1z6JB1U/dYjRPydo1z6JB1U/BQj1Pzx2DT2JB1U/BQj1Pzx2DT2JB1U/BQj1Pzx2DT2JB1U/BQj1Pzx2DT2JB1U/Tdb4P5zrZD2JB1U/Tdb4P5zrZD2JB1U/Tdb4P5zrZD2JB1U/Tdb4P5zrZD1EIBA/k4H5P7wRLz1EIBA/k4H5P7wRLz1EIBA/h2n2P3fwzzxEIBA/h2n2P3fwzzwnyRY/h2n2P3fwzzwnyRY/h2n2P3fwzzxEIBA/MN3QP2Mj3j5EIBA/MN3QP2Mj3j4nyRY/MN3QP2Mj3j4nyRY/MN3QP2Mj3j5EIBA/PPXTP5MG5z5EIBA/PPXTP5MG5z4nyRY/PPXTP5MG5z4nyRY/PPXTP5MG5z4nyRY/k4H5P7wRLz0nyRY/k4H5P7wRLz0yyRa/PTj4P2BRaLwyyRa/PTj4P2BRaLwyyRa/MSD1P+AtAb0yyRa/MSD1P+AtAb1PIBC/MSD1P+AtAb1PIBC/MSD1P+AtAb0yyRa/25PPP5z+wD4yyRa/25PPP5z+wD5PIBC/25PPP5z+wD5PIBC/25PPP5z+wD4yyRa/5qvSP83hyT4yyRa/5qvSP83hyT5PIBC/5qvSP83hyT5PIBC/5qvSP83hyT5PIBC/PTj4P2BRaLxPIBC/PTj4P2BRaLxmHVW8PTj4P2BRaLxmHVW8PTj4P2BRaLxmHVW8MSD1P+AtAb1mHVW8MSD1P+AtAb1mG1U8MSD1P+AtAb1mG1U8MSD1P+AtAb1mHVW825PPP5z+wD5mHVW825PPP5z+wD5mG1U825PPP5z+wD5mG1U825PPP5z+wD5mHVW85qvSP83hyT5mHVW85qvSP83hyT5mG1U85qvSP83hyT5mG1U85qvSP83hyT5mG1U8PTj4P2BRaLxmG1U8PTj4P2BRaLxEIBA/PTj4P2BRaLxEIBA/PTj4P2BRaLxEIBA/MSD1P+AtAb1EIBA/MSD1P+AtAb0nyRY/MSD1P+AtAb0nyRY/MSD1P+AtAb1EIBA/25PPP5z+wD5EIBA/25PPP5z+wD4nyRY/25PPP5z+wD4nyRY/25PPP5z+wD5EIBA/5qvSP83hyT5EIBA/5qvSP83hyT4nyRY/5qvSP83hyT4nyRY/5qvSP83hyT4nyRY/PTj4P2BRaLwnyRY/PTj4P2BRaLz+/3+/AAAAAAAAAID+/3+/AAAAAAAAAID+/3+/zcwMQAAAAID+/3+/zcwMQAAAAID+/3+/hesBQAAAAID+/3+/hesBQAAAAID+/3+/kML1PQDcpbj+/3+/kML1PQDcpbj+/3+/uB4FPgAAAID+/3+/uB4FPgAAAIAAAIA/zcwMQAAAAIAAAIA/zcwMQAAAAIAAAIA/AAAAAAAAAIAAAIA/AAAAAAAAAIAAAIA/uB4FPgAAAIAAAIA/kML1PQAAAIAAAIA/hesBQAAAAIC1HmW/zcwMQAAAAIC5HmU/zcwMQAAAAIC1HmW/AAAAAAAAAIC4HmU/AAAAAAAAAIAAAIA/ZmZmPwDcpbj+/3+/ZmZmPwAAAID+/3+/ZmZmPwAAAIAAAAAAzcwMQAAAAIAAAAAAAAAAAAAAAIC4HmU/hesBQAAAAIC4HmU/hesBQAAAAIC4HmU/ZmZmPwAAAIC4HmU/ZmZmPwAAAIC1HmW/ZmZmPwAAAIC1HmW/ZmZmPwAAAIC1HmW/hesBQAAAAIC1HmW/hesBQAAAAIAAAIAzhesBQAAAAIAAAIAzhesBQAAAAIAAAIAzZmZmPwAAAIAAAIAzZmZmPwAAAIDTd1e/GkPYP+Q4kT7Td1e/GkPYP+Q4kT7Td1e/VlXbP6Q2iD7Td1e/VlXbP6Q2iD6LXFy/GkPYP+Q4kT6LXFy/GkPYP+Q4kT6LXFy/VlXbP6Q2iD6LXFy/VlXbP6Q2iD7Td1e/KgW/PwAvcTzTd1e/KgW/PwAvcTzTd1e/KgW/PwAvcTzTd1e/ZRfCPwBkPLvTd1e/ZRfCPwBkPLvTd1e/ZRfCPwBkPLuLXFy/KgW/PwAvcTyLXFy/KgW/PwAvcTyLXFy/KgW/PwAvcTyLXFy/ZRfCPwBkPLuLXFy/ZRfCPwBkPLuLXFy/ZRfCPwBkPLvTd1e/OMzZP8S3jD7Td1e/OMzZP8S3jD6LXFy/OMzZP8S3jD6LXFy/OMzZP8S3jD6LXFy/NYG/PwCpqLuLXFy/NYG/PwCpqLuLXFy/NYG/PwCpqLuLXFy/NYG/PwCpqLvTd1e/NYG/PwCpqLvTd1e/NYG/PwCpqLvTd1e/NYG/PwCpqLvTd1e/NYG/PwCpqLsv6lm/GkPYP+Q4kT4v6lm/GkPYP+Q4kT4v6lm/VlXbP6Q2iD4v6lm/VlXbP6Q2iD4v6lm/KgW/PwAvcTwv6lm/KgW/PwAvcTwv6lm/KgW/PwAvcTwv6lm/ZRfCPwBkPLsv6lm/ZRfCPwBkPLsv6lm/ZRfCPwBkPLsv6lm/ZRfCPwBkPLsv6lm/NYG/PwCpqLsv6lm/NYG/PwCpqLsv6lm/NYG/PwCpqLuIXFw/GkPYP+Q4kT6IXFw/GkPYP+Q4kT6IXFw/VlXbP6Q2iD6IXFw/VlXbP6Q2iD7Qd1c/GkPYP+Q4kT7Qd1c/GkPYP+Q4kT7Qd1c/VlXbP6Q2iD7Qd1c/VlXbP6Q2iD6IXFw/KgW/PwAvcTyIXFw/KgW/PwAvcTyIXFw/KgW/PwAvcTyIXFw/ZRfCPwBkPLuIXFw/ZRfCPwBkPLuIXFw/ZRfCPwBkPLvQd1c/KgW/PwAvcTzQd1c/KgW/PwAvcTzQd1c/KgW/PwAvcTzQd1c/ZRfCPwBkPLvQd1c/ZRfCPwBkPLvQd1c/ZRfCPwBkPLuIXFw/OMzZP8S3jD6IXFw/OMzZP8S3jD7Qd1c/OMzZP8S3jD7Qd1c/OMzZP8S3jD7Qd1c/NYG/PwCpqLvQd1c/NYG/PwCpqLvQd1c/NYG/PwCpqLvQd1c/NYG/PwCpqLuIXFw/NYG/PwCpqLuIXFw/NYG/PwCpqLuIXFw/NYG/PwCpqLuIXFw/NYG/PwCpqLss6lk/GkPYP+Q4kT4s6lk/VlXbP6Q2iD4s6lk/KgW/PwAvcTws6lk/KgW/PwAvcTws6lk/ZRfCPwBkPLss6lk/ZRfCPwBkPLss6lk/ZRfCPwBkPLss6lk/NYG/PwCpqLss6lk/NYG/PwCpqLss6lk/NYG/PwCpqLv+/3+/AAAAAI7C9b3+/3+/AAAAAI7C9b3+/3+/AAAAAI7C9b3+/3+/zswMQMzMzL3+/3+/zswMQMzMzL3+/3+/zswMQMzMzL3+/3+/hesBQMzMzL3+/3+/hesBQMzMzL3+/3+/hesBQMzMzL3+/3+/kML1PY7C9b3+/3+/kML1PY7C9b3+/3+/kML1PY7C9b3+/3+/kML1PY7C9b3+/3+/uB4FPszMzL3+/3+/uB4FPszMzL3+/3+/uB4FPszMzL0AAIA/kML1PY7C9b0AAIA/kML1PY7C9b0AAIA/kML1PY7C9b0AAIA/kML1PY7C9b0AAIA/uB4FPszMzL0AAIA/uB4FPszMzL0AAIA/uB4FPszMzL0AAIA/hesBQMzMzL0AAIA/hesBQMzMzL0AAIA/hesBQMzMzL0BAIA/zswMQMzMzL0BAIA/zswMQMzMzL0BAIA/zswMQMzMzL0AAIA/AAAAAI7C9b0AAIA/AAAAAI7C9b0AAIA/AAAAAI7C9b24HmU/kML1PY7C9b24HmU/kML1PY7C9b24HmU/kML1PY7C9b24HmU/kML1PY7C9b21HmW/kML1PY7C9b21HmW/kML1PY7C9b21HmW/kML1PY7C9b21HmW/kML1PY7C9b21HmW/uB4FPszMzL21HmW/uB4FPszMzL21HmW/uB4FPszMzL21HmW/uB4FPszMzL24HmU/uB4FPszMzL24HmU/uB4FPszMzL24HmU/uB4FPszMzL21HmW/hesBQMzMzL21HmW/hesBQMzMzL21HmW/hesBQMzMzL21HmW/hesBQMzMzL24HmU/hesBQMzMzL24HmU/hesBQMzMzL24HmU/hesBQMzMzL24HmU/hesBQMzMzL21HmW/AAAAAI7C9b21HmW/AAAAAI7C9b21HmW/AAAAAI7C9b24HmU/AAAAAI7C9b24HmU/AAAAAI7C9b24HmU/AAAAAI7C9b26HmU/zswMQMzMzL26HmU/zswMQMzMzL26HmU/zswMQMzMzL21HmW/zswMQMzMzL21HmW/zswMQMzMzL21HmW/zswMQMzMzL21HmW/zswMQMzMzL3+/3+/ZmZmP8zMzL3+/3+/ZmZmP8zMzL3+/3+/ZmZmP8zMzL0AAIA/ZmZmP8zMzL0AAIA/ZmZmP8zMzL0AAIA/ZmZmP8zMzL21HmW/ZmZmP8zMzL21HmW/ZmZmP8zMzL21HmW/ZmZmP8zMzL21HmW/ZmZmP8zMzL24HmU/ZmZmP8zMzL24HmU/ZmZmP8zMzL24HmU/ZmZmP8zMzL0AAACmzswMQMzMzL0AAACmzswMQMzMzL0AAACmzswMQMzMzL0AAACmhesBQMzMzL0AAACmhesBQMzMzL0AAACmhesBQMzMzL0AAACmhesBQMzMzL0AAACmkML1PY7C9b0AAACmkML1PY7C9b0AAACmkML1PY7C9b0AAACmkML1PY7C9b0AAACmuB4FPszMzL0AAACmuB4FPszMzL0AAACmuB4FPszMzL0AAACmuB4FPszMzL0AAACmAAAAAI7C9b0AAACmAAAAAI7C9b0AAACmAAAAAI7C9b0AAACmZmZmP8zMzL0AAACmZmZmP8zMzL0AAACmZmZmP8zMzL0AAACmZmZmP8zMzL3+/3+/AAAAAAAAAC/+/3+/AAAAAAAAAC/+/3+/zswMQACAB7H+/3+/zswMQACAB7H+/3+/hesBQAAAAC/+/3+/hesBQAAAAC/+/3+/kML1PQAAAC/+/3+/kML1PQAAAC/+/3+/uB4FPgAAAC8AAIA/zswMQAAAAC8AAIA/zswMQAAAAC8AAIA/AAAAAAAAAC8AAIA/AAAAAAAAAC8AAIA/uB4FPgAAAC8AAIA/kML1PQAAAC8AAIA/kML1PQAAAC8AAIA/hesBQAAAAC8AAIA/hesBQAAAAC+1HmW/zswMQAAAAC+1HmW/zswMQAAAAC+5HmU/zswMQAAAAC+1HmW/AAAAAAAAAC+4HmU/AAAAAAAAAC8AAIA/ZmZmPwAAAC8AAIA/ZmZmPwAAAC/+/3+/ZmZmPwAAAC/+/3+/ZmZmPwAAAC8AAACmzswMQAAAAIAAAACmAAAAAAAAAIC4HmU/hesBQAAAAIC4HmU/hesBQAAAAIC4HmU/ZmZmPwAAAIC4HmU/ZmZmPwAAAIC1HmW/ZmZmPwAAAIC1HmW/ZmZmPwAAAIC1HmW/hesBQAAAAIC1HmW/hesBQAAAAIAAAACmhesBQAAAAIAAAACmhesBQAAAAIAAAACmZmZmPwAAAIAAAACmZmZmPwAAAIAAAIC/AAAAAAAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgD8AAIC/AAAAAAAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgL8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAA//9/PwAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAA//9/PwAAAIAAAIA/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAA//9/PwAAAIAAAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAA//9/PwAAAIAAAAAA//9/vwAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAA//9/PwAAAIAAAAAA//9/PwAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8AAAAA//9/PwAAAIAAAAAA//9/PwAAAIAAAAAA//9/vwAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL///3+/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIC/AAAAAAAAAID//3+/doxiMwAAAIAAAAAAAAAAAAAAgD+Sc8U5GM0SuP7/fz8AAIC/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAMvlkPyX55D4AAIC/2Tums9DKT7UAAIC/AAAAAAAAAIAAAAAAMvlkPyX55D6Vc8U5eG9XOP//fz8AAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAICSc8W5GM0SuP7/fz8AAAAAAAAAAAAAgD8AAIA/AAAAAAAAAICec8W5gm9XOP7/fz8AAAAAMflkPyT55D4AAIA/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAMflkPyT55D4AAIA/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIC/AAAAAAAAAICSc8W5GM0SuP7/fz8AAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAAAAAACAvwAAAIAAAAAAAAAAAAAAgD+Sc8U5GM0SuP7/fz8AAIA/AAAAAAAAAICec8W5gm9XOP7/fz8AAAAAMmrXOAAAgD8AAAAAMflkPyT55D4AAAAAMvlkPyX55D4AAAAAPWPXOP//fz8AAAAAMvlkPyL55D4AAAAAMvlkPyX55D6Vc8U5eG9XOP//fz8AAAAAAAAAAP//fz8AAAAAAAAAAAAAgD8AAAAAMvlkPyL55D4AAAAAMvlkPyX55D4AAAAAAAAAAP//fz8AAAAAAAAAAAAAgD8AAAAAMflkPyT55D4AAAAAMvlkPyX55D4AAAAAAACAvwAAAIAAAAAAAAAAAP//fz8AAAAAAAAAAAAAgD8AAAAAAACAvwAAAIAAAAAAAAAAAP//fz8AAAAAAAAAAAAAgD8AAIC/2Tums9DKT7X//3+/doxiMwAAAICSc8U5GM0SuP7/fz+Vc8U5eG9XOP//fz+ec8W5gm9XOP7/fz+Sc8W5GM0SuP7/fz8AAIA/AAAAAAAAAIAAAAAAPWPXOP//fz8AAAAA//9/PwAAAICSc8U5GM0SuP7/fz+Vc8U5eG9XOP//fz8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAICec8W5gm9XOP7/fz+Sc8W5GM0SuP7/fz8AAAAAMmrXOAAAgD8AAAAA//9/PwAAAIAAAAAAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAAAAAACAvwAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAPWPXOP//fz8AAAAAMmrXOAAAgD8AAAAAMvlkPyL55D4AAAAAMvlkPyX55D4AAAAAAAAAAP//fz8AAAAAAAAAAP//fz8AAAAAMvlkPyL55D4AAAAAMvlkPyX55D4AAAAAAACAvwAAAIAAAAAAAAAAAP//fz8AAAAAAAAAAP//fz8AAAAAPWPXOP//fz8AAAAAMmrXOAAAgD8AAAAA//9/PwAAAIAAAAAA//9/PwAAAIAAAAAAAAAAAAAAgD8AAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIDGOZGxAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAxVnQsgAAgL8AAAAAAAAAAAAAgL8AAAAAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAA//9/PwAAAIAAAIA/AAAAAAAAAIDFOZGxAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8AAIC/Pc9zMwAAAIAAAAAAAAAAAAAAgL8AAAAA//9/PwAAAIAAAIC/Pc9zMwAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgL8AAIC/Pc9zMwAAAIAAAAAAAAAAAAAAgD8AAAAA//9/PwAAAIAAAAAAAACAPwAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAIC/Ps9zMwAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIC/Pc9zMwAAAIAAAAAAAACAvwAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgD8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIC/AAAAAAAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgD8AAIC/AAAAAAAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgL8AAIC/Ps9zMwAAAIAAAAAAAACAvwAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgL8AAAAAAACAvwAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIAAAIC/Ps9zMwAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAIC/Ps9zMwAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIC/Pc9zMwAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIC/Pc9zMwAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAAAAAAAAAAAAgL8AAAAA//9/PwAAAIAAAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAIC/Pc9zMwAAAIDFOZGxAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIC/Pc9zMwAAAIDGOZGxAAAAAAAAgD8AAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIA/Pc9zswAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIA/Pc9zswAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAIA/Pc9zswAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAIA/Pc9zswAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIA/Pc9zswAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIA/Pc9zswAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgL8AAIA/Pc9zswAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgD8AAIA/Pc9zswAAAIAAAAAAAACAvwAAAIAAAAAA//9/vwAAAIAAAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAAAA//9/vwAAAIAAAAAAxVnQsgAAgL8AAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIDGOZGxAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAAACAvwAAAIAAAAAAAACAvwAAAIDGOZGxAAAAAAAAgD8AAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAAAAAACAvwAAAIAAAAAAAACAvwAAAIAAAAAA//9/vwAAAIAAAAAA//9/vwAAAIAAAAAAxVnQsgAAgL8AAAAAAAAAAAAAgL8AAAAAxVnQsgAAgL8AAAAAAAAAAAAAgL/FOZGxAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL8AAAAA//9/PwAAAIAAAAAAAACAPwAAAIAAAAAA//9/PwAAAIAAAAAAAACAPwAAAIAAAAAA//9/PwAAAIAAAAAAAACAPwAAAIDFOZGxAAAAAAAAgD8AAAAAAAAAAAAAgD8AAAAA//9/PwAAAIAAAAAAAACAPwAAAIAAAAAAAACAPwAAAIAAAAAAAACAPwAAAIAAAIC/AAAAAAAAAIAAAAAArFMVP7DvT78AAAAAqu9PP7RTFT/0Pbc1sO9PP6xTFT8AAAAAqFMVv7PvTz8AAAAAqu9PP7RTFT/0Pbc1sO9PP6xTFT8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIBIyFW2sO9Pv6xTFb8AAAAAre9Pv7BTFb8AAAAArFMVP7DvT78AAIC/AAAAAAAAAIAAAAAApVMVv7TvTz8AAAAAme9PP8tTFT/0Pbc1sO9PP6xTFT/1Pbe1qu9PP7RTFT8AAAAArFMVP7DvT78AAAAAqu9PP7RTFT///38/U/sFs9IWxDMAAIC/AAAAAAAAAID1Pbe1qu9PP7RTFT8AAAAAqFMVv7PvTz8AAAAAqu9PP7RTFT8AAAAAre9Pv7BTFb8AAAAArFMVP7DvT79IyFU2qu9Pv7RTFb///38/U/sFs9IWxDP1Pbe1qu9PP7RTFT8AAAAApVMVv7TvTz8AAAAAme9PP8tTFT///38/U/sFs9IWxDMAAIC/AAAAAAAAAID1Pbe1qu9PP7RTFT8AAAAAslMVP6rvT78AAAAAme9PP8tTFT8AAAAAn+9Pv8FTFb8AAAAApVMVv7TvTz9IyFU2qu9Pv7RTFb///38/U/sFs9IWxDMAAIC/AAAAAAAAAIAAAAAAn+9Pv8FTFb8AAAAAslMVP6rvT79IyFU2qu9Pv7RTFb8AAIC/AAAAAAAAAIBIyFW2sO9Pv6xTFb8AAAAAn+9Pv8FTFb8AAAAApVMVv7TvTz9IyFW2sO9Pv6xTFb8AAAAAn+9Pv8FTFb8AAAAAslMVP6rvT78AAIA/AAAAAAAAAIAAAAAAslMVP6rvT78AAAAAme9PP8tTFT/0Pbc1sO9PP6xTFT8AAIA/AAAAAAAAAIBIyFW2sO9Pv6xTFb8AAAAAre9Pv7BTFb8AAAAAqFMVv7PvTz8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAre9Pv7BTFb8AAAAAqFMVv7PvTz9IyFU2qu9Pv7RTFb8AAIC/AAAAAAAAAIAAAAAArFMVP7DvT78AAAAAne9PP8RTFT+RUnQ2qu9PP7FTFT8AAAAArFMVv6/vTz8AAAAAne9PP8RTFT+RUnQ2qu9PP7FTFT8AAIA/AAAAAMDVZTUAAIC/AAAAAAAAAID0Pbe1s+9Pv6hTFb8AAAAAnu9Pv8RTFb8AAAAArFMVP7DvT78AAIC/AAAAAAAAAIAAAAAApVMVv7TvTz8AAAAAue9PP6BTFT+RUnQ2qu9PP7FTFT/0Pbe1s+9Pv6hTFb8AAAAAnu9Pv8RTFb8AAAAArFMVv6/vTz8AAIA/AAAAAMDVZTX0Pbe1s+9Pv6hTFb8AAAAAu+9Pv51TFb8AAAAAqlMVP7HvT78AAIA/AAAAAMDVZTUAAIC/AAAAAAAAAID0Pbe1s+9Pv6hTFb8AAAAAu+9Pv51TFb8AAAAApVMVv7TvTz8AAAAAqlMVP7HvT78AAAAAue9PP6BTFT+RUnQ2qu9PP7FTFT8AAIA/AAAAAMDVZTWZUnS2rO9PP7JTFT8AAAAApVMVv7TvTz8AAAAAue9PP6BTFT8AAIA/LPsFs5oWxDOZUnS2rO9PP7JTFT8AAAAArFMVP7DvT78AAAAAne9PP8RTFT8AAIA/LPsFs5oWxDMAAIC/AAAAAAAAAICZUnS2rO9PP7JTFT8AAAAAqlMVP7HvT78AAAAAue9PP6BTFT8AAAAAu+9Pv51TFb8AAAAApVMVv7TvTz/zPbc1rO9Pv7JTFb8AAIA/LPsFs5oWxDMAAAAAnu9Pv8RTFb8AAAAArFMVP7DvT7/zPbc1rO9Pv7JTFb8AAIA/LPsFs5oWxDMAAIC/AAAAAAAAAIAAAAAAu+9Pv51TFb8AAAAAqlMVP7HvT7/zPbc1rO9Pv7JTFb8AAIC/AAAAAAAAAIAAAAAAnu9Pv8RTFb8AAAAArFMVv6/vTz/zPbc1rO9Pv7JTFb8AAIC/AAAAAAAAAICZUnS2rO9PP7JTFT8AAAAArFMVv6/vTz8AAAAAne9PP8RTFT///3+/AAAAAAAAAIAAAAAAse9PP6lTFT///3+/AAAAAAAAAIAAAAAAse9Pv6lTFb8AAAAAse9Pv6lTFb///38/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAse9Pv6lTFb8AAAAAse9Pv6lTFb///38/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAse9PP6lTFT8AAAAAse9PP6lTFT///38/AAAAAAAAAIAAAAAAse9PP6lTFT///38/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAArFMVP6/vT78AAAAArO9PP7NTFT/9Pbc1ru9PP6xTFT8AAAAAqFMVv7PvTz8AAAAArO9PP7NTFT/9Pbc1ru9PP6xTFT8AAIA/AAAAAFxgrDMAAIC/AAAAAAAAAIBSyFW2ru9Pv6xTFb8AAAAAru9Pv7FTFb8AAAAArFMVP6/vT78AAIC/AAAAAAAAAIAAAAAApVMVv7PvTz8AAAAAne9PP8ZTFT/9Pbc1ru9PP6xTFT//Pbe1sO9PP6tTFT8AAAAArFMVP6/vT78AAAAArO9PP7NTFT///38/AAAAANIWRLQAAIC/AAAAAAAAAID/Pbe1sO9PP6tTFT8AAAAAqFMVv7PvTz8AAAAArO9PP7NTFT8AAAAAru9Pv7FTFb8AAAAArFMVP6/vT79UyFU2sO9Pv6tTFb///38/AAAAANIWRLT/Pbe1sO9PP6tTFT8AAAAApVMVv7PvTz8AAAAAne9PP8ZTFT///38/AAAAANIWRLQAAIC/AAAAAAAAAID/Pbe1sO9PP6tTFT8AAAAAslMVP6rvT78AAAAAne9PP8ZTFT8AAAAAn+9Pv8FTFb8AAAAApVMVv7PvTz9UyFU2sO9Pv6tTFb///38/AAAAANIWRLQAAIC/AAAAAAAAAIAAAAAAn+9Pv8FTFb8AAAAAslMVP6rvT79UyFU2sO9Pv6tTFb8AAIC/AAAAAAAAAIBSyFW2ru9Pv6xTFb8AAAAAn+9Pv8FTFb8AAAAApVMVv7PvTz9SyFW2ru9Pv6xTFb8AAAAAn+9Pv8FTFb8AAAAAslMVP6rvT78AAIA/AAAAAFxgrDMAAAAAslMVP6rvT78AAAAAne9PP8ZTFT/9Pbc1ru9PP6xTFT8AAIA/AAAAAFxgrDNSyFW2ru9Pv6xTFb8AAAAAru9Pv7FTFb8AAAAAqFMVv7PvTz8AAIA/AAAAAFxgrDMAAIC/AAAAAAAAAIAAAAAAru9Pv7FTFb8AAAAAqFMVv7PvTz9UyFU2sO9Pv6tTFb8AAIC/AAAAAAAAAIAAAAAArVMVP6/vT78AAAAAnu9PP8VTFT+kUnQ2ru9PP61TFT8AAAAArFMVv6/vTz8AAAAAnu9PP8VTFT+kUnQ2ru9PP61TFT8AAIA/AAAAAFBgrDMAAIC/AAAAAAAAAID7Pbe1ru9Pv61TFb8AAAAAnu9Pv8VTFb8AAAAArVMVP6/vT78AAIC/AAAAAAAAAIAAAAAApVMVv7PvTz8AAAAAue9PP59TFT+kUnQ2ru9PP61TFT/7Pbe1ru9Pv61TFb8AAAAAnu9Pv8VTFb8AAAAArFMVv6/vTz8AAIA/AAAAAFBgrDP7Pbe1ru9Pv61TFb8AAAAAvu9Pv5dTFb8AAAAAqlMVP7HvT78AAIA/AAAAAFBgrDMAAIC/AAAAAAAAAID7Pbe1ru9Pv61TFb8AAAAAvu9Pv5dTFb8AAAAApVMVv7PvTz8AAAAAqlMVP7HvT78AAAAAue9PP59TFT+kUnQ2ru9PP61TFT8AAIA/AAAAAFBgrDOmUnS2sO9PP61TFT8AAAAApVMVv7PvTz8AAAAAue9PP59TFT8AAIA/AAAAAJoWRLSmUnS2sO9PP61TFT8AAAAArVMVP6/vT78AAAAAnu9PP8VTFT8AAIA/AAAAAJoWRLQAAIC/AAAAAAAAAICmUnS2sO9PP61TFT8AAAAAqlMVP7HvT78AAAAAue9PP59TFT8AAAAAvu9Pv5dTFb8AAAAApVMVv7PvTz/8Pbc1sO9Pv61TFb8AAIA/AAAAAJoWRLQAAAAAnu9Pv8VTFb8AAAAArVMVP6/vT7/8Pbc1sO9Pv61TFb8AAIA/AAAAAJoWRLQAAIC/AAAAAAAAAIAAAAAAvu9Pv5dTFb8AAAAAqlMVP7HvT7/8Pbc1sO9Pv61TFb8AAIC/AAAAAAAAAIAAAAAAnu9Pv8VTFb8AAAAArFMVv6/vTz/8Pbc1sO9Pv61TFb8AAIC/AAAAAAAAAICmUnS2sO9PP61TFT8AAAAArFMVv6/vTz8AAAAAnu9PP8VTFT///3+/AAAAAAAAAIAAAAAAre9PP69TFT///3+/AAAAAAAAAIAAAAAAru9Pv69TFb8AAAAAru9Pv69TFb///38/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAru9Pv69TFb8AAAAAru9Pv69TFb///38/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAre9PP69TFT8AAAAAre9PP69TFT///38/AAAAAAAAAIAAAAAAre9PP69TFT///38/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAq1MVP7HvT78AAAAAqu9PP7NTFT8KPrc1sO9PP6xTFT8AAAAAqFMVv7LvTz8AAAAAqu9PP7NTFT8KPrc1sO9PP6xTFT8AAIA/FQodtNDV5TMAAIC/AAAAAAAAAIBhyFW2sO9Pv6xTFb8AAAAAre9Pv7FTFb8AAAAAq1MVP7HvT78AAIC/AAAAAAAAAIAAAAAApVMVv7XvTz8AAAAAne9PP8ZTFT8KPrc1sO9PP6xTFT/tPbe1qO9PP7VTFT8AAAAAq1MVP7HvT78AAAAAqu9PP7NTFT///38/AAAAANIWxDQAAIC/AAAAAMrVZbXtPbe1qO9PP7VTFT8AAAAAqFMVv7LvTz8AAAAAqu9PP7NTFT8AAAAAre9Pv7FTFb8AAAAAq1MVP7HvT78/yFU2qO9Pv7VTFb///38/AAAAANIWxDTtPbe1qO9PP7VTFT8AAAAApVMVv7XvTz8AAAAAne9PP8ZTFT///38/AAAAANIWxDQAAIC/AAAAAMrVZbXtPbe1qO9PP7VTFT8AAAAAqVMVP7LvT78AAAAAne9PP8ZTFT8AAAAAoO9Pv8FTFb8AAAAApVMVv7XvTz8/yFU2qO9Pv7VTFb///38/AAAAANIWxDQAAIC/AAAAAMrVZbUAAAAAoO9Pv8FTFb8AAAAAqVMVP7LvT78/yFU2qO9Pv7VTFb8AAIC/AAAAAAAAAIBhyFW2sO9Pv6xTFb8AAAAAoO9Pv8FTFb8AAAAApVMVv7XvTz9hyFW2sO9Pv6xTFb8AAAAAoO9Pv8FTFb8AAAAAqVMVP7LvT78AAIA/FQodtNDV5TMAAAAAqVMVP7LvT78AAAAAne9PP8ZTFT8KPrc1sO9PP6xTFT8AAIA/FQodtNDV5TNhyFW2sO9Pv6xTFb8AAAAAre9Pv7FTFb8AAAAAqFMVv7LvTz8AAIA/FQodtNDV5TMAAIC/AAAAAMrVZbUAAAAAre9Pv7FTFb8AAAAAqFMVv7LvTz8/yFU2qO9Pv7VTFb8AAIC/AAAAAAAAAIAAAAAAq1MVP7DvT78AAAAAnu9PP8RTFT+2UnQ2sO9PP6xTFT8AAAAArFMVv67vTz8AAAAAnu9PP8RTFT+2UnQ2sO9PP6xTFT8AAIA/CgodtMDV5TMAAIC/AAAAAAAAAIAHPre1r+9Pv6tTFb8AAAAAnu9Pv8RTFb8AAAAAq1MVP7DvT78AAIC/AAAAAAAAAIAAAAAApVMVv7XvTz8AAAAAve9PP5pTFT+2UnQ2sO9PP6xTFT8HPre1r+9Pv6tTFb8AAAAAnu9Pv8RTFb8AAAAArFMVv67vTz8AAIA/CgodtMDV5TMHPre1r+9Pv6tTFb8AAAAAu+9Pv5xTFb8AAAAAqVMVP7LvT78AAIA/CgodtMDV5TMAAIC/AAAAAAAAAIAHPre1r+9Pv6tTFb8AAAAAu+9Pv5xTFb8AAAAApVMVv7XvTz8AAAAAqVMVP7LvT78AAAAAve9PP5pTFT+2UnQ2sO9PP6xTFT8AAIA/CgodtMDV5TOIUnS2o+9PP71TFT8AAAAApVMVv7XvTz8AAAAAve9PP5pTFT8AAIA/AAAAAJoWxDSIUnS2o+9PP71TFT8AAAAAq1MVP7DvT78AAAAAnu9PP8RTFT8AAIA/AAAAAJoWxDQAAIC/AAAAAMrVZbWIUnS2o+9PP71TFT8AAAAAqVMVP7LvT78AAAAAve9PP5pTFT8AAAAAu+9Pv5xTFb8AAAAApVMVv7XvTz/mPbc1o+9Pv71TFb8AAIA/AAAAAJoWxDQAAAAAnu9Pv8RTFb8AAAAAq1MVP7DvT7/mPbc1o+9Pv71TFb8AAIA/AAAAAJoWxDQAAIC/AAAAAMrVZbUAAAAAu+9Pv5xTFb8AAAAAqVMVP7LvT7/mPbc1o+9Pv71TFb8AAIC/AAAAAMrVZbUAAAAAnu9Pv8RTFb8AAAAArFMVv67vTz/mPbc1o+9Pv71TFb8AAIC/AAAAAMrVZbWIUnS2o+9PP71TFT8AAAAArFMVv67vTz8AAAAAnu9PP8RTFT///3+/AAAAAAAAAIAAAAAAse9PP6lTFT///3+/AAAAAAAAAIAAAAAAse9Pv6lTFb8AAAAAse9Pv6lTFb///38/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAse9Pv6lTFb8AAAAAse9Pv6lTFb///38/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAse9PP6lTFT8AAAAAse9PP6lTFT///38/AAAAAAAAAIAAAAAAse9PP6lTFT///38/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAr+9PP6pTFT///3+/AAAAAAAAAIAAAAAAr+9Pv6pTFb8AAAAAr+9Pv6pTFb///38/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAr+9Pv6pTFb8AAAAAr+9Pv6pTFb///38/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAr+9PP6pTFT8AAAAAr+9PP6pTFT///38/AAAAAAAAAIAAAAAAr+9PP6pTFT///38/AAAAAAAAAID//3+/AAAAAM6jhTIAAAAArO9PP7BTFT///3+/AAAAAM6jhTIAAAAAru9Pv65TFb8AAAAAru9Pv65TFb///38/AAAAAM6jhTL//3+/AAAAAM6jhTIAAAAAru9Pv65TFb8AAAAAru9Pv65TFb///38/AAAAAM6jhTL//3+/AAAAAM6jhTIAAAAArO9PP7BTFT8AAAAArO9PP7BTFT///38/AAAAAM6jhTIAAAAArO9PP7BTFT///38/AAAAAM6jhTL//3+/AAAAAAAAAIAAAAAAr+9PP6pTFT///3+/AAAAAAAAAIAAAAAAr+9Pv6pTFb8AAAAAr+9Pv6pTFb///38/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAr+9Pv6pTFb8AAAAAr+9Pv6pTFb///38/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAr+9PP6pTFT8AAAAAr+9PP6pTFT///38/AAAAAAAAAIAAAAAAr+9PP6pTFT///38/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAAACAvwAAAIAAAIC/AAAAAAAAAIAAAAAAAACAPwAAAIAAAIC/AAAAAAAAAID//3+/doxiMwAAAIAAAIC/AAAAAAAAAID//3+/AAAAAAAAAIAAAIC/2Tums9DKT7UAAIC/AAAAAAAAAIAAAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAAAAAACAvwAAAIAAAIA/AAAAAAAAAIAAAIA/AAAAAAAAAIAAAIA/AAAAAAAAAIAAAIA/AAAAAAAAAIAAAAAAAACAPwAAAIAAAAAAAACAPwAAAIAAAAAAAACAvwAAAIAAAAAAAACAvwAAAIAAAIA/AAAAAAAAAIAAAIC/2Tums9DKT7X//3+/doxiMwAAAIAAAAAAAACAPwAAAIAAAAAAAACAvwAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAIC/AAAAAAAAAIAAAAAA//9/PwAAAIAAAAAA//9/PwAAAIAAAIA/AAAAAAAAAIAAAAAAAACAvwAAAIAAAIA/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAACAvwAAAIAAAAAA//9/PwAAAIAAAAAA//9/PwAAAIAAAAAA2HBOvzZjFz8AAIA/AAAAACO63jUAAAAA2HBOPzdjF78AAIA/AAAAAI5frLUAAIC/AAAAAEyp/bUAAAAAs3BOv2ljFz8AAIC/AAAAAE//RDYAAAAAs3BOP2pjF78AAAAA2nl7v76oP74AAAAA2HBOvzZjFz8AAIA/AAAAACO63jUAAAAA19zkPYJlfr8AAAAA2HBOPzdjF78AAIA/AAAAAI5frLUAAIC/AAAAAEyp/bUAAAAA2nl7v76oP74AAAAAs3BOv2ljFz8AAIC/AAAAAE//RDYAAAAASdzkPYVlfr8AAAAAs3BOP2pjF78AAIA/AAAAAI5frLUAAIA/AAAAACO63jUAAIC/AAAAAEyp/bUAAIC/AAAAAE//RDYAAIC/AAAAAEyp/bUAAIC/AAAAAE//RDYAAAAA2nl7v76oP74AAAAASdzkPYVlfr8AAAAA2nl7v76oP74AAAAA19zkPYJlfr8AAIA/AAAAAI5frLUAAIA/AAAAACO63jUAAAAA2HBOvzZjFz8AAAAAs3BOv2ljFz8AAAAAs3BOP2pjF78AAAAA2HBOPzdjF78AAAAA2nl7v76oP74AAAAA2HBOvzZjFz8AAAAAs3BOv2ljFz8AAAAASdzkPYVlfr8AAAAA19zkPYJlfr8AAAAAs3BOP2pjF78AAAAA2HBOPzdjF78AAAAA2nl7v76oP74AAAAASdzkPYVlfr8AAAAA19zkPYJlfr8AAAAA2HBOvzZjFz8AAIA/AAAAAAAAAIAAAAAA2HBOPzdjF78AAIA/AAAAAAAAAIAAAIC/AAAAAGcciLUAAAAA2HBOvzZjFz8AAIC/AAAAAGVfLLYAAAAA2HBOPzdjF78AAAAA2nl7v76oP74AAAAA2HBOvzZjFz8AAIA/AAAAAAAAAIAAAAAASdzkPYVlfr8AAAAA2HBOPzdjF78AAIA/AAAAAAAAAIAAAIC/AAAAAGcciLUAAAAA2nl7v76oP74AAAAA2HBOvzZjFz8AAIC/AAAAAGVfLLYAAAAA19zkPYJlfr8AAAAA2HBOPzdjF78AAIA/AAAAAAAAAIAAAIA/AAAAAAAAAIAAAIC/AAAAAGVfLLYAAIC/AAAAAGcciLUAAIC/AAAAAGVfLLYAAIC/AAAAAGcciLUAAAAA2nl7v76oP74AAAAA19zkPYJlfr8AAAAA2nl7v76oP74AAAAASdzkPYVlfr8AAIA/AAAAAAAAAIAAAIA/AAAAAAAAAIAAAAAA2HBOvzZjFz8AAAAA2HBOPzdjF78AAAAA2nl7v76oP74AAAAA2HBOvzZjFz8AAAAASdzkPYVlfr8AAAAA19zkPYJlfr8AAAAA2HBOPzdjF78AAAAA2nl7v76oP74AAAAASdzkPYVlfr8AAAAA19zkPYJlfr///3+/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL9N5eo0AACAPwAAAIAAAIC/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAIC/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAMPlkPyn55L4AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAMPlkPyn55L4AAAAAAAAAAAAAgL8AAAAAMPlkPyn55L7//38/AAAAAAAAAIAAAIA/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAMPlkPyn55L4AAIA/AAAAAAAAAIAAAAAAAAAAAAAAgL///38/AAAAAAAAAIAAAIA/Ijy8tAAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIA/Ijy8tAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL///38/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAAAAL/lkPyj55L4AAAAAMPlkPyn55L4AAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAAAAMPlkPyn55L4AAAAAMvlkPyL55L4AAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAAAAMPlkPyn55L4AAAAAMvlkPyL55L4AAAAAAAAAAAAAgL8AAAAAL/lkPyj55L4AAAAAMPlkPyn55L4AAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAP//f7///38/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAAAAymH8Mv//f78AAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAAAAAAAAAAAAgL8AAAAAymH8Mv//f78AAAAAAACAPwAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAAAAAACAPwAAAIBN5eo0AACAPwAAAIAAAIC/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAAAAgL///38/AAAAAAAAAIAAAIA/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAAAAAACAPwAAAID//38/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAAAAAAAAAP//f78AAAAAymH8Mv//f78AAAAAAACAPwAAAIAAAAAAAACAvwAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAP//f78AAAAAymH8Mv//f78AAAAAAAAAAP//f78AAAAAAAAAAP//f78AAAAAL/lkPyj55L4AAAAAMvlkPyL55L4AAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAAAAL/lkPyj55L4AAAAAMvlkPyL55L4AAAAAAACAvwAAAIAAAAAAAAAAAP//f78AAAAAAAAAAP//f78AAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAAAAAACAPwAAAIAAAAAAAACAPwAAAID//3+/AAAAAAAAAIAAAAAAAACAvwAAAIAAAIC/AAAAAAAAAIBN5eo0AACAPwAAAIAAAIC/AAAAAAAAAID//3+/AAAAAAAAAIAAAIC/AAAAAAAAAID//3+/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAACAPwAAAIAAAIA/Ijy8tAAAAIAAAAAAAACAvwAAAID//38/AAAAAAAAAIAAAIA/AAAAAAAAAID//38/AAAAAAAAAIAAAIA/AAAAAAAAAID//38/AAAAAAAAAIAAAIA/Ijy8tAAAAIAAAAAAAACAPwAAAIBN5eo0AACAPwAAAIAAAAAAAACAPwAAAIAAAAAAAACAvwAAAIAAAAAAAACAvwAAAID//38/AAAAAAAAAIAAAIA/AAAAAAAAAIAAAIC/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAAACAPwAAAIAAAAAAAACAvwAAAID//3+/AAAAAAAAAIAAAAAAAACAvwAAAID//3+/AAAAAAAAAIAAAAAAAACAPwAAAIAAAAAAAACAPwAAAID//38/AAAAAAAAAIAAAAAAAACAvwAAAID//38/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAACAvwAAAIAAAAAAAACAPwAAAIAAAAAAAACAPwAAAIA1uwg/d/g8PwgFFz/jrRI/HaQIP+OtEj9GexY/d/g8P+afCz/jrRI/HaQIPwUxOz81uwg/S3lAP2oBCz/jrRI/5p8LP+OtEj8IBRc/BTE7Px2kCD8FMTs/RnsWP3f4PD/mnws/BTE7Px2kCD/jrRI/NbsIP3f4PD9qAQs/BTE7P+afCz8FMTs/tWsWP0t5QD9qAQs/460SPwgFFz8FMTs/NbsIP0t5QD+1axY/S3lAP2oBCz8FMTs/CAUXP+OtEj8IBRc/460SPwgFFz8FMTs/HaQIP+OtEj8dpAg/BTE7P2oBCz/jrRI/agELPwUxOz/mnws/460SP+afCz8FMTs/agELP+OtEj9qAQs/BTE7PwgFFz/jrRI/CAUXPwUxOz/mnws/460SP+afCz8FMTs/HaQIP+OtEj8dpAg/BTE7PwDAfz8AwH8/AMB/PwDAfz+grwA8CshuPwDAfz8AwH8/4Lj1O0AnRzwAwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz/guPU7GAW5PeC49TsYBbk9AMB/PwDAfz8AwH8/AMB/P6CvADyTyGI/oK8APJPIYj8AwH8/AMB/PwDAfz8AwH8/oK8APE5eYT/guPU71FpIPx0Ayj7Ay008AMB/PwDAfz8AwH8/AMB/Px0Ayj6o2bk9HQDKPqjZuT0AwH8/AMB/Px0Ayj5mdUg/ptnJPk5eYT8AwH8/AMB/P6bZyT6QyGI/ptnJPpDIYj8AwH8/AMB/PwDAfz8AwH8/ptnJPgrIbj8AwH8/AMB/PzDrOT1AJ0c8AMB/PwDAfz/kVLc+QCdHPADAfz8AwH8/y632PiB9uD3yVLc+GAW5Pfvx3T7uEUo/8lS3PhgFuT0o3m097hFKPzDrOT0YBbk9MOs5PRgFuT0Vs88+IH24Pf1Utz7UWkg//VS3PtRaSD+M56E+Tl5hP4znoT5OXmE/MOs5PdRaSD9Apa49Tl5hP0Clrj1OXmE/MOs5PdRaSD9Apa49k8hiP0Clrj2TyGI/QKWuPZPIYj9Apa49k8hiP4znoT6QyGI/jOehPpDIYj+M56E+kMhiP4znoT6QyGI/AMB/PwDAfz9Apa49CshuP0Clrj0KyG4/AMB/PwDAfz+M56E+CshuP4znoT4KyG4/AMB/PwDAfz8AwH8/AMB/P+C49TtsY/8+4Lj1O2xj/z4dAMo+kJj/Ph0Ayj6QmP8+AMB/PwDAfz8w6zk9bGP/PniSVD3m518/MOs5PWxj/z4w6zk9bGP/PhWzzz5sY/8+y632Pmxj/z71VLc+bGP/PvVUtz5sY/8+9VS3Pmxj/z778d0+5udfP+C49TtAJ0c8HQDKPsDLTTwAwH8/AMB/PwAD/DvuEUo/eVDzPu4RSj/guPU7GAW5PR0Ayj6o2bk9HQDKPmZ1SD/guPU71FpIP6bZyT5OXmE/oK8APE5eYT+grwA8kMhiP6bZyT6QyGI/ptnJPpDIYj+grwA8kMhiPwDAfz8AwH8/oK8APArIbj+m2ck+CshuPx0Ayj6QmP8+4Lj1O2xj/z4AA/w75udfPwvY9T7m518/K3c3P0msAT+mpzI/mTcJPzRPNT+yvAM/IZgtP/sIRz8rdzc/wThRPyt3Nz/BOFE/KXc3P744UT8pdzc/vjhRPz9e/j42rAE/G1cBP6S8Az/zpjI/gsYFPyGYLT8mEBI/LV7+PsY4UT8tXv4+xjhRPzte/j7GOFE/GVcBP1YoTz+jpzI/mTcJP/MIIz8wFBI/MF7+PjesAT8rdzc/PawBPyGYLT8mEBI/FlcBP6e8Az/skgM/lzcJPyGYLT/7CEc/PpIDP4LGBT8tTzU/p7wDP6DPKz8mEBI/oM8rPyYQEj/skgM/HEAIP+ySAz8cQAg/dtEkPzIUEj+jpzI/H0AIP3bRJD8yFBI/BhUpPysSEj8GFSk/KxISP5SSAz+P6Qc/mc8rP/oIRz8+kgM//L0GPz6SAz/8vQY/mc8rP/oIRz+55io/OBASP7nmKj84EBI/ROQCP6xACD/l/Sk/GhISP+X9KT8aEhI/6+MCPx3qBz+55io/EQlHP5fjAj+LvgY/ueYqPxEJRz/i/Sk/8gpHP/HjAj8XFQc/4v0pP/IKRz8DFSk/AQtHP5iSAz+KFAc/mJIDP4oUBz8DFSk/AQtHP06nMj+MFAc/TqcyP4wUBz8HjCc/AQtHPweMJz8BC0c/B4wnPwELRz+YkgM/kukHPweMJz8BC0c/DownPysSEj8OjCc/KxISP5SSAz+GFAc/bdEkPwcNRz/wkgM/H0AIP23RJD8HDUc/TqcyP5TpBz8DFSk/AQtHPwMVKT8BC0c/JqMmPxQLRz/x4wI/H+oHPyajJj8UC0c/LqMmPzoSEj8uoyY/OhISP+vjAj8WFQc/TrolP/QMRz9G5AI/sEAIP066JT/0DEc/VbolPxwUEj9VuiU/HBQSP5bjAj+HvgY/dtEkPzAUEj920SQ/MBQSPzuSAz/6vQY/oM8rPyYQEj/zpjI/+r0GP/OmMj/6vQY/oM8rPyYQEj/zCCM/MBQSPxRXAT9aKE8/FFcBP1ooTz87kgM/gsYFP+oIIz8HDUc/LU81P1QoTz/wkgM/mTcJPy1PNT9UKE8/BhUpPywSEj9OpzI/ihQHPwYVKT8sEhI/pqcyPyBACD+bzys/+ghHP5vPKz/6CEc/ueYqPzgQEj+aVTM/a70GP7nmKj84EBI/5f0pPxoSEj/zVTM/+xMHP+X9KT8aEhI/TlYzP5M/CD+55io/EQlHP7nmKj8RCUc/9lUzPwbpBz/j/Sk/8gpHP+P9KT/yCkc/DownPywSEj9OpzI/kukHPw6MJz8sEhI/LqMmPz4SEj/zVTM/AukHPy6jJj8+EhI/VbolPxwUEj9OVjM/kT8IP1W6JT8cFBI/9lUzP/4TBz8moyY/FAtHPyajJj8UC0c/nVUzP229Bj9OuiU/9AxHP066JT/0DEc/+KYyP/29Bj/4pjI//b0GP23RJD8HDUc/bdEkPwcNRz/4pjI/g8YFPzBPNT9SKE8/ME81P1IoTz/qCCM/Bw1HPyt3Nz9uDCk/K3c3P24MKT+bXBs/ixQHP5tcGz+T6Qc/Mk81P2wMKT/0XBs/mTcJPzJPNT9sDCk/9FwbPyBACD9FXBs//L0GP0VcGz/8vQY/RVwbP4LGBT8wTzU/ZgwpPzBPNT9mDCk/K3c3P2gMKT8rdzc/aAwpPzJe/j5oDCk/Ml7+PmgMKT8yXv4+aAwpPxZXAT9oDCk/8VwbP5g3CT/xXBs/mDcJP/FcGz8eQAg/8VwbPx5ACD9AXBs/+r0GP0BcGz/6vQY/FlcBP2kMKT8WVwE/aQwpP0BcGz+CxgU/QFwbP4LGBT+ZXBs/iBQHP5lcGz+Q6Qc/6OAuP1N4az/o4C4/IzhoP/yiAz9Rk1c//KIDP1GTVz+hBy8/6YtuP38+Bj/0xlk/fz4GP/TGWT/o4C4/AS1oP+jgLj8jOGg/YPsyP1GTVz9g+zI/UZNXP+jgLj9TeGs/rs0HP1N4az/o4C4/U3hrP/yiAz/KkHU//KIDP8qQdT9g+zI/UZNXP67NBz8jOGg/YPsyP1GTVz/o4C4/6ThoP+jgLj89hGs/3F8wP/TGWT/tAAg/6YtuP9xfMD/0xlk//KIDP1GTVz+uzQc/U3hrP/yiAz9Rk1c/6OAuPxp5az9g+zI/x5B1P67NBz9TeGs/YPsyP8eQdT+uzQc/6ThoP67NBz89hGs/3F8wPyNdcz/tAAg/MJtsP9xfMD8jXXM//KIDP8qQdT+uzQc/IzhoP/yiAz/KkHU/rs0HPxp5az+uzQc/AS1oP38+Bj8jXXM/7QAIP+mLbj9/PgY/I11zP67NBz8jOGg/YPsyP8eQdT9g+zI/x5B1P+jgLj8jOGg/3F8wPyNdcz/cXzA/I11zP6EHLz/pi24/rs0HPz2Eaz+hBy8/MJtsP38+Bj8jXXM/fz4GPyNdcz+uzQc/AS1oP9xfMD/0xlk/3F8wP/TGWT+hBy8/MJtsP+jgLj89hGs/6OAuPwEtaD9/PgY/9MZZP+0ACD8wm2w/fz4GP/TGWT+hBy8/BPFxP6EHLz9vVm8//KIDP1GTVz/8ogM/UZNXP6EHLz/pi24/fz4GP/TGWT9/PgY/9MZZP+jgLj8BLWg/oQcvP29Wbz9g+zI/UZNXP2D7Mj9Rk1c/oQcvPwTxcT/tAAg/BPFxP6EHLz8E8XE//KIDP8qQdT/8ogM/ypB1P9xfMD/0xlk/3F8wP/TGWT+hBy8/MJtsP+jgLj89hGs/3F8wPyNdcz/cXzA/I11zP6EHLz/pi24/rs0HPz2Eaz/tAAg/bFZvP2D7Mj/HkHU/YPsyP8eQdT+hBy8/b1ZvP6EHLz8wm2w/fz4GPyNdcz9/PgY/I11zP67NBz8BLWg/YPsyP8eQdT/tAAg/BPFxP2D7Mj/HkHU/7QAIP29Wbz9g+zI/UZNXP+0ACD9vVm8/YPsyP1GTVz+hBy8/b1ZvP67NBz89hGs/3F8wPyNdcz/tAAg/MJtsP9xfMD8jXXM//KIDP8qQdT/tAAg/bFZvP/yiAz/KkHU/7QAIPwTxcT/8ogM/UZNXP+0ACD8E8XE//KIDP1GTVz+hBy8/BPFxP67NBz8BLWg/fz4GPyNdcz/tAAg/6YtuP38+Bj8jXXM/6OAuPwEtaD9/PgY/9MZZP+0ACD8wm2w/fz4GP/TGWT/o4C4/PYRrP9xfMD/0xlk/7QAIP+mLbj/cXzA/9MZZP6EHLz/pi24/oQcvPzCbbD+hBy8/MJtsP6EHLz/pi24/oQcvPzCbbD+hBy8/6YtuP+0ACD8wm2w/7QAIP+mLbj/tAAg/MJtsP+0ACD/pi24/7QAIP+mLbj/tAAg/MJtsP+0ACD/pi24/7QAIPzCbbD+hBy8/6YtuP6EHLz8wm2w/6OAuP1N4az/o4C4/IzhoP/yiAz9Rk1c//KIDP1GTVz+hBy8/6YtuP38+Bj/0xlk/fz4GP/TGWT/o4C4/AS1oP+jgLj8jOGg/YPsyP1GTVz9g+zI/UZNXP+jgLj9TeGs/rs0HP1N4az/o4C4/U3hrP/yiAz/KkHU//KIDP8qQdT9g+zI/UZNXP67NBz8jOGg/YPsyP1GTVz/o4C4/6ThoP+jgLj89hGs/3F8wP/TGWT/tAAg/6YtuP9xfMD/0xlk//KIDP1GTVz+uzQc/U3hrP/yiAz9Rk1c/6OAuPxp5az9g+zI/x5B1P67NBz9TeGs/YPsyP8eQdT+uzQc/6ThoP67NBz89hGs/3F8wPyNdcz/tAAg/MJtsP9xfMD8jXXM//KIDP8qQdT+uzQc/IzhoP/yiAz/KkHU/rs0HPxp5az+uzQc/AS1oP38+Bj8jXXM/7QAIP+mLbj9/PgY/I11zP67NBz8jOGg/YPsyP8eQdT9g+zI/x5B1P+jgLj8jOGg/3F8wPyNdcz/cXzA/I11zP6EHLz/pi24/rs0HPz2Eaz+hBy8/MJtsP38+Bj8jXXM/fz4GPyNdcz+uzQc/AS1oP9xfMD/0xlk/3F8wP/TGWT+hBy8/MJtsP+jgLj89hGs/6OAuPwEtaD9/PgY/9MZZP+0ACD8wm2w/fz4GP/TGWT+hBy8/BPFxP6EHLz9vVm8//KIDP1GTVz/8ogM/UZNXP6EHLz/pi24/fz4GP/TGWT9/PgY/9MZZP+jgLj8BLWg/oQcvP29Wbz9g+zI/UZNXP2D7Mj9Rk1c/oQcvPwTxcT/tAAg/BPFxP6EHLz8E8XE//KIDP8qQdT/8ogM/ypB1P9xfMD/0xlk/3F8wP/TGWT+hBy8/MJtsP+jgLj89hGs/3F8wPyNdcz/cXzA/I11zP6EHLz/pi24/rs0HPz2Eaz/tAAg/bFZvP2D7Mj/HkHU/YPsyP8eQdT+hBy8/b1ZvP6EHLz8wm2w/fz4GPyNdcz9/PgY/I11zP67NBz8BLWg/YPsyP8eQdT/tAAg/BPFxP2D7Mj/HkHU/7QAIP29Wbz9g+zI/UZNXP+0ACD9vVm8/YPsyP1GTVz+hBy8/b1ZvP67NBz89hGs/3F8wPyNdcz/tAAg/MJtsP9xfMD8jXXM//KIDP8qQdT/tAAg/bFZvP/yiAz/KkHU/7QAIPwTxcT/8ogM/UZNXP+0ACD8E8XE//KIDP1GTVz+hBy8/BPFxP67NBz8BLWg/fz4GPyNdcz/tAAg/6YtuP38+Bj8jXXM/6OAuPwEtaD9/PgY/9MZZP+0ACD8wm2w/fz4GP/TGWT/o4C4/PYRrP9xfMD/0xlk/7QAIP+mLbj/cXzA/9MZZP6EHLz/pi24/oQcvPzCbbD+hBy8/MJtsP6EHLz/pi24/oQcvPzCbbD+hBy8/6YtuP+0ACD8wm2w/7QAIP+mLbj/tAAg/MJtsP+0ACD/pi24/7QAIP+mLbj/tAAg/MJtsP+0ACD/pi24/7QAIPzCbbD+hBy8/6YtuP6EHLz8wm2w/6OAuP1N4az/o4C4/IzhoP/yiAz9Rk1c//KIDP1GTVz+hBy8/6YtuP38+Bj/0xlk/fz4GP/TGWT/o4C4/AS1oP+jgLj8jOGg/YPsyP1GTVz9g+zI/UZNXP+jgLj9TeGs/rs0HP1N4az/o4C4/U3hrP/yiAz/KkHU//KIDP8qQdT9g+zI/UZNXP67NBz8jOGg/YPsyP1GTVz/o4C4/6ThoP+jgLj89hGs/3F8wP/TGWT/tAAg/6YtuP9xfMD/0xlk//KIDP1GTVz+uzQc/U3hrP/yiAz9Rk1c/6OAuPxp5az9g+zI/x5B1P67NBz9TeGs/YPsyP8eQdT+uzQc/6ThoP67NBz89hGs/3F8wPyNdcz/tAAg/MJtsP9xfMD8jXXM//KIDP8qQdT+uzQc/IzhoP/yiAz/KkHU/rs0HPxp5az+uzQc/AS1oP38+Bj8jXXM/7QAIP+mLbj9/PgY/I11zP67NBz8jOGg/YPsyP8eQdT9g+zI/x5B1P+jgLj8jOGg/3F8wPyNdcz/cXzA/I11zP6EHLz/pi24/rs0HPz2Eaz+hBy8/MJtsP38+Bj8jXXM/fz4GPyNdcz+uzQc/AS1oP9xfMD/0xlk/3F8wP/TGWT+hBy8/MJtsP+jgLj89hGs/6OAuPwEtaD9/PgY/9MZZP+0ACD8wm2w/fz4GP/TGWT+hBy8/BPFxP6EHLz9vVm8//KIDP1GTVz/8ogM/UZNXP6EHLz/pi24/fz4GP/TGWT9/PgY/9MZZP+jgLj8BLWg/oQcvP29Wbz9g+zI/UZNXP2D7Mj9Rk1c/oQcvPwTxcT/tAAg/BPFxP6EHLz8E8XE//KIDP8qQdT/8ogM/ypB1P9xfMD/0xlk/3F8wP/TGWT+hBy8/MJtsP+jgLj89hGs/3F8wPyNdcz/cXzA/I11zP6EHLz/pi24/rs0HPz2Eaz/tAAg/bFZvP2D7Mj/HkHU/YPsyP8eQdT+hBy8/b1ZvP6EHLz8wm2w/fz4GPyNdcz9/PgY/I11zP67NBz8BLWg/YPsyP8eQdT/tAAg/BPFxP2D7Mj/HkHU/7QAIP29Wbz9g+zI/UZNXP+0ACD9vVm8/YPsyP1GTVz+hBy8/b1ZvP67NBz89hGs/3F8wPyNdcz/tAAg/MJtsP9xfMD8jXXM//KIDP8qQdT/tAAg/bFZvP/yiAz/KkHU/7QAIPwTxcT/8ogM/UZNXP+0ACD8E8XE//KIDP1GTVz+hBy8/BPFxP67NBz8BLWg/fz4GPyNdcz/tAAg/6YtuP38+Bj8jXXM/6OAuPwEtaD9/PgY/9MZZP+0ACD8wm2w/fz4GP/TGWT/o4C4/PYRrP9xfMD/0xlk/7QAIP+mLbj/cXzA/9MZZP6EHLz/pi24/oQcvPzCbbD+hBy8/MJtsP6EHLz/pi24/oQcvPzCbbD+hBy8/6YtuP+0ACD8wm2w/7QAIP+mLbj/tAAg/MJtsP+0ACD/pi24/7QAIP+mLbj/tAAg/MJtsP+0ACD/pi24/7QAIPzCbbD+hBy8/6YtuP6EHLz8wm2w/oQcvP+mLbj+hBy8/MJtsP6EHLz8wm2w/oQcvP+mLbj+hBy8/MJtsP6EHLz/pi24/7QAIPzCbbD/tAAg/6YtuP+0ACD8wm2w/7QAIP+mLbj/tAAg/6YtuP+0ACD8wm2w/7QAIP+mLbj/tAAg/MJtsP6EHLz/pi24/oQcvPzCbbD+hBy8/6YtuP6EHLz8wm2w/oQcvPzCbbD+hBy8/6YtuP6EHLz8wm2w/oQcvP+mLbj/tAAg/MJtsP+0ACD/pi24/7QAIPzCbbD/tAAg/6YtuP+0ACD/pi24/7QAIPzCbbD/tAAg/6YtuP+0ACD8wm2w/oQcvP+mLbj+hBy8/MJtsP6EHLz/pi24/oQcvPzCbbD+hBy8/MJtsP6EHLz/pi24/oQcvPzCbbD+hBy8/6YtuP+0ACD8wm2w/7QAIP+mLbj/tAAg/MJtsP+0ACD/pi24/7QAIP+mLbj/tAAg/MJtsP+0ACD/pi24/7QAIPzCbbD+hBy8/6YtuP6EHLz8wm2w/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/P3Aw4z4gfbg9+/HdPur8VD9wMOM+bGP/Pvvx3T7q/FQ/eJJUPer8VD9wMOM+bGP/PijebT3q/FQ/cDDjPiB9uD0AA/w76vxUP3lQ8z7q/FQ/AAP8O+r8VD8L2PU+6vxUP7TXFj+WNEQ/tNcWP5Y0RD9M2hY/zY1FP0zaFj/NjUU/GNgWP+1mQz8Y2BY/7WZDP+bZFj98W0Y/5tkWP3xbRj/MEwo/uihEP8wTCj+6KEQ/zBMKP7ooRD8WIAo/DZBFPxYgCj8NkEU/FiAKPw2QRT+uHAo/RGlDP64cCj9EaUM/rhwKP0RpQz8uFwo/lE9GPy4XCj+UT0Y/LhcKP5RPRj/u2BY/JuFEP8vVFj8m4UQ/v9YWP2W6Qj/61xY/KAhHP52/CD9M6UI/7NsIP/XPRj+dvwg/TOlCP+zbCD/1z0Y/vNsIPwCoRD+ivwg/Aw9FP6K/CD8DD0U/vNsIPwCoRD8Y2BY/mNRDPxjYFj+Y1EM/TNoWP4b7RT9M2hY/hvtFP6EOCj8oyUM/oQ4KPyjJQz+hDgo/KMlDPwcSCj/370U/BxIKP/fvRT8HEgo/9+9FPwcSCj/370U/3qgIP6jJQz/eqAg/ZvBFP96oCD9m8EU/tNcWP5Y0RD+01xY/ljREP0zaFj/NjUU/TNoWP82NRT8Y2BY/7WZDPxjYFj/tZkM/5tkWP3xbRj/m2RY/fFtGP8wTCj+6KEQ/zBMKP7ooRD/MEwo/uihEPxYgCj8NkEU/FiAKPw2QRT8WIAo/DZBFP64cCj9EaUM/rhwKP0RpQz+uHAo/RGlDPy4XCj+UT0Y/LhcKP5RPRj8uFwo/lE9GP8vVFj8m4UQ/7tgWPybhRD/61xY/KAhHP7/WFj9lukI/7NsIP/XPRj+dvwg/TOlCP52/CD9M6UI/7NsIP/XPRj+82wg/AKhEP6K/CD8DD0U/or8IPwMPRT+82wg/AKhEPxjYFj+Y1EM/TNoWP4b7RT+hDgo/KMlDP6EOCj8oyUM/BxIKP/fvRT8HEgo/9+9FPwcSCj/370U/3qgIP6jJQz/eqAg/ZvBFP96oCD9m8EU/AMB/PwDAfz8AwH8/AMB/P6bZyT4KyG4/AMB/PwDAfz8dAMo+QMxNPADAfz8AwH8/AMB/PwDAfz8AwH8/AMB/Px0Ayj6o2bk9AMB/PwDAfz8AwH8/AMB/P6bZyT6QyGI/ptnJPpDIYj8AwH8/AMB/Px0Ayj5mdUg/ptnJPk5eYT+grwA8jshiP6CvADyOyGI/AMB/PwDAfz8AwH8/AMB/P+C49TvUWkg/oK8APE5eYT8AwH8/AMB/P+C49TsYBbk9AMB/PwDAfz8AwH8/AMB/P+C49TvAJ0c8AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/oK8APArIbj8AwH8/AMB/P5alrj2OyGI/lqWuPY7IYj+Wpa49jshiP5alrj2OyGI/nOehPpDIYj+c56E+kMhiP5znoT6QyGI/nOehPpDIYj/kVLc+1FpIP+RUtz7UWkg/nOehPk5eYT+c56E+Tl5hP0TrOT3UWkg/lqWuPU5eYT+Wpa49Tl5hPyjebT3m518/9VS3PhgFuT31VLc+GAW5Pcut9j4gfbg9FbPPPiB9uD378d0+5udfP6zqOT0YBbk9rOo5PRgFuT0AwH8/AMB/P5znoT4KyG4/nOehPgrIbj8AwH8/AMB/P5alrj0KyG4/lqWuPQrIbj+s6jk9wCdHPKzqOT3AJ0c8AMB/PwDAfz/1VLc+wCdHPPVUtz7AJ0c8AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8dAMo+kJj/PuC49TtsY/8+AMB/PwDAfz8AwH8/AMB/P+xUtz5sY/8+7FS3Pmxj/z54klQ97hFKP8ut9j5sY/8+FbPPPmxj/z4U6zk9bGP/Pvvx3T7uEUo/4Lj1O8AnRzwdAMo+QMxNPADAfz8AwH8/AAP8O+bnXz95UPM+5udfP+C49TsYBbk9HQDKPqjZuT2grwA8kMhiP6bZyT6QyGI/ptnJPpDIYj+grwA8kMhiPx0Ayj5mdUg/4Lj1O9RaSD+m2ck+Tl5hP6CvADxOXmE/AMB/PwDAfz+grwA8CshuP6bZyT4KyG4/HQDKPpCY/z7guPU7bGP/PgAD/DvuEUo/C9j1Pu4RSj8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/cDDjPiB9uD378d0+6vxUP3Aw4z5sY/8++/HdPur8VD94klQ96vxUP3Aw4z5sY/8+KN5tPer8VD9wMOM+IH24PQAD/Dvq/FQ/eVDzPur8VD8AA/w76vxUPwvY9T7q/FQ/JAAMAAkAJAAJABgAAAAGABUAAAAVAAMAGwAdAAcAGwAHAAIADgAUABEADgARAAsAIwAXAAgAIwAIAB8AJwAhABIAJwASAA0ABQAWACAABQAgACYAEwAiAB4AEwAeABAACgAPABwACgAcABoABAAlABkABAAZAAEAJwMvA0wAJwNMADsAbwB4AFUAbwBVAEAAQwBiAGoAQwBqAEcAOgBLAFAAOgBQAD4AQQBXAGMAQQBjAEQAMgMtAz8AMgM/AHEAXgA0ACoAXgAqAGcAdQBuADkAdQA5AFwAWwA4ADUAWwA1AGAASQAsADAASQAwAFIAhgCKAGQAhgBkAFgANQN+AEwANQNMAC8DhwCMAGkAhwBpAGEAjwCEAFYAjwBWAHoAQgM7A3MAQgNzAJEAfACBAFAAfABQAEsALgMgAy0ALgMtAEoANwM5A3cANwN3AE0AUwAxAG0AUwBtAHQAKwMyA3EAKwNxAEIAPQBOAHkAPQB5AHAAPAM+A1QAPANUAHYAPwM4A08APwNPAH8APQNAA4AAPQOAAFEASQBSAIIASQCCAH0ALgNKAH4ALgN+ADUDOgNBA5AAOgOQAHsAcgBZAIMAcgCDAI4AXQBmAI0AXQCNAIgAWgBfAIkAWgCJAIUAlACSAJoAlACaAJsAHwGSAJQAHwGUACQBLgE4AZsALgGbAJoALwGgAKEALwGhADABmQAcAaEAmQChAKAAqwClAKQAqwCkAKcAMwGuAKgAMwGoADEBrAC2AKkArACpAKYANAE8AbUANAG1AK8AtQC/ALwAtQC8AK8ArQC7AMIArQDCALkAugC9AMMAugDDAMAAuADBAMQAuADEAMgAyQDFAL4AyQC+ALQAJgEgAcoAJgHKABYB0QDOAMYA0QDGALMAIQEgAccAIQHHAM8A0gDeANwA0gDcANAAzwDbAOEAzwDhANUAIQElAfgAIQH4ANcA3QDjAOAA3QDgANoA1gDiAOQA1gDkAOcA6ADlAN8A6ADfANMAOwE2AegAOwHoANMAOgHwAOgAOgHoADYB7QDxANQA7QDUAOYAlwD0AO8AlwDvAJ8AIwElAdUAIwHVAPMA9gD/APwA9gD8AOsA6QD7AAIB6QACAfkA+gCVAJ0A+gCdAOwA/QAAAQYB/QAGAQMB+AABAQQB+AAEAdcA2AAFAf4A2AD+APUAOwHTALUAOwG1ADwBzQDZAPcAzQD3AAkBsQAOAQsBsQALAQgBBwEKAREBBwERAcwADAEPARUBDAEVARIBywAQARMBywATARcBGAEUAQ0BGAENAbAAJwEoAaoAJwGqALgAHQEZAbIAHQGyAKMAKwEpARsBKwEbAZgApQCrACoBpQAqASwBFwEaASgBFwEoAScBkwD4ACUBkwAlASMBzwDVACUBzwAlASEB1wDKACAB1wAgASEBtwDHACABtwAgASYBlgAeASIBlgAiAfIA9gA7ATwB9gA8AQgBnAA5ATUBnAA1AeoA9gDrADYB9gA2ATsBsQAIATwBsQA8ATQBsQA0ATIBsQAyAaIApAAvATABpAAwAacAngDuADcBngA3AS0BPwFCAVQBPwFUAU8BQwFAAUwBQwFMAXMBTgFWAUgBTgFIAT4BSQE9AUUBSQFFAWkBTQFSAV4BTQFeAVkBWAFQAVwBWAFcAWQBcgFLAVsBcgFbAWABYgFaAUoBYgFKAWwBfAFXAWMBfAFjAWgBawFuAWYBawFmAWEBRgF1AW0BRgFtAWoBbwFxAV8BbwFfAWcBeAFEAXQBeAF0AXABdgFHAVUBdgFVAXoBewFTAUEBewFBAXcBXQFRAXkBXQF5AWUBgwGAAYwBgwGMAZsBiQF9AYUBiQGFAZUBqgGeAYoBqgGKAZgBmQGnAbMBmQGzAZMBhgGNAZEBhgGRAZYBkAGEAZwBkAGcAZQBowF/AYIBowGCAbwBiwGfAagBiwGoAZoBsAGkAaABsAGgAawBoQG6AaYBoQGmAZ0BuAGvAasBuAGrAbQBrgGIAX4BrgF+AaIBpQG5AbUBpQG1AbEBlwGSAbIBlwGyAakBrQG2AY4BrQGOAYcBuwGBAY8BuwGPAbcBxAHAAcEBxAHBAcUBxwG9Ab8BxwG/AcMByQHLAb4ByQG+AcgBxgHCAcwBxgHMAcoBzwHSAeQBzwHkAd8B0wHQAdwB0wHcAQMC3gHmAdgB3gHYAc4B2QHNAdUB2QHVAfkB3QHiAe4B3QHuAekB6AHgAewB6AHsAfQBAgLbAesBAgLrAfAB8gHqAdoB8gHaAfwBDALnAfMBDALzAfgB+wH+AfYB+wH2AfEB1gEFAv0B1gH9AfoB/wEBAu8B/wHvAfcBCALUAQQCCAIEAgACBgLXAeUBBgLlAQoCCwLjAdEBCwLRAQcC7QHhAQkC7QEJAvUBEwIQAhwCEwIcAisCGQINAhUCGQIVAiUCOgIuAhoCOgIaAigCKQI3AkMCKQJDAiMCFgIdAiECFgIhAiYCIAIUAiwCIAIsAiQCMwIPAhICMwISAkwCGwIvAjgCGwI4AioCQAI0AjACQAIwAjwCMQJKAjYCMQI2Ai0CSAI/AjsCSAI7AkQCPgIYAg4CPgIOAjICNQJJAkUCNQJFAkECJwIiAkICJwJCAjkCPQJGAh4CPQIeAhcCSwIRAh8CSwIfAkcCVAJQAlECVAJRAlUCVwJNAk8CVwJPAlMCWQJbAk4CWQJOAlgCVgJSAlwCVgJcAloCXwJiAnQCXwJ0Am8CYwJgAmwCYwJsApMCbgJ2AmgCbgJoAl4CaQJdAmUCaQJlAokCbQJyAn4CbQJ+AnkCeAJwAnwCeAJ8AoQCkgJrAnsCkgJ7AoACggJ6AmoCggJqAowCnAJ3AoMCnAKDAogCiwKOAoYCiwKGAoECZgKVAo0CZgKNAooCjwKRAn8CjwJ/AocCmAJkApQCmAKUApAClgJnAnUClgJ1ApoCmwJzAmECmwJhApcCfQJxApkCfQKZAoUCowKgAqwCowKsArsCqQKdAqUCqQKlArUCygK+AqoCygKqArgCuQLHAtMCuQLTArMCpgKtArECpgKxArYCsAKkArwCsAK8ArQCwwKfAqICwwKiAtwCqwK/AsgCqwLIAroC0ALEAsAC0ALAAswCwQLaAsYCwQLGAr0C2ALPAssC2ALLAtQCzgKoAp4CzgKeAsICxQLZAtUCxQLVAtECtwKyAtICtwLSAskCzQLWAq4CzQKuAqcC2wKhAq8C2wKvAtcC5ALgAuEC5ALhAuUC5wLdAt8C5wLfAuMC6QLrAt4C6QLeAugC5gLiAuwC5gLsAuoC9ALwAvEC9ALxAvUC9wLtAu8C9wLvAvMC+QL7Au4C+QLuAvgC9gLyAvwC9gL8AvoCBAMAAwEDBAMBAwUDBwP9Av8CBwP/AgMDCQMLA/4CCQP+AggDBgMCAwwDBgMMAwoDFAMQAxEDFAMRAxUDFwMNAw8DFwMPAxMDGQMbAw4DGQMOAxgDFgMSAxwDFgMcAxoDZQAwAzYDZQA2A4sANgBrADMDNgAzAyUDiwA2AzEDiwAxA2gAZQApAB4DZQAeAzADPAA/AC0DPAAtAygDRQBIACoDRQAqAywDQgBFACwDQgAsAysDMgA3ACYDMgAmAyMDKAAzACQDKAAkAx0DbAAvACIDbAAiAzQDRgBoADEDRgAxAykDLgArAB8DLgAfAyEDWgNJA1QDWgNUA1wDcANrA04DcANOA2ADYQNQA0YDYQNGA1cDYwNoA0wDYwNMA0MDbQNmA0UDbQNFA08DTQNiA1gDTQNYA0QDZwNuA18DZwNfA0sDRwNZA1sDRwNbA1EDUgNdA24DUgNuA2cDVgNKA2UDVgNlA2wDSANTA2kDSANpA2QDXgNVA2oDXgNqA28DhwN3A4IDhwOCA4kDmQOVA3wDmQN8A44DjwN+A3QDjwN0A4YDkQOUA3oDkQN6A3EDlwOSA3MDlwNzA30DewOQA4UDewOFA3IDkwOYA40DkwONA3kDdQOIA4oDdQOKA38DgAOLA5gDgAOYA5MDhAN4A5IDhAOSA5cDdgOBA5QDdgOUA5EDjAODA5YDjAOWA5oDBgQEBJ4DBgSeA6ED5QPhA6MD5QOjA8sDsgPQA9gDsgPYA7UDDQQYBNUDDQTVA7gD4gPqA9AD4gPQA7IDHAQHBKIDHASiA+ADAgQJBKUDAgSlA5sDCAQKBKgDCASoA6QDuQPWA7sDuQO7A6sDDwQRBK4DDwSuA7EDEAQOBLoDEAS6A60DDAQTBLQDDAS0A7cD0wOdA6YD0wOmA78DwQOnA6oDwQOqA8UDFwQDBJwDFwScA9IDywOjA58DywOfA9sDrAO+A8kDrAPJA7AD9QP5A8gD9QPIA70DHgT7A9UDHgTVAxgE8gPtA9kD8gPZA9ED/QP0A7wD/QO8A9cD9wP+A+oD9wPqA8cDCgQbBN8DCgTfA6gDrwPHA+oDrwPqA+IDwwOpA+EDwwPhA+UDzAPcA+wDzAPsA/EDxAPmA/8DxAP/A/gD1APAA/MD1APzA/wDFwTSA/sDFwT7Ax4EwgPGA/oDwgP6A/YD3QMUBB0E3QMdBO4DsQPkAxoEsQMaBA8E3gOgAwUE3gMFBBUE7gMdBBYE7gMWBNoD4wOzAxIE4wMSBBkEtgPaAxYEtgMWBAsE6wMABCkE6wMpBCIEygPwAygEygMoBCUE7wPPAyAE7wMgBCcE6APNAyYE6AMmBCQEzgPpAyEEzgMhBB8EAQTnAyMEAQQjBCoEAAAAvwAAAACPwvU9AAAAvwAAAACPwvU9AAAAvwAAAACPwvU9AAAAv87MDEDMzMw9AAAAv87MDEDMzMw9AAAAv87MDEDMzMw9AAAAPwAAAACPwvU9AAAAPwAAAACPwvU9AAAAPwAAAACPwvU9AAAAP87MDEDMzMw9AAAAP87MDEDMzMw9AAAAP87MDEDMzMw978TRvgAAAACPwvU978TRvgAAAACPwvU978TRvgAAAACPwvU9XwLcvs7MDEDMzMw9XwLcvs7MDEDMzMw9GBLSPgAAAACPwvU9GBLSPgAAAACPwvU9GBLSPgAAAACPwvU9ik/cPs7MDEDMzMw9ik/cPs7MDEDMzMw9ik/cPs7MDEDMzMw9AAAAv4XrAUDMzMw9AAAAv4XrAUDMzMw9AAAAP4XrAUDMzMw9AAAAP4XrAUDMzMw9AAAAP4XrAUDMzMw9XwLcvoXrAUDMzMw9XwLcvoXrAUDMzMw9XwLcvoXrAUDMzMw9iE/cPoXrAUDMzMw9iE/cPoXrAUDMzMw9iE/cPoXrAUDMzMw9iE/cPoXrAUDMzMw9iE/cPoXrAUDMzMw978TRvpDC9T2PwvU978TRvpDC9T2PwvU978TRvpDC9T2PwvU978TRvpDC9T2PwvU9AAAAv5DC9T2PwvU9AAAAv5DC9T2PwvU9AAAAv5DC9T2PwvU9AAAAP5DC9T2PwvU9AAAAP5DC9T2PwvU9AAAAP5DC9T2PwvU9GBLSPpDC9T2PwvU9GBLSPpDC9T2PwvU9GBLSPpDC9T2PwvU9GBLSPpDC9T2PwvU9AAAAv7geBT7MzMw9AAAAv7geBT7MzMw9AAAAv7geBT7MzMw9XwLcvrgeBT7MzMw9XwLcvrgeBT7MzMw9XwLcvrgeBT7MzMw9XwLcvrgeBT7MzMw9AAAAP7geBT7MzMw9AAAAP7geBT7MzMw9AAAAP7geBT7MzMw9iE/cPrgeBT7MzMw9iE/cPrgeBT7MzMw9iE/cPrgeBT7MzMw9iE/cPrgeBT7MzMw9AAAAM87MDEDMzMw9AAAAM87MDEDMzMw9AAAAM87MDEDMzMw9AAAAs4XrAUDMzMw9AAAAs4XrAUDMzMw9AAAAs4XrAUDMzMw9AAAAv87MDEBedFGxAAAAv87MDEBedFGxAAAAPwAAAABedFGxAAAAPwAAAABedFGxiE/cPoXrAUBedFGxiE/cPoXrAUBedFGxAAAAv4XrAUBedFGxAAAAv5DC9T1edFGxAAAAv7geBT5edFGxAACAsoXrAUBedFGxAACAMs7MDEBedFGxiU/cPs7MDEBedFGxAAAAP7geBT5edFGxAAAAP5DC9T1edFGxiU/cPrgeBT5edFGxiU/cPrgeBT5edFGxXwLcvrgeBT5edFGxXwLcvrgeBT5edFGx78TRvpDC9T1edFGx78TRvpDC9T1edFGxGRLSPpDC9T1edFGxGRLSPpDC9T1edFGx78TRvgAAAABedFGx78TRvgAAAABedFGxAAAAvwAAAABedFGxAAAAvwAAAABedFGxAAAAP4XrAUBedFGxXwLcvoXrAUBedFGxXwLcvoXrAUBedFGxGRLSPgAAAABedFGxGRLSPgAAAABedFGxAAAAP87MDEBedFGxAAAAP87MDEBedFGxXwLcvs7MDEBedFGxAAAAvwAAAACPwvW9AAAAvwAAAACPwvW9AAAAvwAAAACPwvW9AAAAv5DC9T2PwvW9AAAAv5DC9T2PwvW9AAAAv5DC9T2PwvW978TRvgAAAACPwvW978TRvgAAAACPwvW978TRvgAAAACPwvW9AAAAvwAAAABedFGxAAAAvwAAAABedFGxAAAAv5DC9T1edFGx78TRvgAAAABedFGx78TRvgAAAABedFGx78TRvpDC9T1edFGx78TRvpDC9T1edFGx78TRvpDC9T2PwvW978TRvpDC9T2PwvW978TRvpDC9T2PwvW978TRvpDC9T2PwvW9XwLcvrgeBT5edFGxXwLcvrgeBT5edFGxXwLcvrgeBT7NzMy9XwLcvrgeBT7NzMy9XwLcvrgeBT7NzMy9XwLcvrgeBT7NzMy9XwLcvoXrAUBedFGxXwLcvoXrAUBedFGxXwLcvoXrAUDNzMy9XwLcvoXrAUDNzMy9XwLcvoXrAUDNzMy9AACAsoXrAUBedFGxiE/cPoXrAUBedFGxiE/cPoXrAUBedFGxAAAAAIXrAUDNzMy9AAAAAIXrAUDNzMy9iE/cPoXrAUDNzMy9iE/cPoXrAUDNzMy9iE/cPoXrAUDNzMy9AAAAAM7MDEDNzMy9AAAAAM7MDEDNzMy9iE/cPs7MDEDNzMy9iE/cPs7MDEDNzMy9XwLcvs7MDEDNzMy9XwLcvs7MDEDNzMy9AACAMs7MDEBedFGxiU/cPs7MDEBedFGxXwLcvs7MDEBedFGxAAAAv87MDEBedFGxAAAAv87MDEBedFGxAAAAv4XrAUBedFGxAAAAv87MDEDNzMy9AAAAv87MDEDNzMy9AAAAv87MDEDNzMy9AAAAv4XrAUDNzMy9AAAAv4XrAUDNzMy9AAAAv7geBT7NzMy9AAAAv7geBT7NzMy9AAAAv7geBT7NzMy9AAAAv7geBT5edFGxAAAAP87MDEBedFGxAAAAP87MDEBedFGxAAAAP87MDEDNzMy9AAAAP87MDEDNzMy9AAAAP87MDEDNzMy9AAAAP4XrAUBedFGxAAAAP4XrAUDNzMy9AAAAP4XrAUDNzMy9AAAAP7geBT5edFGxAAAAP7geBT7NzMy9AAAAP7geBT7NzMy9AAAAP7geBT7NzMy9AAAAP5DC9T1edFGxAAAAP5DC9T2PwvW9AAAAP5DC9T2PwvW9AAAAP5DC9T2PwvW9AAAAPwAAAABedFGxAAAAPwAAAABedFGxGRLSPgAAAABedFGxGRLSPgAAAABedFGxAAAAPwAAAACPwvW9AAAAPwAAAACPwvW9AAAAPwAAAACPwvW9GhLSPgAAAACPwvW9GhLSPgAAAACPwvW9GhLSPgAAAACPwvW9GhLSPpDC9T2PwvW9GhLSPpDC9T2PwvW9GhLSPpDC9T2PwvW9GhLSPpDC9T2PwvW9ik/cPrgeBT7NzMy9ik/cPrgeBT7NzMy9ik/cPrgeBT7NzMy9ik/cPrgeBT7NzMy9GRLSPpDC9T1edFGxGRLSPpDC9T1edFGxiU/cPrgeBT5edFGxiU/cPrgeBT5edFGxAACAvwAAAAAAAACAAAAAAP//f78AAACAAAAAAAAAAAD//38/AACAvwAAAAAAAACAAAAAAAAAAAAAAIA/AAAAAAAAgD8AAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIA/AACAPwAAAAAAAACAAAAAAI8FBzIAAIA/AAAAAAAAgD8AAACAAACAPwAAAAAAAACAAAAAAP//f78AAACAAAAAAAAAAAD//38/AACAPwAAAAAAAACAAAAAAAAAAAAAAIA/AAAAAAAAgD8AAACAAACAvwAAAACO44q0AAAAAAAAgL8AAACAAAAAAAAAAAAAAIA/AAAAAI8FBzIAAIA/AAAAAIn7rjIAAIA/AAAAAAAAgD8AAACAAACAvwAAAAAAAACAAAAAAAAAAAAAAIA/AAAAAAAAAAAAAIA/AAAAAI8FBzIAAIA/AACAPwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIA/AACAPwAAAAAAAACAAACAv6O8BrIAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIA/AAAAAI8FBzIAAIA/AAAAAIn7rjIAAIA/AAAAAAAAAAD//38/AAAAADH5ZD8k+eQ+JfnkPjD5ZD8AAACAAACAPwAAAAAAAACAAACAvwAAAAAAAACAAAAAAAAAAAD//38/AAAAADH5ZD8k+eQ+AAAAAAAAAAAAAIA/AAAAADH5ZD8m+eQ+AACAPwAAAAAAAACAAACAvwAAAACO44q0JvnkvjD5ZD92R0u0AAAAAAAAAAAAAIA/AAAAADH5ZD8m+eQ+AACAvwAAAAAAAACAAAAAAAAAAAAAAIA/AAAAADH5ZD8k+eQ+AAAAAAAAAAAAAIA/AAAAADH5ZD8k+eQ+JfnkPjD5ZD8AAACAAACAPwAAAAAAAACAAAAAAAAAAAAAAIA/AAAAADH5ZD8m+eQ+AACAPwAAAAAAAACAAACAv6O8BrIAAACAJvnkvjD5ZD92R0u0AAAAAAAAAAAAAIA/AAAAADH5ZD8m+eQ+AAAAAAAAAAAAAIA/AAAAAIn7rjIAAIA/AAAAAAAAgD8AAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIA/AAAAAIn7rjIAAIA/AACAvwAAAAAAAACAAAAAAAAAgD8AAACAAAAAAAAAgL8AAACAAACAPwAAAAAAAACAAACAv6O8BrIAAACAAAAAAAAAgL8AAACAAACAvwAAAAAAAACAAACAvwAAAAAAAACAAACAvwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAAAAgD8AAACAAAAAAAAAgD8AAACAAACAPwAAAAAAAACAAACAPwAAAAAAAACAAACAv6O8BrIAAACAJvnkvjD5ZD92R0u0JfnkPjD5ZD8AAACAAACAPwAAAAAAAACAJfnkPjD5ZD8AAACAAACAPwAAAAAAAACAAACAvwAAAACO44q0JvnkvjD5ZD92R0u0AAAAAP//f78AAACAAACAPwAAAAAAAACAAACAvwAAAAAAAACAAAAAAP//f78AAACAAACAPwAAAAAAAACAAAAAAAAAgL8AAACAAACAPwAAAAAAAACAAACAvwAAAACO44q0AAAAAAAAgL8AAACAAAAAAAAAgD8AAACAAACAPwAAAAAAAACAAAAAAAAAgD8AAACAAACAvwAAAAAAAACAAAAAAP//f78AAACAAAAAAAAAAAD//3+/AACAvwAAAAAAAACAAAAAAAAAAAD//3+/AAAAADD5ZD8l+eS+AAAAAP//f78AAACAAAAAAAAAAAD//3+/AACAPwAAAAAAAACAAACAvwAAAAAAAACAAAAAAP//f78AAACAAACAvwAAAAAAAACAAAAAAP//f78AAACAAACAPwAAAAAAAACAJfnkPjD5ZD8AAACAAACAPwAAAAAAAACAAAAAAAAAAAD//3+/AAAAADD5ZD8l+eS+JfnkPjD5ZD8AAACAAACAPwAAAAAAAACAJfnkPjD5ZD8AAACAAACAPwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAADD5ZD8l+eS+JfnkPjD5ZD8AAACAAACAPwAAAAAAAACAAAAAAAAAgL8AAACAAACAPwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AACAPwAAAAAAAACAAAAAAAAAgL8AAACAAACAv/MayrLKa6i0AAAAAAAAgL8AAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AACAv/MayrLKa6i0AAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AAAAAAAAAAAAAIC/AAAAAAAAgD8AAACAAAAAAAAAAAAAAIC/AAAAAAAAgD8AAACAAAAAAAAAAAAAAIC/AAAAAAAAgD8AAACAAAAAAAAAgD8AAACAAAAAAAAAgD8AAACAAAAAAAAAgD8AAACAAACAvwAAAAAAAACAAAAAAAAAgD8AAACAAACAvwAAAAAAAACAAACAvwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAAAAAgD8AAACAAACAvwAAAAAAAACAAAAAAAAAAAAAAIC/AACAvwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAADD5ZD8l+eS+AACAvwAAAAAAAACAAAAAAAAAgD8AAACAAACAPwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAAAAAgD8AAACAAACAPwAAAAAAAACAAACAPwAAAAAAAACAAAAAAAAAAAAAAIC/AACAPwAAAAAAAACAAACAPwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAADH5ZD8o+eS+AACAPwAAAAAAAACAAACAPwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAADH5ZD8o+eS+AACAPwAAAAAAAACAAAAAAAAAgL8AAACAAACAPwAAAAAAAACAAACAvwAAAACO44q0AAAAAAAAgL8AAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AACAPwAAAAAAAACAAACAvwAAAACO44q0AAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/AACAvwAAAACO44q0I/nkvjH5ZD9zR0u0AAAAAAAAAAAAAIC/AAAAADH5ZD8o+eS+AACAv/MayrLKa6i0I/nkvjH5ZD9zR0u0AAAAAAAAAAAAAIC/AAAAADH5ZD8o+eS+AACAvwAAAACO44q0I/nkvjH5ZD9zR0u0AACAv/MayrLKa6i0I/nkvjH5ZD9zR0u0AMB/PwDAfz8AwH8/AMB/P6CvADwKyG4/AMB/PwDAfz/guPU7gEJHPADAfz8AwH8/AMB/PwDAfz8gZSU9CshuPwDAfz8AwH8/HQDKPgDnTTwAwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8gZSU9CshuP8wnzz68324/SKcGPYBCRzwAwH8/AMB/P4hd9j68324/AMB/PwDAfz+grwA8CshuP7Rbuz6AQkc8tFu7PoBCRzwAwH8/AMB/PwDAfz8AwH8/4Lj1OxgFuT0dAMo+qNm5PR0Ayj6o2bk9AMB/PwDAfz+IahM97hFKP4ijBz0YBbk9FbPPPsBOuT3LrfY+wE65PTFb5D7uEUo/gYO7PhgFuT2Bg7s+GAW5PYGDuz4YBbk9BH8lPUC6Yj8EfyU9QLpiP8wnzz5T9mI/zCfPPlP2Yj8AwH8/AMB/P6CvADykumI/oK8APKS6Yj8EfyU9QLpiPwR/JT1AumI/AMB/PwDAfz+IXfY+U/ZiP4hd9j5T9mI/oK8APKS6Yj+grwA8pLpiPwDAfz8AwH8/4Lj1O9RaSD+grwA8Tl5hP8QYCD3UWkg/yIAlPU5eYT/MJ88+NHNhPxWzzz4UbEg/HQDKPmZ1SD/IgCU9Tl5hPwDAfz8AwH8/y632PhRsSD+IXfY+M3NhP0+Wuz7UWkg/oK8APE5eYT8QqUw+gEJHPBCpTD6AQkc8AMB/PwDAfz9bw3Y+7hFKP0ICTT4YBbk9QgJNPhgFuT0AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/P3Aw4z7ATrk9MVvkPur8VD8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz9bw3Y+6vxUPwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/cDDjPhRsSD+qwuI+NHNhP6rC4j40c2E/cDDjPhRsSD+qwuI+U/ZiP6rC4j5T9mI/qsLiPlP2Yj+qwuI+U/ZiPwDAfz8AwH8/qsLiPrzfbj8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz+IahM96vxUP3Aw4z7ATrk9qsLiPrzfbj8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8gZSU9CshuPwDAfz8AwH8/BH8lPUC6Yj8EfyU9QLpiPwDAfz8AwH8/oK8APArIbj+IXfY+vN9uPwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/qsLiPrzfbj+qwuI+U/ZiP6rC4j5T9mI/oK8APKS6Yj+grwA8pLpiP4hd9j5T9mI/iF32PlP2Yj+qwuI+NHNhP3Aw4z4UbEg/T5a7PtRaSD+grwA8Tl5hP4hd9j4zc2E/y632PhRsSD+IahM96vxUP3Aw4z7ATrk9iGoTPebnXz+Bg7s+GAW5Pcut9j7ATrk9W8N2Pur8VD9wMOM+wE65PTFb5D7q/FQ/W8N2PubnXz9/7Uw+GAW5PRWzzz7ATrk9MVvkPubnXz+Iowc9GAW5PRCpTD6AQkc8AMB/PwDAfz9IpwY9gEJHPADAfz8AwH8/tFu7PoBCRzwAwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz8AwH8/HQDKPgDnTTwAwH8/AMB/PwDAfz8AwH8/HQDKPqjZuT0AwH8/AMB/Px0Ayj5mdUg/yIAlPU5eYT8AwH8/AMB/PwDAfz8AwH8/AMB/PwDAfz/guPU7gEJHPADAfz8AwH8/AMB/PwDAfz8AwH8/AMB/P+C49TsYBbk9AMB/PwDAfz8AwH8/AMB/P+C49TvUWkg/oK8APE5eYT8AwH8/AMB/PwDAfz8AwH8/oK8APKS6Yj+grwA8pLpiPwDAfz8AwH8/AMB/PwDAfz8AwH8/AMB/P6rC4j68324/AMB/PwDAfz8AwH8/AMB/P6CvADwKyG4/AMB/PwDAfz/MJ88+vN9uPwDAfz8AwH8/IGUlPQrIbj/MJ88+U/ZiP8wnzz5T9mI/BH8lPUC6Yj8EfyU9QLpiPxWzzz4UbEg/zCfPPjRzYT/EGAg91FpIP8iAJT1OXmE/qsLiPlP2Yj+qwuI+U/ZiP3Aw4z4UbEg/qsLiPjRzYT9gAGYACwBgAAsAGwAdAA8ABAAdAAQAGABkAEgABgBkAAYAEgBnAEcABQBnAAUAEABQAGcAEABQABAAQgBfAFwADABfAAwAAQBEAEAADwBEAA8AHQAaAAkAFAAaABQAIgBlAFEAFgBlABYACgBaAGMAEQBaABEALgA5ABkAIQA5ACEAPgBXAGIAHgBXAB4AOAA1AB0AGAA1ABgAMwBSAGAAGwBSABsAOwANACQAKQANACkAAgBdAFkAJwBdACcADgBJAFMALQBJAC0ACAAHACsAMAAHADAAEwBVAFsALwBVAC8APQAlADYANAAlADQAKgBYAFYANwBYADcAJgBKAFQAPABKADwAHwBTAFIAOwBTADsALQAsADoAPwAsAD8AMQAjABUAQQAjAEEARQBRAFAAQgBRAEIAFgAgAEMATwAgAE8ASwAoADIATgAoAE4ATQAAACgATQAAAE0AXgAyABcATAAyAEwATgBDABwAYQBDAGEATwAXAAMARgAXAEYATABqAGwAeABqAHgAbwBxAHMAawBxAGsAaABpAG4AdABpAHQAcgBwAHsAdwBwAHcAdQB6AIAAfAB6AHwAdgCBAIYAgwCBAIMAfQCHAIIAhACHAIQAigCJAIcAigCJAIoAjQCLAI8AkQCLAJEAjgCFAJMAjwCFAI8AiwCSAJAAlQCSAJUAlgCQAJQAlwCQAJcAlQCUAJ0AmQCUAJkAlwCaAJgAmwCaAJsAngCfAJwAkwCfAJMAhQChAJ8AhQChAIUAfgCjAJoAngCjAJ4AoABtAKIAfwBtAH8AeQBzAKMAoABzAKAAawCnAJIAlgCnAJYApACrAKgApQCrAKUAqQCvAKsAqQCvAKkArACzAK8ArACzAKwAsAC6ALMAsAC6ALAAtQC8ALgAtAC8ALQAtwC9AMAAsQC9ALEAuQC+ALsAtgC+ALYAxgDDAL8AxwDDAMcAyQDBAMUArgDBAK4AsgCMAMIAyACMAMgAiADEAI4AqgDEAKoArQCOAJEApgCOAKYAqgCQrjM/Bm17P9xMSj2QrjM/fUmCP9xMSj2QrjM/Bm17P8SloDyQrjM/fUmCP8SloDyC1Dw/Bm17P9xMSj2C1Dw/fUmCP9xMSj2C1Dw/Bm17P8SloDyC1Dw/fUmCP8aloDzCAzM/OMJ6P2BB0jz1rTI/bGx6P99PDT31rTI/bGx6P99PDT3CAzM/OMJ6Pw1/MT3CAzM/Q0l9P0EyUz31rTI/AACAPzmqVz3CAzM/XluBP0EyUz3CAzM/5J6CPw1/MT31rTI/ysmCP99PDT31rTI/ysmCP99PDT3CAzM/5J6CP2BB0jzCAzM/XluBP/rajjz1rTI/AACAPwzrhTzCAzM/Q0l9P/rajjxG+Do/OMJ6P/rajjyJQTg/bGx6PwzrhTzMijU/OMJ6P/rajjzMijU/5J6CP/rajjyJQTg/ysmCPwzrhTxG+Do/5J6CP/rajjxQfz0/XluBP/rajjwd1T0/AACAPwrrhTxQfz0/Q0l9P/rajjxQfz0/OMJ6Pw1/MT0d1T0/bGx6P99PDT0d1T0/bGx6P99PDT1Qfz0/OMJ6P2BB0jxQfz0/5J6CP2BB0jwd1T0/ysmCP99PDT0d1T0/ysmCP99PDT1Qfz0/5J6CPw1/MT1Qfz0/XluBP0EyUz0d1T0/AACAPzmqVz1Qfz0/Q0l9P0EyUz3MijU/OMJ6P0EyUz2JQTg/bGx6PziqVz1G+Do/OMJ6P0EyUz1G+Do/5J6CP0EyUz2JQTg/ysmCPziqVz3MijU/5J6CP0EyUz1HljE/lBt9Py/gMz2IGjE/AACAP4HyNT1HljE/NnKBPy/gMz2IGjE/zvN8P99PDT2IGjE/zvN8P99PDT10kzA/AACAP99PDT10kzA/AACAP99PDT2IGjE/GYaBP99PDT2IGjE/GYaBP99PDT1HljE/lBt9Px5/zTyIGjE/AACAP3hayTxHljE/NnKBPx5/zTwdXTU/lBt9P9CRUTxWNTU/AACAPwfKNzwdXTU/NnKBP8+RUTyJQTg/zvN8PwnKNzyJQTg/AACAP+SlGzyJQTg/GYaBPwnKNzz1JTs/lBt9P8+RUTy8TTs/AACAPwfKNzz1JTs/NnKBP9CRUTzL7D4/lBt9Px5/zTyKaD8/AACAP3hayTzL7D4/NnKBPx5/zTyKaD8/zvN8P99PDT2KaD8/zvN8P99PDT2e7z8/AACAP99PDT2e7z8/AACAP99PDT2KaD8/GYaBP99PDT2KaD8/GYaBP99PDT3L7D4/lBt9Py/gMz2KaD8/AACAP4HyNT3L7D4/NnKBPy/gMz31JTs/lBt9P0o7Zj28TTs/AACAPzutbD31JTs/NnKBP0o7Zj2JQTg/zvN8PzutbD2JQTg/AACAP0W2cz2JQTg/GYaBPzutbD0dXTU/lBt9P0o7Zj1WNTU/AACAPzutbD0dXTU/NnKBP0o7Zj0dXTU/vlR5Px5/zTyJQTg/ANl4P3hayTz1JTs/vlR5Px5/zTxWNTU/ANl4P99PDT1WNTU/ANl4P99PDT2JQTg/7FF4P99PDT2JQTg/7FF4P99PDT28TTs/ANl4P99PDT28TTs/ANl4P99PDT0dXTU/vlR5Py/gMz2JQTg/ANl4P4HyNT31JTs/vlR5Py/gMz31JTs/oVWDPx5/zTyJQTg/gJODP3hayTwdXTU/oVWDPx5/zTy8TTs/gJODP99PDT28TTs/gJODP99PDT2JQTg/CteDP99PDT2JQTg/CteDP99PDT1WNTU/gJODP99PDT1WNTU/gJODP99PDT31JTs/oVWDPy/gMz2JQTg/gJODP4HyNT0dXTU/oVWDPy/gMz2WGDs/h2uBP710kzuJQTg/CteDP1E5tLuJQTg/CteDP710kzvDrz0/HbeCP1k5tLvDrz0/HbeCP710kzud7z8/AACAP1k5tLud7z8/AACAP710kzvDrz0/xpF6P1k5tLvDrz0/xpF6P710kzuJQTg/7FF4P1k5tLuJQTg/7FF4P7V0kztP0zI/xpF6P1k5tLtP0zI/xpF6P710kzt1kzA/AACAP1k5tLt1kzA/AACAP710kztO0zI/HbeCP1k5tLtO0zI/HbeCP710kzvvej0/s5yCP710kzuJQTg/r7GDP710kzvnpD8/AACAP710kzvvej0/msZ6P710kzuJQTg/opx4P7V0kzsjCDM/msZ6P710kzsr3jA/AACAP710kzsjCDM/s5yCP710kzvw5Do/s1GBP710kzuJQTg/lN2BP710kzuy/Ds/AACAP710kzvw5Do/mlx9P710kzuJQTg/10R8P710kzsinjU/mlx9P710kztghjQ/AACAP710kzsinjU/s1GBP710kzuJQTg/kRaBP55NgzyJQTg/GgKCP710kzt9yzk/+sSAP55Ngzyrbjo/AACAP55Ngzx9yzk/DHZ+P55NgzyJQTg/3tJ9P55NgzyVtzY/DHZ+P55NgzxnFDY/AACAP55NgzyVtzY/+sSAP55Ngzy+RTw/AACAP710kzuWGDs/8ih9P710kzuJQTg/y/t7P710kzt8ajU/8ih9P710kztUPTQ/AACAP710kzt8ajU/h2uBP710kzuJQTg/F1l8P6espjugmjQ/AACAP6espjt0rDU/62p9P6espjt0rDU/ikqBP6espjue1jo/ikqBP6espjuJQTg/dNOBP6espjue1jo/62p9P6espjty6Ds/AACAP6espjuJQTg/CteDPwIhcjvDrz0/HbeCPwIhcjud7z8/AACAPwIhcjvDrz0/xpF6PwIhcjuJQTg/7FF4PwIhcjtP0zI/xpF6PwIhcjt1kzA/AACAPwIhcjtO0zI/HbeCPwIhcjuC1Dw/Bm17P4LUrL2C1Dw/fUmCP4LUrL2C1Dw/Bm17PwyvX72C1Dw/fUmCPwyvX72QrjM/Bm17P4LUrL2QrjM/fUmCP4LUrL2QrjM/Bm17PwqvX72QrjM/fUmCPwuvX71Qfz0/OMJ6P9l8eL0c1T0/bGx6PwRWjr0c1T0/bGx6PwRWjr1Qfz0/OMJ6P5ttoL1Qfz0/Q0l9PzVHsb0c1T0/AACAPzKDs71Qfz0/XluBPzVHsb1Qfz0/5J6CP5ttoL0c1T0/ysmCPwRWjr0c1T0/ysmCPwRWjr1Qfz0/5J6CP9p8eL1Qfz0/XluBP6bJVr0d1T0/AACAP69RUr1Qfz0/Q0l9P6bJVr3MijU/OMJ6P6bJVr2JQTg/bGx6P65RUr1G+Do/OMJ6P6bJVr1G+Do/5J6CP6bJVr2JQTg/ysmCP65RUr3MijU/5J6CP6bJVr3CAzM/XluBP6bJVr31rTI/AACAP65RUr3CAzM/Q0l9P6bJVr3CAzM/OMJ6P5ttoL31rTI/bGx6PwRWjr31rTI/bGx6PwRWjr3CAzM/OMJ6P9h8eL3CAzM/5J6CP9h8eL31rTI/ysmCPwRWjr31rTI/ysmCPwRWjr3CAzM/5J6CP5ttoL3CAzM/XluBPzVHsb31rTI/AACAPzCDs73CAzM/Q0l9PzVHsb1G+Do/OMJ6PzVHsb2JQTg/bGx6PzCDs73MijU/OMJ6PzVHsb3MijU/5J6CPzVHsb2JQTg/ysmCPzCDs71G+Do/5J6CPzVHsb3L7D4/lBt9Pyyeob2KaD8/AACAP1anor3L7D4/NnKBPyyeob2KaD8/zvN8PwRWjr2KaD8/zvN8PwRWjr2d7z8/AACAPwRWjr2d7z8/AACAPwRWjr2KaD8/GYaBPwRWjr2KaD8/GYaBPwRWjr3L7D4/lBt9P7gbdr2KaD8/AACAP2YJdL3L7D4/NnKBP7gbdr31JTs/lBt9P53AQ728TTs/AACAP6tOPb31JTs/NnKBP53AQ72JQTg/zvN8P6tOPb2JQTg/AACAP6JFNr2JQTg/GYaBP6tOPb0dXTU/lBt9P5zAQ71WNTU/AACAP6pOPb0dXTU/NnKBP5zAQ71HljE/lBt9P7cbdr2IGjE/AACAP2QJdL1HljE/NnKBP7cbdr2IGjE/zvN8PwRWjr2IGjE/zvN8PwRWjr10kzA/AACAPwRWjr10kzA/AACAPwRWjr2IGjE/GYaBPwRWjr2IGjE/GYaBPwRWjr1HljE/lBt9Pyyeob2IGjE/AACAP1Snor1HljE/NnKBPyyeob0cXTU/lBt9P7rLur1WNTU/AACAP7IEvr0cXTU/NnKBP7rLur2JQTg/zvN8P7IEvr2JQTg/AACAPzeJwb2JQTg/GYaBP7IEvr31JTs/lBt9P7rLur28TTs/AACAP7IEvr31JTs/NnKBP7rLur31JTs/vlR5P7gbdr2JQTg/ANl4P2UJdL0dXTU/vlR5P7cbdr28TTs/ANl4PwRWjr28TTs/ANl4PwRWjr2JQTg/7FF4PwRWjr2JQTg/7FF4PwRWjr1WNTU/ANl4PwRWjr1WNTU/ANl4PwRWjr31JTs/vlR5Pyyeob2JQTg/ANl4P1Wnor0cXTU/vlR5Pyyeob0dXTU/oVWDP7cbdr2JQTg/gJODP2UJdL31JTs/oVWDP7gbdr1WNTU/gJODPwRWjr1WNTU/gJODPwRWjr2JQTg/CteDPwRWjr2JQTg/CteDPwRWjr28TTs/gJODPwRWjr28TTs/gJODPwRWjr0dXTU/oVWDPyyeob2JQTg/gJODP1Wnor31JTs/oVWDPyyeob18ajU/h2uBP8DKIb2JQTg/CteDP/2p8byJQTg/CteDP8DKIb1P0zI/HbeCP/qp8bxP0zI/HbeCP8DKIb11kzA/AACAP/qp8bx1kzA/AACAP8DKIb1P0zI/xpF6P/qp8bxP0zI/xpF6P8DKIb2JQTg/7FF4P/up8byJQTg/7FF4P7/KIb3Drz0/xpF6P/yp8bzDrz0/xpF6P8HKIb2d7z8/AACAP/2p8byd7z8/AACAP8HKIb3Erz0/HbeCP/yp8bzErz0/HbeCP8HKIb0jCDM/s5yCP8DKIb2JQTg/r7GDP8DKIb0r3jA/AACAP8DKIb0jCDM/msZ6P8DKIb2JQTg/opx4P7/KIb3vej0/msZ6P8HKIb3npD8/AACAP8HKIb3vej0/s5yCP8HKIb0injU/s1GBP8DKIb2JQTg/lN2BP8DKIb1ghjQ/AACAP8DKIb0injU/mlx9P8DKIb2JQTg/10R8P8DKIb3w5Do/mlx9P8HKIb2y/Ds/AACAP8HKIb3w5Do/s1GBP8HKIb2JQTg/kRaBP/gCUb2JQTg/GgKCP8DKIb2VtzY/+sSAP/gCUb1nFDY/AACAP/gCUb2VtzY/DHZ+P/gCUb2JQTg/3tJ9P/gCUb19yzk/DHZ+P/gCUb2rbjo/AACAP/gCUb19yzk/+sSAP/gCUb1UPTQ/AACAP8DKIb18ajU/8ih9P8DKIb2JQTg/y/t7P8DKIb2WGDs/8ih9P8HKIb2+RTw/AACAP8HKIb2WGDs/h2uBP8HKIb2JQTg/F1l8P74xJL1y6Ds/AACAP74xJL2e1jo/62p9P74xJL2e1jo/ikqBP74xJL10rDU/ikqBP70xJL2JQTg/dNOBP74xJL10rDU/62p9P70xJL2gmjQ/AACAP70xJL2JQTg/CteDPzl+Hr1P0zI/HbeCPzh+Hr11kzA/AACAPzh+Hr1P0zI/xpF6Pzh+Hr2JQTg/7FF4Pzl+Hr3Drz0/xpF6Pzl+Hr2d7z8/AACAPzp+Hr3Erz0/HbeCPzl+Hr0AAICzABCrOSCN87kAAICzABCrOSCN87kAAICzABCrOSCN87kAAICzABCrOSCN87kAAICzWAUAQCCN87kAAICzWAUAQCCN87kAAICzWAUAQCCN87kAAICzWAUAQCCN87kAAICzABCrObAqDb0AAICzABCrObAqDb0AAICzABCrObAqDb0AAICzABCrObAqDb0AAICzWAUAQLAqDb0AAICzWAUAQLAqDb0AAICzWAUAQLAqDb0AAICzWAUAQLAqDb3MzEw/ABCrOSCN87nMzEw/ABCrOSCN87nMzEw/ABCrOSCN87nMzEw/ABCrOSCN87nMzEw/WAUAQCCN87nMzEw/WAUAQCCN87nMzEw/WAUAQCCN87nMzEw/WAUAQCCN87nMzEw/ABCrObAqDb3MzEw/ABCrObAqDb3MzEw/ABCrObAqDb3MzEw/ABCrObAqDb3MzEw/WAUAQLAqDb3MzEw/WAUAQLAqDb3MzEw/WAUAQLAqDb3MzEw/WAUAQLAqDb0AAICzsQqAPyCN87kAAICzsQqAPyCN87kAAICzsQqAPyCN87kAAICzsQqAP7AqDb0AAICzsQqAP7AqDb0AAICzsQqAP7AqDb3MzEw/sQqAP7AqDb3MzEw/sQqAP7AqDb3MzEw/sQqAP7AqDb3MzEw/sQqAPyCN87nMzEw/sQqAPyCN87nMzEw/sQqAPyCN87kgX449pPCIP7AqDb0gX449pPCIP7AqDb0gX449pPCIP7AqDb0gX449viT3P7AqDb0gX449viT3P7AqDb0gX449viT3P7AqDb0gX449viT3P7AqDb3nADs/viT3P7AqDb3nADs/viT3P7AqDb3nADs/viT3P7AqDb3nADs/viT3P7AqDb3nADs/pPCIP7AqDb3nADs/pPCIP7AqDb3nADs/pPCIP7AqDb3nADs/pPCIPyCN87nnADs/pPCIPyCN87nnADs/pPCIPyCN87nnADs/viT3PyCN87nnADs/viT3PyCN87nnADs/viT3PyCN87nnADs/viT3PyCN87kgX449viT3PyCN87kgX449viT3PyCN87kgX449viT3PyCN87kgX449viT3PyCN87kgX449pPCIPyCN87kgX449pPCIPyCN87kgX449pPCIPyCN87nnADs/OAqPPSCN87nnADs/OAqPPSCN87nnADs/OAqPPSCN87nnADs/OAqPPSCN87nnADs/fUluPyCN87nnADs/fUluPyCN87nnADs/fUluPyCN87nnADs/fUluPyCN87kgX449fUluPyCN87kgX449fUluPyCN87kgX449fUluPyCN87kgX449fUluPyCN87kgX449OAqPPSCN87kgX449OAqPPSCN87kgX449OAqPPSCN87kgX449OAqPPSCN87kgX449OAqPPbAqDb0gX449OAqPPbAqDb0gX449OAqPPbAqDb0gX449OAqPPbAqDb0gX449fUluP7AqDb0gX449fUluP7AqDb0gX449fUluP7AqDb0gX449fUluP7AqDb3nADs/fUluP7AqDb3nADs/fUluP7AqDb3nADs/fUluP7AqDb3nADs/fUluP7AqDb3nADs/OAqPPbAqDb3nADs/OAqPPbAqDb3nADs/OAqPPbAqDb3nADs/OAqPPbAqDb3U96I9LjqKP7AqDb3U96I9LjqKP7AqDb3U96I9LjqKP7AqDb3U96I9M9v1P7AqDb3U96I9M9v1P7AqDb3U96I9M9v1P7AqDb3RbTg/M9v1P7AqDb3RbTg/M9v1P7AqDb3RbTg/M9v1P7AqDb3RbTg/LjqKP7AqDb3RbTg/LjqKP7AqDb3RbTg/LjqKP7AqDb3RbTg/LjqKPyCN87nRbTg/LjqKPyCN87nRbTg/LjqKPyCN87nRbTg/M9v1PyCN87nRbTg/M9v1PyCN87nRbTg/M9v1PyCN87nU96I9M9v1PyCN87nU96I9M9v1PyCN87nU96I9M9v1PyCN87nU96I9LjqKPyCN87nU96I9LjqKPyCN87nU96I9LjqKPyCN87nRbTg/7KKjPSCN87nRbTg/7KKjPSCN87nRbTg/7KKjPSCN87nRbTg/ZrZrPyCN87nRbTg/ZrZrPyCN87nRbTg/ZrZrPyCN87nU96I9ZrZrPyCN87nU96I9ZrZrPyCN87nU96I9ZrZrPyCN87nU96I97KKjPSCN87nU96I97KKjPSCN87nU96I97KKjPSCN87nU96I97KKjPbAqDb3U96I97KKjPbAqDb3U96I97KKjPbAqDb3U96I9ZrZrP7AqDb3U96I9ZrZrP7AqDb3U96I9ZrZrP7AqDb3RbTg/ZrZrP7AqDb3RbTg/ZrZrP7AqDb3RbTg/ZrZrP7AqDb3RbTg/7KKjPbAqDb3RbTg/7KKjPbAqDb3RbTg/7KKjPbAqDb0gX449viT3P5az1LwgX449viT3P5az1LwgX449viT3P5az1LwgX449pPCIP5az1LwgX449pPCIP5az1LwgX449pPCIP5az1LznADs/pPCIP5az1LznADs/pPCIP5az1LznADs/pPCIP5az1LznADs/viT3P5az1LznADs/viT3P5az1LznADs/viT3P5az1LznADs/viT3PwDgErznADs/viT3PwDgErznADs/viT3PwDgErznADs/viT3PwDgErznADs/pPCIPwDgErznADs/pPCIPwDgErznADs/pPCIPwDgErwgX449pPCIPwDgErwgX449pPCIPwDgErwgX449pPCIPwDgErwgX449viT3PwDgErwgX449viT3PwDgErwgX449viT3PwDgErwgX449viT3PwDgErznADs/fUluPwDgErznADs/fUluPwDgErznADs/fUluPwDgErznADs/fUluPwDgErznADs/OAqPPQDgErznADs/OAqPPQDgErznADs/OAqPPQDgErwgX449OAqPPQDgErwgX449OAqPPQDgErwgX449OAqPPQDgErwgX449fUluPwDgErwgX449fUluPwDgErwgX449fUluPwDgErwgX449fUluPwDgErwgX449fUluP5az1LwgX449fUluP5az1LwgX449fUluP5az1LwgX449OAqPPZaz1LwgX449OAqPPZaz1LwgX449OAqPPZaz1LznADs/OAqPPZaz1LznADs/OAqPPZaz1LznADs/OAqPPZaz1LznADs/fUluP5az1LznADs/fUluP5az1LznADs/fUluP5az1LzU96I9M9v1P5az1LzU96I9M9v1P5az1LzU96I9M9v1P5az1LzU96I9LjqKP5az1LzU96I9LjqKP5az1LzU96I9LjqKP5az1LzRbTg/LjqKP5az1LzRbTg/LjqKP5az1LzRbTg/LjqKP5az1LzRbTg/M9v1P5az1LzRbTg/M9v1P5az1LzRbTg/M9v1P5az1LzRbTg/M9v1PwDgErzRbTg/M9v1PwDgErzRbTg/M9v1PwDgErzRbTg/M9v1PwDgErzRbTg/LjqKPwDgErzRbTg/LjqKPwDgErzRbTg/LjqKPwDgErzU96I9LjqKPwDgErzU96I9LjqKPwDgErzU96I9LjqKPwDgErzU96I9M9v1PwDgErzU96I9M9v1PwDgErzU96I9M9v1PwDgErzU96I9M9v1PwDgErzRbTg/ZrZrPwDgErzRbTg/ZrZrPwDgErzRbTg/ZrZrPwDgErzRbTg/ZrZrPwDgErzRbTg/8KKjPQDgErzRbTg/8KKjPQDgErzRbTg/8KKjPQDgErzU96I98KKjPQDgErzU96I98KKjPQDgErzU96I98KKjPQDgErzU96I9ZrZrPwDgErzU96I9ZrZrPwDgErzU96I9ZrZrPwDgErzU96I9ZrZrPwDgErzU96I9ZrZrP5az1LzU96I9ZrZrP5az1LzU96I9ZrZrP5az1LzU96I98KKjPZaz1LzU96I98KKjPZaz1LzU96I98KKjPZaz1LzRbTg/8KKjPZaz1LzRbTg/8KKjPZaz1LzRbTg/8KKjPZaz1LzRbTg/ZrZrP5az1LzRbTg/ZrZrP5az1LzRbTg/ZrZrP5az1LwAQDo4BhStPwCmErgAQDo4BhStPwg0mbzAS5Y8BhStPwCkErgAQDo4BhStP2OhmDxwkZW8BhStPwCmErjgTlO8BhStPyqvVzzgTlO8BhStP3TUWLzg0Ji8BhStPwCmErjg0Ji8BhStPwCmErig5le8BhStP1JeXDyg5le8BhStP1JeXDzg0Ji8CDCtPwCmErig5le8BhStP5qDXbyg5le8BhStP5qDXbyg5le8CDCtP5qDXbwAQDo4BhStP/aDnLwAQDo4BhStP/aDnLwAQDo4BhStP/aDnLwgW1k8BhStP5qDXbwgW1k8BhStP5qDXbwAQDo4CDCtP/aDnLwAQDo4CDCtP/aDnLwgW1k8CDCtP5qDXbwAQDo4cA6zP/aDnLwAQDo4cA6zP/aDnLwAQDo4wRuzP/aDnLwAQDo4wRuzP/aDnLyg5le8cA6zP5qDXbwgW1k8cA6zP5qDXbwgW1k8wRuzP5qDXbwgi5k8cA6zPwCkErggi5k8CDCtPwCkErggi5k8wRuzPwCkErggW1k8cA6zP05eXDwgW1k8CDCtP05eXDwgW1k8wRuzP05eXDwAQDo4cA6zP0/xmzwAQDo4CDCtP0/xmzwAQDo4wRuzP0/xmzyg5le8cA6zP1JeXDyg5le8CDCtP1JeXDyg5le8wRuzP1JeXDzg0Ji8cA6zPwCmErjg0Ji8wRuzPwCmErgQX5a8NDOzPwCmErig5le8wRuzP5qDXbygcVS8NDOzP/r8WbwAQDo4NDOzP7YFmrwAQDo4NDOzP7YFmryg5le8pkqzP5qDXbzg0Ji8pkqzPwCmErgAQDo4pkqzP/aDnLwAQDo4pkqzP/aDnLyg5le891ezP5qDXbyg5le8Xja5P5qDXbzg0Ji891ezPwCmErgAQDo491ezP/aDnLwAQDo491ezP/aDnLwAQDo4Xja5P/aDnLwAQDo4Xja5P/aDnLwgW1k891ezP5qDXbwgW1k8Xja5P5qDXbwgW1k8pkqzP5qDXbwgi5k891ezPwCkErggi5k8Xja5PwCkErggi5k8pkqzPwCkErggW1k891ezP05eXDwgW1k8Xja5P05eXDwgW1k8pkqzP05eXDwAQDo491ezP0/xmzwAQDo4Xja5P0/xmzwAQDo4pkqzP0/xmzyg5le891ezP1JeXDyg5le8Xja5P1JeXDyg5le8pkqzP1JeXDygcVS8NDOzP7DXWDwAQDo4NDOzPw5zmTwg5lU8NDOzP7DXWDxQGZc8NDOzPwCkErgg5lU8NDOzP/z8Wbyg5le8YFK5P1JeXDyg5le8YFK5P1JeXDzg0Ji8Xja5PwCmErjg0Ji8YFK5PwCmErjg0Ji8YFK5PwCmErig5le8YFK5P5qDXbyg5le8YFK5P5qDXbxwkZW8YFK5PwCmErgAQDo4YFK5PwCmErjgTlO8YFK5PyqvVzzgTlO8YFK5P3TUWLwAQDo4YFK5Pwg0mbxgw1Q8YFK5P3TUWLwAQDo4YFK5P/aDnLwAQDo4YFK5P/aDnLwAQDo4YFK5P/aDnLwgW1k8YFK5P5qDXbwgW1k8YFK5P5qDXbwgi5k8YFK5PwCkErggi5k8YFK5PwCkErggW1k8YFK5P05eXDwgW1k8YFK5P05eXDzAS5Y8YFK5PwCkErhgw1Q8YFK5PyavVzwAQDo4YFK5P2OhmDwAQDo4YFK5P0/xmzwAQDo4YFK5P0/xmzwAQDo4BhStP0/xmzwAQDo4BhStP0/xmzwgW1k8BhStP05eXDwgW1k8BhStP05eXDwgi5k8BhStPwCkErggi5k8BhStPwCkErhgw1Q8BhStPyavVzxgw1Q8BhStP3TUWLwAYDo4QlsNPwCmErgAYDo4QlsNPwg0mbzQS5Y8QlsNPwCkErgAYDo4QlsNP2OhmDxwkZW8QlsNPwCmErjATlO8QlsNPyavVzzATlO8QlsNP3LUWLzA0Ji8QlsNPwCmErjA0Ji8QlsNPwCmEriA5le8QlsNP05eXDyA5le8QlsNP05eXDzA0Ji8RpMNPwCmEriA5le8QlsNP5iDXbyA5le8QlsNP5iDXbyA5le8RpMNP5iDXbwAYDo4QlsNP/aDnLwAYDo4QlsNP/aDnLwAYDo4QlsNP/aDnLxgW1k8QlsNP5qDXbxgW1k8QlsNP5qDXbwAYDo4RpMNP/aDnLwAYDo4RpMNP/aDnLxgW1k8RpMNP5qDXbwAYDo4E1AZP/aDnLwAYDo4E1AZP/aDnLwAYDo4uGoZP/aDnLwAYDo4uGoZP/aDnLyA5le8E1AZP5iDXbxgW1k8E1AZP5qDXbxgW1k8uGoZP5qDXbwwi5k8E1AZPwCkErgwi5k8RpMNPwCkErgwi5k8uGoZPwCkErhgW1k8E1AZP05eXDxgW1k8RpMNP05eXDxgW1k8uGoZP05eXDwAYDo4E1AZP0/xmzwAYDo4RpMNP0/xmzwAYDo4uGoZP0/xmzyA5le8E1AZP05eXDyA5le8RpMNP05eXDyA5le8uGoZP05eXDzA0Ji8E1AZPwCmErjA0Ji8uGoZPwCmErjwXpa8nJkZPwCmEriA5le8uGoZP5iDXbxgcVS8nJkZP/j8WbwAYDo4nJkZP7YFmrwAYDo4nJkZP7YFmryA5le8f8gZP5iDXbzA0Ji8f8gZPwCmErgAYDo4f8gZP/aDnLwAYDo4f8gZP/aDnLyA5le8JOMZP5iDXbyA5le88Z8lP5iDXbzA0Ji8JOMZPwCmErgAYDo4JOMZP/aDnLwAYDo4JOMZP/aDnLwAYDo48Z8lP/aDnLwAYDo48Z8lP/aDnLxgW1k8JOMZP5qDXbxgW1k88Z8lP5qDXbxgW1k8f8gZP5qDXbwwi5k8JOMZPwCkErgwi5k88Z8lPwCkErgwi5k8f8gZPwCkErhgW1k8JOMZP05eXDxgW1k88Z8lP05eXDxgW1k8f8gZP05eXDwAYDo4JOMZP0/xmzwAYDo48Z8lP0/xmzwAYDo4f8gZP0/xmzyA5le8JOMZP05eXDyA5le88Z8lP05eXDyA5le8f8gZP05eXDxgcVS8nJkZP7DXWDwAYDo4nJkZPw5zmTxA5lU8nJkZP7DXWDxgGZc8nJkZPwCkErhA5lU8nJkZP/r8WbyA5le89dclP05eXDyA5le89dclP05eXDzA0Ji88Z8lPwCmErjA0Ji89dclPwCmErjA0Ji89dclPwCmEriA5le89dclP5iDXbyA5le89dclP5iDXbxwkZW89dclPwCmErgAYDo49dclPwCmErjATlO89dclPyavVzzATlO89dclP3LUWLwAYDo49dclPwg0mbyAw1Q89dclP3TUWLwAYDo49dclP/aDnLwAYDo49dclP/aDnLwAYDo49dclP/aDnLxgW1k89dclP5qDXbxgW1k89dclP5qDXbwwi5k89dclPwCkErgwi5k89dclPwCkErhgW1k89dclP05eXDxgW1k89dclP05eXDzQS5Y89dclPwCkEriAw1Q89dclPyavVzwAYDo49dclP2OhmDwAYDo49dclP0/xmzwAYDo49dclP0/xmzwAYDo4QlsNP0/xmzwAYDo4QlsNP0/xmzxgW1k8QlsNP05eXDxgW1k8QlsNP05eXDwwi5k8QlsNPwCkErgwi5k8QlsNPwCkEriAw1Q8QlsNPyavVzyAw1Q8QlsNP3TUWLzbRgq/k0YKv442JT+kRgq/p0YKP6w2JT/CRgq/vEYKv4E2Jb9rRgq/o0YKP982Jb+kRgo/rkYKv6U2JT+rRgo/p0YKP6Q2JT+3Rgo/r0YKv5Y2Jb+tRgo/pEYKP6U2Jb8+Xyi/S18ov3oEvL79BDW/6gQ1v+fWK7X9BDW/6gQ1v+fWK7VTXyi/Ml8ov4oEvD5t7h6/Lq+UvuppOj8SZia/8sIBNFWLQj9K7h6/NK+UPgVqOj8RXyi/Z18oP68EvD6yBDW/NgU1P3yy/zSyBDW/NgU1P3yy/zQJXyi/ZV8oP94EvL497h6/Qa+UPgxqOr9BZia/EiuHMyyLQr+C7h6/T6+Uvs9pOr8wr5Q+sO4ev7FpOr8AAAAAZ2Ymvw2LQr9Dr5S+ru4ev61pOr9Vr5S+k+4eP8JpOr+JF5o1YWYmPxGLQr/Hr5Q+l+4eP6dpOr9p7h4/Oq+UPuppOr9VZiY/9sKBMhmLQr+I7h4/Pa+Uvs5pOr8/Xyg/TF8ov3kEvD7+BDU/6AQ1vwD5gzP+BDU/6AQ1vwD5gzNLXyg/RV8ov2gEvL4XXyg/bF8oP5UEvL60BDU/MQU1PwT5AzO0BDU/MQU1PwT5AzMYXyg/al8oP5AEvD5i7h4/O6+UPvBpOj9JZiY/N5MMNCWLQj937h4/Oq+Uvt1pOj92r5S+o+4ev61pOj94EJi1bWYmvwiLQj8Nr5Q+sO4ev7dpOj+mr5Q+nO4eP6hpOj/lWJQ1ZmYmPwyLQj99r5S+m+4eP7JpOj81Zly/fTiovlvaxj5ArWm/CCvAtL0a0T4eZly/xDioPoXaxj7PPm+/3C62vladVjXPPm+/3C62vladVjUAAIC/Zk0+tVfX6jUAAIC/Zk0+tVfX6jXEPm+/DS+2PpCwWjXEPm+/DS+2PpCwWjVBZly/nziovgnaxr5XrWm/zUx2tFoa0b4gZly/xjioPnnaxr5Zf5a+Z3+WvkXVaL/AeJ2+uoPJs1mXc79Pf5a+dn+WPkXVaL/dnPI0sHidvluXc7/+gpM02M3nsgAAgL8kNkS0r3idPluXc79hf5Y+cH+WvkHVaL/CeJ0+AnwUM1mXc790f5Y+Yn+WPkLVaL9IZlw/gziovv3Zxr5ZrWk/WAy4tFca0b4yZlw/yzioPinaxr7PPm8/3i62vhyZQzTPPm8/3i62vhyZQzQAAIA/ToEztWOqiTQAAIA/ToEztWOqiTTEPm8/EC+2PjYqPjTEPm8/EC+2PjYqPjRBZlw/lTiovhHaxj5WrWk/paVgtGEa0T4sZlw/0TioPjnaxj5Vf5Y+YH+WvkbVaD+6eJ0+SLKpsVqXcz98f5Y+Y3+WPkHVaD8fVWm0vXidvliXcz8AAAAAAAAAAAAAgD8Bul40vHidPlqXcz9vf5a+Z3+Wvj/VaD+deJ2+M9URNF2Xcz9uf5a+YX+WPkPVaD8xOKi+b2Zcv6LZxr61OC0ydK1pv+EZ0b4wOKg+cGZcv5nZxr6xLra+1z5vv6/DXrWxLra+1z5vv6/DXrU/kYEyAACAv+ocE7U/kYEyAACAv+ocE7WwLrY+1z5vv1z7j7SwLrY+1z5vv1z7j7SDOKi+YmZcv4/Zxj54fpK1eK1pv8kZ0T47OKg+bmZcv5bZxj6iOKg+YmZcP3nZxr4tp3e1bq1pP/IZ0b67OKi+U2ZcP5/Zxr67LrY+1z5vP4cyZDS7LrY+1z5vP4cyZDQW8QS2AACAP73BrDEW8QS2AACAP73BrDH7Lra+yD5vPz1MszT7Lra+yD5vPz1MszSwOKg+XWZcP4TZxj7WdpA1cK1pP+gZ0T6NOKi+X2ZcP4zZxj4AAAAAHE28sQAAgD89TQQ1AACAPwAAAICbjd40+sBGP+JYIT/nBDU/AQU1PwAAAIBMigw/RYoMP+JYIT8AAIA/AAAAAAAAAID+wEY/AAAAAN9YIT/mBDU/AQU1vwAAAIBQigw/Q4oMv+FYIT8AAAAAAACAvwAAAIAAAAAA/MBGv+BYIT/mBDW/AQU1vwAAAIBQigy/Q4oMv+BYIT8AAIC/XN2ftQAAAID6wEa/kkJrteFYIT/vBDW/9wQ1PwAAAIBUigy/QooMP95YIT8AAAAAZfZhsQAAgD8AAAAAAAAAAAAAgD8AAAAAOfZhMQAAgD+OMW+z6CcDtAAAgD+ebSCpnTeKtAAAgD+FMW8zua8GtAAAgD8AAAAA07I/MwAAgD8AAAAAbpIxMwAAgD8fYpQ+GWKUPriCaT80ZqK1ntnRPneCaT/M2NE+65gaNaOCaT+cY5Q+U2KUvnKCaT91+6C1wNrRvjWCaT/UYpS+N2KUvpWCaT9G1tG+7VYWNTaDaT9WYZS+/GGUPtyCaT/iLg01yX1iP7Gk7j4AAAAAAAAAAAAAgD8+JyA/cCcgP5Wk7j7EfWI/zMmbMsik7j5wJyA/Kicgv8Ok7j5ZvEI0qn1ivy+l7j5eJyC/GycgvyCl7j60fWK/ov+4NAil7j4zJyC/WCcgP/Gk7j4AAAAANE28MQAAgD8KbWOyy008swAAgD+h9oaptGDrswAAgD/IbGMyMNdTswAAgD8AAAAA/ky8sQAAgD8AAAAA5kw8sgAAgD+wWrS1Tn5iv7ui7j5xfGK/+WNeNdCp7j6nJiC/nicgv7Kl7j7AJiC/JCcgP7Cm7j4nJyA/KicgP4ql7j7OFKS12X1iP3+k7j4RJyA/nycgv4uk7j6CfWI/RyI7NcSl7j580Ak1AACAPwAAAIDuBDU/9wQ1PwAAAIAAAIA/AAAAAAAAAIDwBDU/9gQ1vwAAAIAAAAAA//9/vwAAAIDwBDW/9gQ1vwAAAIAAAIC/Xd2ftQAAAID2BDW/7wQ1PwAAAIDYRgo/okYKv4M2Jb+pRgo/pkYKP6g2Jb+qRgo/p0YKv6c2JT+yRgo/pEYKP6I2JT/NRgq/sUYKv4M2Jb+DRgq/oEYKP8w2Jb+5Rgq/mUYKv6U2JT+sRgq/pEYKP6c2JT9GXyg/Tl8ov1cEvD7xBDU/9gQ1v9D00DPxBDU/9gQ1v9D00DNZXyg/Q18ovz4EvL6c7h4/Hq+UvsRpOr9TZiY/qjOisx2LQr907h4/IK+UPuVpOr8fXyg/bl8oP3MEvL6oBDU/PQU1P0D02zOoBDU/PQU1P0D02zMfXyg/cF8oP2oEvD5g7h4/P6+UPvBpOj9JZiY/Z68UNCWLQj927h4/PK+Uvt1pOj8Fr5S+n+4ev8VpOj8AuK81YWYmvxKLQj82r5Q+qO4ev7dpOj+or5Q+mu4eP6ppOj9nrxQ2Z2YmPwyLQj9Xr5S+ou4eP7RpOj9a7h6/Lq+UPvtpOj8pZia/DSuHND+LQj907h6/J6+UvuVpOj9CXyi/Sl8ov3IEvL78BDW/6QQ1v6r2L7T8BDW/6QQ1v6r2L7RFXyi/QF8ov4wEvD4PXyi/Z18oP7YEvD6yBDW/NgU1PxfYFTWyBDW/NgU1PxfYFTUKXyi/YV8oP+cEvL5a7h6/KK+UPvlpOr9hZia/7cKBMxOLQr+n7h6/PK+UvrNpOr9Qr5Q+r+4ev6xpOr9kCRY2aWYmvwqLQr/brpS+su4ev75pOr8+r5S+qu4eP7JpOr9dApS1cGYmPwOLQr9Fr5Q+pO4eP7VpOr9RZlw/fziovuLZxr5XrWk/4jvbtFYa0b47Zlw/wjioPgzaxr7OPm8/3C62vtJUWTTOPm8/3C62vtJUWTQAAIA/0/M8tXO8fTQAAIA/0/M8tXO8fTTGPm8/Ci+2PmhMMzTGPm8/Ci+2PmhMMzRJZlw/mziovvDZxj5VrWk/amt+tGEa0T40Zlw/1TioPhfaxj5Pf5Y+X3+WvkfVaD+1eJ0+3B5UsluXcz98f5Y+YH+WPj/VaD9Ek4Q1t3idvlmXcz+FK2U0kuB8sv//fz8TaaE1tnidPlqXcz9Kf5a+aX+WvkfVaD/JeJ2+gipMNFeXcz9pf5a+YX+WPkLVaD82Zly/eziovlfaxj5ArWm/1dyUtMAa0T4fZly/wzioPoHaxj7PPm+/3C62vhH5VzXPPm+/3C62vhH5VzUAAIC/UTQ2tUO+4jUAAIC/UTQ2tUO+4jXFPm+/DC+2Pl+dVjXFPm+/DC+2Pl+dVjVBZly/nTiovgvaxr5ZrWm/1dyUtFca0b4hZly/vjioPn/axr6Nf5a+Y3+Wvj3VaL/9eJ2+cov+sU+Xc79gf5a+cn+WPkHVaL87seQ1tXidvlqXc79/D4I1AAAAAAAAgL/pvaE0uHidPluXc797f5Y+YH+WvkHVaL/keJ0+bov+MVOXc79Lf5Y+Wn+WPknVaL89OKg+bmZcv5bZxj64uOW1cK1pv+wZ0T5kOKi+YGZcv7HZxj7BLrY+1D5vv3cQb7TBLrY+1D5vv3cQb7S0D/21AACAv8iNtzO0D/21AACAv8iNtzPqLra+zD5vvw2ZQzTqLra+zD5vvw2ZQzSBOKg+YWZcv5XZxr64OK01cK1pv+gZ0b5TOKi+Z2Zcv6HZxr6bOKi+X2ZcP43Zxj7yBqA1ca1pP+UZ0T7ROKg+V2ZcP4LZxj74Lra+yj5vP6lUWTX4Lra+yj5vP6lUWTXAwSwy//9/PyKM0jTAwSwy//9/PyKM0jQOL7Y+xj5vP3kdhTQOL7Y+xj5vP3kdhTSzOKi+XGZcP4HZxr7lJ5K1da1pP84Z0b6hOKg+XGZcP4bZxr4AAAAAM048swAAgL/E4yq1AACAPwAAAICX8OY09sBGP+lYIb/oBDW/AAU1PwAAAIBQigy/R4oMP95YIb8AAIC/AAAAAAAAAID9wEa/1o3PNOBYIb/mBDW/AQU1vwAAAIBRigy/QooMv+BYIb/+ZrCyAACAvwAAAIAVBHC0+sBGv+JYIb/lBDU/AgU1vwAAAIBPigw/QooMv+JYIb8AAIA/+Z6itQAAAID6wEY/au+XteNYIb/uBDU/+QQ1PwAAAIBqigw/MYoMP9xYIb8AAAAAzLK/NAAAgL/T1bezh4IJKgAAgL8AAAAAMtLNNAAAgL+FMW8zS/bhMgAAgL8B1Lezh4IJqgAAgL9athe0WfZhswAAgL8AAAAAAAAAAAAAgL9E1rezWfZhMwAAgL9hYZS++WGUPtuCab+2eua1u9nRPnCCab9H1tG+FS0ZNTWDab+jYpS+SGKUvpqCab+ZxeW189rRvimCab9YY5Q+bGKUvnmCab/L2NE+7JgaNaWCab8WYpQ+H2KUPrmCab+SUAg1uX1iP/Kk7r6fH/+zFhdgKgAAgL8wJyC/TicgPxCl7r61fWK/BEOvNAal7r5eJyC/GicgvyKl7r4AAAAAon1iv0+l7r5uJyA/IScgv+Ok7r7EfWI/AAAAAMik7r47JyA/ZicgP7Wk7r4AAAAAAAAAAAAAgL/IbGMy+008MwAAgL+sI/+zFhdgqgAAgL+gyQ20Nn8XNAAAgL8AAAAAAAAAAAAAgL+IIf+zKH8XtAAAgL8G0wC2VH5iv6qi7r6CfWI/sbU1NcSl7r7vJiA/uCcgv6Sk7r4hJyA/MScgP4yl7r7EJiC/ICcgP7Cm7r6SdeK12X1iP3ik7r6RJiC/ricgv72l7r5yfGK/9WNeNdGp7r4LZzAyAACAPwAAAIDyBDW/9QQ1PwAAAIAAAIC/AAAAAAAAAIDwBDW/9QQ1vwAAAIDLgNyzAACAvwAAAIDwBDU/9gQ1vwAAAIAAAIA/oiiztQAAAIACBTU/5AQ1PwAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAP//fz8AAAAAAAAAAAAAgD8AAIC/AAAAAAAAAIAAAAAAAAAAAP//fz8AAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAAAAAACAPwAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAP//fz8AAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAAAAAAAAAP//fz8AAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAIA/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAP//fz8AAAAAAAAAAAAAgD8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAIA/AAAAAAAAAIAAAAAAAAAAAP//fz8AAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAID//3+/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAID//3+/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAP//fz8AAAAAAAAAAAAAgD8AAAAAAACAvwAAAIAAAAAAAAAAAP//fz8AAAAAAAAAAAAAgD///38/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAID//38/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAP//fz8AAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAP//fz8AAAAAAAAAAAAAgD8AAAAAAACAvwAAAIAAAAAAAAAAAP//fz8AAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAAAAAAAAAP//fz8AAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAAAAAP//f78AAAAAAACAPwAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD///38/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAID//38/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAID//3+/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAAAAAACAv0lLa7YAAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIC/AAAAAAAAAIAAAAAAAACAv0lLa7YAAAAAAAAAAAAAgD8AAIC/AAAAAAAAAIAAAAAAAACAv1BLazYAAAAAAAAAAAAAgL8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAAAAAACAv1BLazYAAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL///3+/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAAAAUsOYMwAAgD///3+/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAID//38/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAAAAUsOYMwAAgD///38/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAAAAFsOYMwAAgD8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAAAAAAAAAAAAgD8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD8AAAAAFsOYMwAAgD8AAIA/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIC/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAAAAAACAvwAAAIAAAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAUsOYMwAAgD8AAAAAAACAPwAAAID//38/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD///38/AAAAAAAAAID//3+/AAAAAAAAAIAAAAAAAACAvwAAAIAAAAAAAAAAAAAAgD///3+/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAUsOYMwAAgD8AAAAAAACAPwAAAIAAAAAAAAAAAAAAgD8AAAAAFsOYMwAAgD8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAIAAAAAAAACAv0lLa7YAAAAAAAAAAAAAgD8AAIA/AAAAAAAAAIAAAIC/AAAAAAAAAIAAAAAAAACAv0lLa7YAAAAAAAAAAAAAgD8AAIC/AAAAAAAAAIAAAAAAAAAAAAAAgD8AAAAAFsOYMwAAgD8AAAAAAACAPwAAAIAAAIC/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIC/AAAAAAAAAIAAAAAAAACAv1BLazYAAAAAAAAAAAAAgL8AAAAAAACAv1BLazYAAAAAAAAAAAAAgL8AAIA/AAAAAAAAAIAAAAAAAAAAAAAAgL8AAAAAAACAPwAAAIAAAIA/AAAAAAAAAICUmqc1AACAvwAAAID5a+83AACAvwAAAIDc4Xw1AACAvwAAAICD+aKsAACAvwAAAIA49+W4AACAvwAAAIAhzuQ3AACAvwAAAIAiwOi4AACAvwAAAIDGhka/eqAhvwAAAIDGhka/eqAhvwAAAICpgg2//Vkhv+mOCz+pgg2//Vkhv+mOCz8AAIC/AAAAAAAAAIAviA2/CFchv7qMC78viA2/CFchv7qMC79kRja/AAAAAELBM7/BVug36Qwhv47+Rr/BVug36Qwhv47+Rr/BVug36Qwhv47+Rr98hA0/4lghv1SOC798hA0/4lghv1SOC7+R6zAyAAAAAAAAgL+R6zAyAAAAAAAAgL9pRjY/AAAAAD/BM7+87DAyAAAAAAAAgL+87DAyAAAAAAAAgL9v7iI2kTpDPudNe79v7iI2kTpDPudNe78ESTa/AAAAAJq+M7+qRzY/AAAAAPm/M79W4DI/BL1BPs6dML///38/AAAAAN3rjjQAAIA/AAAAAMXrjjR+cns/GENAPuqQkralRzY/AAAAAP6/Mz/KRjY/AAAAANzAMz+i4DI/57tBPpOdMD/Lghk4AAAAAAAAgD/n6zC0AAAAAAAAgD/YuSQ4wDlDPvJNez/2RTa/AAAAALPBMz/NRja/AAAAANrAMz/f3TK/LsBBPhOgMD8AAIC/AAAAADx6+Dczcnu/PUlAPlAVBDgAAIC/ipHktjebLLMJ4TK/HcBBPuKcML8QnDa/++6dtzpqM78cSAe39SALuAAAgL8cSAe39SALuAAAgL+c3jK/+MNBvhOfML8pcnu/AkpAvocju7JNoyG38T9DvqZNe79NoyG38T9DvqZNe7/5RTa/AAAAALLBM79nRja/AAAAAEDBM78AAIC/AAAAAN7rjrRW6zAyAAAAAAAAgL9W6zAyAAAAAAAAgL+U6zAyAAAAAAAAgL+U6zAyAAAAAAAAgL/7RTY/AAAAAK/BM79qRjY/AAAAAD3BM78r3jI/iMRBvnqfML///38/AAAAAAAAAIAAAIA/AAAAAAAAAIAqcns/6UlAvgAAAID8RTY/AAAAAK7BMz9sRjY/AAAAAD7BMz8r3jI/h8RBvnqfMD/Sxhi4AAAAAAAAgD/wcrY0AAAAAAAAgD95b/e3O0FDvpVNez+pRza/AAAAAPq/Mz9mRja/AAAAAEDBMz+J3zK/c8RBvhqeMD9Dmza/Dla9twxrMz/jIjc38wUbuP//fz+VnDY/7/AXuLRpMz8AAIA/U+MGuI3TorZKnDY/XuECuP9pM781gw2/hlkhP+OOCz81gw2/hlkhP+OOCz8AAIC/AAAAAMfrjrTeg0a/DKQhPwAAAIDeg0a/DKQhPwAAAIA0gw2/hlkhP+KOC780gw2/hlkhP+KOC7+OLUO1AACAPwAAAIDMWwE2AACAPwAAAIDMC8K1AACAPwAAAIAAAAAAAACAPwAAAIAumWS4AACAPwAAAICNECy5AACAPwAAAICQRWi46QwhP47+Rr+QRWi46QwhP47+Rr+QRWi46QwhP47+Rr+rew0/UF0hPymSC7+rew0/UF0hPymSC7/3gEY/m6chPwAAAID3gEY/m6chPwAAAIA0gw0/hlkhP+KOCz80gw0/hlkhP+KOCz9uZuG4AACAPwAAAIDRC0I2AACAPwAAAIC94UA1AACAPwAAAIAAAAAA6wwhP4z+Rj8AAAAA6wwhP4z+Rj9aSc4sSg0hv0H+Rj9aSc4sSg0hv0H+Rj+pgg0//lkhv+mOCz+pgg0//lkhv+mOCz/gg0Y/DKQhvwAAAIDgg0Y/DKQhvwAAAIAfzuS3AACAvwAAAICQhPQ3AACAvwAAAIDoWhy1AACAvwAAAIC93mi3AACAvwAAAIAi7qKzAACAvwAAAIDH4cC0AACAvwAAAIBwLcO0AACAvwAAAIDQC0K1AACAvwAAAIDlzWS3AACAvwAAAIDcg0a/EKQhvwAAAIDcg0a/EKQhvwAAAICcgw2/bVkhv5eOCz+cgw2/bVkhv5eOCz8AAIC/AAAAAL7rDrRBhA2/HFkhv0+OC79BhA2/HFkhv0+OC7+lRja/AAAAAAHBM7+Upve2MQ0hv1T+Rr+Upve2MQ0hv1T+Rr+Upve2MQ0hv1T+Rr8shA0/aVkhvwqOC78shA0/aVkhvwqOC79TCYU2AAAAAAAAgL9TCYU2AAAAAAAAgL//RjY/AAAAAKfAM78briC3AAAAAAAAgL8briC3AAAAAAAAgL8b+Iq2ckFDPpNNe78b+Iq2ckFDPpNNe78DRza/AAAAAKLAM7+TRjY/AAAAABPBM7913jI/GshBPvKeML8AAIA/AAAAABbqmTMAAIA/AAAAANV9cDbWcXs/wlBAPun8QLb+RjY/AAAAAKfAMz+hRjY/AAAAAAbBMz+t3jI/u8dBPsCeMD+In9e0AAAAAP//fz/uF9K0AAAAAAAAgD+kjI2zA0JDPoxNez9WRja/AAAAAFLBMz+mRja/AAAAAP/AMz/23TK/d8dBPn2fMD8AAIC/AAAAAGHRdTf1cXu/NU5APlb2uzcAAIC/uaqbt3ybLDNO3zK/y8VBPj+eML+wmza/fyfJt5xqM7+3kWA18P+EtwAAgL+3kWA18P+EtwAAgL8J3zK/v8pBvi6eML/IcXu/91FAviCY3rYEkrC2E0VDvmZNe78EkrC2E0VDvmZNe78GRza/AAAAAKDAM7+nRja/AAAAAP/AM78AAIC/AAAAAKbrDjQoGNK0AAAAAP//f78oGNK0AAAAAP//f7/uF9K0AAAAAAAAgL/uF9K0AAAAAAAAgL//RjY/AAAAAKbAM7+hRjY/AAAAAAbBM79A3zI/Z8lBvg6eML8AAIA/AAAAABbqGbQAAIA/AAAAAL7rDrTIcXs/9lFAvkRT3zYBRzY/AAAAAKXAMz+jRjY/AAAAAATBMz/P3jI/DstBvmOeMD+In9e0AAAAAP//fz/uF9K0AAAAAAAAgD/wocK0PUVDvmNNez8DRza/AAAAAKLAMz+lRja/AAAAAAHBMz9H3zK/aslBvgeeMD9Amza/oo0Ttw5rMz/0g5ezsfRvtwAAgD/NmjY/URmKt4NrMz8AAIA/c/MAt96XjTaJmzY/kGTvtsNqM7/4gg2/wFkhP96OCz/4gg2/wFkhP96OCz8AAIC/AAAAAL/rDjTcg0a/EKQhPwAAAIDcg0a/EKQhPwAAAIBBhA2/HFkhP0+OC79BhA2/HFkhP0+OC78WYhI1AACAPwAAAIC2CcI1AACAPwAAAIDBvV43AACAPwAAAIBsjEy3AACAPwAAAIBQnBA1AACAPwAAAIBUvl43AACAPwAAAIA3T6O0Gg0hP2j+Rr83T6O0Gg0hP2j+Rr83T6O0Gg0hP2j+Rr89hA0/GlkhP1OOC789hA0/GlkhP1OOC79mgkY/2KUhPwAAAIBmgkY/2KUhPwAAAIAcgQ0/rVohP6+PCz8cgQ0/rVohP6+PCz+1rWO4AACAPwAAAIAqrmK4AACAPwAAAICip3A3AACAPwAAAICJPGM3HA0hP2j+Rj+JPGM3HA0hP2j+Rj83T6O0HA0hv2j+Rj83T6O0HA0hv2j+Rj+Zgw0/bVkhv5uOCz+Zgw0/bVkhv5uOCz/pg0Y//qMhv8tKtzbpg0Y//qMhv8tKtzYAAAAAAACAvwAAAIBa/CG0AACAvwAAAICMSkw+OAZ3PwTHWT6bqnQ/SSWWPrYJeD+J45w+VGV6PwS5VT5TZXo/bDVjPrYJeD+J3Jo+map0P7maoT44Bnc/72mUPu8weD9MqkM+i6R2PyPVkT5ia3g/3NNIPv/edj+0uU4+/ld2P0xcUj7BmnU/lGJWPiYBdT/sY1o+7sxzP7RNWz6JgnI/1aadPmWNfD/5MZ0+AEN7P0kxmz7IDno/JS6ZPi11eT/VXJc+8Ld4Pw2AmT5gRnU/lQWYPgovdj9d0pY+mzB3P/U/nj6OyXk/cbqfPuXgeD+p7aA+Ud93PzFjoD7+V3Y/4ZGePr+adT+xjpw+JgF1PyQcVT4AQ3s/TDJUPmWNfD8xGZo+iYJyPw2Omj7tzHM/GVajPgHfdj+81Ws+ZGt4P+HqpT6NpHY/NKxmPu8weD9cxmA+8rd4P7QjXT4vdXk/bB1ZPsoOej+8pE0+Ud93PzQLUD7l4Hg/FABTPo/JeT9U22E+oDB3P+R0Xz4JL3Y/7H9cPmJGdT8cO0s+sJt1P1SNTz6+mXQ/DNJUPnjucz8kTUY+s9Z0P4kmkz46OXo/pOFLPtRJcz/R8JU+GsZ7P+SeUz6JgnI/fc+ZPmWNfD+LnZU+QXR5P6XGlz4udno/BWmaPnYhez9Nopg+XdF3P11+mj7OhHg/0XKcPtUmeT9R5pk+Jdd2PwXgmz72h3c/sdmdPso4eD8xTZs+Gul1P6lBnT4gi3Y/uR2fPpI+dz8BV50+d+5zP1X5nz68mXQ/eSKiPq6bdT8U4Vs+ZY18P4nwnT6JgnI/VJ5jPhzGez81z6E+0klzP+wyaT48OXo/fZmkPrXWdD/8rVo+eCF7P6TyXz4ydno/9ERkPkN0eT9kmlY+1SZ5P0yDWj7OhHg/ZDtePl/Rdz+szFM+yTh4PwzAVz74h3c/VLNbPiXXdj+ERFE+kT53P7T8VD4gi3Y/nOVYPhzpdT8JrZQ+d8x2P5EDlj5Le3U/dQeYPrtmdD9MqkM+O5B4PyPVkT6xf3Y/bMdGPo5/ej/BY5M+X5B0P/T6TD6z5Hs/gX2WPj0rcz/8WUk+d0N4PxQHTD6klHk/3A5QPjGpej/9EqM+d0N4P3W8oT6hlHk/mbifPjGpej+81Ws+sn92P+HqpT4+kHg/lLhoPmCQdD9FXKQ+kH96PwyFYj48K3M/jUKhPrLkez8MJmY+esx2P9x4Yz5Oe3U/JHFfPr1mdD+R5eA+x3l2P12Q2j7IOnk/jY/dPheYeD9ppto+dSp1P82m3T6exXU/+W/gPuZXcj+9tuE+idJzP1l+6D7oUXI/NVDnPh7Vcz/VWO4+2C51P81V6z4U2HU/1VjuPjlSeT+ZSes+37Z4P9116D5PMHw/dS7nPoiuej/xReA+XSl8PyV/4T47pXo/XfHdPtTVdT990t0+4op4P0XR4T6R83M//TPnPrz4cz99Dus+fed1P8H96j6ipng//RPnPvOMej/Jn+E+nX96P1Ej4T6xh3Y/1RThPrLldz+NGOM+LJR1P9Ha5T4OlnU/CcznPqCRdj8Nwuc+W/J3P43I5T4H53g/jQLjPvnieD/hWOM+U4B3P23T4D6x8nc/QVLjPtkIdz8hAOQ+MLV2PxHa5D4yrHY/LYPlPnr6dj/5k+U+JHN3P03h5D5fwXc/yQTkPp7Ldz8pAOM+sXV1P4X05T5bdnU/hQ3oPmWEdj9tAOg+UQB4P+ng5T7LBXk/aejiPqwCeT/1ouc+7Zl2P2W55T7b03g/JZvnPp7pdz/ZEuM+Jc94P91J4T5pkHY/1T3hPojddz/ZyuU+4Kl1P7kn4z4wp3U/vVjdPgmkeD9Zb90+srp1P9We4T6At3M/aWXnPkW5cz8Bjes+tMt1PxGC6z7MwXg/aUbnPgrKej8paeE+O8F6P4LjhD6bqnQ/tpqJPrYJeD+K3LI+m6p0P0olrj62CXg/jEp8PjYGdz+G3II+VGV6P7qauT47Bnc/euO0PlNlej8OjrI+7MxzP9qmhT6JgnI/MhmyPomCcj/uMYU+7cxzP/I/hj5gRnU/crqHPgcvdj+q7Yg+njB3PxpWiz7tMHg/3uqNPmJreD8j1ak+YWt4P+9prD7vMHg/XtKuPp4wdz+WBbA+CS92Pw6AsT5fRnU/MmO4Pv5Xdj/akbY+wJp1P7KOtD4mAXU/0lyvPvK3eD8eLrE+L3V5P0oxsz7IDno/9j+2Po/JeT9yurc+5eB4P6rtuD5T33c/3NN4Pv3edj9MqnM+i6R2P+LqvT6NpHY/Gla7Pv/edj/6MbU+AkN7PyYZgj5ljXw/1qa1PmWNfD8SjoI+AEN7PwqAgT6MyXk/mgWAPuXgeD+8pH0+Ud93P0oxgz4kAXU/Ji6BPr+adT+0uX4+/Fd2P7aOhD7IDno/4pGGPi11eT8uY4g+8Ld4P5K4hz67ZnQ/bryJPkt7dT/+Eos+d8x2P4ZCiT49K3M/gn2uPjwrcz9KXIw+X5B0P8Fjqz5gkHQ/3uqNPrF/dj8j1ak+sX92P3YHsD69ZnQ/kgOuPk57dT8Jraw+eMx2Pz5Nsz4c6XU/UuaxPiXXdj9OorA+XdF3P6pBtT4gi3Y/BuCzPvaHdz9efrI+zoR4P7odtz6RPnc/qtm1Psk4eD/ScrQ+1SZ5P/4Suz55Q3g/dry5PqSUeT+SuLc+NKl6P0yqcz47kHg/4uq9Pj6QeD9sx3Y+jn96P0ZcvD6Qf3o/9Pp8PrLkez+OQrk+teR7P/xZeT51Q3g/FAd8PqGUeT9uB4A+Mal6P0qigD6PPnc/VuaBPso4eD8yTYM+0iZ5P2J+gj4gi3Y/BuCDPvaHdz+mQYU+zoR4P85yhD4a6XU/stmFPiXXdj+6HYc+XdF3PwJXtT547nM/Vvm3Pr6ZdD96Iro+sJt1P3LPgT6JgnI/ivC1PomCcj+k4Xs+1UlzPyrPuT7USXM/JE12PrPWdD92mbw+tdZ0PwZpgj537nM/VI1/Pr6ZdD8cO3s+sJt1PwZpsj52IXs/psavPjB2ej+Lna0+QHR5P4rwhT5ljXw/fs+xPmWNfD82z4k+GsZ7P9LwrT4axns/fpmMPjo5ej+JJqs+OTl6P/5WhT52IXs/UvmHPi52ej9yIoo+QXR5P4jjyD7Pd3Y/l5DCPl46eT9Zj8U+l5d4P+Wlwj7GKHU/h6XFPunDdT9wccg+PFZyP2S2yT7l0HM/eIHQPpVScj/YUc8+ENVzP5xY1j6fMHU/SFfTPhzZdT+cWNY+slF5P/BL0z7ptng/MHrQPqIvfD+sM88+dK56P4RJyD4VKXw/vILJPjKlej9p8MU+KtR1P6PSxT4+ing/BNHJPhrycz+ANc8+0vhzP9QP0z6c6HU/8P/SPrKmeD8YGc8+wYx6P4yjyT5mf3o/SCHJPq6Fdj/EFck+wON3P6wWyz5Fk3U/UNrNPuyWdT98zs8+dZN2P9jFzz4h83c/+M7NPrPmeD/YBss+zuF4P9Rayz7Zenc/XNTIPuDwdz8oSss+9wN3P+jzyz7MsnY/YNfMPje0dj+wic0+Vv52P/CXzT6+dHc/iO7MPvO/dz/oC8w+vMd3P5T+yj6zdHU/KPTNPid3dT/wD9A+IYZ2PwQE0D4CAXg/IOfNPoAFeT+Y7Mo+nAF5P0ylzz7hm3Y/7L/NPoHTeD8En88+aup3PywXyz7ezXg/1EfJPl6Odj/YPsk+ddt3PzTKzT7fqnU/oCXLPlimdT+DWMU+o6N4P/dtxT4NuXU/bJ7JPta1cz8YZ88+KrlzP3CO0z6qzHU/XITTPr3BeD+4S88+8cl6P9RsyT5BwXo/xohJP45zfT9fbj4/SfB7P9VaST+8fno/1VpJP7x+ej8UkHg/jXN9P9VaST/NJgM/1VpJP80mAz9fbj4/hgZcP8aIST/kpnw/p8o/P0nwez+ZF3k/vH56P5kXeT+8fno/FJB4P+SmfD+ZF3k/zSYDP5kXeT/NJgM/p8o/P4YGXD9fbj4/hgZcP5kXeT+8fno/mRd5P7x+ej/GiEk/5KZ8P5kXeT/NJgM/mRd5P80mAz9fbj4/SfB7PxSQeD/kpnw/p8o/P4YGXD/VWkk/vH56P9VaST+8fno/xohJP45zfT/VWkk/zSYDP9VaST/NJgM/p8o/P0nwez8UkHg/jXN9P20MYT+Oc30/1VpJP8TSPj/VWkk/xNI+P20MYT/kpnw/mRd5P8TSPj+ZF3k/xNI+P9VaST/E0j4/1VpJP8TSPj9tDGE/jXN9P5kXeT/E0j4/mRd5P8TSPj9tDGE/5KZ8P6jxdD/TrDo/6s5CP4YGXD8olUA/SfB7P+rOQj9J8Hs/qPF0P8BMBz+o8XQ/wEwHPyiVQD+GBlw/90RAP4YGXD/qzkI/hgZcP8eATT/ATAc/x4BNP8BMBz/3REA/SfB7P8eATT/TrDo/6s5CP0nwez8olUA/SfB7P6jxdD/TrDo/eWZCP0nwez8olUA/hgZcP3lmQj+GBlw/qPF0P8BMBz+o8XQ/wEwHP31mQj9J8Hs/x4BNP8BMBz/HgE0/wEwHP/dEQD+GBlw/x4BNP9OsOj95ZkI/hgZcP/dEQD9J8Hs/KJVAP0nwez+o8XQ/yFh2P6jxdD/IWHY/eWZCP0nwez8olUA/hgZcP3lmQj+GBlw/qPF0P7b4Qj+o8XQ/tvhCP3lmQj9J8Hs/x4BNP7b4Qj/HgE0/tvhCP/dEQD+GBlw/x4BNP8hYdj/HgE0/yFh2P3lmQj+GBlw/90RAP0nwez+r8XQ/yFh2P6vxdD/IWHY/6s5CP4YGXD8olUA/SfB7P+rOQj9J8Hs/qPF0P7b4Qj+o8XQ/tvhCPyiVQD+GBlw/90RAP4YGXD/qzkI/hgZcP8eATT+2+EI/x4BNP7b4Qj/3REA/SfB7P8eATT/IWHY/x4BNP8hYdj/qzkI/SfB7P1DgQD9J8Hs/RNI9Pxnsez9jJHM/FEY4P1DgQD+GBlw/YyRzP0w9CT9E0j0/MBlcP4xLTz9MPQk/RNI9Pxnsez/tMkE/hgZcP0TSPT8uGVw/jEtPPxRGOD/tMkE/SfB7P0adQT+GBlw/YyRzPxRGOD9Q4EA/SfB7P2Mkcz9MPQk/N2Y9Pxnsez9Q4EA/hgZcP+0yQT+GBlw/jEtPP0w9CT83Zj0/MBlcP+0yQT9J8Hs/Rp1BP0nwez+MS08/FEY4P0adQT+GBlw/YyRzP8VZdD9Q4EA/SfB7P2Mkcz/+UEU/Rp1BP0nwez9Q4EA/hgZcP+0yQT+GBlw/jEtPP/5QRT9GnUE/hgZcP+0yQT9J8Hs/Rp1BP0nwez+MS08/xVl0P1DgQD9J8Hs/RNI9Pxnsez9jJHM/xVl0P1DgQD+GBlw/YyRzP/5QRT9E0j0/MBlcP4xLTz/+UEU/RNI9Pxnsez9Q4EA/SfB7P0TSPT8uGVw/jEtPP8dZdD9Q4EA/hgZcP3lmQj9J8Hs/n5ZFP875WT/3REA/hgZcP5+WRT/7On0/eWZCP4YGXD/3REA/SfB7PyiVQD9J8Hs/2bY6P/s6fT95ZkI/SfB7PyiVQD+GBlw/eWZCP4YGXD/Ztjo/zvlZP/dEQD+GBlw/6s5CP4YGXD+flkU/zvlZP5+WRT/O+Vk/90RAP0nwez+flkU/+zp9P+rOQj9J8Hs/2bY6P/s6fT/qzkI/hgZcPyiVQD9J8Hs/6s5CP0nwez/Ztjo/zvlZP9m2Oj/O+Vk/KJVAP4YGXD/3REA/hgZcP+rOQj+GBlw/n5ZFP875WT+flkU/zvlZP/dEQD9J8Hs/n5ZFP/s6fT/qzkI/SfB7P9m2Oj/7On0/6s5CP4YGXD8olUA/SfB7P+rOQj9J8Hs/2bY6P875WT/Ztjo/zvlZPyiVQD+GBlw/eWZCP0nwez+flkU/zvlZP/dEQD+GBlw/n5ZFP/s6fT95ZkI/hgZcP/dEQD9J8Hs/KJVAP0nwez/Ztjo/+zp9P3lmQj9J8Hs/KJVAP4YGXD95ZkI/hgZcP9m2Oj/O+Vk/7TJBP4YGXD9FbEU/UEtaPzdmPT8wGVw/7TJBP0nwez83Zj0/Gex7P0VsRT946Xw/N2Y9Py4ZXD8z4To/eOl8P1DgQD9J8Hs/M+E6P1BLWj83Zj0/Gex7P1DgQD+GBlw/RWxFP1BLWj9FbEU/UEtaP0TSPT8Z7Hs/7TJBP4YGXD+fCUI/hgZcP0VsRT946Xw/7TJBP0nwez9Q4EA/SfB7P58JQj9J8Hs/M+E6P3jpfD9Q4EA/hgZcPzPhOj9QS1o/M+E6P1BLWj9E0j0/MBlcP0VsRT9QS1o/RWxFP1BLWj+fCUI/SfB7P+0yQT+GBlw/nwlCP4YGXD9FbEU/eOl8P+0yQT9J8Hs/UOBAP0nwez+fCUI/SfB7PzPhOj946Xw/UOBAP4YGXD8z4To/UEtaPzPhOj9QS1o/nwlCP4YGXD/tMkE/hgZcP0VsRT9QS1o/N2Y9PzAZXD/tMkE/SfB7PzdmPT8Z7Hs/RWxFP3jpfD83Zj0/LhlcPzPhOj946Xw/7TJBP4YGXD8z4To/UEtaPzdmPT8Z7Hs/7TJBP0nwez8O/Cc+MOR2Pw78Jz4DnnI/vhQ5PjDkdj8O/Cc+Xip7P1rjFj4w5HY/PuUbPuPpeT8+5Rs+fN5zP0Ap+DvJsXQ/ioQWPjDkdj9AKfg7Su11PzaiGz6m+nk/uPNUPcmxdD9AKfg7R3ZzPzaiGz66zXM/uPNUPUd2cz9AKfg7xTpyP0Ap+DvUFnw/DvwnPlCGcj9AKfg7Udt6P+JVND66zXM/uPNUPcU6cj+481Q91BZ8P7jzVD1R23o/BN+APcU6cj8E34A91BZ8PyxElz3FOnI/LESXPdQWfD8E34A9R3ZzPwTfgD1R23o/LESXPVHbej8E34A9z595P7jzVD3Pn3k/LESXPc+feT8E34A9TmR4P7jzVD1OZHg/LESXPU5keD8E34A9zCh3P7jzVD3MKHc/LESXPcwodz8E34A9Su11P7jzVD1K7XU/LESXPUrtdT8E34A9ybF0PyxElz3JsXQ/hPWXPcmxdD8sRJc9R3ZzP4T1lz1HdnM/fPWXPdQWfD+E9Zc9xTpyP9ymmD1HdnM/3KaYPcmxdD/cppg9xTpyP9ymmD3UFnw//AuvPUd2cz8cccU9R3ZzP/wLrz3JsXQ//AuvPcU6cj/8C6891BZ8PxxxxT3FOnI/HHHFPdQWfD/8C689Udt6PxxxxT1R23o/3KaYPVHbej/8C689z595PxxxxT3Pn3k/3KaYPc+feT/8C689TmR4PxxxxT1OZHg/3KaYPU5keD/8C689zCh3PxxxxT3MKHc/3KaYPcwodz/8C689Su11PxxxxT1K7XU/3KaYPUrtdT+E9Zc9Su11P3z1lz3MKHc/fPWXPU5keD989Zc9z595P3z1lz1R23o/MjQQPkrtdT82ohs+pvp5PxxxxT3JsXQ/MjQQPsmxdD+KhBY+MOR2PzI0ED5HdnM/NqIbPrrNcz9a4xY+MOR2Pw78Jz4w5HY/PuUbPuPpeT8+5Rs+fN5zPw78Jz4DnnI/2hI0Pnzecz8yNBA+xTpyPzI0ED7UFnw/DvwnPlCGcj8yNBA+Udt6P+ZVND66zXM/MjQQPs+feT+Sczk+MOR2PzI0ED5OZHg/5lU0Pqb6eT++FDk+MOR2P9oSND7j6Xk/DvwnPl4qez8yNBA+zCh3Pw78Jz4RQns/QCn4O8wodz8O/Cc+EUJ7P0Ap+DtOZHg/4lU0Pqb6eT9AKfg7z595P5JzOT4w5HY/2hI0PuPpeT/aEjQ+fN5zPw78Jz4w5HY/DvwnPgOecj++FDk+MOR2Pw78Jz5eKns/WuMWPjDkdj8+5Rs+4+l5Pz7lGz593nM/QCn4O8mxdD+KhBY+MOR2P0Ap+DtK7XU/NqIbPqX6eT+481Q9ybF0P0Ap+DtHdnM/NqIbPrvNcz+481Q9R3ZzP0Ap+DvFOnI/QCn4O9QWfD8O/Cc+UIZyP0Ap+DtR23o/4lU0PrvNcz+481Q9xTpyP7jzVD3UFnw/uPNUPVHbej8E34A9xTpyPwTfgD3UFnw/LESXPcU6cj8sRJc91BZ8PwTfgD1HdnM/BN+APVHbej8sRJc9Udt6PwTfgD3Pn3k/uPNUPc+feT8sRJc9z595PwTfgD1OZHg/uPNUPU5keD8sRJc9TmR4PwTfgD3MKHc/uPNUPcwodz8sRJc9zCh3PwTfgD1K7XU/uPNUPUrtdT8sRJc9Su11PwTfgD3JsXQ/LESXPcmxdD+E9Zc9ybF0PyxElz1HdnM/hPWXPUd2cz989Zc91BZ8P4T1lz3FOnI/3KaYPUd2cz/cppg9ybF0P9ymmD3FOnI/3KaYPdQWfD/8C689R3ZzPxxxxT1HdnM//AuvPcmxdD/8C689xTpyP/wLrz3UFnw/HHHFPcU6cj8cccU91BZ8P/wLrz1R23o/HHHFPVHbej/cppg9Udt6P/wLrz3Pn3k/HHHFPc+feT/cppg9z595P/wLrz1OZHg/HHHFPU5keD/cppg9TmR4P/wLrz3MKHc/HHHFPcwodz/cppg9zCh3P/wLrz1K7XU/HHHFPUrtdT/cppg9Su11P4T1lz1K7XU/fPWXPcwodz989Zc9TmR4P3z1lz3Pn3k/fPWXPVHbej8yNBA+Su11PzaiGz6k+nk/HHHFPcmxdD8yNBA+ybF0P4qEFj4w5HY/MjQQPkd2cz82ohs+us1zP1rjFj4w5HY/DvwnPjDkdj8+5Rs+4+l5Pz7lGz583nM/DvwnPgOecj/aEjQ+fN5zPzI0ED7FOnI/MjQQPtQWfD8O/Cc+UIZyPzI0ED5R23o/5lU0PrrNcz8yNBA+z595P5JzOT4w5HY/MjQQPk5keD/mVTQ+pPp5P74UOT4w5HY/2hI0PuPpeT8O/Cc+Xip7PzI0ED7MKHc/DvwnPhFCez9AKfg7zCh3Pw78Jz4RQns/QCn4O05keD/iVTQ+pfp5P0Ap+DvPn3k/knM5PjDkdj/aEjQ+4+l5P9oSND593nM/MAAxADUAMAA1ADMAMQAyADcAMQA3ADUANAA2ADoANAA6ADkANgA4ADsANgA7ADoAAAAMADAAAAAwAAsADAANADEADAAxADAADQAOADIADQAyADEADgABAA8ADgAPADIAMgAPABAAMgAQADcAOAARABIAOAASADsAOwASAAMAOwADABMAOgA7ABMAOgATABQAOQA6ABQAOQAUABUACAA5ABUACAAVAAIACgA0ADkACgA5AAgACwAwADMACwAzAAkAPAA9AEAAPABAAD8APQA+AEEAPQBBAEAAPwBAAEMAPwBDAEIAQABBAEQAQABEAEMAAgAVADwAAgA8ABgAFQAUAD0AFQA9ADwAFAATAD4AFAA+AD0AEwADABkAEwAZAD4APgAZABoAPgAaAEEAQQAaABsAQQAbAEQARAAbAAcARAAHABwAQwBEABwAQwAcAB0AQgBDAB0AQgAdAB4AFgBCAB4AFgAeAAYAFwA/AEIAFwBCABYAGAA8AD8AGAA/ABcARQBGAEsARQBLAEkARgBHAE0ARgBNAEsASABKAE8ASABPAE4ASgBMAFAASgBQAE8ABgAeAEUABgBFACIAHgAdAEYAHgBGAEUAHQAcAEcAHQBHAEYAHAAHACMAHAAjAEcARwAjACUARwAlAE0ATAAkACYATAAmAFAAUAAmAAUAUAAFACcATwBQACcATwAnACgATgBPACgATgAoACkAHwBOACkAHwApAAQAIABIAE4AIABOAB8AIgBFAEkAIgBJACEAUQBSAFUAUQBVAFQAUgBTAFYAUgBWAFUAVABVAFgAVABYAFcAVQBWAFkAVQBZAFgABAApAFEABABRACwAKQAoAFIAKQBSAFEAKAAnAFMAKABTAFIAJwAFAC0AJwAtAFMAUwAtAC4AUwAuAFYAVgAuAC8AVgAvAFkAWQAvAAEAWQABAA4AWABZAA4AWAAOAA0AVwBYAA0AVwANAAwAKgBXAAwAKgAMAAAAKwBUAFcAKwBXACoALABRAFQALABUACsAWgBbAGAAWgBgAF4AWwBcAGIAWwBiAGAAXQBfAGQAXQBkAGMAXwBhAGUAXwBlAGQAAgAYAFoAAgBaAAgAGAAXAFsAGABbAFoAFwAWAFwAFwBcAFsAFgAGACIAFgAiAFwAXAAiACEAXAAhAGIAYQAgAB8AYQAfAGUAZQAfAAQAZQAEACwAZABlACwAZAAsACsAYwBkACsAYwArACoACwBjACoACwAqAAAACQBdAGMACQBjAAsACABaAF4ACABeAAoAZgBnAGwAZgBsAGoAZwBoAG4AZwBuAGwAaQBrAHAAaQBwAG8AawBtAHEAawBxAHAABwAbAGYABwBmACMAGwAaAGcAGwBnAGYAGgAZAGgAGgBoAGcAGQADABIAGQASAGgAaAASABEAaAARAG4AbQAQAA8AbQAPAHEAcQAPAAEAcQABAC8AcABxAC8AcAAvAC4AbwBwAC4AbwAuAC0AJgBvAC0AJgAtAAUAJABpAG8AJABvACYAIwBmAGoAIwBqACUApACiAJgApACYAJkAqgB0AHYAqgB2AKsApQCjAJoApQCaAJsAqwB2AHgAqwB4AKwAqQCmAJUAqQCVAJYArAB4AHoArAB6AK0AogCoAJcAogCXAJgArQB6AHwArQB8AK4AowCkAJkAowCZAJoArgB8AH4ArgB+AK8ApwClAJsApwCbAJMArwB+AIAArwCAALAApgCnAJMApgCTAJUAsACAAIIAsACCALEAqACpAJYAqACWAJcAsQCCAHQAsQB0AKoAhACDAHYAhAB2AHQAgwCFAHgAgwB4AHYAhQCGAHoAhQB6AHgAhgCHAHwAhgB8AHoAhwCIAH4AhwB+AHwAiACJAIAAiACAAH4AiQCKAIIAiQCCAIAAigCEAHQAigB0AIIAlAByAIMAlACDAIQAcgCcAIUAcgCFAIMAnACdAIYAnACGAIUAnQCeAIcAnQCHAIYAngCfAIgAngCIAIcAnwCgAIkAnwCJAIgAoAChAIoAoACKAIkAoQCUAIQAoQCEAIoAjACLAHIAjAByAJQAiwCNAJwAiwCcAHIAjQCOAJ0AjQCdAJwAjgCPAJ4AjgCeAJ0AjwCQAJ8AjwCfAJ4AkACRAKAAkACgAJ8AkQCSAKEAkQChAKAAkgCMAJQAkgCUAKEAjgCNAKkAjgCpAKgAiwCMAKcAiwCnAKYAjACSAKUAjAClAKcAkQCQAKQAkQCkAKMAjwCOAKgAjwCoAKIAjQCLAKYAjQCmAKkAkgCRAKMAkgCjAKUAkACPAKIAkACiAKQAgQCxAKoAgQCqAHMAfwCwALEAfwCxAIEAfQCvALAAfQCwAH8AewCuAK8AewCvAH0AeQCtAK4AeQCuAHsAdwCsAK0AdwCtAHkAdQCrAKwAdQCsAHcAcwCqAKsAcwCrAHUA4gDjAOcA4gDnAOUA4wDkAOkA4wDpAOcA5gDoAOwA5gDsAOsA6ADqAO0A6ADtAOwAsgC+AOIAsgDiAL0AvgC/AOMAvgDjAOIAvwDAAOQAvwDkAOMAwACzAMEAwADBAOQA5ADBAMIA5ADCAOkA6gDDAMQA6gDEAO0A7QDEALUA7QC1AMUA7ADtAMUA7ADFAMYA6wDsAMYA6wDGAMcAugDrAMcAugDHALQAvADmAOsAvADrALoAvQDiAOUAvQDlALsA7gDvAPIA7gDyAPEA7wDwAPMA7wDzAPIA8QDyAPUA8QD1APQA8gDzAPYA8gD2APUAtADHAO4AtADuAMoAxwDGAO8AxwDvAO4AxgDFAPAAxgDwAO8AxQC1AMsAxQDLAPAA8ADLAMwA8ADMAPMA8wDMAM0A8wDNAPYA9gDNALkA9gC5AM4A9QD2AM4A9QDOAM8A9AD1AM8A9ADPANAAyAD0ANAAyADQALgAyQDxAPQAyQD0AMgAygDuAPEAygDxAMkA9wD4AP0A9wD9APsA+AD5AP8A+AD/AP0A+gD8AAEB+gABAQAB/AD+AAIB/AACAQEBuADQAPcAuAD3ANQA0ADPAPgA0AD4APcAzwDOAPkAzwD5APgAzgC5ANUAzgDVAPkA+QDVANcA+QDXAP8A/gDWANgA/gDYAAIBAgHYALcAAgG3ANkAAQECAdkAAQHZANoAAAEBAdoAAAHaANsA0QAAAdsA0QDbALYA0gD6AAAB0gAAAdEA1AD3APsA1AD7ANMAAwEEAQcBAwEHAQYBBAEFAQgBBAEIAQcBBgEHAQoBBgEKAQkBBwEIAQsBBwELAQoBtgDbAAMBtgADAd4A2wDaAAQB2wAEAQMB2gDZAAUB2gAFAQQB2QC3AN8A2QDfAAUBBQHfAOAABQHgAAgBCAHgAOEACAHhAAsBCwHhALMACwGzAMAACgELAcAACgHAAL8ACQEKAb8ACQG/AL4A3AAJAb4A3AC+ALIA3QAGAQkB3QAJAdwA3gADAQYB3gAGAd0ADAENARIBDAESARABDQEOARQBDQEUARIBDwERARYBDwEWARUBEQETARcBEQEXARYBtADKAAwBtAAMAboAygDJAA0BygANAQwByQDIAA4ByQAOAQ0ByAC4ANQAyADUAA4BDgHUANMADgHTABQBEwHSANEAEwHRABcBFwHRALYAFwG2AN4AFgEXAd4AFgHeAN0AFQEWAd0AFQHdANwAvQAVAdwAvQDcALIAuwAPARUBuwAVAb0AugAMARABugAQAbwAGAEZAR4BGAEeARwBGQEaASABGQEgAR4BGwEdASIBGwEiASEBHQEfASMBHQEjASIBuQDNABgBuQAYAdUAzQDMABkBzQAZARgBzADLABoBzAAaARkBywC1AMQAywDEABoBGgHEAMMAGgHDACABHwHCAMEAHwHBACMBIwHBALMAIwGzAOEAIgEjAeEAIgHhAOAAIQEiAeAAIQHgAN8A2AAhAd8A2ADfALcA1gAbASEB1gAhAdgA1QAYARwB1QAcAdcAVgFUAUoBVgFKAUsBXAEmASgBXAEoAV0BVwFVAUwBVwFMAU0BXQEoASoBXQEqAV4BWwFYAUcBWwFHAUgBXgEqASwBXgEsAV8BVAFaAUkBVAFJAUoBXwEsAS4BXwEuAWABVQFWAUsBVQFLAUwBYAEuATABYAEwAWEBWQFXAU0BWQFNAUUBYQEwATIBYQEyAWIBWAFZAUUBWAFFAUcBYgEyATQBYgE0AWMBWgFbAUgBWgFIAUkBYwE0ASYBYwEmAVwBNgE1ASgBNgEoASYBNQE3ASoBNQEqASgBNwE4ASwBNwEsASoBOAE5AS4BOAEuASwBOQE6ATABOQEwAS4BOgE7ATIBOgEyATABOwE8ATQBOwE0ATIBPAE2ASYBPAEmATQBRgEkATUBRgE1ATYBJAFOATcBJAE3ATUBTgFPATgBTgE4ATcBTwFQATkBTwE5ATgBUAFRAToBUAE6ATkBUQFSATsBUQE7AToBUgFTATwBUgE8ATsBUwFGATYBUwE2ATwBPgE9ASQBPgEkAUYBPQE/AU4BPQFOASQBPwFAAU8BPwFPAU4BQAFBAVABQAFQAU8BQQFCAVEBQQFRAVABQgFDAVIBQgFSAVEBQwFEAVMBQwFTAVIBRAE+AUYBRAFGAVMBQAE/AVsBQAFbAVoBPQE+AVkBPQFZAVgBPgFEAVcBPgFXAVkBQwFCAVYBQwFWAVUBQQFAAVoBQQFaAVQBPwE9AVgBPwFYAVsBRAFDAVUBRAFVAVcBQgFBAVQBQgFUAVYBMwFjAVwBMwFcASUBMQFiAWMBMQFjATMBLwFhAWIBLwFiATEBLQFgAWEBLQFhAS8BKwFfAWABKwFgAS0BKQFeAV8BKQFfASsBJwFdAV4BJwFeASkBJQFcAV0BJQFdAScBhAFoAXABhAFwAYcBzgHQAdIBzgHSAdYBjAGDAXsBjAF7AY8B2QHbAd8B2QHfAeMBbQF8AXQBbQF0AWUBggFzAWsBggFrAXoB5QHnAesB5QHrAe8BfwGMAY8BfwGPAXcB8gH0AfYB8gH2AfoBZAGEAYcBZAGHAWwBiAFxAZQBiAGUAZABcgGBAZoBcgGaAZUBgAGKAZwBgAGcAZkBigGIAZABigGQAZwBjgF5AaQBjgGkAZ8BeAFpAaYBeAGmAaMBagGGAakBagGpAacBhgGOAZ8BhgGfAakBdgGOAbMBdgGzAa4BjQGFAbUBjQG1AbIBhgFnAbkBhgG5AbYBZgF1Aa0BZgGtAbgBbgGIAcEBbgHBAbwBiQGLAccBiQHHAcIBigF9AckBigHJAcYBfgFvAb0BfgG9AcoBlwGbAQIClwECAgUC4QHeAUYC4QFGAkMCrAGwARYCrAEWAhoC8wHwAVsC8wFbAlgCkwGYAQYCkwEGAvwB4AHcAT4C4AE+AkkCnQGRAQACnQEAAgQC2AHiAUQC2AFEAkACxAHIASoCxAEqAi0CkgGWAf4BkgH+AQEC3QHaAUIC3QFCAj8CwAHFAS4CwAEuAiQCywG+ASgCywEoAiwCqAGrARECqAERAhUC7QHqAVQC7QFUAlECvwHDASYCvwEmAikC/wH9ATEC/wExAjUC/QEHAjkC/QE5AjECBwIDAjcCBwI3AjkCAwL/ATUCAwI1AjcCDQIKAjwCDQI8AkECCwIUAkgCCwJIAj0CEwIPAkUCEwJFAkcCDwINAkECDwJBAkUCGwIYAkoCGwJKAk8CGQIiAlYCGQJWAksCIQIdAlMCIQJTAlUCHQIbAk8CHQJPAlMCJwIlAlkCJwJZAl0CJQIvAmECJQJhAlkCLwIrAl8CLwJfAmECKwInAl0CKwJdAl8C8QH5AV4C8QFeAlwCugGvARwCugEcAh4C9wH1AVoC9wFaAmICsQG0ASACsQEgAhcCzwHMATMCzwEzAjAC+wH4AWMC+wFjAmACtwG7AR8CtwEfAiMCzQHVATYCzQE2AjQC0wHRATIC0wEyAjoC6QHmAVAC6QFQAk0CngGhAQgCngEIAgwC1wHUATsC1wE7AjgC5AHuAVIC5AFSAk4CqgGgAQ4CqgEOAhAC7AHoAUwC7AFMAlcCogGlARICogESAgkCZQLWAmYCZQJmAmQCaAJqAmUCaAJlAmQCZgLVAmcCZgJnAmQCZwJpAmgCZwJoAmQCaAJpAm4CaAJuAmwCagJoAmwCagJsAnECbQKMAm8CbQJvAmsCawJvAnICawJyAnACcAJyAngCcAJ4AnMCZQJqAnECZQJxAnUC1gJlAnUC1gJ1AncCdAJ5AnoCdAJ6AnYCcgJ/AnsCcgJ7AngCfAKAAnoCfAJ6AnkCfAJ+AoECfAKBAoACkQJ9AnsCkQJ7An8CgAKCAoMCgAKDAnoCgAKBAoQCgAKEAoICggKFAoYCggKGAoMCggKEAocCggKHAoUChQKIAokChQKJAoYChQKHAooChQKKAogCiAKLAowCiAKMAokCiAKKAo0CiAKNAosCiwKOAm8CiwJvAowCiwKNAo8CiwKPAo4CjgJ/AnICjgJyAm8CjgKPApECjgKRAn8CkAKSApECkAKRAo8CrwKQAo8CrwKPAo0ClAJ9ApEClAKRApIClgKVApIClgKSApAClQKXApQClQKUApIClgKbApkClgKZApUCmQKcApcCmQKXApUCmQKaAp4CmQKeApwCmgKZApsCmgKbArYCnQKgAqICnQKiApgCnQKfAqECnQKhAqACpAKjAqACpAKgAqECogKgAqMCogKjAqUCpwKmAqMCpwKjAqQCpQKjAqYCpQKmAqgCqgKpAqYCqgKmAqcCqAKmAqkCqAKpAqsCrQKsAqkCrQKpAqoCqwKpAqwCqwKsAq4CtgKbAqwCtgKsAq0CrgKsApsCrgKbApYCrgKWApACrgKQAq8CqwKuAq8CqwKvArACrwKNAooCrwKKArACsQKwAooCsQKKAocCqAKrArACqAKwArECpQKoArECpQKxArICsgKxAocCsgKHAoQCogKlArICogKyArMCsgKEAoECsgKBArMCkwKzAoECkwKBAn4CmAKiArMCmAKzApMCtAK3ArYCtAK2Aq0CzQK0Aq0CzQKtAqoCtwK5ApoCtwKaArYCvQK7ArgCvQK4ArUCuwK+AroCuwK6ArgCvAK7Ar0CvAK9AswCvAK/Ar4CvAK+ArsCvgK/AsMCvgLDAroCvALKAsACvALAAr8CvwLAAsUCvwLFAsMCuQLBAp4CuQKeApoCwgLEAqECwgKhAp8CxALGAqQCxAKkAqECwALKAscCwALHAsUCxgLIAqcCxgKnAqQCygLLAskCygLJAscCvALMAssCvALLAsoCywLMAs4CywLOAskCzAK9ArUCzAK1As4CyALNAqoCyAKqAqcCzwKJAowCzwKMAm0C0QKGAokC0QKJAs8CZwLVAtICZwLSAtACaQJnAtACaQLQAm4C1QJmAtQC1QLUAtIC0wKDAoYC0wKGAtECZgLWAncCZgJ3AtQCdgJ6AoMCdgKDAtMC2wLdAtgC2wLYAtcC2AJJA9kC2ALZAtcC2QJIA9oC2QLaAtcC2gLcAtsC2gLbAtcC2wLcAuEC2wLhAt8C3QLbAt8C3QLfAuQC4AL/AuIC4ALiAt4C3gLiAuUC3gLlAuMC4wLlAusC4wLrAuYC2ALdAuQC2ALkAugCSQPYAugCSQPoAuoC5wLsAu0C5wLtAukC5QLyAu4C5QLuAusC7wLzAu0C7wLtAuwC7wLxAvQC7wL0AvMCBAPwAu4CBAPuAvIC8wL1AvYC8wL2Au0C8wL0AvcC8wL3AvUC9QL4AvkC9QL5AvYC9QL3AvoC9QL6AvgC+AL7AvwC+AL8AvkC+AL6Av0C+AL9AvsC+wL+Av8C+wL/AvwC+wL9AgAD+wIAA/4C/gIBA+IC/gLiAv8C/gIAAwID/gICAwEDAQPyAuUCAQPlAuICAQMCAwQDAQMEA/ICAwMFAwQDAwMEAwIDIgMDAwIDIgMCAwADBwPwAgQDBwMEAwUDCQMIAwUDCQMFAwMDCAMKAwcDCAMHAwUDCQMOAwwDCQMMAwgDDAMPAwoDDAMKAwgDDAMNAxEDDAMRAw8DDQMMAw4DDQMOAykDEAMTAxUDEAMVAwsDEAMSAxQDEAMUAxMDFwMWAxMDFwMTAxQDFQMTAxYDFQMWAxgDGgMZAxYDGgMWAxcDGAMWAxkDGAMZAxsDHQMcAxkDHQMZAxoDGwMZAxwDGwMcAx4DIAMfAxwDIAMcAx0DHgMcAx8DHgMfAyEDKQMOAx8DKQMfAyADIQMfAw4DIQMOAwkDIQMJAwMDIQMDAyIDHgMhAyIDHgMiAyMDIgMAA/0CIgP9AiMDJAMjA/0CJAP9AvoCGwMeAyMDGwMjAyQDGAMbAyQDGAMkAyUDJQMkA/oCJQP6AvcCFQMYAyUDFQMlAyYDJQP3AvQCJQP0AiYDBgMmA/QCBgP0AvECCwMVAyYDCwMmAwYDJwMqAykDJwMpAyADQAMnAyADQAMgAx0DKgMsAw0DKgMNAykDMAMuAysDMAMrAygDLgMxAy0DLgMtAysDLwMuAzADLwMwAz8DLwMyAzEDLwMxAy4DMQMyAzYDMQM2Ay0DLwM9AzMDLwMzAzIDMgMzAzgDMgM4AzYDLAM0AxEDLAMRAw0DNQM3AxQDNQMUAxIDNwM5AxcDNwMXAxQDMwM9AzoDMwM6AzgDOQM7AxoDOQMaAxcDPQM+AzwDPQM8AzoDLwM/Az4DLwM+Az0DPgM/A0EDPgNBAzwDPwMwAygDPwMoA0EDOwNAAx0DOwMdAxoDQgP8Av8CQgP/AuACRAP5AvwCRAP8AkID2gJIA0UD2gJFA0MD3ALaAkMD3AJDA+ECSAPZAkcDSANHA0UDRgP2AvkCRgP5AkQD2QJJA+oC2QLqAkcD6QLtAvYC6QL2AkYDHYXrvgAAADKCwuM9HYXrvgAAADKCwuM9HYXrvgAAADLizN69HYXrvgAAADLizN69nfvLvgAAADKCwuM9nfvLvgAAADKCwuM9nfvLvgAAADLizN69nfvLvgAAADLizN69HYXrvgAAAACsqry9HYXrvgAAAABsoME9nfvLvgAAADIsG0Q9nfvLvgAAADIsG0Q9nfvLvgAAADLsLzq9nfvLvgAAADLsLzq9XI/CvgAAADIsG0Q9XI/CvgAAADIsG0Q9XI/CvgAAADLsLzq9XI/CvgAAADLsLzq9XI/CvlC4/j/sLzq9XI/CvlC4/j/sLzq9XI/CvlC4/j/sLzq9XI/CvlC4/j/sLzq9XI/CvlC4/j8sG0Q9XI/CvlC4/j8sG0Q9XI/CvlC4/j8sG0Q9XI/CvlC4/j8sG0Q9fEXHvlDw/z9ywuM9fEXHvlDw/z9ywuM9fEXHvlDw/z9ywuM9fEXHvlDw/z9ywuM9HoXrvrgeBUBMoME9HoXrvrgeBUBMoME9HoXrvrgeBUBywuM9HoXrvrgeBUBywuM9HoXrvrgeBUBywuM9HoXrvrgeBUBywuM9fEXHvlDw/z8MG0Q9fEXHvlDw/z8MG0Q9fEXHvlDw/z8MG0Q9fEXHvlDw/z8MG0Q9fEXHvlDw/z/yzN69fEXHvlDw/z/yzN69fEXHvlDw/z/yzN69fEXHvlDw/z/yzN69fEXHvlDw/z8MMDq9fEXHvlDw/z8MMDq9fEXHvlDw/z8MMDq9fEXHvlDw/z8MMDq9HoXrvrgeBUDMqry9HoXrvrgeBUDMqry9HoXrvrgeBUDyzN69HoXrvrgeBUDyzN69HoXrvrgeBUDyzN69HoXrvrgeBUDyzN69HYXrPgAAADKCwuM9HYXrPgAAADKCwuM9HYXrPgAAADLizN69HYXrPgAAADLizN69nfvLPgAAADKCwuM9nfvLPgAAADKCwuM9nfvLPgAAADLizN69nfvLPgAAADLizN69HYXrPgAAAACsqry9HYXrPgAAAABsoME9nfvLPgAAADIsG0Q9nfvLPgAAADIsG0Q9nfvLPgAAADLsLzq9nfvLPgAAADLsLzq9XI/CPgAAADIsG0Q9XI/CPgAAADIsG0Q9XI/CPgAAADLsLzq9XI/CPgAAADLsLzq9XI/CPlC4/j/sLzq9XI/CPlC4/j/sLzq9XI/CPlC4/j/sLzq9XI/CPlC4/j/sLzq9XI/CPlC4/j8sG0Q9XI/CPlC4/j8sG0Q9XI/CPlC4/j8sG0Q9XI/CPlC4/j8sG0Q9fEXHPlDw/z9ywuM9fEXHPlDw/z9ywuM9fEXHPlDw/z9ywuM9fEXHPlDw/z9ywuM9HoXrPrgeBUBMoME9HoXrPrgeBUBMoME9HoXrPrgeBUBywuM9HoXrPrgeBUBywuM9HoXrPrgeBUBywuM9HoXrPrgeBUBywuM9fEXHPlDw/z8MG0Q9fEXHPlDw/z8MG0Q9fEXHPlDw/z8MG0Q9fEXHPlDw/z8MG0Q9fEXHPlDw/z/yzN69fEXHPlDw/z/yzN69fEXHPlDw/z/yzN69fEXHPlDw/z/yzN69fEXHPlDw/z8MMDq9fEXHPlDw/z8MMDq9fEXHPlDw/z8MMDq9fEXHPlDw/z8MMDq9HoXrPrgeBUDMqry9HoXrPrgeBUDMqry9HoXrPrgeBUDyzN69HoXrPrgeBUDyzN69HoXrPrgeBUDyzN69HoXrPrgeBUDyzN69HoXrPoYycj9coME9HoXrPoYycj9coME9XI/CPgLliD/sLzq9XI/CPgLliD/sLzq9XI/CPgLliD/sLzq9XI/CPgLliD8sG0Q9XI/CPgLliD8sG0Q9XI/CPgLliD8sG0Q9jKDJPjQ5hz8cG0Q9jKDJPjQ5hz8cG0Q9jKDJPjQ5hz8cG0Q9jKDJPjQ5hz8cG0Q9jKDJPjQ5hz/8Lzq9jKDJPjQ5hz/8Lzq9jKDJPjQ5hz/8Lzq9jKDJPjQ5hz/8Lzq9HoXrPoYycj+8qry9HoXrPoYycj+8qry9jKDJPjQ5hz96wuM9jKDJPjQ5hz96wuM9jKDJPjQ5hz96wuM9jKDJPjQ5hz96wuM9HoXrPoYycj96wuM9HoXrPoYycj96wuM9HoXrPoYycj96wuM9HoXrPoYycj96wuM9jKDJPjQ5hz/qzN69jKDJPjQ5hz/qzN69jKDJPjQ5hz/qzN69jKDJPjQ5hz/qzN69HoXrPoYycj/qzN69HoXrPoYycj/qzN69HoXrPoYycj/qzN69HoXrPoYycj/qzN69HoXrvoYycj9coME9HoXrvoYycj9coME9XI/CvgLliD/sLzq9XI/CvgLliD/sLzq9XI/CvgLliD/sLzq9XI/CvgLliD8sG0Q9XI/CvgLliD8sG0Q9XI/CvgLliD8sG0Q9jKDJvjQ5hz8cG0Q9jKDJvjQ5hz8cG0Q9jKDJvjQ5hz8cG0Q9jKDJvjQ5hz8cG0Q9jKDJvjQ5hz/8Lzq9jKDJvjQ5hz/8Lzq9jKDJvjQ5hz/8Lzq9jKDJvjQ5hz/8Lzq9HoXrvoYycj+8qry9HoXrvoYycj+8qry9jKDJvjQ5hz96wuM9jKDJvjQ5hz96wuM9jKDJvjQ5hz96wuM9jKDJvjQ5hz96wuM9HoXrvoYycj96wuM9HoXrvoYycj96wuM9HoXrvoYycj96wuM9HoXrvoYycj96wuM9jKDJvjQ5hz/qzN69jKDJvjQ5hz/qzN69jKDJvjQ5hz/qzN69jKDJvjQ5hz/qzN69HoXrvoYycj/qzN69HoXrvoYycj/qzN69HoXrvoYycj/qzN69HoXrvoYycj/qzN69BHPIPhhkyD92wuM9BHPIPhhkyD92wuM9BHPIPhhkyD92wuM9BHPIPhhkyD92wuM9HoXrPs+yuT92wuM9HoXrPs+yuT92wuM9HoXrPs+yuT92wuM9BHPIPhhkyD/uzN69BHPIPhhkyD/uzN69BHPIPhhkyD/uzN69BHPIPhhkyD/uzN69HoXrPs+yuT/uzN69HoXrPs+yuT/uzN69HoXrPs+yuT/uzN69HoXrPs+yuT9UoME9XI/CPhchyj/sLzq9XI/CPhchyj/sLzq9XI/CPhchyj/sLzq9XI/CPhchyj8sG0Q9XI/CPhchyj8sG0Q9XI/CPhchyj8sG0Q9BHPIPhhkyD8UG0Q9BHPIPhhkyD8UG0Q9BHPIPhhkyD8UG0Q9BHPIPhhkyD8UG0Q9BHPIPhhkyD8EMDq9BHPIPhhkyD8EMDq9BHPIPhhkyD8EMDq9BHPIPhhkyD8EMDq9HoXrPs+yuT/Eqry9BHPIvhhkyD92wuM9BHPIvhhkyD92wuM9BHPIvhhkyD92wuM9BHPIvhhkyD92wuM9HoXrvs+yuT92wuM9HoXrvs+yuT92wuM9HoXrvs+yuT92wuM9BHPIvhhkyD/uzN69BHPIvhhkyD/uzN69BHPIvhhkyD/uzN69BHPIvhhkyD/uzN69HoXrvs+yuT/uzN69HoXrvs+yuT/uzN69HoXrvs+yuT/uzN69HoXrvs+yuT9UoME9XI/Cvhchyj/sLzq9XI/Cvhchyj/sLzq9XI/Cvhchyj/sLzq9XI/Cvhchyj8sG0Q9XI/Cvhchyj8sG0Q9XI/Cvhchyj8sG0Q9BHPIvhhkyD8UG0Q9BHPIvhhkyD8UG0Q9BHPIvhhkyD8UG0Q9BHPIvhhkyD8UG0Q9BHPIvhhkyD8EMDq9BHPIvhhkyD8EMDq9BHPIvhhkyD8EMDq9BHPIvhhkyD8EMDq9HoXrvs+yuT/Eqry9QNzHPp+S6z90wuM9QNzHPp+S6z90wuM9QNzHPp+S6z90wuM9QNzHPp+S6z90wuM9HoXrPoCx1T90wuM9HoXrPoCx1T90wuM9HoXrPoCx1T90wuM9HoXrPoCx1T90wuM9QNzHPp+S6z/wzN69QNzHPp+S6z/wzN69QNzHPp+S6z/wzN69QNzHPp+S6z/wzN69HoXrPoCx1T/wzN69HoXrPoCx1T/wzN69HoXrPoCx1T/wzN69HoXrPoCx1T9QoME9HoXrPoCx1T9QoME9XI/CPkwp7j/sLzq9XI/CPkwp7j/sLzq9XI/CPkwp7j/sLzq9XI/CPkwp7j8sG0Q9XI/CPkwp7j8sG0Q9XI/CPkwp7j8sG0Q9QNzHPp+S6z8QG0Q9QNzHPp+S6z8QG0Q9QNzHPp+S6z8QG0Q9QNzHPp+S6z8QG0Q9QNzHPp+S6z8IMDq9QNzHPp+S6z8IMDq9QNzHPp+S6z8IMDq9QNzHPp+S6z8IMDq9HoXrPoCx1T/Iqry9QNzHvp+S6z90wuM9QNzHvp+S6z90wuM9QNzHvp+S6z90wuM9QNzHvp+S6z90wuM9HoXrvoCx1T90wuM9HoXrvoCx1T90wuM9HoXrvoCx1T90wuM9QNzHvp+S6z/wzN69QNzHvp+S6z/wzN69QNzHvp+S6z/wzN69QNzHvp+S6z/wzN69HoXrvoCx1T/wzN69HoXrvoCx1T/wzN69HoXrvoCx1T/wzN69HoXrvoCx1T9QoME9XI/Cvkwp7j/sLzq9XI/Cvkwp7j/sLzq9XI/Cvkwp7j/sLzq9XI/Cvkwp7j8sG0Q9XI/Cvkwp7j8sG0Q9XI/Cvkwp7j8sG0Q9QNzHvp+S6z8QG0Q9QNzHvp+S6z8QG0Q9QNzHvp+S6z8QG0Q9QNzHvp+S6z8QG0Q9QNzHvp+S6z8IMDq9QNzHvp+S6z8IMDq9QNzHvp+S6z8IMDq9QNzHvp+S6z8IMDq9HoXrvoCx1T/Iqry9AACAv2xLB7MAAACA2zdds4tEfjMAAIA/AACAv21LB7MAAACA2zddMxMVh7MAAIC/2zdds4tEfjMAAIA/Yv9/Pya2jrsAAACA2zddMxMVh7MAAIC/Yv9/PyW2jrsAAACAAACAv21LB7MAAACAAACAv2xLB7MAAACASiP6tawtEjMAAIA/Yv9/Pya2jrsAAACASiP6NawtErMAAIC/Yv9/PyW2jrsAAACASiP6tawtEjMAAIA/AACAPwAAAAAAAACASiP6NawtErMAAIC/AACAPwAAAAAAAACAAAAAAAAAgL8AAACAAAAAACVGRLcAAIC/SqtAN8wU3rMAAIC/AACAPwAAAAAAAACAOatAty2qsTP//38/AAAAAAAAgL8AAACAAAAAAMLOTDcAAIA/AACAPwAAAAAAAACARekQs1NBSDMAAIA/AAAAAAAAgL8AAACAAAAAAAAAAAAAAIA/Sf5/P1Hi7LsAAACAAACAvwAAAAAAAACAAAAAAAAAgD8AAACAAACAvwAAAAAAAACARekQs1NBSDMAAIA/AAAAAAAAAAAAAIA/AAAAAAAAgD8AAACAOatAty2qsTP//38/AAAAAAAAgL8AAACAAAAAAMLOTDcAAIA/Sf5/P1Hi7LsAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/R+kQM+aLhrMAAIC/Sf5/P1Pi7LsAAACAAAAAAAAAgL8AAACAAAAAACVGRLcAAIC/SqtAN8wU3rMAAIC/Sf5/P1Pi7LsAAACAAACAvwAAAAAAAACAAAAAAAAAgD8AAACAAACAvwAAAAAAAACAAAAAAAAAAAAAAIC/AAAAAAAAgD8AAACAR+kQM+aLhrMAAIC/2zddM2aWejMAAIA/AACAP2xLB7NQYmm02zdds+eKjbMAAIC/AACAP21LB7MAAACAYv9/vya2jrsAAACA2zddM2aWejMAAIA/Yv9/vyW2jrsAAACA2zdds+eKjbMAAIC/AACAP21LB7MAAACAAACAP2xLB7NQYmm0Yv9/vya2jrsAAACASiP6NawtEjMAAIA/Yv9/vyW2jrsAAACASiP6tawtErMAAIC/AACAvwAAAAAAAACASiP6NawtEjMAAIA/AACAvwAAAAAAAACASiP6tawtErMAAIC/AACAvwAAAAAAAACAOatAt7gU3rP//3+/AAAAAAAAgL8AAACAAAAAACVGRLcAAIC/AACAvwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAMLOTDcAAIA/SqtANz2qsTMAAIA/Sv5/v0/i7LsAAACAAAAAAAAAgL8AAACAAAAAAAAAAAAAAIA/R+kQM6xRejMAAIA/AAAAAAAAgD8AAACA//9/PwAAAAAAAACAAAAAAAAAAAAAAIA/AAAAAAAAgD8AAACAR+kQM6xRejMAAIA///9/PwAAAAAAAACASv5/v0/i7LsAAACAAAAAAAAAgL8AAACAAAAAAMLOTDcAAIA/SqtANz2qsTMAAIA/Sv5/v1Hi7LsAAACARekQs/4wlrMAAIC/AAAAAAAAgL8AAACAAAAAAAAAAAAAAIC/Sv5/v1Hi7LsAAACAOatAt7gU3rP//3+/AAAAAAAAgL8AAACAAAAAACVGRLcAAIC/AAAAAAAAgD8AAACAAACAPwAAAAAAAACARekQs/4wlrMAAIC/AAAAAAAAAAAAAIC/AAAAAAAAgD8AAACAAACAPwAAAAAAAACAAACAP2xLB7NQYmm0AACAPwAAAAAAAACAAACAvwAAAAAAAACAixfHtrWGG7MAAIC/SiP6tawtErMAAIC/AACAvwAAAAAAAACASiP6NawtEjMAAIA/fhfHNlZoQjMAAIA/Yv9/vya2jrsAAACAVv9/vyEQlLsAAACASiP6NawtEjMAAIA/fhfHNlZoQjMAAIA/Yv9/vyW2jrsAAACAVv9/vyEQlLsAAACAixfHtrWGG7MAAIC/SiP6tawtErMAAIC/AACAP21LB7MAAACAAACAPwAAAAAAAACAYv9/vya2jrsAAACAVv9/vyEQlLsAAACA2zddM2aWejMAAIA/2dXTMwJCdjMAAIA/2zddM2aWejMAAIA/2dXTMwJCdjMAAIA/AACAP2xLB7NQYmm0AACAPwAAAAAAAACAYv9/vyW2jrsAAACAVv9/vyEQlLsAAACA39XTswkFk7MAAIC/2zdds+eKjbMAAIC/39XTswkFk7MAAIC/2zdds+eKjbMAAIC/AACAP21LB7MAAACAAACAPwAAAAAAAACAAACAv2xLB7MAAACAAACAvwAAAAAAAACASiP6NawtErMAAIC/fhfHNquGG7MAAIC/AACAPwAAAAAAAACAixfHtmJoQjMAAIA/SiP6tawtEjMAAIA/AACAPwAAAAAAAACAixfHtmJoQjMAAIA/SiP6tawtEjMAAIA/Vv9/PyEQlLsAAACAYv9/Pya2jrsAAACASiP6NawtErMAAIC/fhfHNquGG7MAAIC/Vv9/PyEQlLsAAACAYv9/PyW2jrsAAACAAACAv21LB7MAAACAAACAvwAAAAAAAACA39XTs0I7azMAAIA/2zdds4tEfjMAAIA/Vv9/PyEQlLsAAACAYv9/Pya2jrsAAACAAACAv2xLB7MAAACAAACAvwAAAAAAAACA39XTs0I7azMAAIA/2zdds4tEfjMAAIA/2zddMxMVh7MAAIC/2dXTM8gnhrMAAIC/Vv9/PyEQlLsAAACAYv9/PyW2jrsAAACAAACAv21LB7MAAACAAACAvwAAAAAAAACA2zddMxMVh7MAAIC/2dXTM8gnhrMAAIC/bf9/vykhibsAAACAVv9/vyEQlLsAAACA2dXTMwJCdjMAAIA//70GNOo2lTMAAIA/2dXTMwJCdjMAAIA//70GNOo2lTMAAIA/AACAPwAAAAAAAACAbf9/vyshibsAAACAVv9/vyEQlLsAAACA/70GtLjLa7MAAIC/39XTswkFk7MAAIC//70GtLjLa7MAAIC/39XTswkFk7MAAIC/AACAPwAAAAAAAACAAACAPwAAAAAAAACAAACAvwAAAAAAAACAKuIVt2iFd7MAAIC/ixfHtrWGG7MAAIC/AACAvwAAAAAAAACAfhfHNlZoQjMAAIA/HeIVN1uFdzP//38/bf9/vykhibsAAACAVv9/vyEQlLsAAACAfhfHNlZoQjMAAIA/HeIVN1uFdzP//38/bf9/vyshibsAAACAVv9/vyEQlLsAAACAKuIVt2iFd7MAAIC/ixfHtrWGG7MAAIC/AACAPwAAAAAAAACA/70GtMrYsDMAAIA/39XTs0I7azMAAIA/Vv9/PyEQlLsAAACAbP9/PyUhibsAAACAAACAvwAAAAAAAACA/70GtMrYsDMAAIA/39XTs0I7azMAAIA/2dXTM8gnhrMAAIC//70GNBKjSrMAAIC/Vv9/PyEQlLsAAACAbP9/PychibsAAACAAACAvwAAAAAAAACA2dXTM8gnhrMAAIC//70GNBKjSrMAAIC/AACAvwAAAAAAAACAfhfHNquGG7MAAIC/HeIVN3ZETrP//3+/AACAPwAAAAAAAACAKuIVt2iFdzMAAIA/ixfHtmJoQjMAAIA/AACAPwAAAAAAAACAKuIVt2iFdzMAAIA/ixfHtmJoQjMAAIA/Vv9/PyEQlLsAAACAbP9/PyUhibsAAACAfhfHNquGG7MAAIC/HeIVN3ZETrP//3+/Vv9/PyEQlLsAAACAbP9/PychibsAAACAAACAvwAAAAAAAACAbf9/vykhibsAAACASv5/v0/i7LsAAACAR+kQM6xRejMAAIA//70GNOo2lTMAAIA/R+kQM6xRejMAAIA//70GNOo2lTMAAIA///9/PwAAAAAAAACAAACAPwAAAAAAAACAbf9/vyshibsAAACASv5/v1Hi7LsAAACA/70GtLjLa7MAAIC/RekQs/4wlrMAAIC//70GtLjLa7MAAIC/RekQs/4wlrMAAIC/AACAPwAAAAAAAACA//9/PwAAAAAAAACAAACAPwAAAAAAAACAAACAvwAAAAAAAACAOatAt7gU3rP//3+/KuIVt2iFd7MAAIC/AACAvwAAAAAAAACAHeIVN1uFdzP//38/SqtANz2qsTMAAIA/bf9/vykhibsAAACASv5/v0/i7LsAAACAHeIVN1uFdzP//38/SqtANz2qsTMAAIA/bf9/vyshibsAAACASv5/v1Hi7LsAAACAOatAt7gU3rP//3+/KuIVt2iFd7MAAIC/AACAPwAAAAAAAACA/70GtMrYsDMAAIA/RekQs1NBSDMAAIA/Sf5/P1Hi7LsAAACAbP9/PyUhibsAAACAAACAvwAAAAAAAACA/70GtMrYsDMAAIA/RekQs1NBSDMAAIA/R+kQM+aLhrMAAIC//70GNBKjSrMAAIC/Sf5/P1Pi7LsAAACAbP9/PychibsAAACAAACAvwAAAAAAAACAR+kQM+aLhrMAAIC//70GNBKjSrMAAIC/AACAvwAAAAAAAACAHeIVN3ZETrP//3+/SqtAN8wU3rMAAIC/AACAPwAAAAAAAACAOatAty2qsTP//38/KuIVt2iFdzMAAIA/AACAPwAAAAAAAACAOatAty2qsTP//38/KuIVt2iFdzMAAIA/Sf5/P1Hi7LsAAACAbP9/PyUhibsAAACAHeIVN3ZETrP//3+/SqtAN8wU3rMAAIC/Sf5/P1Pi7LsAAACAbP9/PychibsAAACAAACAvwAAAAAAAACA4LxAP+avAD/gvEA/5q8AP0LVOz/nrwA/QtU7P+evAD/VwD8/5q8AP9XAPz/mrwA/TNE8P+evAD9M0Tw/568AP3yjOz/nrwA/pu5AP+evAD+zAz8/5q8AP7MDPz/mrwA/cY49P+evAD9xjj0/568AP3DUPj/mrwA/cNQ+P+avAD+yvT0/568AP7K9PT/nrwA/5to9P2z8GD/m2j0/bPwYP+baPT9s/Bg/5to9P2z8GD/Ruj4/avkYP9G6Pj9q+Rg/0bo+P2r5GD/Ruj4/avkYP4G3Pz9+8Bg/gbc/P37wGD+Btz8/fvAYP4G3Pz9+8Bg/pe5AP85bGT+l7kA/zlsZPwKcQD9qsBY/ApxAP2qwFj8CnEA/arAWPwKcQD9qsBY/xgI/P7cDGT/GAj8/twMZP8YCPz+3Axk/xgI/P7cDGT+a3jw/pPkYP5rePD+k+Rg/mt48P6T5GD+a3jw/pPkYP9KSPT8RBxk/0pI9PxEHGT/Skj0/EQcZP9KSPT8RBxk/fKM7P85bGT98ozs/zlsZP//1Oz/qrhY///U7P+quFj//9Ts/6q4WP//1Oz/qrhY/4LxAPwIpTD/gvEA/AilMP0PVOz8CKUw/Q9U7PwIpTD/WwD8/AilMP9bAPz8CKUw/TNE8PwIpTD9M0Tw/AilMP3yjOz8CKUw/pu5APwIpTD+yAz8/AilMP7IDPz8CKUw/cY49PwIpTD9xjj0/AilMP3DUPj8CKUw/cNQ+PwIpTD+yvT0/AilMP7K9PT8CKUw/S9c9P65+Mz9L1z0/rn4zP0vXPT+ufjM/S9c9P65+Mz8mtz4/XHgzPya3Pj9ceDM/Jrc+P1x4Mz8mtz4/XHgzP3+zPz/cejM/f7M/P9x6Mz9/sz8/3HozP3+zPz/cejM/pu5AP44XMz+m7kA/jhczPxKcQD80xDU/EpxAPzTENT8SnEA/NMQ1PxKcQD80xDU/R/8+P55tMz9H/z4/nm0zP0f/Pj+ebTM/R/8+P55tMz+t2jw/noYzP63aPD+ehjM/rdo8P56GMz+t2jw/noYzP1iPPT8ydDM/WI89PzJ0Mz9Yjz0/MnQzP1iPPT8ydDM/fKM7P44XMz98ozs/jhczPy/2Oz9YwzU/L/Y7P1jDNT8v9js/WMM1Py/2Oz9YwzU/pu5AP0igPz+m7kA/SKA/P37KPT/Y0z8/fso9P9jTPz9+yj0/2NM/P8vFPj+v0D8/y8U+P6/QPz/LxT4/r9A/P3wBPz9Qyz8/fAE/P1DLPz98AT8/UMs/P3wBPz9Qyz8/5I49P5rOPz/kjj0/ms4/P+SOPT+azj8/5I49P5rOPz98ozs/SKA/P3yjOz9IoD8/Kro/P+/RPz8quj8/79E/Pyq6Pz/v0T8/Kro/P+/RPz95rEA/m/ZAP3msQD+b9kA/eaxAP5v2QD95rEA/m/ZAP/zVPD/Q1z8//NU8P9DXPz/81Tw/0Nc/P/zVPD/Q1z8/ueU7Py32QD+55Ts/LfZAP7nlOz8t9kA/ueU7Py32QD+m7kA/2wUNP6buQD/bBQ0/TMw9PyrWDD9MzD0/KtYMP0zMPT8q1gw/oMc+P6jUDD+gxz4/qNQMP6DHPj+o1Aw/PAM/P8/ZDD88Az8/z9kMPzwDPz/P2Qw/PAM/P8/ZDD+ikD0/fNsMP6KQPT982ww/opA9P3zbDD+ikD0/fNsMP3yjOz/bBQ0/fKM7P9sFDT8rvD8/MtAMPyu8Pz8y0Aw/K7w/PzLQDD8rvD8/MtAMP3GsQD8osAs/caxAPyiwCz9xrEA/KLALP3GsQD8osAs/89c8P8bUDD/z1zw/xtQMP/PXPD/G1Aw/89c8P8bUDD+g5Ts/aK8LP6DlOz9orws/oOU7P2ivCz+g5Ts/aK8LP9S2Pz9mpjk/1LY/P2amOT/Utj8/ZqY5P9S2Pz9mpjk/RqRAP2hdOz9GpEA/aF07P0akQD9oXTs/VNg8PzavOT9U2Dw/Nq85P1TYPD82rzk/VNg8PzavOT/07Ts/w1w7P/TtOz/DXDs/9O07P8NcOz+m7kA/61s5P+TQPT9CqTk/5NA9P0KpOT/k0D0/Qqk5P3i+Pj+GpDk/eL4+P4akOT94vj4/hqQ5P2IAPz92nDk/YgA/P3acOT9iAD8/dpw5P2IAPz92nDk/Ho89P2ahOT8ejz0/ZqE5Px6PPT9moTk/Ho89P2ahOT98ozs/61s5P9a5Pz9Y4BI/1rk/P1jgEj/WuT8/WOASP9a5Pz9Y4BI/OqRAP0kwET86pEA/STARPzqkQD9JMBE/Rts8PzXnEj9G2zw/NecSP0bbPD815xI/Rts8PzXnEj/Q7Ts/KS8RP9DtOz8pLxE/0O07PykvET+m7kA/1TATP5nTPT9L6RI/mdM9P0vpEj+Z0z0/S+kSPzjBPj8J5xI/OME+PwnnEj84wT4/CecSPwEDPz/D7hI/AQM/P8PuEj8BAz8/w+4SPwEDPz/D7hI/upE9P0bxEj+6kT0/RvESP7qRPT9G8RI/upE9P0bxEj98ozs/1TATPyq1Pz+hkDY/KrU/P6GQNj8qtT8/oZA2Pyq1Pz+hkDY/LKBAP86QOD8soEA/zpA4PyygQD/OkDg/LKBAP86QOD+A2Tw/6po2P4DZPD/qmjY/gNk8P+qaNj+A2Tw/6po2PxLyOz8OkDg/EvI7Pw6QOD8S8js/DpA4P6buQD+8OTY/pu5AP7w5Nj8Y1D0/+JM2PxjUPT/4kzY/GNQ9P/iTNj/Puj4/cY42P8+6Pj9xjjY/z7o+P3GONj/U/z4/CoU2P9T/Pj8KhTY/1P8+PwqFNj/U/z4/CoU2PzuPPT/MijY/O489P8yKNj87jz0/zIo2PzuPPT/MijY/fKM7P7w5Nj+suD8/a+gVP6y4Pz9r6BU/rLg/P2voFT+suD8/a+gVPx6gQD9a8BM/HqBAP1rwEz8eoEA/WvATP/DcPD9t8BU/8Nw8P23wFT/w3Dw/bfAVP/DcPD9t8BU/6PE7PwrvEz/o8Ts/Cu8TP+jxOz8K7xM/pu5AP1JGFj9A1z0/3PIVP0DXPT/c8hU/QNc9P9zyFT8Evj4/OvAVPwS+Pj868BU/BL4+PzrwFT/kAj8/PfkVP+QCPz89+RU/5AI/Pz35FT/kAj8/PfkVP0aSPT8s/BU/RpI9Pyz8FT9Gkj0/LPwVP0aSPT8s/BU/fKM7P1JGFj8YATUAKgAYASoAEwEVASsALwAVAS8AJwENARoAIQANASEAEgEQASAAHgAQAR4AGgEYAE4AXAAYAFwAJgDtAFAAWgDtAFoABAEoAGAAZAAoAGQALAAmAS4AFAAmARQAHAFhACkAMwBhADMAaQCUAJcACgCUAAoADgAdARUAGQAdARkAIAFWACIAHABWABwAUgAjAFcAVAAjAFQAHwD6AGsAZwD6AGcACwFNABcAEgBNABIASgBRABsAJQBRACUAWwBLABMALQBLAC0AZQD3AF8AaAD3AGgA+QAIAWIAXgAIAV4A9QDwAFgAUwDwAFMA7gBsAIQANwBsADcAPwBqADQAMQBqADEAZgBwAHsAQwBwAEMARwAGAV0ATwAGAU8AAgH9AAABTAD9AEwASAAjAScAHQAjAR0ADgEpATAAMgApATIAFwFGAEQAcQBGAHEAbgBBAHYAcgBBAHIARQDBAMwAegDBAHoAbwC+ALYAhQC+AIUAbQA2AIIAgAA2AIAAOwBCAHgAhgBCAIYAPAA9AIkAiwA9AIsAOAA5AIwAfAA5AHwAPgA6AH4AdAA6AHQAQAAIAJ4ArAAIAKwAAgALAJkAowALAKMABQARAJIAlQARAJUADwDhAOQAlgDhAJYAkwAMAJoAkAAMAJAAEAAAAKQAjgAAAI4ACQAEAKEApwAEAKcAAQAHAKsAnQAHAJ0ADQADAK4AqAADAKgABgD8APMAtgD8ALYAvgD/AAoBywD/AMsAwABuAHEAwgBuAMIAvwB3AMcAwwB3AMMAcwCDALQAsgCDALIAgQB5AMoAuAB5ALgAhwCIALoAvACIALwAigCNAL0AzQCNAM0AfQB/ALEAxgB/AMYAdQAfASIB4wAfAeMA4ACfAOsA2QCfANkArQCYAOUA0ACYANAAogCSAN8A4gCSAOIAlQCbAOcA3QCbAN0AkQClANIA3AClANwAjwCgAM8A1ACgANQApgCqANcA6QCqAOkAnACvANoA1QCvANUAqQBJAGMACQFJAAkB/gBVAFkA8gBVAPIA+wC/AMIAAAG/AAAB/QDIAAUBAQHIAAEBxAC1APEA7wC1AO8AswDJAAcB9ADJAPQAtwC5APYA+AC5APgAuwC9APoACwG9AAsBzQCwAOwAAwGwAAMBxQAWACQAIQEWACEBHgHrACkBFwHrABcB2QDmACQBDwHmAA8B0QDfAB0BIAHfACAB4gDoACUBGwHoABsB3gDSABABGgHSABoB3ADOAAwBEQHOABEB0wDYABYBKAHYACgB6gDbABkBFAHbABQB1gA=" + } + ] +} diff --git a/Assets/Models/HouseModular.shmodel b/Assets/Models/HouseModular.shmodel new file mode 100644 index 00000000..4fb25c50 Binary files /dev/null and b/Assets/Models/HouseModular.shmodel differ diff --git a/Assets/Models/HouseModular.shmodel.shmeta b/Assets/Models/HouseModular.shmodel.shmeta new file mode 100644 index 00000000..936b3fa9 --- /dev/null +++ b/Assets/Models/HouseModular.shmodel.shmeta @@ -0,0 +1,55 @@ +Name: HouseModular +ID: 75328301 +Type: 4 +Sub Assets: +Name: FloorLarge +ID: 142812576 +Type: 8 +Name: FloorSmall +ID: 139921228 +Type: 8 +Name: FloorLong +ID: 136991843 +Type: 8 +Name: Pillar +ID: 150352316 +Type: 8 +Name: WallEnd +ID: 139594893 +Type: 8 +Name: WallCorner +ID: 134714737 +Type: 8 +Name: WallDefault +ID: 140834166 +Type: 8 +Name: WallLarge +ID: 142689599 +Type: 8 +Name: WallDiagonal +ID: 144002377 +Type: 8 +Name: WallTBlock +ID: 149359798 +Type: 8 +Name: WindowLarge +ID: 148351779 +Type: 8 +Name: WindowSmallOpened +ID: 149786048 +Type: 8 +Name: WindowSmallClosed +ID: 147863396 +Type: 8 +Name: WindowLargeOpen +ID: 138781993 +Type: 8 +Name: WallDoorHole +ID: 150924328 +Type: 8 +Name: Door +ID: 147152385 +Type: 8 +Name: DoorFrame +ID: 146862321 +Type: 8 diff --git a/Assets/Scenes/M2Scene.shade b/Assets/Scenes/M2Scene.shade index b2a5683f..bf910737 100644 --- a/Assets/Scenes/M2Scene.shade +++ b/Assets/Scenes/M2Scene.shade @@ -1,10 +1,10 @@ - EID: 0 - Name: Default + Name: Camera IsActive: true NumberOfChildren: 0 Components: Camera Component: - Position: {x: 0, y: 0, z: 0} + Position: {x: 0, y: 0, z: 8} Pitch: 0 Yaw: 0 Roll: 0 @@ -22,7 +22,7 @@ Strength: 0 Scripts: ~ - EID: 1 - Name: Default + Name: Floor IsActive: true NumberOfChildren: 0 Components: @@ -36,8 +36,8 @@ RigidBody Component: Type: Static Mass: 1 - Drag: 0 - Angular Drag: 0 + Drag: 0.00999999978 + Angular Drag: 0.00999999978 Use Gravity: true Interpolate: true Freeze Position X: false @@ -56,18 +56,15 @@ Density: 1 Position Offset: {x: 0, y: 0, z: 0} Scripts: ~ -- EID: 2 - Name: Player +- EID: 10 + Name: Default IsActive: true - NumberOfChildren: 3 + NumberOfChildren: 0 Components: Transform Component: - Translate: {x: -3.06177855, y: -2, z: -5} - Rotate: {x: -0, y: 0, z: -0} - Scale: {x: 2, y: 2, z: 2} - Renderable Component: - Mesh: 149697411 - Material: 126974645 + Translate: {x: -4.40482807, y: 2.57871056, z: -5.21213436} + Rotate: {x: -0.361265004, y: 1.11661232, z: -0.626627684} + Scale: {x: 0.999982238, y: 0.999987125, z: 0.999981165} RigidBody Component: Type: Dynamic Mass: 1 @@ -89,10 +86,10 @@ Friction: 0.400000006 Bounciness: 0 Density: 1 - Position Offset: {x: 0, y: 0.5, z: 0} + Position Offset: {x: 0, y: 0, z: 0} Scripts: ~ - EID: 3 - Name: Default + Name: Empty IsActive: true NumberOfChildren: 0 Components: @@ -102,7 +99,7 @@ Scale: {x: 1, y: 1, z: 1} Scripts: ~ - EID: 4 - Name: Default + Name: Empty2 IsActive: true NumberOfChildren: 0 Components: @@ -112,7 +109,7 @@ Scale: {x: 1, y: 1, z: 1} Scripts: ~ - EID: 9 - Name: Default + Name: Bag IsActive: true NumberOfChildren: 0 Components: @@ -160,7 +157,7 @@ Position Offset: {x: 0, y: 0.5, z: 0} Scripts: ~ - EID: 7 - Name: Default + Name: BigBoi IsActive: true NumberOfChildren: 0 Components: @@ -173,7 +170,7 @@ Material: 126974645 Scripts: ~ - EID: 8 - Name: Default + Name: AmbientLight IsActive: true NumberOfChildren: 0 Components: diff --git a/Assets/Scripts/AIPrototype.cs b/Assets/Scripts/AIPrototype.cs index d678de78..62255778 100644 --- a/Assets/Scripts/AIPrototype.cs +++ b/Assets/Scripts/AIPrototype.cs @@ -51,7 +51,6 @@ public class AIPrototype : Script private GameObject? player; - public AIPrototype(GameObject gameObj) : base(gameObj) { } protected override void awake() { diff --git a/Assets/Scripts/AIPrototype.cs.shmeta b/Assets/Scripts/AIPrototype.cs.shmeta new file mode 100644 index 00000000..80a7d4b4 --- /dev/null +++ b/Assets/Scripts/AIPrototype.cs.shmeta @@ -0,0 +1,3 @@ +Name: AIPrototype +ID: 163215061 +Type: 9 diff --git a/Assets/Scripts/CameraControl.cs b/Assets/Scripts/CameraControl.cs index fc900f46..b25d65eb 100644 --- a/Assets/Scripts/CameraControl.cs +++ b/Assets/Scripts/CameraControl.cs @@ -7,7 +7,6 @@ namespace SHADE_Scripting { public float turnSpeed = 0.5f; - public CameraControl(GameObject go) : base(go) { } protected override void update() { //Camera diff --git a/Assets/Scripts/CameraControl.cs.shmeta b/Assets/Scripts/CameraControl.cs.shmeta new file mode 100644 index 00000000..bf68c31c --- /dev/null +++ b/Assets/Scripts/CameraControl.cs.shmeta @@ -0,0 +1,3 @@ +Name: CameraControl +ID: 158782344 +Type: 9 diff --git a/Assets/Scripts/CameraFix.cs b/Assets/Scripts/CameraFix.cs index 5347a72f..0ca085ad 100644 --- a/Assets/Scripts/CameraFix.cs +++ b/Assets/Scripts/CameraFix.cs @@ -3,7 +3,6 @@ using System; public class CameraFix : Script { - public CameraFix(GameObject gameObj) : base(gameObj) { } private Transform tranform; public Vector3 pos = Vector3.Zero; diff --git a/Assets/Scripts/CameraFix.cs.shmeta b/Assets/Scripts/CameraFix.cs.shmeta new file mode 100644 index 00000000..d1e5412a --- /dev/null +++ b/Assets/Scripts/CameraFix.cs.shmeta @@ -0,0 +1,3 @@ +Name: CameraFix +ID: 162231964 +Type: 9 diff --git a/Assets/Scripts/Item.cs b/Assets/Scripts/Item.cs index 96ec092d..5047a241 100644 --- a/Assets/Scripts/Item.cs +++ b/Assets/Scripts/Item.cs @@ -10,7 +10,6 @@ public class Item : Script } public ItemCategory currCategory; - public Item(GameObject gameObj) : base(gameObj) { } protected override void awake() { diff --git a/Assets/Scripts/Item.cs.shmeta b/Assets/Scripts/Item.cs.shmeta new file mode 100644 index 00000000..84830b76 --- /dev/null +++ b/Assets/Scripts/Item.cs.shmeta @@ -0,0 +1,3 @@ +Name: Item +ID: 163145289 +Type: 9 diff --git a/Assets/Scripts/PhysicsTest.cs b/Assets/Scripts/PhysicsTest.cs index cc01615d..9726a51c 100644 --- a/Assets/Scripts/PhysicsTest.cs +++ b/Assets/Scripts/PhysicsTest.cs @@ -8,7 +8,6 @@ public class PhysicsTest : Script private Transform Transform; private RigidBody RigidBody; private Collider Collider; - public PhysicsTest(GameObject gameObj) : base(gameObj) { } protected override void awake() { diff --git a/Assets/Scripts/PhysicsTest.cs.shmeta b/Assets/Scripts/PhysicsTest.cs.shmeta new file mode 100644 index 00000000..99b809c5 --- /dev/null +++ b/Assets/Scripts/PhysicsTest.cs.shmeta @@ -0,0 +1,3 @@ +Name: PhysicsTest +ID: 159771801 +Type: 9 diff --git a/Assets/Scripts/PickAndThrow.cs b/Assets/Scripts/PickAndThrow.cs index ea814b36..ec8846c5 100644 --- a/Assets/Scripts/PickAndThrow.cs +++ b/Assets/Scripts/PickAndThrow.cs @@ -14,7 +14,6 @@ public class PickAndThrow : Script private float lastXDir; private float lastZDir; private bool inRange = false; - public PickAndThrow(GameObject gameObj) : base(gameObj) { } protected override void awake() { diff --git a/Assets/Scripts/PickAndThrow.cs.shmeta b/Assets/Scripts/PickAndThrow.cs.shmeta new file mode 100644 index 00000000..0eb38f59 --- /dev/null +++ b/Assets/Scripts/PickAndThrow.cs.shmeta @@ -0,0 +1,3 @@ +Name: PickAndThrow +ID: 165331952 +Type: 9 diff --git a/Assets/Scripts/PlayerController.cs b/Assets/Scripts/PlayerController.cs index 86ba7c98..4a02d470 100644 --- a/Assets/Scripts/PlayerController.cs +++ b/Assets/Scripts/PlayerController.cs @@ -73,8 +73,6 @@ public class PlayerController : Script public float mediumMultiper = 0.5f; public float heavyMultiper = 0.25f; - public PlayerController(GameObject gameObj) : base(gameObj) { } - protected override void awake() { //default setup diff --git a/Assets/Scripts/PlayerController.cs.shmeta b/Assets/Scripts/PlayerController.cs.shmeta new file mode 100644 index 00000000..8b71915c --- /dev/null +++ b/Assets/Scripts/PlayerController.cs.shmeta @@ -0,0 +1,3 @@ +Name: PlayerController +ID: 164563088 +Type: 9 diff --git a/Assets/Scripts/PrintWhenActive.cs b/Assets/Scripts/PrintWhenActive.cs index 41afdd58..11d7f025 100644 --- a/Assets/Scripts/PrintWhenActive.cs +++ b/Assets/Scripts/PrintWhenActive.cs @@ -2,8 +2,6 @@ public class PrintWhenActive : Script { - public PrintWhenActive(GameObject gameObj) : base(gameObj) { } - protected override void update() { Debug.Log("Active!"); diff --git a/Assets/Scripts/PrintWhenActive.cs.shmeta b/Assets/Scripts/PrintWhenActive.cs.shmeta new file mode 100644 index 00000000..2b8c4173 --- /dev/null +++ b/Assets/Scripts/PrintWhenActive.cs.shmeta @@ -0,0 +1,3 @@ +Name: PrintWhenActive +ID: 162536221 +Type: 9 diff --git a/Assets/Scripts/RaccoonShowcase.cs b/Assets/Scripts/RaccoonShowcase.cs index 4583a699..3c767f7f 100644 --- a/Assets/Scripts/RaccoonShowcase.cs +++ b/Assets/Scripts/RaccoonShowcase.cs @@ -1,5 +1,6 @@ using SHADE; using System; +using System.Collections.Generic; public class RaccoonShowcase : Script { @@ -17,7 +18,11 @@ public class RaccoonShowcase : Script private double rotation = 0.0; private Vector3 scale = Vector3.Zero; private double originalScale = 1.0f; - public RaccoonShowcase(GameObject gameObj) : base(gameObj) {} + [Tooltip("Sample list of Vector3s.")] + public List vecList = new List(new Vector3[] { new Vector3(1, 2, 3), new Vector3(4, 5, 6) }); + [Range(-5, 5)] + public List intList = new List(new int[] { 2, 8, 2, 6, 8, 0, 1 }); + public List enumList = new List(new Light.Type[] { Light.Type.Point, Light.Type.Directional, Light.Type.Ambient }); protected override void awake() { @@ -27,6 +32,11 @@ public class RaccoonShowcase : Script Debug.LogError("Transform is NULL!"); } + foreach (var child in Owner) + { + Debug.Log(child.Name); + } + originalScale = Transform.LocalScale.z; } protected override void update() diff --git a/Assets/Scripts/RaccoonShowcase.cs.shmeta b/Assets/Scripts/RaccoonShowcase.cs.shmeta new file mode 100644 index 00000000..6ce5bc3d --- /dev/null +++ b/Assets/Scripts/RaccoonShowcase.cs.shmeta @@ -0,0 +1,3 @@ +Name: RaccoonShowcase +ID: 159969631 +Type: 9 diff --git a/Assets/Scripts/RaccoonSpin.cs b/Assets/Scripts/RaccoonSpin.cs index efdfadeb..84100a21 100644 --- a/Assets/Scripts/RaccoonSpin.cs +++ b/Assets/Scripts/RaccoonSpin.cs @@ -14,8 +14,6 @@ public class RaccoonSpin : Script [SerializeField] private CallbackEvent testEvent3 = new CallbackEvent(); private Transform Transform; - public RaccoonSpin(GameObject gameObj) : base(gameObj) { } - protected override void awake() { diff --git a/Assets/Scripts/RaccoonSpin.cs.shmeta b/Assets/Scripts/RaccoonSpin.cs.shmeta new file mode 100644 index 00000000..9a1e05c8 --- /dev/null +++ b/Assets/Scripts/RaccoonSpin.cs.shmeta @@ -0,0 +1,3 @@ +Name: RaccoonSpin +ID: 157367824 +Type: 9 diff --git a/Assets/Scripts/ThirdPersonCamera.cs b/Assets/Scripts/ThirdPersonCamera.cs index 141865e8..fed26ae9 100644 --- a/Assets/Scripts/ThirdPersonCamera.cs +++ b/Assets/Scripts/ThirdPersonCamera.cs @@ -15,7 +15,6 @@ namespace SHADE_Scripting public float turnSpeedPitch = 0.3f; public float turnSpeedYaw = 0.5f; public float pitchClamp = 45.0f; - public ThirdPersonCamera(GameObject go) : base(go) { } protected override void awake() { diff --git a/Assets/Scripts/ThirdPersonCamera.cs.shmeta b/Assets/Scripts/ThirdPersonCamera.cs.shmeta new file mode 100644 index 00000000..2f18c2fb --- /dev/null +++ b/Assets/Scripts/ThirdPersonCamera.cs.shmeta @@ -0,0 +1,3 @@ +Name: ThirdPersonCamera +ID: 154161201 +Type: 9 diff --git a/Assets/racoon.fbx b/Assets/racoon.fbx deleted file mode 100644 index 4d823d9d..00000000 Binary files a/Assets/racoon.fbx and /dev/null differ diff --git a/Assets/racoon.gltf b/Assets/racoon.gltf deleted file mode 100644 index 459a542d..00000000 --- a/Assets/racoon.gltf +++ /dev/null @@ -1,4993 +0,0 @@ -{ - "asset" : { - "generator" : "Khronos glTF Blender I/O v3.3.27", - "version" : "2.0" - }, - "extensionsUsed" : [ - "KHR_materials_specular", - "KHR_materials_ior" - ], - "scene" : 0, - "scenes" : [ - { - "name" : "Scene", - "nodes" : [ - 55 - ] - } - ], - "nodes" : [ - { - "name" : "L_Toe_end", - "rotation" : [ - -1.304514398725587e-07, - -4.8278069232242024e-14, - -3.113858042524953e-07, - 1 - ], - "translation" : [ - 2.9270432744255004e-09, - 0.02392714098095894, - 1.3476908478082805e-10 - ] - }, - { - "children" : [ - 0 - ], - "name" : "L_Toe", - "rotation" : [ - 0.32702386379241943, - 1.1310142156162328e-07, - 1.641405731334089e-07, - 0.945016086101532 - ], - "scale" : [ - 1, - 0.9999999403953552, - 0.9999999403953552 - ], - "translation" : [ - -8.650776095464607e-09, - 0.03380582109093666, - -2.448857117087755e-09 - ] - }, - { - "children" : [ - 1 - ], - "name" : "L_Feet", - "rotation" : [ - 0.516292929649353, - -0.020581310614943504, - -0.05452270060777664, - 0.854426920413971 - ], - "translation" : [ - 1.2865877252465907e-09, - 0.06353945285081863, - 2.6193447411060333e-10 - ] - }, - { - "children" : [ - 2 - ], - "name" : "L_Shin", - "rotation" : [ - -0.054226718842983246, - 0.00034972387948073447, - -0.0027083493769168854, - 0.9985249042510986 - ], - "scale" : [ - 0.9999998807907104, - 0.9999999403953552, - 0.9999998807907104 - ], - "translation" : [ - -8.217813984856548e-09, - 0.012935775332152843, - -1.1059455573558807e-09 - ] - }, - { - "children" : [ - 3 - ], - "name" : "L_Knee", - "rotation" : [ - -0.117364302277565, - -0.00023353073629550636, - -0.005353146698325872, - 0.9930744767189026 - ], - "scale" : [ - 1, - 1.0000001192092896, - 1 - ], - "translation" : [ - -7.161837345392996e-09, - 0.08009886741638184, - -3.725290298461914e-09 - ] - }, - { - "children" : [ - 4 - ], - "name" : "L_Thigh", - "rotation" : [ - 0.005340703763067722, - -0.08032803982496262, - -0.9945576786994934, - 0.06613556295633316 - ], - "scale" : [ - 1.0000009536743164, - 1.0000001192092896, - 1.0000014305114746 - ], - "translation" : [ - 0.06634333729743958, - 0.021777987480163574, - -0.000205356627702713 - ] - }, - { - "name" : "Head_end", - "rotation" : [ - 0, - 3.552713678800501e-15, - 0, - 1 - ], - "translation" : [ - -8.470329472543003e-22, - 0.11583378911018372, - 0 - ] - }, - { - "children" : [ - 6 - ], - "name" : "Head", - "rotation" : [ - 0, - 5.960462701182223e-08, - 0, - 1 - ], - "scale" : [ - 1, - 0.9999999403953552, - 1 - ], - "translation" : [ - 0, - 0.022377878427505493, - 0 - ] - }, - { - "children" : [ - 7 - ], - "name" : "Neck", - "translation" : [ - 0, - 0.10304805636405945, - 0 - ] - }, - { - "name" : "L_Hand_end", - "rotation" : [ - 1.3239958462918366e-08, - -2.4324227076988336e-09, - 1.4901161193847656e-08, - 1 - ], - "translation" : [ - 2.2351740014414645e-08, - 0.016836093738675117, - -5.329070518200751e-15 - ] - }, - { - "children" : [ - 9 - ], - "name" : "L_Hand", - "rotation" : [ - -0.10859407484531403, - -0.0013414795976132154, - -0.012280543334782124, - 0.9940094351768494 - ], - "scale" : [ - 1, - 1, - 0.9999999403953552 - ], - "translation" : [ - -5.215407838932151e-08, - 0.030574528500437737, - 4.579678858362968e-09 - ] - }, - { - "children" : [ - 10 - ], - "name" : "L_Forearm", - "rotation" : [ - 0.03182216361165047, - -0.010124370455741882, - -0.05386859551072121, - 0.9979895353317261 - ], - "scale" : [ - 1, - 0.9999999403953552, - 0.9999999403953552 - ], - "translation" : [ - -1.4001724224499412e-08, - 0.011892830953001976, - -4.656612873077393e-10 - ] - }, - { - "children" : [ - 11 - ], - "name" : "L_Elbow", - "rotation" : [ - 0.13403145968914032, - 0.0004466302052605897, - 0.0229647234082222, - 0.9907108545303345 - ], - "translation" : [ - 9.490547014934236e-09, - 0.07338026165962219, - 1.862645149230957e-09 - ] - }, - { - "children" : [ - 12 - ], - "name" : "L_Shoulder", - "rotation" : [ - -0.05528340861201286, - 0.01580565795302391, - -0.27442947030067444, - 0.9598866701126099 - ], - "translation" : [ - 1.1175854908174188e-08, - 0.034574370831251144, - -3.3306690738754696e-15 - ] - }, - { - "children" : [ - 13 - ], - "name" : "L_Clavicle", - "rotation" : [ - -4.527326780134899e-08, - -2.4482876170850432e-08, - -0.6586140990257263, - 0.7524808645248413 - ], - "scale" : [ - 0.9999998807907104, - 0.9999998807907104, - 1 - ], - "translation" : [ - 0.03500552102923393, - 0.07119831442832947, - -6.646381223163189e-10 - ] - }, - { - "name" : "R_Hand_end", - "rotation" : [ - 1.3239958462918366e-08, - 2.4324227076988336e-09, - -1.4901161193847656e-08, - 1 - ], - "translation" : [ - -2.2351740014414645e-08, - 0.016836093738675117, - -5.329070518200751e-15 - ] - }, - { - "children" : [ - 15 - ], - "name" : "R_Hand", - "rotation" : [ - -0.10859407484531403, - 0.0013414795976132154, - 0.012280543334782124, - 0.9940094351768494 - ], - "scale" : [ - 1, - 1, - 0.9999999403953552 - ], - "translation" : [ - 5.215407838932151e-08, - 0.030574528500437737, - 4.579678858362968e-09 - ] - }, - { - "children" : [ - 16 - ], - "name" : "R_Forearm", - "rotation" : [ - 0.03182216361165047, - 0.010124370455741882, - 0.05386859551072121, - 0.9979895353317261 - ], - "scale" : [ - 1, - 0.9999999403953552, - 0.9999999403953552 - ], - "translation" : [ - 1.4001724224499412e-08, - 0.011892830953001976, - -4.656612873077393e-10 - ] - }, - { - "children" : [ - 17 - ], - "name" : "R_Elbow", - "rotation" : [ - 0.13403145968914032, - -0.0004466302052605897, - -0.0229647234082222, - 0.9907108545303345 - ], - "translation" : [ - -9.490547014934236e-09, - 0.07338026165962219, - 1.862645149230957e-09 - ] - }, - { - "children" : [ - 18 - ], - "name" : "R_Shoulder", - "rotation" : [ - -0.05528340861201286, - -0.01580565795302391, - 0.27442947030067444, - 0.9598866701126099 - ], - "translation" : [ - -1.1175854908174188e-08, - 0.034574370831251144, - -3.3306690738754696e-15 - ] - }, - { - "children" : [ - 19 - ], - "name" : "R_Clavicle", - "rotation" : [ - -4.527326780134899e-08, - 2.4482876170850432e-08, - 0.6586140990257263, - 0.7524808645248413 - ], - "scale" : [ - 0.9999998807907104, - 0.9999998807907104, - 1 - ], - "translation" : [ - -0.03500552102923393, - 0.07119831442832947, - -6.646381223163189e-10 - ] - }, - { - "name" : "L_IK_Arm_Pole_end", - "rotation" : [ - -8.14913803104389e-10, - -2.8273916541365907e-08, - 3.597233089180918e-08, - 1 - ], - "translation" : [ - 1.3742706528319104e-08, - 0.04507105425000191, - 1.6264998237147665e-08 - ] - }, - { - "children" : [ - 21 - ], - "name" : "L_IK_Arm_Pole", - "rotation" : [ - -0.3575689494609833, - -0.6109033823013306, - 0.6082502007484436, - 0.3591284155845642 - ], - "scale" : [ - 0.9999999403953552, - 0.9999998807907104, - 0.9999999403953552 - ], - "translation" : [ - 0.0021197572350502014, - -0.04126967862248421, - -0.053202081471681595 - ] - }, - { - "children" : [ - 22 - ], - "name" : "L_IK_Arm_Target", - "rotation" : [ - -0.0011026781285181642, - 0.0018760154489427805, - -0.8620717525482178, - 0.5067814588546753 - ], - "scale" : [ - 0.9999999403953552, - 1, - 1 - ], - "translation" : [ - 0.17300567030906677, - 0.02745041251182556, - 3.304734264020226e-10 - ] - }, - { - "name" : "R_IK_Arm_Pole_end", - "rotation" : [ - -8.14913803104389e-10, - 2.8273916541365907e-08, - -3.597233089180918e-08, - 1 - ], - "translation" : [ - -1.3742706528319104e-08, - 0.04507105425000191, - 1.6264998237147665e-08 - ] - }, - { - "children" : [ - 24 - ], - "name" : "R_IK_Arm_Pole", - "rotation" : [ - -0.3575689494609833, - 0.6109033823013306, - -0.6082502007484436, - 0.3591284155845642 - ], - "scale" : [ - 0.9999999403953552, - 0.9999998807907104, - 0.9999999403953552 - ], - "translation" : [ - -0.0021197572350502014, - -0.04126967862248421, - -0.053202081471681595 - ] - }, - { - "children" : [ - 25 - ], - "name" : "R_IK_Arm_Target", - "rotation" : [ - -0.0011026781285181642, - -0.0018760154489427805, - 0.8620717525482178, - 0.5067814588546753 - ], - "scale" : [ - 0.9999999403953552, - 1, - 1 - ], - "translation" : [ - -0.17300567030906677, - 0.02745041251182556, - 3.304734264020226e-10 - ] - }, - { - "children" : [ - 8, - 14, - 20, - 23, - 26 - ], - "name" : "Upper_Spine", - "translation" : [ - 0, - 0.06622835993766785, - 0 - ] - }, - { - "children" : [ - 27 - ], - "name" : "Lower_Spine", - "translation" : [ - 0, - 0.06622838973999023, - 0 - ] - }, - { - "name" : "Tail_end", - "translation" : [ - 0, - 0.07595176249742508, - -1.3838050705317073e-09 - ] - }, - { - "children" : [ - 29 - ], - "name" : "Tail", - "rotation" : [ - -0.7071068286895752, - 0, - 0, - 0.7071068286895752 - ], - "translation" : [ - -5.8597615213960615e-18, - 0.03983837366104126, - -0.09847982972860336 - ] - }, - { - "name" : "L_Hip_end", - "translation" : [ - 0, - 0.032987553626298904, - -1.5967565047958487e-09 - ] - }, - { - "children" : [ - 31 - ], - "name" : "L_Hip", - "translation" : [ - 0.06953180581331253, - 0.04957667365670204, - 0.061330340802669525 - ] - }, - { - "name" : "L_Butt_end", - "translation" : [ - 0, - 0.03298754245042801, - 1.3750955929481279e-09 - ] - }, - { - "children" : [ - 33 - ], - "name" : "L_Butt", - "translation" : [ - 0.06953180581331253, - -0.0007792188553139567, - -0.04653617739677429 - ] - }, - { - "name" : "R_Toe_end", - "rotation" : [ - -1.304514398725587e-07, - 4.8278069232242024e-14, - 3.113858042524953e-07, - 1 - ], - "translation" : [ - -2.9270432744255004e-09, - 0.02392714098095894, - 1.3476908478082805e-10 - ] - }, - { - "children" : [ - 35 - ], - "name" : "R_Toe", - "rotation" : [ - 0.32702386379241943, - -1.1310142156162328e-07, - -1.641405731334089e-07, - 0.945016086101532 - ], - "scale" : [ - 1, - 0.9999999403953552, - 0.9999999403953552 - ], - "translation" : [ - 8.650776095464607e-09, - 0.03380582109093666, - -2.448857117087755e-09 - ] - }, - { - "children" : [ - 36 - ], - "name" : "R_Feet", - "rotation" : [ - 0.516292929649353, - 0.020581310614943504, - 0.05452270060777664, - 0.854426920413971 - ], - "translation" : [ - -1.2865877252465907e-09, - 0.06353945285081863, - 2.6193447411060333e-10 - ] - }, - { - "children" : [ - 37 - ], - "name" : "R_Shin", - "rotation" : [ - -0.054226718842983246, - -0.00034972387948073447, - 0.0027083493769168854, - 0.9985249042510986 - ], - "scale" : [ - 0.9999998807907104, - 0.9999999403953552, - 0.9999998807907104 - ], - "translation" : [ - 8.217813984856548e-09, - 0.012935775332152843, - -1.1059455573558807e-09 - ] - }, - { - "children" : [ - 38 - ], - "name" : "R_Knee", - "rotation" : [ - -0.117364302277565, - 0.00023353073629550636, - 0.005353146698325872, - 0.9930744767189026 - ], - "scale" : [ - 1, - 1.0000001192092896, - 1 - ], - "translation" : [ - 7.161837345392996e-09, - 0.08009886741638184, - -3.725290298461914e-09 - ] - }, - { - "children" : [ - 39 - ], - "name" : "R_Thigh", - "rotation" : [ - 0.005340703763067722, - 0.08032803982496262, - 0.9945576786994934, - 0.06613556295633316 - ], - "scale" : [ - 1.0000009536743164, - 1.0000001192092896, - 1.0000014305114746 - ], - "translation" : [ - -0.06634333729743958, - 0.021777987480163574, - -0.000205356627702713 - ] - }, - { - "name" : "R_Hip_end", - "translation" : [ - 0, - 0.032987553626298904, - -1.5967565047958487e-09 - ] - }, - { - "children" : [ - 41 - ], - "name" : "R_Hip", - "translation" : [ - -0.06953180581331253, - 0.04957667365670204, - 0.061330340802669525 - ] - }, - { - "name" : "R_Butt_end", - "translation" : [ - 0, - 0.03298754245042801, - 1.3750955929481279e-09 - ] - }, - { - "children" : [ - 43 - ], - "name" : "R_Butt", - "translation" : [ - -0.06953180581331253, - -0.0007792188553139567, - -0.04653617739677429 - ] - }, - { - "children" : [ - 5, - 28, - 30, - 32, - 34, - 40, - 42, - 44 - ], - "name" : "Pelvis", - "translation" : [ - 0, - 0.15915730595588684, - 0 - ] - }, - { - "name" : "L_IK_Leg_Pole_end", - "translation" : [ - 0, - 0.04320859909057617, - 2.2203057170600005e-09 - ] - }, - { - "children" : [ - 46 - ], - "name" : "L_IK_Leg_Pole", - "rotation" : [ - 0, - 0, - -1, - 0 - ], - "translation" : [ - -0.008841380476951599, - -0.08020301908254623, - 0.0748630166053772 - ] - }, - { - "children" : [ - 47 - ], - "name" : "L_IK_Leg_Target", - "rotation" : [ - -0.7071068286895752, - 0, - 0, - 0.7071068286895752 - ], - "translation" : [ - 0.08565311133861542, - 0.027707800269126892, - 0.00015427125617861748 - ] - }, - { - "name" : "R_IK_Leg_Pole_end", - "translation" : [ - 0, - 0.04320859909057617, - 2.2203057170600005e-09 - ] - }, - { - "children" : [ - 49 - ], - "name" : "R_IK_Leg_Pole", - "rotation" : [ - 0, - 0, - -1, - 0 - ], - "translation" : [ - 0.008841380476951599, - -0.08020301908254623, - 0.0748630166053772 - ] - }, - { - "children" : [ - 50 - ], - "name" : "R_IK_Leg_Target", - "rotation" : [ - -0.7071068286895752, - 0, - 0, - 0.7071068286895752 - ], - "translation" : [ - -0.08565311133861542, - 0.027707800269126892, - 0.00015427125617861748 - ] - }, - { - "children" : [ - 45, - 48, - 51 - ], - "name" : "Root" - }, - { - "mesh" : 0, - "name" : "Bag", - "skin" : 0 - }, - { - "mesh" : 1, - "name" : "Raccoon", - "skin" : 0 - }, - { - "children" : [ - 53, - 54, - 52 - ], - "name" : "Armature" - } - ], - "animations" : [ - { - "channels" : [ - { - "sampler" : 0, - "target" : { - "node" : 52, - "path" : "translation" - } - }, - { - "sampler" : 1, - "target" : { - "node" : 52, - "path" : "rotation" - } - }, - { - "sampler" : 2, - "target" : { - "node" : 52, - "path" : "scale" - } - }, - { - "sampler" : 3, - "target" : { - "node" : 45, - "path" : "translation" - } - }, - { - "sampler" : 4, - "target" : { - "node" : 45, - "path" : "rotation" - } - }, - { - "sampler" : 5, - "target" : { - "node" : 45, - "path" : "scale" - } - }, - { - "sampler" : 6, - "target" : { - "node" : 5, - "path" : "translation" - } - }, - { - "sampler" : 7, - "target" : { - "node" : 5, - "path" : "rotation" - } - }, - { - "sampler" : 8, - "target" : { - "node" : 5, - "path" : "scale" - } - }, - { - "sampler" : 9, - "target" : { - "node" : 4, - "path" : "translation" - } - }, - { - "sampler" : 10, - "target" : { - "node" : 4, - "path" : "rotation" - } - }, - { - "sampler" : 11, - "target" : { - "node" : 4, - "path" : "scale" - } - }, - { - "sampler" : 12, - "target" : { - "node" : 3, - "path" : "translation" - } - }, - { - "sampler" : 13, - "target" : { - "node" : 3, - "path" : "rotation" - } - }, - { - "sampler" : 14, - "target" : { - "node" : 3, - "path" : "scale" - } - }, - { - "sampler" : 15, - "target" : { - "node" : 2, - "path" : "translation" - } - }, - { - "sampler" : 16, - "target" : { - "node" : 2, - "path" : "rotation" - } - }, - { - "sampler" : 17, - "target" : { - "node" : 2, - "path" : "scale" - } - }, - { - "sampler" : 18, - "target" : { - "node" : 1, - "path" : "translation" - } - }, - { - "sampler" : 19, - "target" : { - "node" : 1, - "path" : "rotation" - } - }, - { - "sampler" : 20, - "target" : { - "node" : 1, - "path" : "scale" - } - }, - { - "sampler" : 21, - "target" : { - "node" : 0, - "path" : "translation" - } - }, - { - "sampler" : 22, - "target" : { - "node" : 0, - "path" : "rotation" - } - }, - { - "sampler" : 23, - "target" : { - "node" : 0, - "path" : "scale" - } - }, - { - "sampler" : 24, - "target" : { - "node" : 28, - "path" : "translation" - } - }, - { - "sampler" : 25, - "target" : { - "node" : 28, - "path" : "rotation" - } - }, - { - "sampler" : 26, - "target" : { - "node" : 28, - "path" : "scale" - } - }, - { - "sampler" : 27, - "target" : { - "node" : 27, - "path" : "translation" - } - }, - { - "sampler" : 28, - "target" : { - "node" : 27, - "path" : "rotation" - } - }, - { - "sampler" : 29, - "target" : { - "node" : 27, - "path" : "scale" - } - }, - { - "sampler" : 30, - "target" : { - "node" : 8, - "path" : "translation" - } - }, - { - "sampler" : 31, - "target" : { - "node" : 8, - "path" : "rotation" - } - }, - { - "sampler" : 32, - "target" : { - "node" : 8, - "path" : "scale" - } - }, - { - "sampler" : 33, - "target" : { - "node" : 7, - "path" : "translation" - } - }, - { - "sampler" : 34, - "target" : { - "node" : 7, - "path" : "rotation" - } - }, - { - "sampler" : 35, - "target" : { - "node" : 7, - "path" : "scale" - } - }, - { - "sampler" : 36, - "target" : { - "node" : 6, - "path" : "translation" - } - }, - { - "sampler" : 37, - "target" : { - "node" : 6, - "path" : "rotation" - } - }, - { - "sampler" : 38, - "target" : { - "node" : 6, - "path" : "scale" - } - }, - { - "sampler" : 39, - "target" : { - "node" : 14, - "path" : "translation" - } - }, - { - "sampler" : 40, - "target" : { - "node" : 14, - "path" : "rotation" - } - }, - { - "sampler" : 41, - "target" : { - "node" : 14, - "path" : "scale" - } - }, - { - "sampler" : 42, - "target" : { - "node" : 13, - "path" : "translation" - } - }, - { - "sampler" : 43, - "target" : { - "node" : 13, - "path" : "rotation" - } - }, - { - "sampler" : 44, - "target" : { - "node" : 13, - "path" : "scale" - } - }, - { - "sampler" : 45, - "target" : { - "node" : 12, - "path" : "translation" - } - }, - { - "sampler" : 46, - "target" : { - "node" : 12, - "path" : "rotation" - } - }, - { - "sampler" : 47, - "target" : { - "node" : 12, - "path" : "scale" - } - }, - { - "sampler" : 48, - "target" : { - "node" : 11, - "path" : "translation" - } - }, - { - "sampler" : 49, - "target" : { - "node" : 11, - "path" : "rotation" - } - }, - { - "sampler" : 50, - "target" : { - "node" : 11, - "path" : "scale" - } - }, - { - "sampler" : 51, - "target" : { - "node" : 10, - "path" : "translation" - } - }, - { - "sampler" : 52, - "target" : { - "node" : 10, - "path" : "rotation" - } - }, - { - "sampler" : 53, - "target" : { - "node" : 10, - "path" : "scale" - } - }, - { - "sampler" : 54, - "target" : { - "node" : 9, - "path" : "translation" - } - }, - { - "sampler" : 55, - "target" : { - "node" : 9, - "path" : "rotation" - } - }, - { - "sampler" : 56, - "target" : { - "node" : 9, - "path" : "scale" - } - }, - { - "sampler" : 57, - "target" : { - "node" : 20, - "path" : "translation" - } - }, - { - "sampler" : 58, - "target" : { - "node" : 20, - "path" : "rotation" - } - }, - { - "sampler" : 59, - "target" : { - "node" : 20, - "path" : "scale" - } - }, - { - "sampler" : 60, - "target" : { - "node" : 19, - "path" : "translation" - } - }, - { - "sampler" : 61, - "target" : { - "node" : 19, - "path" : "rotation" - } - }, - { - "sampler" : 62, - "target" : { - "node" : 19, - "path" : "scale" - } - }, - { - "sampler" : 63, - "target" : { - "node" : 18, - "path" : "translation" - } - }, - { - "sampler" : 64, - "target" : { - "node" : 18, - "path" : "rotation" - } - }, - { - "sampler" : 65, - "target" : { - "node" : 18, - "path" : "scale" - } - }, - { - "sampler" : 66, - "target" : { - "node" : 17, - "path" : "translation" - } - }, - { - "sampler" : 67, - "target" : { - "node" : 17, - "path" : "rotation" - } - }, - { - "sampler" : 68, - "target" : { - "node" : 17, - "path" : "scale" - } - }, - { - "sampler" : 69, - "target" : { - "node" : 16, - "path" : "translation" - } - }, - { - "sampler" : 70, - "target" : { - "node" : 16, - "path" : "rotation" - } - }, - { - "sampler" : 71, - "target" : { - "node" : 16, - "path" : "scale" - } - }, - { - "sampler" : 72, - "target" : { - "node" : 15, - "path" : "translation" - } - }, - { - "sampler" : 73, - "target" : { - "node" : 15, - "path" : "rotation" - } - }, - { - "sampler" : 74, - "target" : { - "node" : 15, - "path" : "scale" - } - }, - { - "sampler" : 75, - "target" : { - "node" : 23, - "path" : "translation" - } - }, - { - "sampler" : 76, - "target" : { - "node" : 23, - "path" : "rotation" - } - }, - { - "sampler" : 77, - "target" : { - "node" : 23, - "path" : "scale" - } - }, - { - "sampler" : 78, - "target" : { - "node" : 22, - "path" : "translation" - } - }, - { - "sampler" : 79, - "target" : { - "node" : 22, - "path" : "rotation" - } - }, - { - "sampler" : 80, - "target" : { - "node" : 22, - "path" : "scale" - } - }, - { - "sampler" : 81, - "target" : { - "node" : 21, - "path" : "translation" - } - }, - { - "sampler" : 82, - "target" : { - "node" : 21, - "path" : "rotation" - } - }, - { - "sampler" : 83, - "target" : { - "node" : 21, - "path" : "scale" - } - }, - { - "sampler" : 84, - "target" : { - "node" : 26, - "path" : "translation" - } - }, - { - "sampler" : 85, - "target" : { - "node" : 26, - "path" : "rotation" - } - }, - { - "sampler" : 86, - "target" : { - "node" : 26, - "path" : "scale" - } - }, - { - "sampler" : 87, - "target" : { - "node" : 25, - "path" : "translation" - } - }, - { - "sampler" : 88, - "target" : { - "node" : 25, - "path" : "rotation" - } - }, - { - "sampler" : 89, - "target" : { - "node" : 25, - "path" : "scale" - } - }, - { - "sampler" : 90, - "target" : { - "node" : 24, - "path" : "translation" - } - }, - { - "sampler" : 91, - "target" : { - "node" : 24, - "path" : "rotation" - } - }, - { - "sampler" : 92, - "target" : { - "node" : 24, - "path" : "scale" - } - }, - { - "sampler" : 93, - "target" : { - "node" : 30, - "path" : "translation" - } - }, - { - "sampler" : 94, - "target" : { - "node" : 30, - "path" : "rotation" - } - }, - { - "sampler" : 95, - "target" : { - "node" : 30, - "path" : "scale" - } - }, - { - "sampler" : 96, - "target" : { - "node" : 29, - "path" : "translation" - } - }, - { - "sampler" : 97, - "target" : { - "node" : 29, - "path" : "rotation" - } - }, - { - "sampler" : 98, - "target" : { - "node" : 29, - "path" : "scale" - } - }, - { - "sampler" : 99, - "target" : { - "node" : 32, - "path" : "translation" - } - }, - { - "sampler" : 100, - "target" : { - "node" : 32, - "path" : "rotation" - } - }, - { - "sampler" : 101, - "target" : { - "node" : 32, - "path" : "scale" - } - }, - { - "sampler" : 102, - "target" : { - "node" : 31, - "path" : "translation" - } - }, - { - "sampler" : 103, - "target" : { - "node" : 31, - "path" : "rotation" - } - }, - { - "sampler" : 104, - "target" : { - "node" : 31, - "path" : "scale" - } - }, - { - "sampler" : 105, - "target" : { - "node" : 34, - "path" : "translation" - } - }, - { - "sampler" : 106, - "target" : { - "node" : 34, - "path" : "rotation" - } - }, - { - "sampler" : 107, - "target" : { - "node" : 34, - "path" : "scale" - } - }, - { - "sampler" : 108, - "target" : { - "node" : 33, - "path" : "translation" - } - }, - { - "sampler" : 109, - "target" : { - "node" : 33, - "path" : "rotation" - } - }, - { - "sampler" : 110, - "target" : { - "node" : 33, - "path" : "scale" - } - }, - { - "sampler" : 111, - "target" : { - "node" : 40, - "path" : "translation" - } - }, - { - "sampler" : 112, - "target" : { - "node" : 40, - "path" : "rotation" - } - }, - { - "sampler" : 113, - "target" : { - "node" : 40, - "path" : "scale" - } - }, - { - "sampler" : 114, - "target" : { - "node" : 39, - "path" : "translation" - } - }, - { - "sampler" : 115, - "target" : { - "node" : 39, - "path" : "rotation" - } - }, - { - "sampler" : 116, - "target" : { - "node" : 39, - "path" : "scale" - } - }, - { - "sampler" : 117, - "target" : { - "node" : 38, - "path" : "translation" - } - }, - { - "sampler" : 118, - "target" : { - "node" : 38, - "path" : "rotation" - } - }, - { - "sampler" : 119, - "target" : { - "node" : 38, - "path" : "scale" - } - }, - { - "sampler" : 120, - "target" : { - "node" : 37, - "path" : "translation" - } - }, - { - "sampler" : 121, - "target" : { - "node" : 37, - "path" : "rotation" - } - }, - { - "sampler" : 122, - "target" : { - "node" : 37, - "path" : "scale" - } - }, - { - "sampler" : 123, - "target" : { - "node" : 36, - "path" : "translation" - } - }, - { - "sampler" : 124, - "target" : { - "node" : 36, - "path" : "rotation" - } - }, - { - "sampler" : 125, - "target" : { - "node" : 36, - "path" : "scale" - } - }, - { - "sampler" : 126, - "target" : { - "node" : 35, - "path" : "translation" - } - }, - { - "sampler" : 127, - "target" : { - "node" : 35, - "path" : "rotation" - } - }, - { - "sampler" : 128, - "target" : { - "node" : 35, - "path" : "scale" - } - }, - { - "sampler" : 129, - "target" : { - "node" : 42, - "path" : "translation" - } - }, - { - "sampler" : 130, - "target" : { - "node" : 42, - "path" : "rotation" - } - }, - { - "sampler" : 131, - "target" : { - "node" : 42, - "path" : "scale" - } - }, - { - "sampler" : 132, - "target" : { - "node" : 41, - "path" : "translation" - } - }, - { - "sampler" : 133, - "target" : { - "node" : 41, - "path" : "rotation" - } - }, - { - "sampler" : 134, - "target" : { - "node" : 41, - "path" : "scale" - } - }, - { - "sampler" : 135, - "target" : { - "node" : 44, - "path" : "translation" - } - }, - { - "sampler" : 136, - "target" : { - "node" : 44, - "path" : "rotation" - } - }, - { - "sampler" : 137, - "target" : { - "node" : 44, - "path" : "scale" - } - }, - { - "sampler" : 138, - "target" : { - "node" : 43, - "path" : "translation" - } - }, - { - "sampler" : 139, - "target" : { - "node" : 43, - "path" : "rotation" - } - }, - { - "sampler" : 140, - "target" : { - "node" : 43, - "path" : "scale" - } - }, - { - "sampler" : 141, - "target" : { - "node" : 48, - "path" : "translation" - } - }, - { - "sampler" : 142, - "target" : { - "node" : 48, - "path" : "rotation" - } - }, - { - "sampler" : 143, - "target" : { - "node" : 48, - "path" : "scale" - } - }, - { - "sampler" : 144, - "target" : { - "node" : 47, - "path" : "translation" - } - }, - { - "sampler" : 145, - "target" : { - "node" : 47, - "path" : "rotation" - } - }, - { - "sampler" : 146, - "target" : { - "node" : 47, - "path" : "scale" - } - }, - { - "sampler" : 147, - "target" : { - "node" : 46, - "path" : "translation" - } - }, - { - "sampler" : 148, - "target" : { - "node" : 46, - "path" : "rotation" - } - }, - { - "sampler" : 149, - "target" : { - "node" : 46, - "path" : "scale" - } - }, - { - "sampler" : 150, - "target" : { - "node" : 51, - "path" : "translation" - } - }, - { - "sampler" : 151, - "target" : { - "node" : 51, - "path" : "rotation" - } - }, - { - "sampler" : 152, - "target" : { - "node" : 51, - "path" : "scale" - } - }, - { - "sampler" : 153, - "target" : { - "node" : 50, - "path" : "translation" - } - }, - { - "sampler" : 154, - "target" : { - "node" : 50, - "path" : "rotation" - } - }, - { - "sampler" : 155, - "target" : { - "node" : 50, - "path" : "scale" - } - }, - { - "sampler" : 156, - "target" : { - "node" : 49, - "path" : "translation" - } - }, - { - "sampler" : 157, - "target" : { - "node" : 49, - "path" : "rotation" - } - }, - { - "sampler" : 158, - "target" : { - "node" : 49, - "path" : "scale" - } - }, - { - "sampler" : 159, - "target" : { - "node" : 55, - "path" : "translation" - } - }, - { - "sampler" : 160, - "target" : { - "node" : 55, - "path" : "rotation" - } - }, - { - "sampler" : 161, - "target" : { - "node" : 55, - "path" : "scale" - } - } - ], - "name" : "Armature|Armature|ArmatureAction", - "samplers" : [ - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 15 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 16 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 17 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 18 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 19 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 20 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 21 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 22 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 23 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 24 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 25 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 26 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 27 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 28 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 29 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 30 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 31 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 32 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 33 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 34 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 35 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 36 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 37 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 38 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 39 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 40 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 41 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 42 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 43 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 44 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 45 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 46 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 47 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 48 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 49 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 50 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 51 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 52 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 53 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 54 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 55 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 56 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 57 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 58 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 59 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 60 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 61 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 62 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 63 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 64 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 65 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 66 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 67 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 68 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 69 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 70 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 71 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 72 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 73 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 74 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 75 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 76 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 77 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 78 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 79 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 80 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 81 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 82 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 83 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 84 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 85 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 86 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 87 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 88 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 89 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 90 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 91 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 92 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 93 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 94 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 95 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 96 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 97 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 98 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 99 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 100 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 101 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 102 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 103 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 104 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 105 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 106 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 107 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 108 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 109 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 110 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 111 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 112 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 113 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 114 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 115 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 116 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 117 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 118 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 119 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 120 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 121 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 122 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 123 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 124 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 125 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 126 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 127 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 128 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 129 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 130 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 131 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 132 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 133 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 134 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 135 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 136 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 137 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 138 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 139 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 140 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 141 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 142 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 143 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 144 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 145 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 146 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 147 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 148 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 149 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 150 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 151 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 152 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 153 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 154 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 155 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 156 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 157 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 158 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 159 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 160 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 161 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 162 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 163 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 164 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 165 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 166 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 167 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 168 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 169 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 170 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 171 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 172 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 173 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 174 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 175 - }, - { - "input" : 14, - "interpolation" : "LINEAR", - "output" : 176 - } - ] - } - ], - "materials" : [ - { - "doubleSided" : true, - "name" : "BagMaterial", - "pbrMetallicRoughness" : { - "baseColorFactor" : [ - 0.800000011920929, - 0.800000011920929, - 0.800000011920929, - 1 - ], - "metallicFactor" : 0, - "roughnessFactor" : 0.5 - } - }, - { - "alphaMode" : "BLEND", - "doubleSided" : true, - "extensions" : { - "KHR_materials_specular" : { - "specularColorFactor" : [ - 0, - 0, - 0 - ] - }, - "KHR_materials_ior" : { - "ior" : 1.4500000476837158 - } - }, - "name" : "BodyMaterial", - "pbrMetallicRoughness" : { - "baseColorFactor" : [ - 0.800000011920929, - 0.800000011920929, - 0.800000011920929, - 1 - ], - "metallicFactor" : 0 - } - } - ], - "meshes" : [ - { - "name" : "Cube.003", - "primitives" : [ - { - "attributes" : { - "POSITION" : 0, - "NORMAL" : 1, - "TEXCOORD_0" : 2, - "JOINTS_0" : 3, - "WEIGHTS_0" : 4 - }, - "indices" : 5, - "material" : 0 - } - ] - }, - { - "name" : "Cube.012", - "primitives" : [ - { - "attributes" : { - "POSITION" : 7, - "NORMAL" : 8, - "TEXCOORD_0" : 9, - "COLOR_0" : 10, - "JOINTS_0" : 11, - "WEIGHTS_0" : 12 - }, - "indices" : 13, - "material" : 1 - } - ] - } - ], - "skins" : [ - { - "inverseBindMatrices" : 6, - "joints" : [ - 52, - 45, - 5, - 4, - 3, - 2, - 1, - 0, - 28, - 27, - 8, - 7, - 6, - 14, - 13, - 12, - 11, - 10, - 9, - 20, - 19, - 18, - 17, - 16, - 15, - 23, - 22, - 21, - 26, - 25, - 24, - 30, - 29, - 32, - 31, - 34, - 33, - 40, - 39, - 38, - 37, - 36, - 35, - 42, - 41, - 44, - 43, - 48, - 47, - 46, - 51, - 50, - 49 - ], - "name" : "Armature" - } - ], - "accessors" : [ - { - "bufferView" : 0, - "componentType" : 5126, - "count" : 506, - "max" : [ - 0.1090814545750618, - 0.40452075004577637, - 0.0857388824224472 - ], - "min" : [ - -0.09462108463048935, - 0.2630254030227661, - -0.11617939174175262 - ], - "type" : "VEC3" - }, - { - "bufferView" : 1, - "componentType" : 5126, - "count" : 506, - "type" : "VEC3" - }, - { - "bufferView" : 2, - "componentType" : 5126, - "count" : 506, - "type" : "VEC2" - }, - { - "bufferView" : 3, - "componentType" : 5121, - "count" : 506, - "type" : "VEC4" - }, - { - "bufferView" : 4, - "componentType" : 5126, - "count" : 506, - "type" : "VEC4" - }, - { - "bufferView" : 5, - "componentType" : 5123, - "count" : 2346, - "type" : "SCALAR" - }, - { - "bufferView" : 6, - "componentType" : 5126, - "count" : 53, - "type" : "MAT4" - }, - { - "bufferView" : 7, - "componentType" : 5126, - "count" : 3484, - "max" : [ - 0.2035536766052246, - 0.5987313389778137, - 0.09013944119215012 - ], - "min" : [ - -0.19493983685970306, - -0.0017474208725616336, - -0.19020147621631622 - ], - "type" : "VEC3" - }, - { - "bufferView" : 8, - "componentType" : 5126, - "count" : 3484, - "type" : "VEC3" - }, - { - "bufferView" : 9, - "componentType" : 5126, - "count" : 3484, - "type" : "VEC2" - }, - { - "bufferView" : 10, - "componentType" : 5123, - "count" : 3484, - "normalized" : true, - "type" : "VEC4" - }, - { - "bufferView" : 11, - "componentType" : 5121, - "count" : 3484, - "type" : "VEC4" - }, - { - "bufferView" : 12, - "componentType" : 5126, - "count" : 3484, - "type" : "VEC4" - }, - { - "bufferView" : 13, - "componentType" : 5123, - "count" : 17472, - "type" : "SCALAR" - }, - { - "bufferView" : 14, - "componentType" : 5126, - "count" : 51, - "max" : [ - 2.125 - ], - "min" : [ - 0.041666666666666664 - ], - "type" : "SCALAR" - }, - { - "bufferView" : 15, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 16, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 17, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 18, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 19, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 20, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 21, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 22, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 23, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 24, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 25, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 26, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 27, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 28, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 29, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 30, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 31, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 32, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 33, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 34, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 35, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 36, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 37, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 38, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 39, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 40, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 41, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 42, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 43, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 44, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 45, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 46, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 47, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 48, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 49, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 50, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 51, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 52, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 53, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 54, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 55, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 56, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 57, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 58, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 59, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 60, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 61, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 62, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 63, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 64, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 65, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 66, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 67, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 68, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 69, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 70, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 71, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 72, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 73, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 74, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 75, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 76, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 77, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 78, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 79, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 80, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 81, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 82, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 83, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 84, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 85, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 86, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 87, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 88, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 89, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 90, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 91, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 92, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 93, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 94, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 95, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 96, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 97, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 98, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 99, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 100, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 101, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 102, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 103, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 104, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 105, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 106, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 107, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 108, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 109, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 110, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 111, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 112, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 113, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 114, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 115, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 116, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 117, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 118, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 119, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 120, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 121, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 122, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 123, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 124, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 125, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 126, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 127, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 128, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 129, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 130, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 131, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 132, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 133, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 134, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 135, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 136, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 137, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 138, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 139, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 140, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 141, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 142, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 143, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 144, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 145, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 146, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 147, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 148, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 149, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 150, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 151, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 152, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 153, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 154, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 155, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 156, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 157, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 158, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 159, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 160, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 161, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 162, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 163, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 164, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 165, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 166, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 167, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 168, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 169, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 170, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 171, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 172, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 173, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 174, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - }, - { - "bufferView" : 175, - "componentType" : 5126, - "count" : 51, - "type" : "VEC4" - }, - { - "bufferView" : 176, - "componentType" : 5126, - "count" : 51, - "type" : "VEC3" - } - ], - "bufferViews" : [ - { - "buffer" : 0, - "byteLength" : 6072, - "byteOffset" : 0, - "target" : 34962 - }, - { - "buffer" : 0, - "byteLength" : 6072, - "byteOffset" : 6072, - "target" : 34962 - }, - { - "buffer" : 0, - "byteLength" : 4048, - "byteOffset" : 12144, - "target" : 34962 - }, - { - "buffer" : 0, - "byteLength" : 2024, - "byteOffset" : 16192, - "target" : 34962 - }, - { - "buffer" : 0, - "byteLength" : 8096, - "byteOffset" : 18216, - "target" : 34962 - }, - { - "buffer" : 0, - "byteLength" : 4692, - "byteOffset" : 26312, - "target" : 34963 - }, - { - "buffer" : 0, - "byteLength" : 3392, - "byteOffset" : 31004 - }, - { - "buffer" : 0, - "byteLength" : 41808, - "byteOffset" : 34396, - "target" : 34962 - }, - { - "buffer" : 0, - "byteLength" : 41808, - "byteOffset" : 76204, - "target" : 34962 - }, - { - "buffer" : 0, - "byteLength" : 27872, - "byteOffset" : 118012, - "target" : 34962 - }, - { - "buffer" : 0, - "byteLength" : 27872, - "byteOffset" : 145884, - "target" : 34962 - }, - { - "buffer" : 0, - "byteLength" : 13936, - "byteOffset" : 173756, - "target" : 34962 - }, - { - "buffer" : 0, - "byteLength" : 55744, - "byteOffset" : 187692, - "target" : 34962 - }, - { - "buffer" : 0, - "byteLength" : 34944, - "byteOffset" : 243436, - "target" : 34963 - }, - { - "buffer" : 0, - "byteLength" : 204, - "byteOffset" : 278380 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 278584 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 279196 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 280012 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 280624 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 281236 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 282052 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 282664 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 283276 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 284092 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 284704 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 285316 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 286132 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 286744 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 287356 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 288172 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 288784 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 289396 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 290212 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 290824 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 291436 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 292252 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 292864 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 293476 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 294292 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 294904 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 295516 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 296332 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 296944 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 297556 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 298372 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 298984 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 299596 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 300412 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 301024 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 301636 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 302452 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 303064 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 303676 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 304492 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 305104 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 305716 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 306532 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 307144 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 307756 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 308572 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 309184 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 309796 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 310612 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 311224 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 311836 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 312652 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 313264 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 313876 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 314692 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 315304 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 315916 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 316732 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 317344 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 317956 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 318772 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 319384 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 319996 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 320812 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 321424 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 322036 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 322852 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 323464 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 324076 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 324892 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 325504 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 326116 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 326932 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 327544 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 328156 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 328972 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 329584 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 330196 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 331012 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 331624 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 332236 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 333052 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 333664 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 334276 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 335092 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 335704 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 336316 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 337132 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 337744 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 338356 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 339172 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 339784 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 340396 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 341212 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 341824 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 342436 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 343252 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 343864 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 344476 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 345292 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 345904 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 346516 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 347332 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 347944 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 348556 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 349372 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 349984 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 350596 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 351412 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 352024 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 352636 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 353452 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 354064 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 354676 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 355492 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 356104 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 356716 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 357532 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 358144 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 358756 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 359572 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 360184 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 360796 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 361612 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 362224 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 362836 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 363652 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 364264 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 364876 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 365692 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 366304 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 366916 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 367732 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 368344 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 368956 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 369772 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 370384 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 370996 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 371812 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 372424 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 373036 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 373852 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 374464 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 375076 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 375892 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 376504 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 377116 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 377932 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 378544 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 379156 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 379972 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 380584 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 381196 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 382012 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 382624 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 383236 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 384052 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 384664 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 385276 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 386092 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 386704 - }, - { - "buffer" : 0, - "byteLength" : 816, - "byteOffset" : 387316 - }, - { - "buffer" : 0, - "byteLength" : 612, - "byteOffset" : 388132 - } - ], - "buffers" : [ - { - "byteLength" : 388744, - "uri" : "data:application/octet-stream;base64,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" - } - ] -} diff --git a/SHADE_Application/premake5.lua b/SHADE_Application/premake5.lua index 395c3a48..cba0c35e 100644 --- a/SHADE_Application/premake5.lua +++ b/SHADE_Application/premake5.lua @@ -75,7 +75,8 @@ project "SHADE_Application" "26439", "26451", "26437", - "4275" + "4275", + "4635" } linkoptions { "-IGNORE:4006" } diff --git a/SHADE_Application/src/Application/SBApplication.cpp b/SHADE_Application/src/Application/SBApplication.cpp index 6b67dbce..1095f965 100644 --- a/SHADE_Application/src/Application/SBApplication.cpp +++ b/SHADE_Application/src/Application/SBApplication.cpp @@ -8,8 +8,8 @@ //#include "Scenes/SBEditorScene.h" #endif // SHEDITOR -#include "Tools/SHLogger.h" -#include "Tools/SHFileUtilties.h" +#include "Tools/Logger/SHLogger.h" +#include "Tools/Utilities/SHFileUtilties.h" #include #include @@ -24,14 +24,15 @@ #include "Scene/SHSceneManager.h" // Systems -#include "Scripting/SHScriptEngine.h" -#include "Physics/SHPhysicsSystem.h" -#include "Math/Transform/SHTransformSystem.h" -#include "Input/SHInputManager.h" -#include "FRC/SHFramerateController.h" #include "AudioSystem/SHAudioSystem.h" #include "Camera/SHCameraSystem.h" +#include "FRC/SHFramerateController.h" #include "Graphics/MiddleEnd/Interface/SHDebugDrawSystem.h" +#include "Input/SHInputManager.h" +#include "Math/Transform/SHTransformSystem.h" +#include "Physics/System/SHPhysicsSystem.h" +#include "Physics/System/SHPhysicsDebugDrawSystem.h" +#include "Scripting/SHScriptEngine.h" // Components #include "Graphics/MiddleEnd/Interface/SHRenderable.h" @@ -39,12 +40,11 @@ #include "Scenes/SBTestScene.h" - #include "Assets/SHAssetManager.h" #include "Scenes/SBMainScene.h" #include "Serialization/Configurations/SHConfigurationManager.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" #include "Tools/SHDebugDraw.h" using namespace SHADE; @@ -60,6 +60,8 @@ namespace Sandbox _In_ INT nCmdShow ) { + SHLOG_INFO_D("Initialising SHADE engine") + // Set working directory SHFileUtilities::SetWorkDirToExecDir(); WindowData wndData{}; @@ -67,16 +69,21 @@ namespace Sandbox window.Create(hInstance, hPrevInstance, lpCmdLine, nCmdShow, wndData); // Create Systems - SHSystemManager::CreateSystem(); + SHSystemManager::CreateSystem(); - SHSystemManager::CreateSystem(); SHSystemManager::CreateSystem(); - SHGraphicsSystem* graphicsSystem = static_cast(SHSystemManager::GetSystem()); + SHSystemManager::CreateSystem(); + SHSystemManager::CreateSystem(); + SHSystemManager::CreateSystem(); SHSystemManager::CreateSystem(); - SHSystemManager::CreateSystem(); + + + SHSystemManager::CreateSystem(); + SHGraphicsSystem* graphicsSystem = static_cast(SHSystemManager::GetSystem()); // Link up SHDebugDraw + SHSystemManager::CreateSystem(); SHDebugDraw::Init(SHSystemManager::GetSystem()); #ifdef SHEDITOR @@ -101,7 +108,8 @@ namespace Sandbox SHSystemManager::RegisterRoutine(); SHSystemManager::RegisterRoutine(); SHSystemManager::RegisterRoutine(); - SHSystemManager::RegisterRoutine(); + + SHSystemManager::RegisterRoutine(); SHSystemManager::RegisterRoutine(); SHSystemManager::RegisterRoutine(); @@ -165,7 +173,7 @@ namespace Sandbox if (SHInputManager::GetKeyDown(SHInputManager::SH_KEYCODE::F10)) { drawColliders = !drawColliders; - SHSystemManager::GetSystem()->SetDrawColliders(drawColliders); + SHSystemManager::GetSystem()->SetDebugDrawFlag(SHPhysicsDebugDrawSystem::DebugDrawFlags::COLLIDER, drawColliders); } } // Finish all graphics jobs first diff --git a/SHADE_Application/src/Scenes/SBMainScene.cpp b/SHADE_Application/src/Scenes/SBMainScene.cpp index 34190915..b14f2e6f 100644 --- a/SHADE_Application/src/Scenes/SBMainScene.cpp +++ b/SHADE_Application/src/Scenes/SBMainScene.cpp @@ -10,8 +10,8 @@ #include "Scripting/SHScriptEngine.h" #include "Math/Transform/SHTransformComponent.h" #include "Graphics/MiddleEnd/Interface/SHMaterialInstance.h" -#include "Physics/Components/SHRigidBodyComponent.h" -#include "Physics/Components/SHColliderComponent.h" +#include "Physics/Interface/SHRigidBodyComponent.h" +#include "Physics/Interface/SHColliderComponent.h" #include "Graphics/MiddleEnd/Lights/SHLightComponent.h" #include "Assets/SHAssetManager.h" diff --git a/SHADE_Application/src/Scenes/SBTestScene.cpp b/SHADE_Application/src/Scenes/SBTestScene.cpp index 8281f114..bcc7f09d 100644 --- a/SHADE_Application/src/Scenes/SBTestScene.cpp +++ b/SHADE_Application/src/Scenes/SBTestScene.cpp @@ -10,8 +10,8 @@ #include "Scripting/SHScriptEngine.h" #include "Math/Transform/SHTransformComponent.h" #include "Graphics/MiddleEnd/Interface/SHMaterialInstance.h" -#include "Physics/Components/SHRigidBodyComponent.h" -#include "Physics/Components/SHColliderComponent.h" +#include "Physics/Interface/SHRigidBodyComponent.h" +#include "Physics/Interface/SHColliderComponent.h" #include "Graphics/MiddleEnd/Lights/SHLightComponent.h" #include "Assets/SHAssetManager.h" diff --git a/SHADE_Application/src/WinMain.cpp b/SHADE_Application/src/WinMain.cpp index f672cead..9dcab1ab 100644 --- a/SHADE_Application/src/WinMain.cpp +++ b/SHADE_Application/src/WinMain.cpp @@ -1,6 +1,6 @@ #include "SBpch.h" #include -#include +#include #include #include "Application/SBApplication.h" diff --git a/SHADE_CSharp/premake5.lua b/SHADE_CSharp/premake5.lua index 2d6c1edb..39ef8281 100644 --- a/SHADE_CSharp/premake5.lua +++ b/SHADE_CSharp/premake5.lua @@ -27,6 +27,12 @@ project "SHADE_CSharp" warnings 'Extra' + postbuildcommands + { + "xcopy /r /y /q \"%{outputdir}\\net5.0\\SHADE_CSharp.xml\" \"%{outputdir}\"", + "xcopy /r /y /q \"%{outputdir}\\net5.0\\SHADE_CSharp.pdb\" \"%{outputdir}\"" + } + filter "configurations:Debug" symbols "On" defines {"_DEBUG"} @@ -41,12 +47,18 @@ project "SHADE_CSharp" require "vstudio" - function platformsElement(cfg) + function platformsElementCS(cfg) _p(2,'x64') end + function docsElementCS(cfg) + _p(2,'true') + end + function docsLocationElementCS(cfg) + _p(2,'$(OutDir)') + end premake.override(premake.vstudio.cs2005.elements, "projectProperties", function (oldfn, cfg) return table.join(oldfn(cfg), { - platformsElement, + platformsElementCS, docsElementCS, docsLocationElementCS, }) end) \ No newline at end of file diff --git a/SHADE_Engine/premake5.lua b/SHADE_Engine/premake5.lua index 42f95520..1d6d7bef 100644 --- a/SHADE_Engine/premake5.lua +++ b/SHADE_Engine/premake5.lua @@ -78,7 +78,8 @@ project "SHADE_Engine" "26439", "26451", "26437", - "4275" + "4275", + "4635" } linkoptions { "-IGNORE:4006" } diff --git a/SHADE_Engine/src/Assets/SHAssetMacros.h b/SHADE_Engine/src/Assets/SHAssetMacros.h index 92c4b69e..44dfd5c5 100644 --- a/SHADE_Engine/src/Assets/SHAssetMacros.h +++ b/SHADE_Engine/src/Assets/SHAssetMacros.h @@ -52,6 +52,8 @@ enum class AssetType : AssetTypeMeta PREFAB, MATERIAL, MESH, + SCRIPT, + FONT, MAX_COUNT }; constexpr size_t TYPE_COUNT{ static_cast(AssetType::MAX_COUNT) }; @@ -85,32 +87,39 @@ constexpr std::string_view SCENE_EXTENSION {".shade"}; constexpr std::string_view PREFAB_EXTENSION {".shprefab"}; constexpr std::string_view MATERIAL_EXTENSION {".shmat"}; constexpr std::string_view TEXTURE_EXTENSION {".shtex"}; -constexpr std::string_view MODEL_EXTENSION {".shmodel"}; +constexpr std::string_view MODEL_EXTENSION{ ".shmodel" }; +constexpr std::string_view FONT_EXTENSION{ ".shfont" }; constexpr std::string_view EXTENSIONS[] = { AUDIO_EXTENSION, SHADER_EXTENSION, SHADER_BUILT_IN_EXTENSION, - MATERIAL_EXTENSION, - TEXTURE_EXTENSION, + TEXTURE_EXTENSION, MODEL_EXTENSION, - SCRIPT_EXTENSION, - SCENE_EXTENSION, + SCENE_EXTENSION, PREFAB_EXTENSION, + MATERIAL_EXTENSION, + "dummy", + SCRIPT_EXTENSION, + FONT_EXTENSION, AUDIO_WAV_EXTENSION, }; +constexpr size_t EXTENSIONS_COUNT{ 11 }; + // EXTERNAL EXTENSIONS constexpr std::string_view GLSL_EXTENSION{ ".glsl" }; constexpr std::string_view DDS_EXTENSION{ ".dds" }; constexpr std::string_view FBX_EXTENSION{ ".fbx" }; constexpr std::string_view GLTF_EXTENSION{ ".gltf" }; +constexpr std::string_view TTF_EXTENSION{ ".ttf" }; constexpr std::string_view EXTERNALS[] = { GLSL_EXTENSION, DDS_EXTENSION, FBX_EXTENSION, - GLTF_EXTENSION + GLTF_EXTENSION, + TTF_EXTENSION }; // SHADER IDENTIFIERS @@ -125,11 +134,4 @@ constexpr std::pair SHADER_IDENTIFIERS[ }; constexpr size_t SHADER_TYPE_MAX_COUNT{ 3 }; - -// Error flags -constexpr std::string_view FILE_NOT_FOUND_ERR {"FILE NOT FOUND"}; -constexpr std::string_view META_NOT_FOUND_ERR {"META NOT FOUND"}; -constexpr std::string_view ASSET_NOT_FOUND_ERR {"ASSET NOT FOUND"}; -constexpr std::string_view EXT_DOES_NOT_EXIST {"TYPE DOES NOT HAVE EXTENSION DEFINED"}; - #endif // !SH_ASSET_MACROS_H diff --git a/SHADE_Engine/src/Assets/SHAssetManager.cpp b/SHADE_Engine/src/Assets/SHAssetManager.cpp index 3fd71a8e..b4ea7d35 100644 --- a/SHADE_Engine/src/Assets/SHAssetManager.cpp +++ b/SHADE_Engine/src/Assets/SHAssetManager.cpp @@ -83,7 +83,7 @@ namespace SHADE AssetPath SHAssetManager::GenerateLocalPath(AssetPath path) noexcept { - if (!IsRecognised(path.extension().string().c_str())) + if (!SHFileSystem::IsRecognised(path.extension().string().c_str())) { //TODO:ASSERT UNRECOGNISED FILE TYPE return std::filesystem::path(); @@ -161,21 +161,39 @@ namespace SHADE newPath += PREFAB_FOLDER; newPath += name; newPath += PREFAB_EXTENSION; - data = new SHPrefabAsset(); + { + auto prefab = new SHPrefabAsset(); + prefab->name = name; + + data = prefab; + } + break; case AssetType::SCENE: newPath += SCENE_FOLDER; newPath += name; newPath += SCENE_EXTENSION; - data = new SHSceneAsset(); + + { + auto scene = new SHSceneAsset(); + scene->name = name; + + data = scene; + } break; case AssetType::MATERIAL: newPath += MATERIAL_FOLDER; newPath += name; newPath += MATERIAL_EXTENSION; - data = new SHMaterialAsset(); + + { + auto material = new SHMaterialAsset(); + material->name = name; + + data = material; + } break; default: @@ -192,7 +210,7 @@ namespace SHADE false }; - assetCollection.insert({ + auto result = assetCollection.emplace( id, SHAsset( name, @@ -201,10 +219,13 @@ namespace SHADE newPath, false ) - }); + ); assetData.emplace(id, data); + SHAssetMetaHandler::WriteMetaData(asset); + SaveAsset(id); + return id; } @@ -338,7 +359,7 @@ namespace SHADE return result; } - void SHAssetManager::CompileAsset(AssetPath const& path) noexcept + void SHAssetManager::CompileAsset(AssetPath const& path, bool genMeta) noexcept { if (!std::filesystem::exists(path)) { @@ -360,10 +381,27 @@ namespace SHADE std::string modelPath = path.string().substr(0, path.string().find_last_of('.')); modelPath += MODEL_EXTENSION; newPath = modelPath; - - GenerateNewMeta(newPath); + } + else if (ext == DDS_EXTENSION.data()) + { + auto pathGen = SHTextureCompiler::CompileTextureAsset(path); + if (!pathGen.has_value()) + { + SHLOG_ERROR("Texture Compilation Failed for: {}", path.string()); + return; + } + newPath = pathGen.value(); + } + else + { + SHLOG_WARNING("File Type compilation not yet Implemented: {}", path.string()); + return; } + if (genMeta) + { + GenerateNewMeta(newPath); + } } FolderPointer SHAssetManager::GetRootFolder() noexcept @@ -371,18 +409,12 @@ namespace SHADE return folderRoot; } - bool SHAssetManager::IsRecognised(char const* ext) noexcept - { - for (auto const& e : EXTENSIONS) - { - if (strcmp(ext, e.data()) == 0) - { - return true; - } - } - - return false; - } + void SHAssetManager::RefreshDirectory() noexcept + { + SHFileSystem::DestroyDirectory(folderRoot); + //assetCollection.clear(); + BuildAssetCollection(); + } SHAsset SHAssetManager::CreateAssetFromPath(AssetPath path) noexcept { @@ -396,51 +428,6 @@ namespace SHADE return result; } - void SHAssetManager::CompileAll() noexcept - { - std::vector paths; - - for (auto const& dir : std::filesystem::recursive_directory_iterator{ ASSET_ROOT }) - { - if (dir.is_regular_file()) - { - for (auto const& ext : EXTERNALS) - { - if (dir.path().extension().string() == ext.data()) - { - paths.push_back(dir.path()); - } - } - } - } - - for (auto const& path : paths) - { - AssetPath newPath; - auto const ext{ path.extension().string() }; - if (ext == GLSL_EXTENSION.data()) - { - newPath = SHShaderSourceCompiler::LoadAndCompileShader(path).value(); - } - else if (ext == DDS_EXTENSION.data()) - { - newPath = SHTextureCompiler::CompileTextureAsset(path).value(); - } - else if (ext == GLTF_EXTENSION.data() || ext == FBX_EXTENSION.data()) - { - std::string command = MODEL_COMPILER_EXE.data(); - command += " " + path.string(); - std::system(command.c_str()); - - std::string modelPath = path.string().substr(0, path.string().find_last_of('.')); - modelPath += MODEL_EXTENSION; - newPath = modelPath; - } - - GenerateNewMeta(newPath); - } - } - bool SHAssetManager::DeleteLocalFile(AssetPath path) noexcept { //TODO Move this to dedicated library @@ -536,7 +523,7 @@ namespace SHADE { } - void SHAssetManager::GenerateNewMeta(AssetPath path) noexcept + std::optional SHAssetManager::GenerateNewMeta(AssetPath path) noexcept { auto const ext = path.extension().string(); if (ext == SHADER_BUILT_IN_EXTENSION.data()) @@ -556,7 +543,7 @@ namespace SHADE { SHAsset newAsset{ path.stem().string(), - GenerateAssetID(AssetType::SHADER_BUILT_IN), + GenerateAssetID(AssetType::TEXTURE), AssetType::SHADER_BUILT_IN, path, false @@ -597,11 +584,63 @@ namespace SHADE SHAssetMetaHandler::WriteMetaData(assetCollection[newAsset.id]); } + else if (ext == SCRIPT_EXTENSION) + { + SHAsset newAsset{ + path.stem().string(), + GenerateAssetID(AssetType::SCRIPT), + AssetType::SCRIPT, + path, + false + }; + assetCollection.emplace(newAsset.id, newAsset); + SHAssetMetaHandler::WriteMetaData(newAsset); + + return newAsset.id; + } + else if (ext == SCENE_EXTENSION) + { + SHAsset newAsset{ + path.stem().string(), + GenerateAssetID(AssetType::SCENE), + AssetType::SCENE, + path, + false + }; + assetCollection.emplace(newAsset.id, newAsset); + SHAssetMetaHandler::WriteMetaData(newAsset); + + return newAsset.id; + } + else if (ext == FONT_EXTENSION) + { + SHAsset newAsset{ + path.stem().string(), + GenerateAssetID(AssetType::FONT), + AssetType::FONT, + path, + false + }; + assetCollection.emplace(newAsset.id, newAsset); + SHAssetMetaHandler::WriteMetaData(newAsset); + + return newAsset.id; + } } void SHAssetManager::BuildAssetCollection() noexcept { - SHFileSystem::BuildDirectory(ASSET_ROOT.data(), folderRoot, assetCollection); + std::vector toGenNew; + SHFileSystem::BuildDirectory(ASSET_ROOT.data(), folderRoot, assetCollection, toGenNew); + + for (auto& file : toGenNew) + { + auto newID{ GenerateNewMeta(file->path) }; + if (newID.has_value()) + { + file->assetMeta = &assetCollection[newID.value()]; + } + } for (auto& asset : std::ranges::views::values(assetCollection)) { @@ -611,6 +650,12 @@ namespace SHADE for (auto i{ 0 }; i < asset.subAssets.size(); ++i) { auto const id = asset.subAssets[i]->id; + + if (assetCollection.contains(id)) + { + continue; + } + assetCollection[id] = *asset.subAssets[i]; delete asset.subAssets[i]; asset.subAssets[i] = &assetCollection[id]; diff --git a/SHADE_Engine/src/Assets/SHAssetManager.h b/SHADE_Engine/src/Assets/SHAssetManager.h index ba10d84f..f6ecb3a3 100644 --- a/SHADE_Engine/src/Assets/SHAssetManager.h +++ b/SHADE_Engine/src/Assets/SHAssetManager.h @@ -87,9 +87,10 @@ namespace SHADE static std::vector GetAllDataOfType(AssetType type) noexcept; static std::vector GetAllRecordOfType(AssetType type) noexcept; - static void CompileAsset(AssetPath const& path) noexcept; + static void CompileAsset(AssetPath const& path, bool genMeta) noexcept; static FolderPointer GetRootFolder() noexcept; + static void RefreshDirectory() noexcept; private: @@ -98,16 +99,12 @@ namespace SHADE static SHAssetData* LoadData(SHAsset const& asset) noexcept; static SHAssetData* LoadSubData(SHAsset const& asset) noexcept; static void LoadNewData(AssetPath path) noexcept; - static void GenerateNewMeta(AssetPath path) noexcept; + static std::optional GenerateNewMeta(AssetPath path) noexcept; inline static void BuildAssetCollection() noexcept; - - static bool IsRecognised(char const*) noexcept; static SHAsset CreateAssetFromPath(AssetPath path) noexcept; - static void CompileAll() noexcept; - static bool DeleteLocalFile(AssetPath path) noexcept; //TODO use this function to create asset data internall at all calls to generate id diff --git a/SHADE_Engine/src/Assets/SHAssetMetaHandler.cpp b/SHADE_Engine/src/Assets/SHAssetMetaHandler.cpp index 9ae8cde2..b5c78514 100644 --- a/SHADE_Engine/src/Assets/SHAssetMetaHandler.cpp +++ b/SHADE_Engine/src/Assets/SHAssetMetaHandler.cpp @@ -38,7 +38,7 @@ namespace SHADE ****************************************************************************/ AssetType SHAssetMetaHandler::GetTypeFromExtension(AssetExtension ext) noexcept { - for (int i{0}; i < EXTENSIONS->size(); ++i) + for (auto i{0}; i < EXTENSIONS_COUNT; ++i) { if (strcmp(ext.c_str(), EXTENSIONS[i].data()) == 0) { @@ -98,6 +98,7 @@ namespace SHADE meta.type = static_cast(type); meta.isSubAsset = false; + meta.parent = 0; // Burn Line if (std::getline(metaFile, line)) @@ -137,6 +138,7 @@ namespace SHADE metaFile.close(); meta.path = path.parent_path().string() + "/" + path.stem().string(); + meta.path.make_preferred(); return meta; } diff --git a/SHADE_Engine/src/Camera/SHCameraDirector.cpp b/SHADE_Engine/src/Camera/SHCameraDirector.cpp index 98341098..9e9ddb5c 100644 --- a/SHADE_Engine/src/Camera/SHCameraDirector.cpp +++ b/SHADE_Engine/src/Camera/SHCameraDirector.cpp @@ -5,7 +5,7 @@ #include "ECS_Base/Managers/SHComponentManager.h" #include "ECS_Base/SHECSMacros.h" #include "ECS_Base/Managers/SHEntityManager.h" -#include "Tools/SHLog.h" +#include "Tools/Logger/SHLog.h" namespace SHADE { diff --git a/SHADE_Engine/src/Camera/SHCameraSystem.cpp b/SHADE_Engine/src/Camera/SHCameraSystem.cpp index d5bd414d..ff942666 100644 --- a/SHADE_Engine/src/Camera/SHCameraSystem.cpp +++ b/SHADE_Engine/src/Camera/SHCameraSystem.cpp @@ -7,13 +7,15 @@ #include "ECS_Base/Managers/SHComponentManager.h" #include "Math/Transform/SHTransformComponent.h" #include - +#include "Scene/SHSceneManager.h" namespace SHADE { void SHCameraSystem::UpdateEditorCamera(double dt) noexcept { + + auto& camera = editorCamera; SHVec3 view, right, UP; GetCameraAxis(camera, view, right, UP); @@ -61,63 +63,43 @@ namespace SHADE } UpdateCameraComponent(editorCamera); + } + + void SHCameraSystem::UpdateEditorArm(double dt,bool active ,SHVec3 const& targetPos) noexcept + { + if (active == false) + { + editorCameraArm.offset = SHVec3{0.0f}; + return; + } + + editorCamera.SetPosition(targetPos); + double mouseX, mouseY; + SHInputManager::GetMouseVelocity(&mouseX, &mouseY); + + editorCameraArm.pitch -= mouseY * dt * editorCamera.turnSpeed.x; + editorCameraArm.yaw -= mouseX * dt * editorCamera.turnSpeed.y; + + constexpr float pitchClamp = 85.0f; + + if (editorCameraArm.pitch > pitchClamp) + editorCameraArm.pitch = pitchClamp; + if (editorCameraArm.pitch < -pitchClamp) + editorCameraArm.pitch = -pitchClamp; + + editorCameraArm.armLength -= SHInputManager::GetMouseWheelVerticalDelta() * dt; + + if (editorCameraArm.armLength < 1.0f) + editorCameraArm.armLength = 1.0f; + + UpdatePivotArmComponent(editorCameraArm); + + editorCamera.offset = editorCameraArm.GetOffset(); + + CameraLookAt(editorCamera, targetPos); } - void SHCameraSystem::EditorCameraUpdate::Execute(double dt) noexcept - { - SHCameraSystem* system = static_cast(GetSystem()); - auto& camera = system->editorCamera; - SHVec3 view, right, UP; - system->GetCameraAxis(camera, view, right, UP); - if (SHInputManager::GetKey(SHInputManager::SH_KEYCODE::A)) - { - //std::cout << "Camera movement: "<UpdateCameraComponent(system->editorCamera); - - system->DecomposeViewMatrix(camera.viewMatrix, camera.pitch, camera.yaw, camera.roll, camera.position); - } void SHCameraSystem::Init(void) { @@ -164,6 +146,9 @@ namespace SHADE void SHCameraSystem::UpdateCameraComponent(SHCameraComponent& camera) noexcept { + if (camera.isActive == false) + return; + if (SHComponentManager::HasComponent(camera.GetEID()) == true && &camera != &editorCamera) { auto transform = SHComponentManager::GetComponent(camera.GetEID()); @@ -183,11 +168,17 @@ namespace SHADE if (SHComponentManager::HasComponent(camera.GetEID())) { auto arm = SHComponentManager::GetComponent(camera.GetEID()); - camera.offset = arm->GetOffset(); - if(arm->lookAtCameraOrigin) - CameraLookAt(camera, camera.position); + if (arm->isActive == true) + { + camera.offset = arm->GetOffset(); + if (arm->lookAtCameraOrigin) + CameraLookAt(camera, camera.position); + } + } + + SHVec3 view, right, UP; @@ -287,12 +278,14 @@ namespace SHADE for (auto& pivot : pivotDense) { - system->UpdatePivotArmComponent(pivot); + if(SHSceneManager::CheckNodeAndComponentsActive(pivot.GetEID())) + system->UpdatePivotArmComponent(pivot); } for (auto& cam : dense) { - system->UpdateCameraComponent(cam); + if (SHSceneManager::CheckNodeAndComponentsActive(cam.GetEID())) + system->UpdateCameraComponent(cam); } for (auto& handle : system->directorHandleList) { @@ -399,7 +392,7 @@ namespace SHADE SHVec3 up = { 0.0f,1.0f,0.0f }; - ////SHVec3::RotateZ(target, SHMath::DegreesToRadians(camera.roll)); + //SHVec3::RotateZ(target, SHMath::DegreesToRadians(camera.roll)); //target = SHVec3::Normalise(target); diff --git a/SHADE_Engine/src/Camera/SHCameraSystem.h b/SHADE_Engine/src/Camera/SHCameraSystem.h index 98fd442f..fc6e9166 100644 --- a/SHADE_Engine/src/Camera/SHCameraSystem.h +++ b/SHADE_Engine/src/Camera/SHCameraSystem.h @@ -5,6 +5,7 @@ #include "ECS_Base/System/SHSystemRoutine.h" #include "Resource/SHResourceLibrary.h" #include "SHCameraDirector.h" +#include "SHCameraArmComponent.h" #include "SH_API.h" namespace SHADE @@ -18,6 +19,7 @@ namespace SHADE //A camera component that represents editor camera. //This is not tied to any entity. Hence this EID should not be used. SHCameraComponent editorCamera; + SHCameraArmComponent editorCameraArm; SHResourceLibrary directorLibrary; std::vector directorHandleList; @@ -34,14 +36,7 @@ namespace SHADE void Init (void); void Exit (void); - class SH_API EditorCameraUpdate final : public SHSystemRoutine - { - public: - EditorCameraUpdate() : SHSystemRoutine("Editor Camera Update", true) { }; - virtual void Execute(double dt) noexcept override final; - - }; friend class EditorCameraUpdate; class SH_API CameraSystemUpdate final: public SHSystemRoutine @@ -63,6 +58,7 @@ namespace SHADE void DecomposeViewMatrix(SHMatrix const& matrix, float& pitch, float& yaw, float& roll, SHVec3& pos) noexcept; void SetCameraViewMatrix(SHCameraComponent& camera, SHMatrix const& viewMatrix) noexcept; void CameraLookAt(SHCameraComponent& camera, SHVec3 target) noexcept; + void UpdateEditorArm(double dt,bool active ,SHVec3 const& targetPos) noexcept; }; diff --git a/SHADE_Engine/src/ECS_Base/UnitTesting/SHECSUnitTest.cpp b/SHADE_Engine/src/ECS_Base/UnitTesting/SHECSUnitTest.cpp index 050d0c2e..db41d848 100644 --- a/SHADE_Engine/src/ECS_Base/UnitTesting/SHECSUnitTest.cpp +++ b/SHADE_Engine/src/ECS_Base/UnitTesting/SHECSUnitTest.cpp @@ -5,7 +5,7 @@ #include "../Managers/SHSystemManager.h" #include "SHTestComponents.h" #include "SHTestSystems.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" diff --git a/SHADE_Engine/src/Editor/Command/SHCommandManager.cpp b/SHADE_Engine/src/Editor/Command/SHCommandManager.cpp index 3c0ee5dd..b86f9247 100644 --- a/SHADE_Engine/src/Editor/Command/SHCommandManager.cpp +++ b/SHADE_Engine/src/Editor/Command/SHCommandManager.cpp @@ -10,63 +10,102 @@ namespace SHADE { - SHCommandManager::CommandStack SHCommandManager::undoStack{}; - SHCommandManager::CommandStack SHCommandManager::redoStack{}; + + SHCommandManager::CommandStack SHCommandManager::undoStack(defaultStackSize); + SHCommandManager::CommandStack SHCommandManager::redoStack(defaultStackSize); + SHCommandManager::CommandStack SHCommandManager::secondaryUndoStack(defaultStackSize); + SHCommandManager::CommandStack SHCommandManager::secondaryRedoStack(defaultStackSize); + + SHCommandManager::CommandStackPtr SHCommandManager::pCurrUndoStack(&undoStack); + SHCommandManager::CommandStackPtr SHCommandManager::pCurrRedoStack(&redoStack); void SHCommandManager::PerformCommand(BaseCommandPtr commandPtr, bool const& overrideValue) { - redoStack = CommandStack(); + *pCurrRedoStack = CommandStack(defaultStackSize); commandPtr->Execute(); - if (overrideValue && !undoStack.empty()) + if (overrideValue && !pCurrUndoStack->Empty()) { - undoStack.top()->Merge(commandPtr); + pCurrUndoStack->Top()->Merge(commandPtr); } else { - undoStack.push(commandPtr); + pCurrUndoStack->Push(commandPtr); } } void SHCommandManager::RegisterCommand(BaseCommandPtr commandPtr) { - undoStack.push(commandPtr); + pCurrUndoStack->Push(commandPtr); } void SHCommandManager::UndoCommand() { - if (undoStack.empty()) + if (pCurrUndoStack->Empty()) return; - undoStack.top()->Undo(); - redoStack.push(undoStack.top()); - undoStack.pop(); + pCurrUndoStack->Top()->Undo(); + pCurrRedoStack->Push(pCurrUndoStack->Top()); + pCurrUndoStack->Pop(); } void SHCommandManager::RedoCommand() { - if (redoStack.empty()) + if (pCurrRedoStack->Empty()) return; - redoStack.top()->Execute(); - undoStack.push(redoStack.top()); - redoStack.pop(); + pCurrRedoStack->Top()->Execute(); + pCurrUndoStack->Push(pCurrRedoStack->Top()); + pCurrRedoStack->Pop(); } std::size_t SHCommandManager::GetUndoStackSize() { - return undoStack.size(); + return pCurrUndoStack->Size(); } std::size_t SHCommandManager::GetRedoStackSize() { - return redoStack.size(); + return pCurrRedoStack->Size(); } void SHCommandManager::PopLatestCommandFromRedoStack() { - redoStack.pop(); + pCurrRedoStack->Pop(); } void SHCommandManager::PopLatestCommandFromUndoStack() { - undoStack.pop(); + pCurrUndoStack->Pop(); } + + void SHCommandManager::SwapStacks() + { + if (pCurrUndoStack == &undoStack) + { + pCurrUndoStack = &secondaryUndoStack; + } + else + { + secondaryUndoStack.Clear(); + pCurrUndoStack = &undoStack; + } + + if (pCurrRedoStack == &redoStack) + { + pCurrRedoStack = &secondaryRedoStack; + } + else + { + secondaryRedoStack.Clear(); + pCurrRedoStack = &redoStack; + } + } + + void SHCommandManager::ClearAll() + { + undoStack.Clear(); + redoStack.Clear(); + + secondaryUndoStack.Clear(); + secondaryRedoStack.Clear(); + } + }//namespace SHADE diff --git a/SHADE_Engine/src/Editor/Command/SHCommandManager.h b/SHADE_Engine/src/Editor/Command/SHCommandManager.h index a514c464..178347b5 100644 --- a/SHADE_Engine/src/Editor/Command/SHCommandManager.h +++ b/SHADE_Engine/src/Editor/Command/SHCommandManager.h @@ -10,6 +10,7 @@ //#==============================================================# #include "SHCommand.hpp" #include "SH_API.h" +#include "Tools/SHDeque.h" namespace SHADE { @@ -22,7 +23,8 @@ namespace SHADE using BaseCommandPtr = std::shared_ptr; template using SHCommandPtr = std::shared_ptr>; - using CommandStack = std::stack; + using CommandStack = SHDeque; + using CommandStackPtr = CommandStack*; static void PerformCommand(BaseCommandPtr commandPtr, bool const& overrideValue = false); static void RegisterCommand(BaseCommandPtr commandPtr); @@ -34,8 +36,17 @@ namespace SHADE static void PopLatestCommandFromRedoStack(); static void PopLatestCommandFromUndoStack(); + static void SwapStacks(); + static void ClearAll(); + + static constexpr CommandStack::SizeType defaultStackSize = 100; private: + static CommandStackPtr pCurrUndoStack; + static CommandStackPtr pCurrRedoStack; + static CommandStack undoStack; + static CommandStack secondaryUndoStack; static CommandStack redoStack; + static CommandStack secondaryRedoStack; }; }//namespace SHADE diff --git a/SHADE_Engine/src/Editor/EditorWindow/AssetBrowser/SHAssetBrowser.cpp b/SHADE_Engine/src/Editor/EditorWindow/AssetBrowser/SHAssetBrowser.cpp index 37b8ecd4..889c24cc 100644 --- a/SHADE_Engine/src/Editor/EditorWindow/AssetBrowser/SHAssetBrowser.cpp +++ b/SHADE_Engine/src/Editor/EditorWindow/AssetBrowser/SHAssetBrowser.cpp @@ -13,11 +13,12 @@ #include "Editor/SHEditor.h" #include "Editor/DragDrop/SHDragDrop.hpp" #include "Editor/EditorWindow/MaterialInspector/SHMaterialInspector.h" +#include "Editor/EditorWindow/SHEditorWindowManager.h" namespace SHADE { SHAssetBrowser::SHAssetBrowser() - :SHEditorWindow("\xee\x8b\x87 Asset Browser", ImGuiWindowFlags_MenuBar), rootFolder(SHAssetManager::GetRootFolder()), prevFolder(rootFolder), currentFolder(rootFolder), assetBeingCreated(std::nullopt) + :SHEditorWindow("\xee\x8b\x87 Asset Browser", ImGuiWindowFlags_MenuBar), rootFolder(SHAssetManager::GetRootFolder()), prevFolder(rootFolder), currentFolder(rootFolder) { } @@ -34,23 +35,48 @@ namespace SHADE RecursivelyDrawTree(rootFolder); DrawMenuBar(); DrawCurrentFolder(); + DrawAssetBeingCreated(); + } ImGui::End(); + if(refreshQueued) + Refresh(); + } + + void SHAssetBrowser::QueueRefresh() noexcept + { + refreshQueued = true; + } + + void SHAssetBrowser::Refresh() noexcept + { + SHAssetManager::RefreshDirectory(); + rootFolder = SHAssetManager::GetRootFolder(); + refreshQueued = false; } void SHAssetBrowser::DrawMenuBar() { if (ImGui::BeginMenuBar()) { - + if(ImGui::SmallButton(ICON_MD_SYNC)) + { + QueueRefresh(); + } + if(ImGui::SmallButton(ICON_FA_CIRCLE_PLUS)) + { + isAssetBeingCreated = true; + } ImGui::EndMenuBar(); } } + //if !compiled, set genMeta to true + ImRect SHAssetBrowser::RecursivelyDrawTree(FolderPointer folder) { auto const& subFolders = folder->subFolders; - auto const& files = folder->files; + auto files = folder->files; const bool isSelected = std::ranges::find(selectedFolders, folder) != selectedFolders.end(); ImGuiTreeNodeFlags flags = (subFolders.empty() && files.empty()) ? ImGuiTreeNodeFlags_Leaf : ImGuiTreeNodeFlags_OpenOnArrow; if (isSelected) @@ -62,21 +88,10 @@ namespace SHADE ImGuiID folderID = ImGui::GetItemID(); const ImRect nodeRect = ImRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax()); - if (ImGui::BeginPopupContextItem()) - { - if (ImGui::BeginMenu("Create Asset")) - { - //TODO: Change to rttr type enum align - if (ImGui::Selectable("Material")) - { - assetBeingCreated = { folder, AssetType::MATERIAL, "New Material" }; - ImGui::TreeNodeSetOpen(folderID, true); - isOpen = true; - } - ImGui::EndMenu(); - } - ImGui::EndPopup(); - } + //if (ImGui::BeginPopupContextItem()) + //{ + // ImGui::EndPopup(); + //} if (ImGui::IsItemClicked()) { @@ -100,19 +115,15 @@ namespace SHADE drawList->AddLine(ImVec2(vertLineStart.x, midPoint), ImVec2(vertLineStart.x + horizontalLineSize, midPoint), treeLineColor, 1); vertLineEnd.y = midPoint; } - for (auto const& file : files) + for (auto& file : files) { - if(file.assetMeta == nullptr) - continue; const float horizontalLineSize = 25.0f; - const ImRect childRect = DrawFile(file.assetMeta); + const ImRect childRect = DrawFile(file); const float midPoint = (childRect.Min.y + childRect.Max.y) * 0.5f; drawList->AddLine(ImVec2(vertLineStart.x, midPoint), ImVec2(vertLineStart.x + horizontalLineSize, midPoint), treeLineColor, 1); vertLineEnd.y = midPoint; } drawList->AddLine(vertLineStart, vertLineEnd, treeLineColor, 1); - if(assetBeingCreated.has_value() && std::get<0>(assetBeingCreated.value()) == folder) - DrawAssetBeingCreated(); ImGui::TreePop(); } @@ -148,7 +159,33 @@ namespace SHADE //} } - ImRect SHAssetBrowser::DrawFile(SHAsset const* const asset) noexcept + ImRect SHAssetBrowser::DrawFile(SHFile& file) noexcept + { + if(file.compilable) + { + ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags_Leaf; + static constexpr std::string_view icon = ICON_MD_FILE_PRESENT; + ImGui::PushID(file.name.data()); + bool const isOpen = ImGui::TreeNodeEx(file.name.data(), flags, "%s %s%s", icon.data(), file.name.data(), file.ext.data()); + const ImRect nodeRect = ImRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax()); + if(ImGui::BeginPopupContextItem()) + { + if(ImGui::Selectable("Compile")) + { + SHAssetManager::CompileAsset(file.path, !file.compiled); + QueueRefresh(); + } + ImGui::EndPopup(); + } + ImGui::TreePop(); + ImGui::PopID(); + return nodeRect; + } + if(file.assetMeta) + DrawAsset(file.assetMeta, file.ext); + } + + ImRect SHAssetBrowser::DrawAsset(SHAsset const* const asset, FileExt const& ext /*= ""*/) noexcept { if (asset == nullptr) return ImRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax()); @@ -173,7 +210,7 @@ namespace SHADE default:; } - bool const isOpen = ImGui::TreeNodeEx(asset, flags, "%s %s", icon.data(), asset->name.data()); + bool const isOpen = ImGui::TreeNodeEx(asset, flags, "%s %s%s", icon.data(), asset->name.data(), ext.data()); const ImRect nodeRect = ImRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax()); if (SHDragDrop::BeginSource()) { @@ -212,7 +249,6 @@ namespace SHADE case AssetType::MAX_COUNT: break; default:; } - } //TODO: Combine Draw asset and Draw Folder recursive drawing @@ -227,7 +263,7 @@ namespace SHADE for(auto const& subAsset : asset->subAssets) { const float horizontalLineSize = 25.0f; - const ImRect childRect = DrawFile(subAsset); + const ImRect childRect = DrawAsset(subAsset); const float midPoint = (childRect.Min.y + childRect.Max.y) * 0.5f; drawList->AddLine(ImVec2(vertLineStart.x, midPoint), ImVec2(vertLineStart.x + horizontalLineSize, midPoint), treeLineColor, 1); vertLineEnd.y = midPoint; @@ -240,19 +276,52 @@ namespace SHADE void SHAssetBrowser::DrawAssetBeingCreated() noexcept { - if (!assetBeingCreated.has_value()) - return; - auto& path = std::get<0>(assetBeingCreated.value()); - auto& type = std::get<1>(assetBeingCreated.value()); - auto& assetName = std::get<2>(assetBeingCreated.value()); - if (ImGui::InputText("##newAssetName", &assetName, ImGuiInputTextFlags_EnterReturnsTrue)) + if(isAssetBeingCreated) + ImGui::OpenPopup(newAssetPopup.data()); + + if(ImGui::BeginPopupModal(newAssetPopup.data(), &isAssetBeingCreated)) { - AssetID assetId = SHAssetManager::CreateNewAsset(type, assetName); - if (auto matInspector = SHEditorWindowManager::GetEditorWindow()) + ImGui::RadioButton("Material", true); + ImGui::SameLine(); + if (ImGui::InputText("##newAssetName", &nameOfAssetBeingCreated, ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_CharsNoBlank | ImGuiInputTextFlags_AutoSelectAll)) { - matInspector->OpenMaterial(assetId, true); + AssetID assetId = SHAssetManager::CreateNewAsset(AssetType::MATERIAL, nameOfAssetBeingCreated); + if (auto matInspector = SHEditorWindowManager::GetEditorWindow()) + { + matInspector->OpenMaterial(assetId, true); + } + nameOfAssetBeingCreated.clear(); + QueueRefresh(); + isAssetBeingCreated = false; + ImGui::CloseCurrentPopup(); } - assetBeingCreated.reset(); + ImGui::EndPopup(); } + //if (ImGui::BeginMenu("Create Asset")) + //{ + // //TODO: Change to rttr type enum align + // if (ImGui::Selectable("Material")) + // { + // assetBeingCreated = { folder, AssetType::MATERIAL, "NewMaterial" }; + // ImGui::TreeNodeSetOpen(folderID, true); + // isOpen = true; + // } + // ImGui::EndMenu(); + //} + //if (!assetBeingCreated.has_value()) + // return; + //auto& path = std::get<0>(assetBeingCreated.value()); + //auto& type = std::get<1>(assetBeingCreated.value()); + //auto& assetName = std::get<2>(assetBeingCreated.value()); + //if (ImGui::InputText("##newAssetName", &assetName, ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_CharsNoBlank | ImGuiInputTextFlags_AutoSelectAll)) + //{ + // AssetID assetId = SHAssetManager::CreateNewAsset(type, assetName); + // if (auto matInspector = SHEditorWindowManager::GetEditorWindow()) + // { + // matInspector->OpenMaterial(assetId, true); + // } + // assetBeingCreated.reset(); + // QueueRefresh(); + //} } } diff --git a/SHADE_Engine/src/Editor/EditorWindow/AssetBrowser/SHAssetBrowser.h b/SHADE_Engine/src/Editor/EditorWindow/AssetBrowser/SHAssetBrowser.h index 00023ebe..6d3c5eb4 100644 --- a/SHADE_Engine/src/Editor/EditorWindow/AssetBrowser/SHAssetBrowser.h +++ b/SHADE_Engine/src/Editor/EditorWindow/AssetBrowser/SHAssetBrowser.h @@ -10,24 +10,29 @@ namespace SHADE class SHAssetBrowser final : public SHEditorWindow { public: - using AssetEntry = std::tuple; SHAssetBrowser(); void Init(); void Update(); - void Refresh(); + void QueueRefresh() noexcept; private: void DrawMenuBar(); ImRect RecursivelyDrawTree(FolderPointer folder); void DrawCurrentFolder(); - ImRect DrawFile(SHAsset const* const asset) noexcept; + ImRect DrawFile(SHFile& file) noexcept; + ImRect DrawAsset(SHAsset const* const asset, FileExt const& ext = "") noexcept; void DrawAssetBeingCreated() noexcept; + void Refresh() noexcept; + FolderPointer rootFolder, prevFolder, currentFolder; - std::optional assetBeingCreated; std::vector selectedFolders; std::vector selectedAssets; static constexpr float tileWidth = 50.0f; + bool refreshQueued = false; + bool isAssetBeingCreated = false; + static constexpr std::string_view newAssetPopup = "Create New Asset"; + std::string nameOfAssetBeingCreated; }; } diff --git a/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.cpp b/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.cpp index ff65ba58..cf545223 100644 --- a/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.cpp +++ b/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.cpp @@ -15,6 +15,7 @@ #include "Editor/DragDrop/SHDragDrop.hpp" #include "Tools/SHException.h" #include "Editor/IconsMaterialDesign.h" +#include "SHHierarchyPanelCommands.h" //#==============================================================# //|| Library Includes || @@ -22,7 +23,7 @@ #include #include "Serialization/SHSerialization.h" -#include "Tools/SHClipboardUtilities.h" +#include "Tools/Utilities/SHClipboardUtilities.h" namespace SHADE @@ -105,14 +106,21 @@ namespace SHADE PasteEntities(editor->selectedEntities.back()); } } + if(ImGui::IsKeyReleased(ImGuiKey_Delete)) + { + DeleteSelectedEntities(); + } } } if(ImGui::IsWindowHovered() && !ImGui::IsAnyItemHovered() && ImGui::IsMouseReleased(ImGuiMouseButton_Left)) { - ParentSelectedEntities(MAX_EID, draggingEntities); - draggingEntities.clear(); - ImGui::ClearDragDrop(); + if(ImGui::IsDragDropActive()) + { + ParentSelectedEntities(MAX_EID, draggingEntities); + draggingEntities.clear(); + ImGui::ClearDragDrop(); + } } ImGui::End(); } @@ -255,9 +263,10 @@ namespace SHADE PasteEntities(eid); skipFrame = true; } - if (ImGui::Selectable(std::format("{} Delete", ICON_MD_DELETE).data())) + if (ImGui::Selectable(std::format("{} Delete selected", ICON_MD_DELETE).data())) { - SHEntityManager::DestroyEntity(eid); + //SHEntityManager::DestroyEntity(eid); + DeleteSelectedEntities(); } if ((currentNode->GetParent() != sceneGraph.GetRoot()) && ImGui::Selectable(std::format("{} Unparent Selected", ICON_MD_NORTH_WEST).data())) @@ -282,9 +291,12 @@ namespace SHADE } else editor->selectedEntities.clear(); } - else if (!ImGui::IsKeyDown(ImGuiKey_LeftCtrl)) - editor->selectedEntities.clear(); - editor->selectedEntities.push_back(eid); + else + { + if (!ImGui::IsKeyDown(ImGuiKey_LeftCtrl)) + editor->selectedEntities.clear(); + editor->selectedEntities.push_back(eid); + } }//if not selected else { @@ -333,10 +345,18 @@ namespace SHADE void SHHierarchyPanel::ParentSelectedEntities(EntityID parentEID, std::vector const& entities) const noexcept { auto const& sceneGraph = SHSceneManager::GetCurrentSceneGraph(); + + std::vector entitiesToParent{}; + std::ranges::copy_if(entities, std::back_inserter(entitiesToParent), [&sceneGraph](EntityID const& eid) + { + if (sceneGraph.GetParent(eid)->GetEntityID() == MAX_EID) + return true; + return false; + }); //auto const editor = SHSystemManager::GetSystem(); SHEntityParentCommand::EntityParentData entityParentData; std::vector parentedEIDS; - for (auto const& eid : entities) + for (auto const& eid : entitiesToParent) { if(eid == parentEID) continue; @@ -365,14 +385,16 @@ namespace SHADE if (eid == beginEID || eid == endEID) { startSelecting = true; - editor->selectedEntities.push_back(eid); + if(std::ranges::find(editor->selectedEntities, eid) == editor->selectedEntities.end()) + editor->selectedEntities.push_back(eid); } } else { if (!endSelecting) { - editor->selectedEntities.push_back(eid); + if (std::ranges::find(editor->selectedEntities, eid) == editor->selectedEntities.end()) + editor->selectedEntities.push_back(eid); if (eid == endEID || eid == beginEID) { endSelecting = true; @@ -397,47 +419,39 @@ namespace SHADE void SHHierarchyPanel::CopySelectedEntities() { const auto editor = SHSystemManager::GetSystem(); - SHClipboardUtilities::WriteToClipboard(SHSerialization::SerializeEntitiesToString(editor->selectedEntities)); + auto const& sceneGraph = SHSceneManager::GetCurrentSceneGraph(); + std::vector entitiesToCopy{}; + std::ranges::copy_if(editor->selectedEntities, std::back_inserter(entitiesToCopy), [&sceneGraph](EntityID const& eid) + { + if(sceneGraph.GetParent(eid)->GetEntityID() == MAX_EID) + return true; + return false; + }); + SHClipboardUtilities::WriteToClipboard(SHSerialization::SerializeEntitiesToString(entitiesToCopy)); } void SHHierarchyPanel::PasteEntities(EntityID parentEID) { - SetScrollTo(SHSerialization::DeserializeEntitiesFromString(SHClipboardUtilities::GetDataFromClipboard(), parentEID)); + //SetScrollTo(SHSerialization::DeserializeEntitiesFromString(SHClipboardUtilities::GetDataFromClipboard(), parentEID).front()); + SHCommandManager::PerformCommand(std::make_shared(SHClipboardUtilities::GetDataFromClipboard(), parentEID)); } - void SHCreateEntityCommand::Execute() + void SHHierarchyPanel::DeleteSelectedEntities() { - EntityID newEID = SHEntityManager::CreateEntity(eid); - if (eid == MAX_EID) - eid = newEID; + const auto editor = SHSystemManager::GetSystem(); + auto const& sceneGraph = SHSceneManager::GetCurrentSceneGraph(); + + std::vector entitiesToDelete{}; + std::ranges::copy_if(editor->selectedEntities, std::back_inserter(entitiesToDelete), [&sceneGraph, &selectedEntities = editor->selectedEntities](EntityID const& eid) + { + EntityID parentEID = sceneGraph.GetParent(eid)->GetEntityID(); + if (parentEID == MAX_EID) + return true; + else if(std::ranges::find(selectedEntities, parentEID) == selectedEntities.end()) + return true; + return false; + }); + SHCommandManager::PerformCommand(std::make_shared(entitiesToDelete)); } - void SHCreateEntityCommand::Undo() - { - SHEntityManager::DestroyEntity(eid); - } - - void SHEntityParentCommand::Execute() - { - auto& sceneGraph = SHSceneManager::GetCurrentSceneGraph(); - for (auto const& eid : entities) - { - if (entityParentData[eid].newParentEID == MAX_EID) - sceneGraph.SetParent(eid, nullptr); - else - sceneGraph.SetParent(eid, entityParentData[eid].newParentEID); - } - } - - void SHEntityParentCommand::Undo() - { - auto& sceneGraph = SHSceneManager::GetCurrentSceneGraph(); - for (auto const& eid : entities) - { - if (entityParentData[eid].oldParentEID == MAX_EID) - sceneGraph.SetParent(eid, nullptr); - else - sceneGraph.SetParent(eid, entityParentData[eid].oldParentEID); - } - } }//namespace SHADE diff --git a/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.h b/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.h index 64f841d6..66b9ca2f 100644 --- a/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.h +++ b/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanel.h @@ -10,7 +10,6 @@ #include "imgui_internal.h" #include "ECS_Base/SHECSMacros.h" #include "Editor/EditorWindow/SHEditorWindow.h" -#include "Editor/Command/SHCommand.hpp" namespace SHADE { class SHSceneNode; @@ -33,6 +32,7 @@ namespace SHADE void SelectAllEntities(); void CopySelectedEntities(); void PasteEntities(EntityID parentEID = MAX_EID); + void DeleteSelectedEntities(); bool skipFrame = false; std::string filter; bool isAnyNodeSelected = false; @@ -41,33 +41,4 @@ namespace SHADE };//class SHHierarchyPanel - //Might move to a different file - class SHCreateEntityCommand final : public SHBaseCommand - { - public: - void Execute() override; - void Undo() override; - private: - EntityID eid = MAX_EID; - }; - - class SHEntityParentCommand final : public SHBaseCommand - { - public: - struct Data - { - EntityID oldParentEID = MAX_EID; - EntityID newParentEID = MAX_EID; - }; - using EntityParentData = std::unordered_map; - - SHEntityParentCommand(std::vector entityIDs, EntityParentData inEntityParentData):entities(entityIDs),entityParentData(inEntityParentData){} - - void Execute() override; - void Undo() override; - private: - std::vector entities; - std::unordered_map entityParentData; - }; - }//namespace SHADE diff --git a/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanelCommands.cpp b/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanelCommands.cpp new file mode 100644 index 00000000..78545829 --- /dev/null +++ b/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanelCommands.cpp @@ -0,0 +1,84 @@ +#include "SHpch.h" +#include "SHHierarchyPanelCommands.h" +#include "ECS_Base/Managers/SHEntityManager.h" +#include "Scene/SHSceneManager.h" +#include "Serialization/SHSerialization.h" +#include "SHHierarchyPanel.h" +#include "Editor/EditorWindow/SHEditorWindowManager.h" + +namespace SHADE +{ + void SHCreateEntityCommand::Execute() + { + EntityID newEID = SHEntityManager::CreateEntity(eid); + if (eid == MAX_EID) + eid = newEID; + } + + void SHCreateEntityCommand::Undo() + { + SHEntityManager::DestroyEntity(eid); + } + + void SHEntityParentCommand::Execute() + { + auto& sceneGraph = SHSceneManager::GetCurrentSceneGraph(); + for (auto const& eid : entities) + { + if (entityParentData[eid].newParentEID == MAX_EID) + sceneGraph.SetParent(eid, nullptr); + else + sceneGraph.SetParent(eid, entityParentData[eid].newParentEID); + } + } + + void SHEntityParentCommand::Undo() + { + auto& sceneGraph = SHSceneManager::GetCurrentSceneGraph(); + for (auto const& eid : entities) + { + if (entityParentData[eid].oldParentEID == MAX_EID) + sceneGraph.SetParent(eid, nullptr); + else + sceneGraph.SetParent(eid, entityParentData[eid].oldParentEID); + } + } + + void SHPasteEntitiesCommand::Execute() + { + data.createdEntities.clear(); + data.createdEntities = SHSerialization::DeserializeEntitiesFromString(data.entityData, data.parentEID); + data.entityData = SHSerialization::ResolveSerializedEntityIndices(data.entityData, data.createdEntities); + SHEditorWindowManager::GetEditorWindow()->SetScrollTo(data.createdEntities.begin()->second); + } + + void SHPasteEntitiesCommand::Undo() + { + for (auto const& [oldEID, newEID] : data.createdEntities) + { + SHEntityManager::DestroyEntity(newEID); + } + } + + void SHDeleteEntitiesCommand::Execute() + { + if(!data.createdEntities.empty()) + { + for(auto& eid : data.entitiesToDelete) + { + eid = data.createdEntities[eid]; + } + } + data.entityData = SHSerialization::SerializeEntitiesToString(data.entitiesToDelete); + for (auto const& eid : data.entitiesToDelete) + { + SHEntityManager::DestroyEntity(eid); + } + } + + void SHDeleteEntitiesCommand::Undo() + { + data.createdEntities = SHSerialization::DeserializeEntitiesFromString(data.entityData); + data.entityData = SHSerialization::ResolveSerializedEntityIndices(data.entityData, data.createdEntities); + } +} diff --git a/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanelCommands.h b/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanelCommands.h new file mode 100644 index 00000000..fccd9489 --- /dev/null +++ b/SHADE_Engine/src/Editor/EditorWindow/HierarchyPanel/SHHierarchyPanelCommands.h @@ -0,0 +1,72 @@ +#pragma once + +#include + +#include "ECS_Base/SHECSMacros.h" +#include "Editor/Command/SHCommand.hpp" +#include "Serialization/SHSerialization.h" +namespace SHADE +{ + class SHCreateEntityCommand final : public SHBaseCommand + { + public: + void Execute() override; + void Undo() override; + private: + EntityID eid = MAX_EID; + }; + + class SHEntityParentCommand final : public SHBaseCommand + { + public: + struct Data + { + EntityID oldParentEID = MAX_EID; + EntityID newParentEID = MAX_EID; + }; + using EntityParentData = std::unordered_map; + + SHEntityParentCommand(std::vector entityIDs, EntityParentData inEntityParentData) :entities(entityIDs), entityParentData(inEntityParentData) {} + + void Execute() override; + void Undo() override; + private: + std::vector entities{}; + std::unordered_map entityParentData{}; + }; + + class SHPasteEntitiesCommand final : public SHBaseCommand + { + public: + struct Data + { + EntityID parentEID{MAX_EID}; + std::string entityData{}; + SHSerialization::CreatedEntitiesList createdEntities{}; + }; + SHPasteEntitiesCommand() = delete; + SHPasteEntitiesCommand(std::string const& serializedEntityData, EntityID parentEid = MAX_EID):data({parentEid, serializedEntityData, {}}){} + + void Execute() override; + void Undo() override; + private: + Data data; + }; + + class SHDeleteEntitiesCommand final : public SHBaseCommand + { + public: + struct Data + { + std::vector entitiesToDelete{}; + SHSerialization::CreatedEntitiesList createdEntities{}; + std::string entityData{}; + }; + SHDeleteEntitiesCommand() = delete; + SHDeleteEntitiesCommand(std::vector entitiesToBeDeleted): data{entitiesToBeDeleted}{} + void Execute() override; + void Undo() override; + private: + Data data; + }; +} diff --git a/SHADE_Engine/src/Editor/EditorWindow/Inspector/SHEditorComponentView.hpp b/SHADE_Engine/src/Editor/EditorWindow/Inspector/SHEditorComponentView.hpp index 85d10c1a..146e36c3 100644 --- a/SHADE_Engine/src/Editor/EditorWindow/Inspector/SHEditorComponentView.hpp +++ b/SHADE_Engine/src/Editor/EditorWindow/Inspector/SHEditorComponentView.hpp @@ -15,7 +15,7 @@ #include "Editor/SHEditorWidgets.hpp" #include "Graphics/MiddleEnd/Interface/SHRenderable.h" #include "Graphics/MiddleEnd/Lights/SHLightComponent.h" -#include "Physics/Components/SHColliderComponent.h" +#include "Physics/Interface/SHColliderComponent.h" #include "Reflection/SHReflectionMetadata.h" #include "Resource/SHResourceManager.h" @@ -68,10 +68,10 @@ namespace SHADE { if (!component) return; + const auto componentType = rttr::type::get(); ImGui::PushID(SHFamilyID::GetID()); SHEditorWidgets::CheckBox("##IsActive", [component]() {return component->isActive; }, [component](bool const& active) {component->isActive = active; }, "Is Component Active"); - ImGui::PopID(); ImGui::SameLine(); if (ImGui::CollapsingHeader(componentType.get_name().data())) { @@ -216,6 +216,8 @@ namespace SHADE } } else DrawContextMenu(component); + ImGui::PopID(); + } template<> @@ -223,6 +225,7 @@ namespace SHADE { if (!component) return; + ImGui::PushID(SHFamilyID::GetID()); const auto componentType = rttr::type::get(*component); SHEditorWidgets::CheckBox("##IsActive", [component]() {return component->isActive; }, [component](bool const& active) {component->isActive = active; }, "Is Component Active"); @@ -246,21 +249,21 @@ namespace SHADE if (collider->GetType() == SHCollisionShape::Type::BOX) { SHEditorWidgets::BeginPanel(std::format("{} Box #{}", ICON_FA_CUBE, i).data(), { ImGui::GetContentRegionAvail().x, ImGui::GetContentRegionAvail().y }); - auto box = reinterpret_cast(collider->GetShape()); + const auto* BOX = reinterpret_cast(collider->GetShape()); SHEditorWidgets::DragVec3 ( "Half Extents", { "X", "Y", "Z" }, - [box] { return box->GetRelativeExtents(); }, + [BOX] { return BOX->GetRelativeExtents(); }, [collider](SHVec3 const& vec) { collider->SetBoundingBox(vec); }); } else if (collider->GetType() == SHCollisionShape::Type::SPHERE) { SHEditorWidgets::BeginPanel(std::format("{} Sphere #{}", ICON_MD_CIRCLE, i).data(), { ImGui::GetContentRegionAvail().x, ImGui::GetContentRegionAvail().y }); - auto sphere = reinterpret_cast(collider->GetShape()); + const auto* SPHERE = reinterpret_cast(collider->GetShape()); SHEditorWidgets::DragFloat ( "Radius", - [sphere] { return sphere->GetRelativeRadius(); }, + [SPHERE] { return SPHERE->GetRelativeRadius(); }, [collider](float const& value) { collider->SetBoundingSphere(value); }); } else if (collider->GetType() == SHCollisionShape::Type::CAPSULE) @@ -322,6 +325,7 @@ namespace SHADE } } else DrawContextMenu(component); + ImGui::PopID(); } template<> @@ -329,6 +333,7 @@ namespace SHADE { if (!component) return; + ImGui::PushID(SHFamilyID::GetID()); const auto componentType = rttr::type::get(*component); SHEditorWidgets::CheckBox("##IsActive", [component]() {return component->isActive; }, [component](bool const& active) {component->isActive = active; }, "Is Component Active"); ImGui::SameLine(); @@ -352,6 +357,7 @@ namespace SHADE { DrawContextMenu(component); } + ImGui::PopID(); } template<> @@ -359,6 +365,7 @@ namespace SHADE { if (!component) return; + ImGui::PushID(SHFamilyID::GetID()); const auto componentType = rttr::type::get(*component); SHEditorWidgets::CheckBox("##IsActive", [component]() {return component->isActive; }, [component](bool const& active) {component->isActive = active; }, "Is Component Active"); ImGui::SameLine(); @@ -396,5 +403,6 @@ namespace SHADE { DrawContextMenu(component); } + ImGui::PopID(); } } diff --git a/SHADE_Engine/src/Editor/EditorWindow/Inspector/SHEditorInspector.cpp b/SHADE_Engine/src/Editor/EditorWindow/Inspector/SHEditorInspector.cpp index 2fecae25..f240e321 100644 --- a/SHADE_Engine/src/Editor/EditorWindow/Inspector/SHEditorInspector.cpp +++ b/SHADE_Engine/src/Editor/EditorWindow/Inspector/SHEditorInspector.cpp @@ -14,8 +14,8 @@ #include "Scripting/SHScriptEngine.h" #include "ECS_Base/Managers/SHSystemManager.h" -#include "Physics/Components/SHRigidBodyComponent.h" -#include "Physics/Components/SHColliderComponent.h" +#include "Physics/Interface/SHRigidBodyComponent.h" +#include "Physics/Interface/SHColliderComponent.h" #include "Camera/SHCameraComponent.h" #include "Camera/SHCameraArmComponent.h" #include "SHEditorComponentView.h" @@ -93,13 +93,14 @@ namespace SHADE { EntityID const& eid = editor->selectedEntities[0]; SHEntity* entity = SHEntityManager::GetEntityByID(eid); - if(!entity) + SHSceneNode* entityNode = SHSceneManager::GetCurrentSceneGraph().GetNode(eid); + if(!entity || !entityNode) { ImGui::End(); return; } ImGui::TextColored(ImGuiColors::green, "EID: %zu", eid); - SHEditorWidgets::CheckBox("##IsActive", [entity]()->bool {return entity->GetActive(); }, [entity](bool const& active) {entity->SetActive(active); }); + SHEditorWidgets::CheckBox("##IsActive", [entityNode]()->bool {return entityNode->IsActive(); }, [entityNode](bool const& active) {entityNode->SetActive(active); }); ImGui::SameLine(); ImGui::InputText("##EntityName", &entity->name); diff --git a/SHADE_Engine/src/Editor/EditorWindow/MenuBar/SHEditorMenuBar.cpp b/SHADE_Engine/src/Editor/EditorWindow/MenuBar/SHEditorMenuBar.cpp index cfb36cd0..2912a0bc 100644 --- a/SHADE_Engine/src/Editor/EditorWindow/MenuBar/SHEditorMenuBar.cpp +++ b/SHADE_Engine/src/Editor/EditorWindow/MenuBar/SHEditorMenuBar.cpp @@ -23,7 +23,7 @@ #include "Scene/SHSceneManager.h" #include "Serialization/SHSerialization.h" #include "Serialization/Configurations/SHConfigurationManager.h" - +#include "Editor/EditorWindow/SHEditorWindowManager.h" const std::string LAYOUT_FOLDER_PATH{ std::string(ASSET_ROOT) + "/Editor/Layouts" }; @@ -35,7 +35,7 @@ namespace SHADE constexpr ImGuiWindowFlags dockspaceFlags = ImGuiDockNodeFlags_PassthruCentralNode; - //#==============================================================# + //#==============================================================# //|| Public Member Functions || //#==============================================================# SHEditorMenuBar::SHEditorMenuBar() @@ -221,41 +221,29 @@ namespace SHADE ImGui::BeginDisabled(editor->editorState == SHEditor::State::PLAY); if(ImGui::SmallButton(ICON_MD_PLAY_ARROW)) { - if(editor->SaveScene()) + if(editor->editorState == SHEditor::State::STOP) { - const SHEditorStateChangeEvent STATE_CHANGE_EVENT + if (editor->SaveScene()) { - .previousState = editor->editorState - }; - editor->editorState = SHEditor::State::PLAY; - - SHEventManager::BroadcastEvent(STATE_CHANGE_EVENT, SH_EDITOR_ON_PLAY_EVENT); + editor->Play(); + } + } + else + { + editor->Play(); } } ImGui::EndDisabled(); - ImGui::BeginDisabled(editor->editorState == SHEditor::State::PAUSE); + ImGui::BeginDisabled(editor->editorState == SHEditor::State::STOP || editor->editorState == SHEditor::State::PAUSE); if(ImGui::SmallButton(ICON_MD_PAUSE)) { - const SHEditorStateChangeEvent STATE_CHANGE_EVENT - { - .previousState = editor->editorState - }; - editor->editorState = SHEditor::State::PAUSE; - - SHEventManager::BroadcastEvent(STATE_CHANGE_EVENT, SH_EDITOR_ON_PAUSE_EVENT); + editor->Pause(); } ImGui::EndDisabled(); ImGui::BeginDisabled(editor->editorState == SHEditor::State::STOP); if(ImGui::SmallButton(ICON_MD_STOP)) { - const SHEditorStateChangeEvent STATE_CHANGE_EVENT - { - .previousState = editor->editorState - }; - editor->editorState = SHEditor::State::STOP; - - SHEventManager::BroadcastEvent(STATE_CHANGE_EVENT, SH_EDITOR_ON_STOP_EVENT); - editor->LoadScene(SHSceneManager::GetCurrentSceneAssetID()); + editor->Stop(); } ImGui::EndDisabled(); ImGui::EndMenuBar(); diff --git a/SHADE_Engine/src/Editor/EditorWindow/SHEditorWindowManager.cpp b/SHADE_Engine/src/Editor/EditorWindow/SHEditorWindowManager.cpp new file mode 100644 index 00000000..420b5414 --- /dev/null +++ b/SHADE_Engine/src/Editor/EditorWindow/SHEditorWindowManager.cpp @@ -0,0 +1,8 @@ +#include "SHpch.h" +#include "SHEditorWindowManager.h" + +namespace SHADE +{ + SHEditorWindowManager::EditorWindowMap SHEditorWindowManager::editorWindows{}; + SHEditorWindowManager::EditorWindowID SHEditorWindowManager::windowCount{}; +} diff --git a/SHADE_Engine/src/Editor/EditorWindow/SHEditorWindowManager.h b/SHADE_Engine/src/Editor/EditorWindow/SHEditorWindowManager.h new file mode 100644 index 00000000..60730f0e --- /dev/null +++ b/SHADE_Engine/src/Editor/EditorWindow/SHEditorWindowManager.h @@ -0,0 +1,77 @@ +#pragma once + +#include +#include +#include "SHEditorWindow.h" +#include "Tools/Logger/SHLog.h" + +namespace SHADE +{ + class SH_API SHEditorWindowManager + { + public: + //#==============================================================# + //|| Type Aliases || + //#==============================================================# + using EditorWindowID = uint8_t; + using EditorWindowPtr = std::unique_ptr; + using EditorWindowMap = std::unordered_map; + /** + * @brief Get ID for the Editor Window Type + * + * @tparam T Type of Editor Window + * @return EditorWindowID ID of Editor Window Type + */ + template , bool> = true> + static EditorWindowID GetEditorWindowID() + { + static EditorWindowID id; + static bool idCreated = false; + if (!idCreated) + { + id = windowCount++; + idCreated = true; + } + return id; + } + + /** + * @brief Create an Editor Window + * + * @tparam T Type of Editor Window to create + */ + template , bool> = true> + static void CreateEditorWindow() + { + static bool isCreated = false; + if (!isCreated) + { + editorWindows[GetEditorWindowID()] = std::make_unique(); + isCreated = true; + } + else + { + SHLog::Warning("Attempt to create duplicate of Editor window type"); + } + } + + /** + * @brief Get pointer to the Editor Window + * + * @tparam T Type of editor window to retrieve + * @return T* Pointer to the editor window + */ + template , bool> = true> + static T* GetEditorWindow() + { + return reinterpret_cast(editorWindows[GetEditorWindowID()].get()); + } + + static EditorWindowMap editorWindows; + private: + // Number of windows; used for Editor Window ID Generation + static EditorWindowID windowCount; + // Map of Editor Windows + friend class SHEditor; + }; +} diff --git a/SHADE_Engine/src/Editor/EditorWindow/ViewportWindow/SHEditorViewport.cpp b/SHADE_Engine/src/Editor/EditorWindow/ViewportWindow/SHEditorViewport.cpp index d6ef8d19..564731d6 100644 --- a/SHADE_Engine/src/Editor/EditorWindow/ViewportWindow/SHEditorViewport.cpp +++ b/SHADE_Engine/src/Editor/EditorWindow/ViewportWindow/SHEditorViewport.cpp @@ -33,12 +33,31 @@ namespace SHADE void SHEditorViewport::Update() { SHEditorWindow::Update(); - if (shouldUpdateCamera) + auto camSystem = SHSystemManager::GetSystem(); + SHEditor* editor = SHSystemManager::GetSystem(); + + if (!editor->selectedEntities.empty()) + { + if (SHTransformComponent* transform = SHComponentManager::GetComponent_s(editor->selectedEntities.front())) + { + targetPos = transform->GetWorldPosition(); + } + else + { + targetPos = {}; + } + } + else + { + targetPos = {}; + } + if (shouldUpdateCamera || shouldUpdateCamArm) { - auto camSystem = SHSystemManager::GetSystem(); camSystem->UpdateEditorCamera(SHFrameRateController::GetRawDeltaTime()); shouldUpdateCamera = false; } + camSystem->UpdateEditorArm(SHFrameRateController::GetRawDeltaTime(), shouldUpdateCamArm, targetPos); + ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f)); if (Begin()) @@ -51,7 +70,6 @@ namespace SHADE beginCursorPos = ImGui::GetCursorScreenPos(); viewportMousePos = { mousePos.x - beginCursorPos.x, mousePos.y - beginCursorPos.y }; gfxSystem->GetMousePickSystem()->SetViewportMousePos(viewportMousePos); - ImGui::Image((ImTextureID)descriptorSet, { beginContentRegionAvailable.x, beginContentRegionAvailable.y }); if (ImGui::IsWindowHovered() && ImGui::IsMouseDown(ImGuiMouseButton_Right)) @@ -64,24 +82,28 @@ namespace SHADE shouldUpdateCamera = true; } - if (ImGui::IsWindowFocused() && !ImGui::IsMouseDown(ImGuiMouseButton_Right)) + + shouldUpdateCamArm = ImGui::IsWindowHovered() && ImGui::IsKeyDown(ImGuiKey_LeftAlt) && ImGui::IsMouseDown(ImGuiMouseButton_Left); + + if (editor->editorState != SHEditor::State::PLAY && !ImGui::IsAnyItemActive() && !ImGui::IsMouseDown(ImGuiMouseButton_Right)) { - if (ImGui::IsKeyReleased(ImGuiKey_Q)) + if (ImGui::IsKeyReleased(ImGuiKey_W)) { transformGizmo.operation = SHTransformGizmo::Operation::TRANSLATE; } - if (ImGui::IsKeyReleased(ImGuiKey_W)) + if (ImGui::IsKeyReleased(ImGuiKey_E)) { transformGizmo.operation = SHTransformGizmo::Operation::ROTATE; } - if (ImGui::IsKeyReleased(ImGuiKey_E)) + if (ImGui::IsKeyReleased(ImGuiKey_R)) { transformGizmo.operation = SHTransformGizmo::Operation::SCALE; } } } ImGuizmo::SetRect(beginCursorPos.x, beginCursorPos.y, beginContentRegionAvailable.x, beginContentRegionAvailable.y); - transformGizmo.Draw(); + if(editor->editorState != SHEditor::State::PLAY) + transformGizmo.Draw(); ImGui::End(); ImGui::PopStyleVar(); } @@ -129,7 +151,7 @@ namespace SHADE if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) { ImGui::BeginTooltip(); - ImGui::Text("Translate [Q]"); + ImGui::Text("Translate [W]"); ImGui::EndTooltip(); } if (isTranslate) @@ -147,7 +169,7 @@ namespace SHADE if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) { ImGui::BeginTooltip(); - ImGui::Text("Rotate [W]"); + ImGui::Text("Rotate [E]"); ImGui::EndTooltip(); } if (isRotate) @@ -165,7 +187,7 @@ namespace SHADE if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) { ImGui::BeginTooltip(); - ImGui::Text("Scale [E]"); + ImGui::Text("Scale [R]"); ImGui::EndTooltip(); } if (isScale) diff --git a/SHADE_Engine/src/Editor/EditorWindow/ViewportWindow/SHEditorViewport.h b/SHADE_Engine/src/Editor/EditorWindow/ViewportWindow/SHEditorViewport.h index 0fae4317..8f49c514 100644 --- a/SHADE_Engine/src/Editor/EditorWindow/ViewportWindow/SHEditorViewport.h +++ b/SHADE_Engine/src/Editor/EditorWindow/ViewportWindow/SHEditorViewport.h @@ -29,5 +29,7 @@ namespace SHADE void DrawMenuBar() noexcept; SHVec2 beginCursorPos; bool shouldUpdateCamera = false; + bool shouldUpdateCamArm = false; + SHVec3 targetPos; };//class SHEditorViewport }//namespace SHADE diff --git a/SHADE_Engine/src/Editor/Gizmos/SHTransformGizmo.cpp b/SHADE_Engine/src/Editor/Gizmos/SHTransformGizmo.cpp index e3bbc809..deea62fc 100644 --- a/SHADE_Engine/src/Editor/Gizmos/SHTransformGizmo.cpp +++ b/SHADE_Engine/src/Editor/Gizmos/SHTransformGizmo.cpp @@ -11,6 +11,8 @@ #include "Camera/SHCameraSystem.h" #include "Editor/Command/SHCommandManager.h" #include "Editor/EditorWindow/ViewportWindow/SHEditorViewport.h" +#include "Editor/EditorWindow/SHEditorWindowManager.h" + namespace SHADE { void SHTransformGizmo::Init() diff --git a/SHADE_Engine/src/Editor/SHEditor.cpp b/SHADE_Engine/src/Editor/SHEditor.cpp index c4ad3459..7372f227 100644 --- a/SHADE_Engine/src/Editor/SHEditor.cpp +++ b/SHADE_Engine/src/Editor/SHEditor.cpp @@ -10,7 +10,7 @@ //#==============================================================# //|| SHADE Includes || //#==============================================================# -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" #include "Tools/SHException.h" #include "ECS_Base/Managers/SHSystemManager.h" @@ -29,6 +29,7 @@ //#==============================================================# //|| Editor Window Includes || //#==============================================================# +#include "EditorWindow/SHEditorWindowManager.h" #include "EditorWindow/SHEditorWindowIncludes.h" //#==============================================================# @@ -77,8 +78,6 @@ namespace SHADE //#==============================================================# //Handle SHEditor::imguiCommandPool; //Handle SHEditor::imguiCommandBuffer; - SHEditorWindowManager::EditorWindowMap SHEditorWindowManager::editorWindows{}; - SHEditorWindowManager::EditorWindowID SHEditorWindowManager::windowCount{}; //std::vector SHEditor::selectedEntities; //#==============================================================# @@ -168,7 +167,19 @@ namespace SHADE { SHCommandManager::UndoCommand(); } - + if(ImGui::IsKeyReleased(ImGuiKey_F5)) + { + Play(); + } + else if (ImGui::IsKeyReleased(ImGuiKey_F6)) + { + Pause(); + } + else if (ImGui::IsKeyReleased(ImGuiKey_F7)) + { + Stop(); + } + Render(); } @@ -597,6 +608,48 @@ namespace SHADE } } + void SHEditor::Play() + { + if(editorState == State::PLAY) + return; + if (SaveScene()) + { + const SHEditorStateChangeEvent STATE_CHANGE_EVENT + { + .previousState = editorState + }; + editorState = State::PLAY; + SHCommandManager::SwapStacks(); + SHEventManager::BroadcastEvent(STATE_CHANGE_EVENT, SH_EDITOR_ON_PLAY_EVENT); + } + } + + void SHEditor::Pause() + { + if (editorState == State::PAUSE) + return; + const SHEditorStateChangeEvent STATE_CHANGE_EVENT + { + .previousState = editorState + }; + editorState = State::PAUSE; + SHEventManager::BroadcastEvent(STATE_CHANGE_EVENT, SH_EDITOR_ON_PAUSE_EVENT); + } + + void SHEditor::Stop() + { + if (editorState == State::STOP) + return; + const SHEditorStateChangeEvent STATE_CHANGE_EVENT + { + .previousState = editorState + }; + editorState = SHEditor::State::STOP; + SHCommandManager::SwapStacks(); + SHEventManager::BroadcastEvent(STATE_CHANGE_EVENT, SH_EDITOR_ON_STOP_EVENT); + LoadScene(SHSceneManager::GetCurrentSceneAssetID()); + } + void SHEditor::NewFrame() { SDL_Event event; diff --git a/SHADE_Engine/src/Editor/SHEditor.h b/SHADE_Engine/src/Editor/SHEditor.h index 0f5a3aaa..0a485109 100644 --- a/SHADE_Engine/src/Editor/SHEditor.h +++ b/SHADE_Engine/src/Editor/SHEditor.h @@ -15,7 +15,7 @@ #include "ECS_Base/System/SHSystemRoutine.h" #include "Resource/SHHandle.h" #include "EditorWindow/SHEditorWindow.h" -#include "Tools/SHLog.h" +#include "Tools/Logger/SHLog.h" #include "Gizmos/SHTransformGizmo.h" #include "Events/SHEventDefines.h" #include "Events/SHEvent.h" @@ -36,73 +36,7 @@ namespace SHADE class SHVkCommandBuffer; class SHVkCommandPool; - class SHEditorWindowManager - { - public: - //#==============================================================# - //|| Type Aliases || - //#==============================================================# - using EditorWindowID = uint8_t; - using EditorWindowPtr = std::unique_ptr; - using EditorWindowMap = std::unordered_map; - /** - * @brief Get ID for the Editor Window Type - * - * @tparam T Type of Editor Window - * @return EditorWindowID ID of Editor Window Type - */ - template , bool> = true> - static EditorWindowID GetEditorWindowID() - { - static EditorWindowID id; - static bool idCreated = false; - if (!idCreated) - { - id = windowCount++; - idCreated = true; - } - return id; - } - /** - * @brief Create an Editor Window - * - * @tparam T Type of Editor Window to create - */ - template , bool> = true> - static void CreateEditorWindow() - { - static bool isCreated = false; - if (!isCreated) - { - editorWindows[GetEditorWindowID()] = std::make_unique(); - isCreated = true; - } - else - { - SHLog::Warning("Attempt to create duplicate of Editor window type"); - } - } - - /** - * @brief Get pointer to the Editor Window - * - * @tparam T Type of editor window to retrieve - * @return T* Pointer to the editor window - */ - template , bool> = true> - static T* GetEditorWindow() - { - return reinterpret_cast(editorWindows[GetEditorWindowID()].get()); - } - - static EditorWindowMap editorWindows; - private: - // Number of windows; used for Editor Window ID Generation - static EditorWindowID windowCount; - // Map of Editor Windows - friend class SHEditor; - }; /** * @brief SHEditor static class contains editor variables and implementation of editor functions. @@ -184,6 +118,10 @@ namespace SHADE void LoadScene(AssetID const& assetID) noexcept; + void Play(); + void Pause(); + void Stop(); + // List of selected entities std::vector selectedEntities; diff --git a/SHADE_Engine/src/Editor/SHEditorUI.cpp b/SHADE_Engine/src/Editor/SHEditorUI.cpp index 49cfbfd6..40e08042 100644 --- a/SHADE_Engine/src/Editor/SHEditorUI.cpp +++ b/SHADE_Engine/src/Editor/SHEditorUI.cpp @@ -53,9 +53,12 @@ namespace SHADE /*-----------------------------------------------------------------------------------*/ /* ImGui Wrapper Functions - Organizers */ /*-----------------------------------------------------------------------------------*/ - bool SHEditorUI::CollapsingHeader(const std::string& title) + bool SHEditorUI::CollapsingHeader(const std::string& title, bool* isHovered) { - return ImGui::CollapsingHeader(title.c_str(), ImGuiTreeNodeFlags_DefaultOpen); + const bool OPENED = ImGui::CollapsingHeader(title.c_str(), ImGuiTreeNodeFlags_DefaultOpen); + if (isHovered) + *isHovered = ImGui::IsItemHovered(); + return OPENED; } void SHEditorUI::SameLine() @@ -75,7 +78,7 @@ namespace SHADE bool SHEditorUI::BeginMenu(const std::string& label) { - return ImGui::BeginMenu(label.data()); + return ImGui::BeginMenu(label.data()); } bool SHEditorUI::BeginMenu(const std::string& label, const char* icon) @@ -143,7 +146,7 @@ namespace SHADE bool SHEditorUI::Selectable(const std::string& label) { - return ImGui::Selectable(label.data()); + return ImGui::Selectable(label.data()); } bool SHEditorUI::Selectable(const std::string& label, const char* icon) @@ -165,8 +168,10 @@ namespace SHADE if (isHovered) *isHovered = ImGui::IsItemHovered(); ImGui::SameLine(); - return ImGui::InputInt("##", &value, - 1, 10, + return ImGui::DragInt("##", &value, 0.001f, + std::numeric_limits::min(), + std::numeric_limits::max(), + "%d", ImGuiInputTextFlags_EnterReturnsTrue); } bool SHEditorUI::InputUnsignedInt(const std::string& label, unsigned int& value, bool* isHovered) @@ -190,31 +195,22 @@ namespace SHADE if (isHovered) *isHovered = ImGui::IsItemHovered(); ImGui::SameLine(); - return ImGui::InputFloat("##", &value, - 0.1f, 1.0f, "%.3f", + return ImGui::DragFloat("##", &value, 0.001f, + std::numeric_limits::lowest(), + std::numeric_limits::max(), + "%.3f", ImGuiInputTextFlags_EnterReturnsTrue); } bool SHEditorUI::InputDouble(const std::string& label, double& value, bool* isHovered) { - ImGui::Text(label.c_str()); - if (isHovered) - *isHovered = ImGui::IsItemHovered(); - ImGui::SameLine(); - return ImGui::InputDouble("##", &value, - 0.1, 1.0, "%.3f", - ImGuiInputTextFlags_EnterReturnsTrue); + float val = value; + const bool CHANGED = InputFloat(label, val, isHovered); + if (CHANGED) + { + value = static_cast(val); + } + return CHANGED; } - bool SHEditorUI::InputAngle(const std::string& label, double& value, bool* isHovered) - { - ImGui::Text(label.c_str()); - if (isHovered) - *isHovered = ImGui::IsItemHovered(); - ImGui::SameLine(); - return ImGui::InputDouble("##", &value, - 1.0, 45.0, "%.3f", - ImGuiInputTextFlags_EnterReturnsTrue); - } - bool SHEditorUI::InputSlider(const std::string& label, int min, int max, int& value, bool* isHovered /*= nullptr*/) { ImGui::Text(label.c_str()); @@ -266,10 +262,10 @@ namespace SHADE static const std::vector COMPONENT_LABELS = { "X", "Y" }; return SHEditorWidgets::DragN(label, COMPONENT_LABELS, { &value.x, &value.y }, 0.1f, "%.3f", float{}, float{}, 0, isHovered); } - bool SHEditorUI::InputVec3(const std::string& label, SHVec3& value, bool* isHovered, float speed) + bool SHEditorUI::InputVec3(const std::string& label, SHVec3& value, bool* isHovered) { static const std::vector COMPONENT_LABELS = { "X", "Y", "Z"}; - return SHEditorWidgets::DragN(label, COMPONENT_LABELS, { &value.x, &value.y, &value.z }, speed, "%.3f", float{}, float{}, 0, isHovered); + return SHEditorWidgets::DragN(label, COMPONENT_LABELS, { &value.x, &value.y, &value.z }, 0.1f, "%.3f", float{}, float{}, 0, isHovered); } bool SHEditorUI::InputTextField(const std::string& label, std::string& value, bool* isHovered) diff --git a/SHADE_Engine/src/Editor/SHEditorUI.h b/SHADE_Engine/src/Editor/SHEditorUI.h index 4e8f4400..f450ac0d 100644 --- a/SHADE_Engine/src/Editor/SHEditorUI.h +++ b/SHADE_Engine/src/Editor/SHEditorUI.h @@ -85,8 +85,9 @@ namespace SHADE /// Wraps up ImGui::CollapsingHeader(). /// /// Label for the header. + /// Label used to identify this widget. - /// Reference to the variable to store the result. - /// Reference to the variable to store the result. /// #include +#include #include "Assets/SHAssetMetaHandler.h" @@ -24,29 +25,94 @@ namespace SHADE return true; } - void SHFileSystem::BuildDirectory(FolderPath path, FolderPointer& root, std::unordered_map& assetCollection) noexcept + bool SHFileSystem::IsRecognised(char const* ext) noexcept + { + for (auto const& e : EXTENSIONS) + { + if (strcmp(ext, e.data()) == 0) + { + return true; + } + } + + return false; + } + + bool SHFileSystem::IsCompilable(std::string ext) noexcept + { + for (auto const& external : EXTERNALS) + { + if (ext == external) + { + return true; + } + } + + return false; + } + + bool SHFileSystem::MatchExtention(FileExt raw, FileExt compiled) noexcept + { + if (raw == GLSL_EXTENSION) + { + if (compiled == SHADER_EXTENSION || + compiled == SHADER_BUILT_IN_EXTENSION) + { + return true; + } + } + else if (raw == DDS_EXTENSION) + { + if (compiled == TEXTURE_EXTENSION) + { + return true; + } + } + else if (raw == FBX_EXTENSION) + { + if (compiled == MODEL_EXTENSION) + { + return true; + } + } + else if (raw == GLTF_EXTENSION) + { + if (compiled == MODEL_EXTENSION) + { + return true; + } + } + + return false; + } + + void SHFileSystem::BuildDirectory( + FolderPath path, + FolderPointer& root, + std::unordered_map& assetCollection, + std::vector& toGenerate) noexcept { - std::queue folderQueue; + std::stack folderStack; root = new SHFolder("root"); root->path = path; - folderQueue.push(root); + folderStack.push(root); - while (!folderQueue.empty()) + while (!folderStack.empty()) { - auto const folder = folderQueue.front(); - folderQueue.pop(); + auto const folder = folderStack.top(); + folderStack.pop(); std::vector assets; - for (auto const& dirEntry : std::filesystem::directory_iterator(folder->path)) + // Get all subfolders/files in this current folder + for (auto& dirEntry : std::filesystem::directory_iterator(folder->path)) { - auto const& path = dirEntry.path(); + auto path = dirEntry.path(); + path.make_preferred(); if (!dirEntry.is_directory()) { if (path.extension().string() == META_EXTENSION) { - //auto asset = SHAssetMetaHandler::RetrieveMetaData(path); - //assetCollection.insert({ asset.id, asset }); assets.push_back(SHAssetMetaHandler::RetrieveMetaData(path)); } else @@ -55,28 +121,101 @@ namespace SHADE path.stem().string(), path.string(), path.extension().string(), - nullptr + nullptr, + IsCompilable(path.extension().string()), + false ); } continue; } + // If item is folder + if (path.stem().string() == "bin" + || path.stem().string() == "obj" + || !std::filesystem::exists(path)) + { + SHLOG_INFO("[FileSystem] Skipped paths in directory building: {}", path.string()); + continue; + } + auto newFolder{ folder->CreateSubFolderHere(path.stem().string()) }; - folderQueue.push(newFolder); + folderStack.push(newFolder); } - for (auto const& asset : assets) + for (auto& file : folder->files) { - assetCollection.emplace(asset.id, asset); - for(auto& file : folder->files) + if (!IsRecognised(file.ext.c_str())) { + continue; + } + + bool found{ false }; + for (auto const& asset : assets) + { + if (!assetCollection.contains(asset.id)) + { + assetCollection.emplace(asset.id, asset); + } if (file.name == asset.name) { - file.assetMeta = &assetCollection[asset.id]; - break; + AssetPath path{ file.path }; + if (SHAssetMetaHandler::GetTypeFromExtension(path.extension().string()) == asset.type) + { + file.assetMeta = &assetCollection[asset.id]; + found = true; + break; + } + } + } + + if (!found) + { + toGenerate.push_back(&file); + } + } + + for (auto i {0}; i < folder->files.size(); ++i) + { + auto& file = folder->files[i]; + if (file.compilable) + { + for (auto j{ 0 }; j < folder->files.size(); ++j) + { + auto& check = folder->files[j]; + if (i == j || check.compilable) + { + continue; + } + + if (file.name == check.name) + { + if (MatchExtention(file.ext, check.ext)) + { + file.compiled = true; + } + } } } } } } + + void SHFileSystem::DestroyDirectory(FolderPointer root) noexcept + { + std::stack folderStack; + folderStack.push(root); + + while(!folderStack.empty()) + { + auto const folder = folderStack.top(); + folderStack.pop(); + + for (auto const& ptr : folder->subFolders) + { + folderStack.push(ptr); + } + + delete folder; + } + } } diff --git a/SHADE_Engine/src/Filesystem/SHFileSystem.h b/SHADE_Engine/src/Filesystem/SHFileSystem.h index 956d3916..4bace233 100644 --- a/SHADE_Engine/src/Filesystem/SHFileSystem.h +++ b/SHADE_Engine/src/Filesystem/SHFileSystem.h @@ -19,10 +19,17 @@ namespace SHADE class SHFileSystem { public: - static void BuildDirectory(FolderPath path, FolderPointer& root, std::unordered_map& assetCollection) noexcept; + static void BuildDirectory( + FolderPath path, + FolderPointer& root, + std::unordered_map& assetCollection, + std::vector& toGenerate) noexcept; + static void DestroyDirectory(FolderPointer root) noexcept; + static bool IsRecognised(char const*) noexcept; private: static bool DeleteFolder(FolderPointer location) noexcept; - + static bool IsCompilable(std::string ext) noexcept; + static bool MatchExtention(FileExt raw, FileExt compiled) noexcept; }; } \ No newline at end of file diff --git a/SHADE_Engine/src/Filesystem/SHFolder.h b/SHADE_Engine/src/Filesystem/SHFolder.h index 54e95033..234e6f19 100644 --- a/SHADE_Engine/src/Filesystem/SHFolder.h +++ b/SHADE_Engine/src/Filesystem/SHFolder.h @@ -33,6 +33,8 @@ namespace SHADE FilePath path; FileExt ext; SHAsset const* assetMeta; + bool compilable; + bool compiled; }; class SHFolder diff --git a/SHADE_Engine/src/Graphics/Commands/SHVkCommandBuffer.cpp b/SHADE_Engine/src/Graphics/Commands/SHVkCommandBuffer.cpp index cc35303b..05fd4288 100644 --- a/SHADE_Engine/src/Graphics/Commands/SHVkCommandBuffer.cpp +++ b/SHADE_Engine/src/Graphics/Commands/SHVkCommandBuffer.cpp @@ -3,7 +3,7 @@ #include "SHVkCommandPool.h" #include "Graphics/Devices/SHVkLogicalDevice.h" #include "SHVkCommandPool.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" #include "Graphics/Renderpass/SHVkRenderpass.h" #include "Graphics/Framebuffer/SHVkFramebuffer.h" #include "Graphics/Pipeline/SHVkPipeline.h" diff --git a/SHADE_Engine/src/Graphics/Commands/SHVkCommandPool.cpp b/SHADE_Engine/src/Graphics/Commands/SHVkCommandPool.cpp index 375ece4d..fc9769d9 100644 --- a/SHADE_Engine/src/Graphics/Commands/SHVkCommandPool.cpp +++ b/SHADE_Engine/src/Graphics/Commands/SHVkCommandPool.cpp @@ -3,7 +3,7 @@ #include "Graphics/Devices/SHVkLogicalDevice.h" #include "Graphics/Instance/SHVkInstance.h" #include "Resource/SHResourceLibrary.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" namespace SHADE { diff --git a/SHADE_Engine/src/Graphics/Debugging/SHValidationLayersQuery.cpp b/SHADE_Engine/src/Graphics/Debugging/SHValidationLayersQuery.cpp index 420fa9e5..0dba5c5b 100644 --- a/SHADE_Engine/src/Graphics/Debugging/SHValidationLayersQuery.cpp +++ b/SHADE_Engine/src/Graphics/Debugging/SHValidationLayersQuery.cpp @@ -1,6 +1,6 @@ #include "SHPch.h" #include "SHValidationLayersQuery.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" namespace SHADE { diff --git a/SHADE_Engine/src/Graphics/Debugging/SHVkDebugMessenger.cpp b/SHADE_Engine/src/Graphics/Debugging/SHVkDebugMessenger.cpp index 3ca5c94d..fd7d55e9 100644 --- a/SHADE_Engine/src/Graphics/Debugging/SHVkDebugMessenger.cpp +++ b/SHADE_Engine/src/Graphics/Debugging/SHVkDebugMessenger.cpp @@ -3,8 +3,8 @@ #include "SHVkDebugMessenger.h" #include "SHVulkanDebugUtil.h" #include "Graphics/Instance/SHVkInstance.h" -#include "Tools/SHLogger.h" -//#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" +//#include "Tools/Logger/SHLogger.h" namespace SHADE { diff --git a/SHADE_Engine/src/Graphics/Debugging/SHVulkanDebugUtil.cpp b/SHADE_Engine/src/Graphics/Debugging/SHVulkanDebugUtil.cpp index fd39da24..eea07ed6 100644 --- a/SHADE_Engine/src/Graphics/Debugging/SHVulkanDebugUtil.cpp +++ b/SHADE_Engine/src/Graphics/Debugging/SHVulkanDebugUtil.cpp @@ -1,6 +1,6 @@ #include "SHPch.h" #include "SHVulkanDebugUtil.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" namespace SHADE { diff --git a/SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorSetGroup.cpp b/SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorSetGroup.cpp index de68c583..adb51586 100644 --- a/SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorSetGroup.cpp +++ b/SHADE_Engine/src/Graphics/Descriptors/SHVkDescriptorSetGroup.cpp @@ -6,7 +6,7 @@ #include "SHVkDescriptorPool.h" #include "Graphics/Devices/SHVkLogicalDevice.h" #include "Graphics/Descriptors/SHVkDescriptorSetLayout.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" #include "Graphics/Images/SHVkImage.h" #include "Graphics/Images/SHVkImageView.h" #include "Graphics/Images/SHVkSampler.h" diff --git a/SHADE_Engine/src/Graphics/Devices/SHVkLogicalDevice.cpp b/SHADE_Engine/src/Graphics/Devices/SHVkLogicalDevice.cpp index 808ce750..272a838d 100644 --- a/SHADE_Engine/src/Graphics/Devices/SHVkLogicalDevice.cpp +++ b/SHADE_Engine/src/Graphics/Devices/SHVkLogicalDevice.cpp @@ -2,7 +2,7 @@ #include "SHVkLogicalDevice.h" #include "SHVkPhysicalDevice.h" #include "Graphics/Instance/SHVkInstance.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" #include "Graphics/Windowing/Surface/SHVkSurface.h" #include "Graphics/Swapchain/SHVkSwapchain.h" #include "Graphics/Commands/SHVkCommandPool.h" diff --git a/SHADE_Engine/src/Graphics/Devices/SHVkPhysicalDevice.cpp b/SHADE_Engine/src/Graphics/Devices/SHVkPhysicalDevice.cpp index 53b352b7..1f40a533 100644 --- a/SHADE_Engine/src/Graphics/Devices/SHVkPhysicalDevice.cpp +++ b/SHADE_Engine/src/Graphics/Devices/SHVkPhysicalDevice.cpp @@ -3,7 +3,7 @@ #include #include #include -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" namespace SHADE { diff --git a/SHADE_Engine/src/Graphics/Devices/SHVkPhysicalDeviceLibrary.cpp b/SHADE_Engine/src/Graphics/Devices/SHVkPhysicalDeviceLibrary.cpp index 3cf0a8e6..050ca769 100644 --- a/SHADE_Engine/src/Graphics/Devices/SHVkPhysicalDeviceLibrary.cpp +++ b/SHADE_Engine/src/Graphics/Devices/SHVkPhysicalDeviceLibrary.cpp @@ -3,7 +3,7 @@ #include #include "SHVkPhysicalDeviceLibrary.h" #include "Graphics/Instance/SHVkInstance.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" namespace SHADE { diff --git a/SHADE_Engine/src/Graphics/Framebuffer/SHVkFramebuffer.cpp b/SHADE_Engine/src/Graphics/Framebuffer/SHVkFramebuffer.cpp index 76e627d3..7a46c473 100644 --- a/SHADE_Engine/src/Graphics/Framebuffer/SHVkFramebuffer.cpp +++ b/SHADE_Engine/src/Graphics/Framebuffer/SHVkFramebuffer.cpp @@ -3,7 +3,7 @@ #include "Graphics/Images/SHVkImageView.h" #include "Graphics/Images/SHVkImage.h" #include "Graphics/Renderpass/SHVkRenderpass.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" #include "Graphics/Devices/SHVkLogicalDevice.h" namespace SHADE diff --git a/SHADE_Engine/src/Graphics/Images/SHVkImage.cpp b/SHADE_Engine/src/Graphics/Images/SHVkImage.cpp index 33bed1b5..fa43cd53 100644 --- a/SHADE_Engine/src/Graphics/Images/SHVkImage.cpp +++ b/SHADE_Engine/src/Graphics/Images/SHVkImage.cpp @@ -2,7 +2,7 @@ #include "SHVkImage.h" #include "Graphics/Devices/SHVkLogicalDevice.h" #include "Graphics/Debugging/SHVulkanDebugUtil.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" #include "SHVkImageView.h" #include "Graphics/Instance/SHVkInstance.h" #include "Graphics/Buffers/SHVkBuffer.h" diff --git a/SHADE_Engine/src/Graphics/Images/SHVkImageView.cpp b/SHADE_Engine/src/Graphics/Images/SHVkImageView.cpp index 44b5718c..d07c66b7 100644 --- a/SHADE_Engine/src/Graphics/Images/SHVkImageView.cpp +++ b/SHADE_Engine/src/Graphics/Images/SHVkImageView.cpp @@ -2,7 +2,7 @@ #include "SHVkImageView.h" #include "SHVkImage.h" #include "Graphics/Devices/SHVkLogicalDevice.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" namespace SHADE { diff --git a/SHADE_Engine/src/Graphics/Instance/SHVkInstance.cpp b/SHADE_Engine/src/Graphics/Instance/SHVkInstance.cpp index edfe4b46..237c6fee 100644 --- a/SHADE_Engine/src/Graphics/Instance/SHVkInstance.cpp +++ b/SHADE_Engine/src/Graphics/Instance/SHVkInstance.cpp @@ -3,7 +3,7 @@ #include "Graphics/Debugging/SHValidationLayersQuery.h" #include "Graphics/Debugging/SHVkDebugMessenger.h" #include "Graphics/Devices/SHVkPhysicalDeviceLibrary.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" #include "Graphics/Devices/SHVkPhysicalDeviceLibrary.h" //#include diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatcher.cpp b/SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatcher.cpp index dc44e7f9..41aebeb6 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatcher.cpp +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Batching/SHBatcher.cpp @@ -22,7 +22,7 @@ of DigiPen Institute of Technology is prohibited. #include "Graphics/MiddleEnd/Interface/SHMaterialInstance.h" #include "Graphics/Pipeline/SHVkPipeline.h" #include "ECS_Base/Managers/SHComponentManager.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" namespace SHADE { diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/GlobalData/SHGraphicsGlobalData.cpp b/SHADE_Engine/src/Graphics/MiddleEnd/GlobalData/SHGraphicsGlobalData.cpp index 53adf2fe..28333820 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/GlobalData/SHGraphicsGlobalData.cpp +++ b/SHADE_Engine/src/Graphics/MiddleEnd/GlobalData/SHGraphicsGlobalData.cpp @@ -5,7 +5,7 @@ #include "Graphics/Pipeline/SHVkPipelineLayout.h" #include "Graphics/Descriptors/SHVkDescriptorSetLayout.h" #include "Graphics/MiddleEnd/Lights/SHLightData.h" -#include "Tools/SHUtilities.h" +#include "Tools/Utilities/SHUtilities.h" namespace SHADE { @@ -60,7 +60,7 @@ namespace SHADE }); - for (uint32_t i = 1; i <= SHUtilities::ToUnderlying(SH_LIGHT_TYPE::NUM_TYPES); ++i) + for (uint32_t i = 1; i <= SHUtilities::ConvertEnum(SH_LIGHT_TYPE::NUM_TYPES); ++i) { lightBindings.push_back (SHVkDescriptorSetLayout::Binding { diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHDebugDrawSystem.cpp b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHDebugDrawSystem.cpp index daa6a23d..60262607 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHDebugDrawSystem.cpp +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHDebugDrawSystem.cpp @@ -317,13 +317,14 @@ namespace SHADE void SHDebugDrawSystem::drawSphere(std::vector& storage, const SHVec4& color, const SHVec3& pos, double radius) { - if (spherePoints.empty()) + //if (spherePoints.empty()) { + spherePoints.clear(); // Generate static const SHMeshData SPHERE = SHPrimitiveGenerator::Sphere(); for (const auto& idx : SPHERE.Indices) { - spherePoints.emplace_back(SPHERE.VertexPositions[idx] * radius); + spherePoints.emplace_back(SPHERE.VertexPositions[idx] * radius + pos); } } drawLineSet(storage, color, spherePoints.begin(), spherePoints.end()); diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterialInstance.cpp b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterialInstance.cpp index 350580bf..ff7084c2 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterialInstance.cpp +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHMaterialInstance.cpp @@ -15,7 +15,7 @@ of DigiPen Institute of Technology is prohibited. #include "SHGraphicsConstants.h" #include "SHMaterial.h" #include "Graphics/Pipeline/SHVkPipeline.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" namespace SHADE { diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHRenderable.cpp b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHRenderable.cpp index 57762324..c5511606 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHRenderable.cpp +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHRenderable.cpp @@ -34,8 +34,11 @@ namespace SHADE void SHRenderable::OnDestroy() { // Remove from SuperBatch - Handle superBatch = sharedMaterial->GetBaseMaterial()->GetPipeline()->GetPipelineState().GetSubpass()->GetSuperBatch(); - superBatch->Remove(this); + if (sharedMaterial) + { + Handle superBatch = sharedMaterial->GetBaseMaterial()->GetPipeline()->GetPipelineState().GetSubpass()->GetSuperBatch(); + superBatch->Remove(this); + } // Free resources if (material) diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHViewport.cpp b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHViewport.cpp index df9e244e..7bd0049f 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHViewport.cpp +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHViewport.cpp @@ -15,7 +15,7 @@ of DigiPen Institute of Technology is prohibited. #include "Graphics/Commands/SHVkCommandBuffer.h" #include "Graphics/Instance/SHVkInstance.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" #include "SHRenderer.h" #include "Resource/SHResourceLibrary.h" #include "Graphics/RenderGraph/SHRenderGraph.h" diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Lights/SHLightingSubSystem.cpp b/SHADE_Engine/src/Graphics/MiddleEnd/Lights/SHLightingSubSystem.cpp index 02bd8f1f..2949ad43 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/Lights/SHLightingSubSystem.cpp +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Lights/SHLightingSubSystem.cpp @@ -1,7 +1,7 @@ #include "SHpch.h" #include "SHLightingSubSystem.h" #include "Graphics/MiddleEnd/GlobalData/SHGraphicsGlobalData.h" -#include "Tools/SHUtilities.h" +#include "Tools/Utilities/SHUtilities.h" #include "Graphics/Devices/SHVkLogicalDevice.h" #include "Graphics/Buffers/SHVkBuffer.h" #include "Graphics/Descriptors/SHVkDescriptorSetGroup.h" @@ -379,7 +379,7 @@ namespace SHADE SHComponentManager::CreateComponentSparseSet(); logicalDevice = device; - uint32_t constexpr NUM_LIGHT_TYPES = SHUtilities::ToUnderlying(SH_LIGHT_TYPE::NUM_TYPES); + uint32_t constexpr NUM_LIGHT_TYPES = SHUtilities::ConvertEnum(SH_LIGHT_TYPE::NUM_TYPES); std::vector variableSizes{ NUM_LIGHT_TYPES }; std::fill (variableSizes.begin(), variableSizes.end(), 1); @@ -431,7 +431,7 @@ namespace SHADE /***************************************************************************/ void SHLightingSubSystem::Run(SHMatrix const& viewMat, uint32_t frameIndex) noexcept { - static uint32_t constexpr NUM_LIGHT_TYPES = SHUtilities::ToUnderlying(SH_LIGHT_TYPE::NUM_TYPES); + static uint32_t constexpr NUM_LIGHT_TYPES = SHUtilities::ConvertEnum(SH_LIGHT_TYPE::NUM_TYPES); auto& lightComps = SHComponentManager::GetDense(); bool expanded = false; @@ -451,7 +451,7 @@ namespace SHADE for (auto& light : lightComps) { - auto enumValue = SHUtilities::ToUnderlying(light.GetLightData().type); + auto enumValue = SHUtilities::ConvertEnum(light.GetLightData().type); // First we want to make sure the light is already bound to the system. if it // isn't, we write it to the correct buffer. @@ -491,7 +491,7 @@ namespace SHADE // is a new buffer. If some expansion was detected, update descriptor sets. if (expanded) { - uint32_t constexpr NUM_LIGHT_TYPES = SHUtilities::ToUnderlying(SH_LIGHT_TYPE::NUM_TYPES); + uint32_t constexpr NUM_LIGHT_TYPES = SHUtilities::ConvertEnum(SH_LIGHT_TYPE::NUM_TYPES); for (uint32_t i = 0; i < NUM_LIGHT_TYPES; ++i) { UpdateDescSet(i); diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/PerFrame/SHRenderContext.cpp b/SHADE_Engine/src/Graphics/MiddleEnd/PerFrame/SHRenderContext.cpp index 1d24d6f7..b12ac75d 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/PerFrame/SHRenderContext.cpp +++ b/SHADE_Engine/src/Graphics/MiddleEnd/PerFrame/SHRenderContext.cpp @@ -1,6 +1,6 @@ #include "SHPch.h" #include "SHRenderContext.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" #include "Graphics/Devices/SHVkLogicalDevice.h" #include "Graphics/Swapchain/SHVkSwapchain.h" diff --git a/SHADE_Engine/src/Graphics/MiddleEnd/Textures/SHTextureLibrary.cpp b/SHADE_Engine/src/Graphics/MiddleEnd/Textures/SHTextureLibrary.cpp index b92ccddf..dfb3f3b9 100644 --- a/SHADE_Engine/src/Graphics/MiddleEnd/Textures/SHTextureLibrary.cpp +++ b/SHADE_Engine/src/Graphics/MiddleEnd/Textures/SHTextureLibrary.cpp @@ -19,7 +19,7 @@ of DigiPen Institute of Technology is prohibited. #include "Graphics/Buffers/SHVkBuffer.h" #include "Graphics/Commands/SHVkCommandBuffer.h" #include "Graphics/SHVkUtil.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" #include "Graphics/MiddleEnd/Interface/SHGraphicsConstants.h" #include "Graphics/Descriptors/SHVkDescriptorSetGroup.h" #include "Graphics/Images/SHVkImage.h" diff --git a/SHADE_Engine/src/Graphics/Pipeline/SHVkPipelineLayout.cpp b/SHADE_Engine/src/Graphics/Pipeline/SHVkPipelineLayout.cpp index 47b2e010..589e66d2 100644 --- a/SHADE_Engine/src/Graphics/Pipeline/SHVkPipelineLayout.cpp +++ b/SHADE_Engine/src/Graphics/Pipeline/SHVkPipelineLayout.cpp @@ -2,7 +2,7 @@ #include "SHVkPipelineLayout.h" #include "Graphics/Devices/SHVkLogicalDevice.h" #include "Graphics/Shaders/SHVkShaderModule.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" #include "Graphics/Instance/SHVkInstance.h" namespace SHADE diff --git a/SHADE_Engine/src/Graphics/Queues/SHVkQueue.cpp b/SHADE_Engine/src/Graphics/Queues/SHVkQueue.cpp index dcb3ff6a..4d8b0d76 100644 --- a/SHADE_Engine/src/Graphics/Queues/SHVkQueue.cpp +++ b/SHADE_Engine/src/Graphics/Queues/SHVkQueue.cpp @@ -1,6 +1,6 @@ #include "SHPch.h" #include "SHVkQueue.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" #include "Graphics/Devices/SHVkLogicalDevice.h" #include "Graphics/Synchronization/SHVkSemaphore.h" #include "Graphics/Synchronization/SHVkFence.h" diff --git a/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraph.cpp b/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraph.cpp index 500bcf04..d9c7f17a 100644 --- a/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraph.cpp +++ b/SHADE_Engine/src/Graphics/RenderGraph/SHRenderGraph.cpp @@ -7,7 +7,7 @@ #include "Graphics/Images/SHVkImageView.h" #include "Graphics/Framebuffer/SHVkFramebuffer.h" #include "Graphics/Buffers/SHVkBuffer.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" #include "SHAttachmentDescInitParams.h" #include "SHRenderGraphStorage.h" #include "Graphics/RenderGraph/SHRenderGraphNodeCompute.h" diff --git a/SHADE_Engine/src/Graphics/Shaders/BlockInterface/SHShaderBlockInterface.cpp b/SHADE_Engine/src/Graphics/Shaders/BlockInterface/SHShaderBlockInterface.cpp index 67c83266..dfb91193 100644 --- a/SHADE_Engine/src/Graphics/Shaders/BlockInterface/SHShaderBlockInterface.cpp +++ b/SHADE_Engine/src/Graphics/Shaders/BlockInterface/SHShaderBlockInterface.cpp @@ -1,6 +1,6 @@ #include "SHPch.h" #include "SHShaderBlockInterface.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" namespace SHADE { diff --git a/SHADE_Engine/src/Graphics/Shaders/SHShaderReflected.cpp b/SHADE_Engine/src/Graphics/Shaders/SHShaderReflected.cpp index 96fa77ab..96de87bb 100644 --- a/SHADE_Engine/src/Graphics/Shaders/SHShaderReflected.cpp +++ b/SHADE_Engine/src/Graphics/Shaders/SHShaderReflected.cpp @@ -1,6 +1,6 @@ #include "SHPch.h" #include "SHShaderReflected.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" #include "Graphics/Instance/SHVkInstance.h" diff --git a/SHADE_Engine/src/Graphics/Shaders/SHVkShaderModule.cpp b/SHADE_Engine/src/Graphics/Shaders/SHVkShaderModule.cpp index c1fac76c..fa6b3182 100644 --- a/SHADE_Engine/src/Graphics/Shaders/SHVkShaderModule.cpp +++ b/SHADE_Engine/src/Graphics/Shaders/SHVkShaderModule.cpp @@ -2,7 +2,7 @@ #include "SHVkShaderModule.h" #include "Graphics/Devices/SHVkLogicalDevice.h" #include "Graphics/Debugging/SHVulkanDebugUtil.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" namespace SHADE { diff --git a/SHADE_Engine/src/Graphics/Swapchain/SHVkSwapchain.cpp b/SHADE_Engine/src/Graphics/Swapchain/SHVkSwapchain.cpp index f46d5d17..40f917a0 100644 --- a/SHADE_Engine/src/Graphics/Swapchain/SHVkSwapchain.cpp +++ b/SHADE_Engine/src/Graphics/Swapchain/SHVkSwapchain.cpp @@ -3,7 +3,7 @@ #include "Graphics/Devices/SHVkPhysicalDevice.h" #include "Graphics/Devices/SHVkLogicalDevice.h" #include "Graphics/Windowing/Surface/SHVkSurface.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" #include "Graphics/Images/SHVkImage.h" #include "Graphics/Instance/SHVkInstance.h" diff --git a/SHADE_Engine/src/Graphics/Windowing/Surface/SHVkSurface.cpp b/SHADE_Engine/src/Graphics/Windowing/Surface/SHVkSurface.cpp index f9cb16c6..7d55ab72 100644 --- a/SHADE_Engine/src/Graphics/Windowing/Surface/SHVkSurface.cpp +++ b/SHADE_Engine/src/Graphics/Windowing/Surface/SHVkSurface.cpp @@ -4,7 +4,7 @@ #include "Graphics/Devices/SHVkLogicalDevice.h" #include "Graphics/Instance/SHVkInstance.h" #include "Graphics/Debugging/SHVulkanDebugUtil.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" namespace SHADE { diff --git a/SHADE_Engine/src/Math/Geometry/SHBoundingBox.cpp b/SHADE_Engine/src/Math/Geometry/SHBox.cpp similarity index 71% rename from SHADE_Engine/src/Math/Geometry/SHBoundingBox.cpp rename to SHADE_Engine/src/Math/Geometry/SHBox.cpp index 5bbf5e15..cf094a9d 100644 --- a/SHADE_Engine/src/Math/Geometry/SHBoundingBox.cpp +++ b/SHADE_Engine/src/Math/Geometry/SHBox.cpp @@ -11,7 +11,7 @@ #include // Primary Header -#include "SHBoundingBox.h" +#include "SHBox.h" // Project Headers #include "Math/SHMathHelpers.h" #include "Math/SHRay.h" @@ -24,13 +24,13 @@ namespace SHADE /* Constructors & Destructor Definitions */ /*-----------------------------------------------------------------------------------*/ - SHBoundingBox::SHBoundingBox() noexcept + SHBox::SHBox() noexcept : RelativeExtents { SHVec3::One } { type = Type::BOX; } - SHBoundingBox::SHBoundingBox(const SHVec3& c, const SHVec3& hE) noexcept + SHBox::SHBox(const SHVec3& c, const SHVec3& hE) noexcept : RelativeExtents { SHVec3::One } { type = Type::BOX; @@ -40,7 +40,7 @@ namespace SHADE } - SHBoundingBox::SHBoundingBox(const SHBoundingBox& rhs) noexcept + SHBox::SHBox(const SHBox& rhs) noexcept { if (this == &rhs) return; @@ -52,7 +52,7 @@ namespace SHADE RelativeExtents = rhs.RelativeExtents; } - SHBoundingBox::SHBoundingBox(SHBoundingBox&& rhs) noexcept + SHBox::SHBox(SHBox&& rhs) noexcept { type = Type::BOX; @@ -65,7 +65,7 @@ namespace SHADE /* Operator Overload Definitions */ /*-----------------------------------------------------------------------------------*/ - SHBoundingBox& SHBoundingBox::operator=(const SHBoundingBox& rhs) noexcept + SHBox& SHBox::operator=(const SHBox& rhs) noexcept { if (rhs.type != Type::BOX) { @@ -81,7 +81,7 @@ namespace SHADE return *this; } - SHBoundingBox& SHBoundingBox::operator=(SHBoundingBox&& rhs) noexcept + SHBox& SHBox::operator=(SHBox&& rhs) noexcept { if (rhs.type != Type::BOX) { @@ -101,27 +101,27 @@ namespace SHADE /* Getter Function Definitions */ /*-----------------------------------------------------------------------------------*/ - SHVec3 SHBoundingBox::GetCenter() const noexcept + SHVec3 SHBox::GetCenter() const noexcept { return Center; } - SHVec3 SHBoundingBox::GetWorldExtents() const noexcept + SHVec3 SHBox::GetWorldExtents() const noexcept { return Extents; } - const SHVec3& SHBoundingBox::GetRelativeExtents() const noexcept + const SHVec3& SHBox::GetRelativeExtents() const noexcept { return RelativeExtents; } - SHVec3 SHBoundingBox::GetMin() const noexcept + SHVec3 SHBox::GetMin() const noexcept { return SHVec3{ Center.x - Extents.x, Center.y - Extents.y, Center.z - Extents.z }; } - SHVec3 SHBoundingBox::GetMax() const noexcept + SHVec3 SHBox::GetMax() const noexcept { return SHVec3{ Center.x + Extents.x, Center.y + Extents.y, Center.z + Extents.z }; } @@ -130,22 +130,22 @@ namespace SHADE /* Setter Function Definitions */ /*-----------------------------------------------------------------------------------*/ - void SHBoundingBox::SetCenter(const SHVec3& newCenter) noexcept + void SHBox::SetCenter(const SHVec3& newCenter) noexcept { Center = newCenter; } - void SHBoundingBox::SetWorldExtents(const SHVec3& newWorldExtents) noexcept + void SHBox::SetWorldExtents(const SHVec3& newWorldExtents) noexcept { Extents = newWorldExtents; } - void SHBoundingBox::SetRelativeExtents(const SHVec3& newRelativeExtents) noexcept + void SHBox::SetRelativeExtents(const SHVec3& newRelativeExtents) noexcept { RelativeExtents = newRelativeExtents; } - void SHBoundingBox::SetMin(const SHVec3& min) noexcept + void SHBox::SetMin(const SHVec3& min) noexcept { const SHVec3 MAX = GetMax(); @@ -153,7 +153,7 @@ namespace SHADE Extents = SHVec3::Abs((MAX - min) * 0.5f); } - void SHBoundingBox::SetMax(const SHVec3& max) noexcept + void SHBox::SetMax(const SHVec3& max) noexcept { const SHVec3 MIN = GetMin(); @@ -161,13 +161,13 @@ namespace SHADE Extents = SHVec3::Abs((max - MIN) * 0.5f); } - void SHBoundingBox::SetMinMax(const SHVec3& min, const SHVec3& max) noexcept + void SHBox::SetMinMax(const SHVec3& min, const SHVec3& max) noexcept { Center = SHVec3::Lerp(min, max, 0.5f); Extents = SHVec3::Abs((max - min) * 0.5f); } - std::vector SHBoundingBox::GetVertices() const noexcept + std::vector SHBox::GetVertices() const noexcept { std::vector vertices{ 8 }; GetCorners(vertices.data()); @@ -178,27 +178,27 @@ namespace SHADE /* Public Function Member Definitions */ /*-----------------------------------------------------------------------------------*/ - bool SHBoundingBox::TestPoint(const SHVec3& point) noexcept + bool SHBox::TestPoint(const SHVec3& point) noexcept { return BoundingBox::Contains(point); } - bool SHBoundingBox::Raycast(const SHRay& ray, float& distance) noexcept + bool SHBox::Raycast(const SHRay& ray, float& distance) noexcept { return BoundingBox::Intersects(ray.position, ray.direction, distance); } - bool SHBoundingBox::Contains(const SHBoundingBox& rhs) const noexcept + bool SHBox::Contains(const SHBox& rhs) const noexcept { return BoundingBox::Contains(rhs); } - float SHBoundingBox::Volume() const noexcept + float SHBox::Volume() const noexcept { return 8.0f * (Extents.x * Extents.y * Extents.z); } - float SHBoundingBox::SurfaceArea() const noexcept + float SHBox::SurfaceArea() const noexcept { return 8.0f * ((Extents.x * Extents.y) + (Extents.x * Extents.z) @@ -209,21 +209,21 @@ namespace SHADE /* Static Function Member Definitions */ /*-----------------------------------------------------------------------------------*/ - SHBoundingBox SHBoundingBox::Combine(const SHBoundingBox& lhs, const SHBoundingBox& rhs) noexcept + SHBox SHBox::Combine(const SHBox& lhs, const SHBox& rhs) noexcept { - SHBoundingBox result; + SHBox result; CreateMerged(result, lhs, rhs); return result; } - bool SHBoundingBox::Intersect(const SHBoundingBox& lhs, const SHBoundingBox& rhs) noexcept + bool SHBox::Intersect(const SHBox& lhs, const SHBox& rhs) noexcept { return lhs.Intersects(rhs); } - SHBoundingBox SHBoundingBox::BuildFromBoxes(const SHBoundingBox* boxes, size_t numBoxes) noexcept + SHBox SHBox::BuildFromBoxes(const SHBox* boxes, size_t numBoxes) noexcept { - SHBoundingBox result; + SHBox result; for (size_t i = 1; i < numBoxes; ++i) CreateMerged(result, boxes[i - 1], boxes[i]); @@ -231,9 +231,9 @@ namespace SHADE return result; } - SHBoundingBox SHBoundingBox::BuildFromVertices(const SHVec3* vertices, size_t numVertices, size_t stride) noexcept + SHBox SHBox::BuildFromVertices(const SHVec3* vertices, size_t numVertices, size_t stride) noexcept { - SHBoundingBox result; + SHBox result; CreateFromPoints(result, numVertices, vertices, stride); return result; } diff --git a/SHADE_Engine/src/Math/Geometry/SHBoundingBox.h b/SHADE_Engine/src/Math/Geometry/SHBox.h similarity index 80% rename from SHADE_Engine/src/Math/Geometry/SHBoundingBox.h rename to SHADE_Engine/src/Math/Geometry/SHBox.h index e2757c17..0ea950ab 100644 --- a/SHADE_Engine/src/Math/Geometry/SHBoundingBox.h +++ b/SHADE_Engine/src/Math/Geometry/SHBox.h @@ -22,8 +22,8 @@ namespace SHADE /* Type Definitions */ /*-----------------------------------------------------------------------------------*/ - class SH_API SHBoundingBox : public SHShape, - private DirectX::BoundingBox + class SH_API SHBox : public SHShape, + private DirectX::BoundingBox { public: /*---------------------------------------------------------------------------------*/ @@ -36,19 +36,19 @@ namespace SHADE /* Constructors & Destructor */ /*---------------------------------------------------------------------------------*/ - ~SHBoundingBox () override = default; + ~SHBox () override = default; - SHBoundingBox () noexcept; - SHBoundingBox (const SHVec3& center, const SHVec3& halfExtents) noexcept; - SHBoundingBox (const SHBoundingBox& rhs) noexcept; - SHBoundingBox (SHBoundingBox&& rhs) noexcept; + SHBox () noexcept; + SHBox (const SHVec3& center, const SHVec3& halfExtents) noexcept; + SHBox (const SHBox& rhs) noexcept; + SHBox (SHBox&& rhs) noexcept; /*---------------------------------------------------------------------------------*/ /* Operator Overloads */ /*---------------------------------------------------------------------------------*/ - SHBoundingBox& operator= (const SHBoundingBox& rhs) noexcept; - SHBoundingBox& operator= (SHBoundingBox&& rhs) noexcept; + SHBox& operator= (const SHBox& rhs) noexcept; + SHBox& operator= (SHBox&& rhs) noexcept; /*---------------------------------------------------------------------------------*/ /* Getter Functions */ @@ -79,7 +79,7 @@ namespace SHADE [[nodiscard]] bool TestPoint (const SHVec3& point) noexcept override; [[nodiscard]] bool Raycast (const SHRay& ray, float& distance) noexcept override; - [[nodiscard]] bool Contains (const SHBoundingBox& rhs) const noexcept; + [[nodiscard]] bool Contains (const SHBox& rhs) const noexcept; [[nodiscard]] float Volume () const noexcept; [[nodiscard]] float SurfaceArea () const noexcept; @@ -87,10 +87,10 @@ namespace SHADE /* Static Function Members */ /*---------------------------------------------------------------------------------*/ - [[nodiscard]] static SHBoundingBox Combine (const SHBoundingBox& lhs, const SHBoundingBox& rhs) noexcept; - [[nodiscard]] static bool Intersect (const SHBoundingBox& lhs, const SHBoundingBox& rhs) noexcept; - [[nodiscard]] static SHBoundingBox BuildFromBoxes (const SHBoundingBox* boxes, size_t numBoxes) noexcept; - [[nodiscard]] static SHBoundingBox BuildFromVertices (const SHVec3* vertices, size_t numVertices, size_t stride = 0) noexcept; + [[nodiscard]] static SHBox Combine (const SHBox& lhs, const SHBox& rhs) noexcept; + [[nodiscard]] static bool Intersect (const SHBox& lhs, const SHBox& rhs) noexcept; + [[nodiscard]] static SHBox BuildFromBoxes (const SHBox* boxes, size_t numBoxes) noexcept; + [[nodiscard]] static SHBox BuildFromVertices (const SHVec3* vertices, size_t numVertices, size_t stride = 0) noexcept; private: /*---------------------------------------------------------------------------------*/ diff --git a/SHADE_Engine/src/Math/Geometry/SHBoundingSphere.cpp b/SHADE_Engine/src/Math/Geometry/SHSphere.cpp similarity index 70% rename from SHADE_Engine/src/Math/Geometry/SHBoundingSphere.cpp rename to SHADE_Engine/src/Math/Geometry/SHSphere.cpp index f843a6bb..d310e30e 100644 --- a/SHADE_Engine/src/Math/Geometry/SHBoundingSphere.cpp +++ b/SHADE_Engine/src/Math/Geometry/SHSphere.cpp @@ -11,7 +11,7 @@ #include // Primary Header -#include "SHBoundingSphere.h" +#include "SHSphere.h" // Project Headers #include "Math/SHMathHelpers.h" #include "Math/SHRay.h" @@ -24,13 +24,13 @@ namespace SHADE /* Constructors & Destructor Definitions */ /*-----------------------------------------------------------------------------------*/ - SHBoundingSphere::SHBoundingSphere() noexcept + SHSphere::SHSphere() noexcept : RelativeRadius { 1.0f } { type = Type::SPHERE; } - SHBoundingSphere::SHBoundingSphere(const SHVec3& center, float radius) noexcept + SHSphere::SHSphere(const SHVec3& center, float radius) noexcept : RelativeRadius { 1.0f } { type = Type::SPHERE; @@ -39,7 +39,7 @@ namespace SHADE Radius = radius; } - SHBoundingSphere::SHBoundingSphere(const SHBoundingSphere& rhs) noexcept + SHSphere::SHSphere(const SHSphere& rhs) noexcept { if (this == &rhs) return; @@ -51,7 +51,7 @@ namespace SHADE RelativeRadius = rhs.RelativeRadius; } - SHBoundingSphere::SHBoundingSphere(SHBoundingSphere&& rhs) noexcept + SHSphere::SHSphere(SHSphere&& rhs) noexcept { type = Type::SPHERE; @@ -64,7 +64,7 @@ namespace SHADE /* Operator Overload Definitions */ /*-----------------------------------------------------------------------------------*/ - SHBoundingSphere& SHBoundingSphere::operator=(const SHBoundingSphere& rhs) noexcept + SHSphere& SHSphere::operator=(const SHSphere& rhs) noexcept { if (rhs.type != Type::SPHERE) { @@ -80,7 +80,7 @@ namespace SHADE return *this; } - SHBoundingSphere& SHBoundingSphere::operator=(SHBoundingSphere&& rhs) noexcept + SHSphere& SHSphere::operator=(SHSphere&& rhs) noexcept { if (rhs.type != Type::SPHERE) { @@ -100,17 +100,17 @@ namespace SHADE /* Getter Function Definitions */ /*-----------------------------------------------------------------------------------*/ - SHVec3 SHBoundingSphere::GetCenter() const noexcept + SHVec3 SHSphere::GetCenter() const noexcept { return Center; } - float SHBoundingSphere::GetWorldRadius() const noexcept + float SHSphere::GetWorldRadius() const noexcept { return Radius; } - float SHBoundingSphere::GetRelativeRadius() const noexcept + float SHSphere::GetRelativeRadius() const noexcept { return RelativeRadius; } @@ -119,17 +119,17 @@ namespace SHADE /* Setter Function Definitions */ /*-----------------------------------------------------------------------------------*/ - void SHBoundingSphere::SetCenter(const SHVec3& center) noexcept + void SHSphere::SetCenter(const SHVec3& center) noexcept { Center = center; } - void SHBoundingSphere::SetWorldRadius(float newWorldRadius) noexcept + void SHSphere::SetWorldRadius(float newWorldRadius) noexcept { Radius = newWorldRadius; } - void SHBoundingSphere::SetRelativeRadius(float newRelativeRadius) noexcept + void SHSphere::SetRelativeRadius(float newRelativeRadius) noexcept { RelativeRadius = newRelativeRadius; } @@ -138,27 +138,27 @@ namespace SHADE /* Public Function Member Definitions */ /*-----------------------------------------------------------------------------------*/ - bool SHBoundingSphere::TestPoint(const SHVec3& point) noexcept + bool SHSphere::TestPoint(const SHVec3& point) noexcept { return BoundingSphere::Contains(point); } - bool SHBoundingSphere::Raycast(const SHRay& ray, float& distance) noexcept + bool SHSphere::Raycast(const SHRay& ray, float& distance) noexcept { return Intersects(ray.position, ray.direction, distance); } - bool SHBoundingSphere::Contains(const SHBoundingSphere& rhs) const noexcept + bool SHSphere::Contains(const SHSphere& rhs) const noexcept { return BoundingSphere::Contains(rhs); } - float SHBoundingSphere::Volume() const noexcept + float SHSphere::Volume() const noexcept { return (4.0f / 3.0f) * SHMath::PI * (Radius * Radius * Radius); } - float SHBoundingSphere::SurfaceArea() const noexcept + float SHSphere::SurfaceArea() const noexcept { return 4.0f * SHMath::PI * (Radius * Radius); } @@ -167,21 +167,21 @@ namespace SHADE /* Static Function Member Definitions */ /*-----------------------------------------------------------------------------------*/ - SHBoundingSphere SHBoundingSphere::Combine(const SHBoundingSphere& lhs, const SHBoundingSphere& rhs) noexcept + SHSphere SHSphere::Combine(const SHSphere& lhs, const SHSphere& rhs) noexcept { - SHBoundingSphere result; + SHSphere result; CreateMerged(result, lhs, rhs); return result; } - bool SHBoundingSphere::Intersect(const SHBoundingSphere& lhs, const SHBoundingSphere& rhs) noexcept + bool SHSphere::Intersect(const SHSphere& lhs, const SHSphere& rhs) noexcept { return lhs.Intersects(rhs); } - SHBoundingSphere SHBoundingSphere::BuildFromSpheres(const SHBoundingSphere* spheres, size_t numSpheres) noexcept + SHSphere SHSphere::BuildFromSpheres(const SHSphere* spheres, size_t numSpheres) noexcept { - SHBoundingSphere result; + SHSphere result; for (size_t i = 1; i < numSpheres; ++i) CreateMerged(result, spheres[i - 1], spheres[i]); @@ -189,9 +189,9 @@ namespace SHADE return result; } - SHBoundingSphere SHBoundingSphere::BuildFromVertices(const SHVec3* vertices, size_t numVertices, size_t stride) noexcept + SHSphere SHSphere::BuildFromVertices(const SHVec3* vertices, size_t numVertices, size_t stride) noexcept { - SHBoundingSphere result; + SHSphere result; CreateFromPoints(result, numVertices, vertices, stride); return result; } diff --git a/SHADE_Engine/src/Math/Geometry/SHBoundingSphere.h b/SHADE_Engine/src/Math/Geometry/SHSphere.h similarity index 76% rename from SHADE_Engine/src/Math/Geometry/SHBoundingSphere.h rename to SHADE_Engine/src/Math/Geometry/SHSphere.h index d94722d6..c13076aa 100644 --- a/SHADE_Engine/src/Math/Geometry/SHBoundingSphere.h +++ b/SHADE_Engine/src/Math/Geometry/SHSphere.h @@ -22,27 +22,27 @@ namespace SHADE /* Type Definitions */ /*-----------------------------------------------------------------------------------*/ - class SH_API SHBoundingSphere : public SHShape, - private DirectX::BoundingSphere + class SH_API SHSphere : public SHShape, + private DirectX::BoundingSphere { public: /*---------------------------------------------------------------------------------*/ /* Constructors & Destructor */ /*---------------------------------------------------------------------------------*/ - SHBoundingSphere () noexcept; - SHBoundingSphere (const SHVec3& center, float radius) noexcept; - SHBoundingSphere (const SHBoundingSphere& rhs) noexcept; - SHBoundingSphere (SHBoundingSphere&& rhs) noexcept; + SHSphere () noexcept; + SHSphere (const SHVec3& center, float radius) noexcept; + SHSphere (const SHSphere& rhs) noexcept; + SHSphere (SHSphere&& rhs) noexcept; - ~SHBoundingSphere () override = default; + ~SHSphere () override = default; /*---------------------------------------------------------------------------------*/ /* Operator Overloads */ /*---------------------------------------------------------------------------------*/ - SHBoundingSphere& operator= (const SHBoundingSphere& rhs) noexcept; - SHBoundingSphere& operator= (SHBoundingSphere&& rhs) noexcept; + SHSphere& operator= (const SHSphere& rhs) noexcept; + SHSphere& operator= (SHSphere&& rhs) noexcept; /*---------------------------------------------------------------------------------*/ /* Getter Functions */ @@ -67,7 +67,7 @@ namespace SHADE [[nodiscard]] bool TestPoint (const SHVec3& point) noexcept override; [[nodiscard]] bool Raycast (const SHRay& ray, float& distance) noexcept override; - [[nodiscard]] bool Contains (const SHBoundingSphere& rhs) const noexcept; + [[nodiscard]] bool Contains (const SHSphere& rhs) const noexcept; [[nodiscard]] float Volume () const noexcept; [[nodiscard]] float SurfaceArea () const noexcept; @@ -76,10 +76,10 @@ namespace SHADE /* Static Function Members */ /*---------------------------------------------------------------------------------*/ - [[nodiscard]] static SHBoundingSphere Combine (const SHBoundingSphere& lhs, const SHBoundingSphere& rhs) noexcept; - [[nodiscard]] static bool Intersect (const SHBoundingSphere& lhs, const SHBoundingSphere& rhs) noexcept; - [[nodiscard]] static SHBoundingSphere BuildFromSpheres (const SHBoundingSphere* spheres, size_t numSpheres) noexcept; - [[nodiscard]] static SHBoundingSphere BuildFromVertices (const SHVec3* vertices, size_t numVertices, size_t stride = 0) noexcept; + [[nodiscard]] static SHSphere Combine (const SHSphere& lhs, const SHSphere& rhs) noexcept; + [[nodiscard]] static bool Intersect (const SHSphere& lhs, const SHSphere& rhs) noexcept; + [[nodiscard]] static SHSphere BuildFromSpheres (const SHSphere* spheres, size_t numSpheres) noexcept; + [[nodiscard]] static SHSphere BuildFromVertices (const SHVec3* vertices, size_t numVertices, size_t stride = 0) noexcept; private: /*---------------------------------------------------------------------------------*/ diff --git a/SHADE_Engine/src/Math/SHQuaternion.cpp b/SHADE_Engine/src/Math/SHQuaternion.cpp index 3564916a..8904cb05 100644 --- a/SHADE_Engine/src/Math/SHQuaternion.cpp +++ b/SHADE_Engine/src/Math/SHQuaternion.cpp @@ -16,7 +16,7 @@ #include "Vector/SHVec3.h" #include "SHMatrix.h" #include "SHMathHelpers.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" using namespace DirectX; diff --git a/SHADE_Engine/src/Math/Vector/SHVec2.cpp b/SHADE_Engine/src/Math/Vector/SHVec2.cpp index 195a8b14..9573be01 100644 --- a/SHADE_Engine/src/Math/Vector/SHVec2.cpp +++ b/SHADE_Engine/src/Math/Vector/SHVec2.cpp @@ -14,7 +14,7 @@ #include "SHVec2.h" // Project Headers #include "Math/SHMatrix.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" using namespace DirectX; diff --git a/SHADE_Engine/src/Math/Vector/SHVec3.cpp b/SHADE_Engine/src/Math/Vector/SHVec3.cpp index cbd8ca32..a696f341 100644 --- a/SHADE_Engine/src/Math/Vector/SHVec3.cpp +++ b/SHADE_Engine/src/Math/Vector/SHVec3.cpp @@ -15,7 +15,7 @@ // Project Headers #include "Math/SHMatrix.h" #include "Math/SHQuaternion.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" using namespace DirectX; diff --git a/SHADE_Engine/src/Math/Vector/SHVec4.cpp b/SHADE_Engine/src/Math/Vector/SHVec4.cpp index 943d540e..c6f01d9e 100644 --- a/SHADE_Engine/src/Math/Vector/SHVec4.cpp +++ b/SHADE_Engine/src/Math/Vector/SHVec4.cpp @@ -15,7 +15,7 @@ // Project Headers #include "Math/SHMatrix.h" #include "Math/SHColour.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" using namespace DirectX; diff --git a/SHADE_Engine/src/Physics/SHPhysicsUtils.cpp b/SHADE_Engine/src/Physics/Collision/SHCollisionInfo.cpp similarity index 72% rename from SHADE_Engine/src/Physics/SHPhysicsUtils.cpp rename to SHADE_Engine/src/Physics/Collision/SHCollisionInfo.cpp index 14b6cc2f..43ad05ca 100644 --- a/SHADE_Engine/src/Physics/SHPhysicsUtils.cpp +++ b/SHADE_Engine/src/Physics/Collision/SHCollisionInfo.cpp @@ -1,7 +1,7 @@ /**************************************************************************************** - * \file SHPhysicsUtils.cpp + * \file SHCollisionInfo.cpp * \author Diren D Bharwani, diren.dbharwani, 390002520 - * \brief Implementation for some Physics Utilities + * \brief Implementation for Collision Info. * * \copyright Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or * disclosure of this file or its contents without the prior written consent @@ -11,7 +11,7 @@ #include // Primary Header -#include "SHPhysicsUtils.h" +#include "SHCollisionInfo.h" namespace SHADE { @@ -19,7 +19,7 @@ namespace SHADE /* Constructors & Destructor Definitions */ /*-----------------------------------------------------------------------------------*/ - SHCollisionEvent::SHCollisionEvent() noexcept + SHCollisionInfo::SHCollisionInfo() noexcept : collisionState { State::INVALID } { ids[ENTITY_A] = MAX_EID; @@ -28,7 +28,7 @@ namespace SHADE ids[COLLIDER_B] = std::numeric_limits::max(); } - SHCollisionEvent::SHCollisionEvent(EntityID entityA, EntityID entityB) noexcept + SHCollisionInfo::SHCollisionInfo(EntityID entityA, EntityID entityB) noexcept : collisionState { State::INVALID } { ids[ENTITY_A] = entityA; @@ -41,12 +41,12 @@ namespace SHADE /* Operator Overload Definitions */ /*-----------------------------------------------------------------------------------*/ - bool SHCollisionEvent::operator==(const SHCollisionEvent& rhs) const noexcept + bool SHCollisionInfo::operator==(const SHCollisionInfo& rhs) const noexcept { return value[0] == rhs.value[0] && value[1] == rhs.value[1]; } - bool SHCollisionEvent::operator!=(const SHCollisionEvent& rhs) const noexcept + bool SHCollisionInfo::operator!=(const SHCollisionInfo& rhs) const noexcept { return value[0] != rhs.value[0] || value[1] != rhs.value[1]; } @@ -55,37 +55,37 @@ namespace SHADE /* Getter Function Definitions */ /*-----------------------------------------------------------------------------------*/ - EntityID SHCollisionEvent::GetEntityA() const noexcept + EntityID SHCollisionInfo::GetEntityA() const noexcept { return ids[ENTITY_A]; } - EntityID SHCollisionEvent::GetEntityB() const noexcept + EntityID SHCollisionInfo::GetEntityB() const noexcept { return ids[ENTITY_B]; } - const SHRigidBodyComponent* SHCollisionEvent::GetRigidBodyA() const noexcept + const SHRigidBodyComponent* SHCollisionInfo::GetRigidBodyA() const noexcept { return SHComponentManager::GetComponent_s(ids[ENTITY_A]); } - const SHRigidBodyComponent* SHCollisionEvent::GetRigidBodyB() const noexcept + const SHRigidBodyComponent* SHCollisionInfo::GetRigidBodyB() const noexcept { return SHComponentManager::GetComponent_s(ids[ENTITY_B]); } - const SHCollisionShape* SHCollisionEvent::GetColliderA() const noexcept + const SHCollisionShape* SHCollisionInfo::GetColliderA() const noexcept { return &SHComponentManager::GetComponent(ids[ENTITY_A])->GetCollisionShape(ids[COLLIDER_A]); } - const SHCollisionShape* SHCollisionEvent::GetColliderB() const noexcept + const SHCollisionShape* SHCollisionInfo::GetColliderB() const noexcept { return &SHComponentManager::GetComponent(ids[ENTITY_B])->GetCollisionShape(ids[COLLIDER_B]); } - SHCollisionEvent::State SHCollisionEvent::GetCollisionState() const noexcept + SHCollisionInfo::State SHCollisionInfo::GetCollisionState() const noexcept { return collisionState; } diff --git a/SHADE_Engine/src/Physics/SHPhysicsUtils.h b/SHADE_Engine/src/Physics/Collision/SHCollisionInfo.h similarity index 71% rename from SHADE_Engine/src/Physics/SHPhysicsUtils.h rename to SHADE_Engine/src/Physics/Collision/SHCollisionInfo.h index 753f8d3b..d2dad647 100644 --- a/SHADE_Engine/src/Physics/SHPhysicsUtils.h +++ b/SHADE_Engine/src/Physics/Collision/SHCollisionInfo.h @@ -1,7 +1,7 @@ /**************************************************************************************** - * \file SHPhysicsUtils.h + * \file SHCollisionInfo.h * \author Diren D Bharwani, diren.dbharwani, 390002520 - * \brief Interface for some Physics Utilities + * \brief Interface for Collision Information for Collision & Triggers. * * \copyright Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or * disclosure of this file or its contents without the prior written consent @@ -11,8 +11,8 @@ #pragma once // Project Headers -#include "Components/SHColliderComponent.h" -#include "Components/SHRigidBodyComponent.h" +#include "Physics/Interface/SHColliderComponent.h" +#include "Physics/Interface/SHRigidBodyComponent.h" namespace SHADE @@ -21,27 +21,14 @@ namespace SHADE /* Type Definitions */ /*-----------------------------------------------------------------------------------*/ - struct SHPhysicsColliderAddedEvent - { - EntityID entityID; - SHCollisionShape::Type colliderType; - int colliderIndex; - }; - - struct SHPhysicsColliderRemovedEvent - { - EntityID entityID; - int colliderIndex; - }; - - class SH_API SHCollisionEvent + class SH_API SHCollisionInfo { private: /*---------------------------------------------------------------------------------*/ /* Friends */ /*---------------------------------------------------------------------------------*/ - friend class SHPhysicsSystem; + friend class SHCollisionListener; public: /*---------------------------------------------------------------------------------*/ @@ -62,23 +49,23 @@ namespace SHADE /* Constructors & Destructor */ /*---------------------------------------------------------------------------------*/ - SHCollisionEvent () noexcept; - SHCollisionEvent (EntityID entityA, EntityID entityB) noexcept; + SHCollisionInfo () noexcept; + SHCollisionInfo (EntityID entityA, EntityID entityB) noexcept; - SHCollisionEvent (const SHCollisionEvent& rhs) = default; - SHCollisionEvent (SHCollisionEvent&& rhs) = default; - ~SHCollisionEvent () = default; + SHCollisionInfo (const SHCollisionInfo& rhs) = default; + SHCollisionInfo (SHCollisionInfo&& rhs) = default; + ~SHCollisionInfo () = default; /*---------------------------------------------------------------------------------*/ /* Operator Overloads */ /*---------------------------------------------------------------------------------*/ - bool operator== (const SHCollisionEvent& rhs) const noexcept; - bool operator!= (const SHCollisionEvent& rhs) const noexcept; + bool operator== (const SHCollisionInfo& rhs) const noexcept; + bool operator!= (const SHCollisionInfo& rhs) const noexcept; - SHCollisionEvent& operator= (const SHCollisionEvent& rhs) = default; - SHCollisionEvent& operator= (SHCollisionEvent&& rhs) = default; + SHCollisionInfo& operator= (const SHCollisionInfo& rhs) = default; + SHCollisionInfo& operator= (SHCollisionInfo&& rhs) = default; /*---------------------------------------------------------------------------------*/ /* Getter Functions */ @@ -88,8 +75,8 @@ namespace SHADE [[nodiscard]] EntityID GetEntityB () const noexcept; [[nodiscard]] const SHRigidBodyComponent* GetRigidBodyA () const noexcept; [[nodiscard]] const SHRigidBodyComponent* GetRigidBodyB () const noexcept; - [[nodiscard]] const SHCollisionShape* GetColliderA () const noexcept; - [[nodiscard]] const SHCollisionShape* GetColliderB () const noexcept; + [[nodiscard]] const SHCollisionShape* GetColliderA () const noexcept; + [[nodiscard]] const SHCollisionShape* GetColliderB () const noexcept; [[nodiscard]] State GetCollisionState () const noexcept; private: @@ -112,5 +99,4 @@ namespace SHADE State collisionState; }; - } // namespace SHADE \ No newline at end of file diff --git a/SHADE_Engine/src/Physics/Collision/SHCollisionListener.cpp b/SHADE_Engine/src/Physics/Collision/SHCollisionListener.cpp new file mode 100644 index 00000000..e8379b09 --- /dev/null +++ b/SHADE_Engine/src/Physics/Collision/SHCollisionListener.cpp @@ -0,0 +1,236 @@ +/**************************************************************************************** + * \file SHCollisionListener.cpp + * \author Diren D Bharwani, diren.dbharwani, 390002520 + * \brief Implementation for a Collision Listener. + * + * \copyright Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or + * disclosure of this file or its contents without the prior written consent + * of DigiPen Institute of Technology is prohibited. +****************************************************************************************/ + +#include + +// Primary Header +#include "SHCollisionListener.h" + +// Project Headers +#include "Physics/PhysicsObject/SHPhysicsObject.h" +#include "Physics/System/SHPhysicsSystem.h" + +/*-------------------------------------------------------------------------------------*/ +/* Local Helper Functions */ +/*-------------------------------------------------------------------------------------*/ + +uint32_t matchColliders(const SHADE::SHPhysicsObject&physicsObject, const rp3d::Entity colliderID) +{ + for (uint32_t i = 0; i < physicsObject.GetCollisionBody()->getNbColliders(); ++i) + { + const auto* collider = physicsObject.GetCollisionBody()->getCollider(i); + if (collider->getEntity() == colliderID) + return i; + } + + return std::numeric_limits::max(); +} + +namespace SHADE +{ + /*-----------------------------------------------------------------------------------*/ + /* Constructors & Destructor Definitions */ + /*-----------------------------------------------------------------------------------*/ + + SHCollisionListener::SHCollisionListener() noexcept + : system { nullptr } + {} + + /*-----------------------------------------------------------------------------------*/ + /* Getter Function Definitions */ + /*-----------------------------------------------------------------------------------*/ + + const std::vector& SHCollisionListener::GetCollisionInfoContainer() const noexcept + { + return collisionInfoContainer; + } + + const std::vector& SHCollisionListener::GetTriggerInfoContainer() const noexcept + { + return triggerInfoContainer; + } + + /*-----------------------------------------------------------------------------------*/ + /* Public Function Member Definitions */ + /*-----------------------------------------------------------------------------------*/ + + void SHCollisionListener::BindToSystem(SHPhysicsSystem* physicsSystem) noexcept + { + system = physicsSystem; + } + + void SHCollisionListener::BindToWorld(rp3d::PhysicsWorld* world) noexcept + { + if (!world) + return; + + world->setEventListener(this); + } + + void SHCollisionListener::CleanContainers() noexcept + { + static const auto CLEAR = [](std::vector& container) + { + for (auto eventIter = container.begin(); eventIter != container.end();) + { + const bool CLEAR_EVENT = eventIter->GetCollisionState() == SHCollisionInfo::State::EXIT + || eventIter->GetCollisionState() == SHCollisionInfo::State::INVALID; + + if (CLEAR_EVENT) + eventIter = container.erase(eventIter); + else + ++eventIter; + } + }; + + CLEAR(collisionInfoContainer); + CLEAR(triggerInfoContainer); + } + + void SHCollisionListener::ClearContainers() noexcept + { + collisionInfoContainer.clear(); + triggerInfoContainer.clear(); + } + + void SHCollisionListener::onContact(const rp3d::CollisionCallback::CallbackData& callbackData) + { + for (uint32_t i = 0; i < callbackData.getNbContactPairs(); ++i) + { + const auto CONTACT_PAIR = callbackData.getContactPair(i); + const SHCollisionInfo NEW_INFO = generateCollisionInfo(CONTACT_PAIR); + + updateInfoContainers(NEW_INFO, collisionInfoContainer); + } + } + + void SHCollisionListener::onTrigger(const rp3d::OverlapCallback::CallbackData& callbackData) + { + for (uint32_t i = 0; i < callbackData.getNbOverlappingPairs(); ++i) + { + const auto OVERLAP_PAIR = callbackData.getOverlappingPair(i); + const SHCollisionInfo NEW_INFO = generateTriggerInfo(OVERLAP_PAIR); + + updateInfoContainers(NEW_INFO, triggerInfoContainer); + } + } + + /*-----------------------------------------------------------------------------------*/ + /* Private Function Member Definitions */ + /*-----------------------------------------------------------------------------------*/ + + void SHCollisionListener::updateInfoContainers(const SHCollisionInfo& collisionEvent, std::vector& container) noexcept + { + const auto IT = std::ranges::find_if(container.begin(), container.end(), [&](const SHCollisionInfo& info) + { + const bool ENTITY_MATCH = (info.ids[0] == collisionEvent.ids[0] && info.ids[1] == collisionEvent.ids[1]) + || (info.ids[0] == collisionEvent.ids[1] && info.ids[1] == collisionEvent.ids[0]); + const bool COLLIDERS_MATCH = (info.ids[2] == collisionEvent.ids[2] && info.ids[3] == collisionEvent.ids[3]) + || (info.ids[2] == collisionEvent.ids[3] && info.ids[3] == collisionEvent.ids[2]); + return ENTITY_MATCH && COLLIDERS_MATCH; + }); + + if (IT == container.end()) + container.emplace_back(collisionEvent); + else + IT->collisionState = collisionEvent.collisionState; + } + + SHCollisionInfo SHCollisionListener::generateCollisionInfo(const rp3d::CollisionCallback::ContactPair& cp) const noexcept + { + SHCollisionInfo cInfo; + + // Update collision state + cInfo.collisionState = static_cast(cp.getEventType()); + + // Match body and collider for collision event + const rp3d::Entity body1 = cp.getBody1()->getEntity(); + const rp3d::Entity body2 = cp.getBody2()->getEntity(); + const rp3d::Entity collider1 = cp.getCollider1()->getEntity(); + const rp3d::Entity collider2 = cp.getCollider2()->getEntity(); + + // Find and match both ids + bool matched[2] = { false, false }; + + + for (auto& [entityID, physicsObject] : system->GetPhysicsObjects()) + { + // Match body 1 + if (matched[SHCollisionInfo::ENTITY_A] == false && physicsObject.GetCollisionBody()->getEntity() == body1) + { + cInfo.ids[SHCollisionInfo::ENTITY_A] = entityID; + cInfo.ids[SHCollisionInfo::COLLIDER_A] = matchColliders(physicsObject, collider1); + + matched[SHCollisionInfo::ENTITY_A] = true; + } + + // Match body 2 + if (matched[SHCollisionInfo::ENTITY_B] == false && physicsObject.GetCollisionBody()->getEntity() == body2) + { + cInfo.ids[SHCollisionInfo::ENTITY_B] = entityID; + cInfo.ids[SHCollisionInfo::COLLIDER_B] = matchColliders(physicsObject, collider2); + + matched[SHCollisionInfo::ENTITY_B] = true; + } + + if (matched[SHCollisionInfo::ENTITY_A] == true && matched[SHCollisionInfo::ENTITY_B] == true) + return cInfo; + } + + return cInfo; + } + + SHCollisionInfo SHCollisionListener::generateTriggerInfo(const rp3d::OverlapCallback::OverlapPair& cp) const noexcept + { + SHCollisionInfo cInfo; + + // Update collision state + cInfo.collisionState = static_cast(cp.getEventType()); + + // Match body and collider for collision event + const rp3d::Entity body1 = cp.getBody1()->getEntity(); + const rp3d::Entity body2 = cp.getBody2()->getEntity(); + const rp3d::Entity collider1 = cp.getCollider1()->getEntity(); + const rp3d::Entity collider2 = cp.getCollider2()->getEntity(); + + // Find and match both ids + bool matched[2] = { false, false }; + + + for (auto& [entityID, physicsObject] : system->GetPhysicsObjects()) + { + // Match body 1 + if (matched[SHCollisionInfo::ENTITY_A] == false && physicsObject.GetCollisionBody()->getEntity() == body1) + { + cInfo.ids[SHCollisionInfo::ENTITY_A] = entityID; + cInfo.ids[SHCollisionInfo::COLLIDER_A] = matchColliders(physicsObject, collider1); + + matched[SHCollisionInfo::ENTITY_A] = true; + } + + // Match body 2 + if (matched[SHCollisionInfo::ENTITY_B] == false && physicsObject.GetCollisionBody()->getEntity() == body2) + { + cInfo.ids[SHCollisionInfo::ENTITY_B] = entityID; + cInfo.ids[SHCollisionInfo::COLLIDER_B] = matchColliders(physicsObject, collider2); + + matched[SHCollisionInfo::ENTITY_B] = true; + } + + if (matched[SHCollisionInfo::ENTITY_A] == true && matched[SHCollisionInfo::ENTITY_B] == true) + return cInfo; + } + + return cInfo; + } + + + +} // namespace SHADE \ No newline at end of file diff --git a/SHADE_Engine/src/Physics/Collision/SHCollisionListener.h b/SHADE_Engine/src/Physics/Collision/SHCollisionListener.h new file mode 100644 index 00000000..6262b946 --- /dev/null +++ b/SHADE_Engine/src/Physics/Collision/SHCollisionListener.h @@ -0,0 +1,81 @@ +/**************************************************************************************** + * \file SHCollisionListener.h + * \author Diren D Bharwani, diren.dbharwani, 390002520 + * \brief Interface for a Collision Listener. + * + * \copyright Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or + * disclosure of this file or its contents without the prior written consent + * of DigiPen Institute of Technology is prohibited. +****************************************************************************************/ + +#pragma once + +// External Dependencies +#include + +// Project Headers +#include "SH_API.h" +#include "SHCollisionInfo.h" + +namespace SHADE +{ + /*-----------------------------------------------------------------------------------*/ + /* Forward Declarations */ + /*-----------------------------------------------------------------------------------*/ + + class SHPhysicsSystem; + + /*-----------------------------------------------------------------------------------*/ + /* Type Definitions */ + /*-----------------------------------------------------------------------------------*/ + + class SH_API SHCollisionListener final : public rp3d::EventListener + { + public: + + /*---------------------------------------------------------------------------------*/ + /* Constructors & Destructor */ + /*---------------------------------------------------------------------------------*/ + + SHCollisionListener() noexcept; + + /*---------------------------------------------------------------------------------*/ + /* Getter Functions */ + /*---------------------------------------------------------------------------------*/ + + [[nodiscard]] const std::vector& GetCollisionInfoContainer () const noexcept; + [[nodiscard]] const std::vector& GetTriggerInfoContainer () const noexcept; + + /*---------------------------------------------------------------------------------*/ + /* Function Members */ + /*---------------------------------------------------------------------------------*/ + + void BindToSystem (SHPhysicsSystem* physicsSystem) noexcept; + void BindToWorld (rp3d::PhysicsWorld* world) noexcept; + void CleanContainers () noexcept; + void ClearContainers () noexcept; + + void onContact (const rp3d::CollisionCallback::CallbackData& callbackData) override; + void onTrigger (const rp3d::OverlapCallback::CallbackData& callbackData) override; + + private: + + /*---------------------------------------------------------------------------------*/ + /* Data Members */ + /*---------------------------------------------------------------------------------*/ + + SHPhysicsSystem* system; + std::vector collisionInfoContainer; + std::vector triggerInfoContainer; + + /*---------------------------------------------------------------------------------*/ + /* Function Members */ + /*---------------------------------------------------------------------------------*/ + + static void updateInfoContainers (const SHCollisionInfo& collisionEvent, std::vector& container) noexcept; + + SHCollisionInfo generateCollisionInfo (const rp3d::CollisionCallback::ContactPair& cp) const noexcept; + SHCollisionInfo generateTriggerInfo (const rp3d::OverlapCallback::OverlapPair& cp) const noexcept; + }; + +} // namespace SHADE \ No newline at end of file diff --git a/SHADE_Engine/src/Physics/Components/SHColliderComponent.cpp b/SHADE_Engine/src/Physics/Interface/SHColliderComponent.cpp similarity index 87% rename from SHADE_Engine/src/Physics/Components/SHColliderComponent.cpp rename to SHADE_Engine/src/Physics/Interface/SHColliderComponent.cpp index 93126fc5..877d238f 100644 --- a/SHADE_Engine/src/Physics/Components/SHColliderComponent.cpp +++ b/SHADE_Engine/src/Physics/Interface/SHColliderComponent.cpp @@ -16,7 +16,7 @@ // Project Headers #include "ECS_Base/Managers/SHSystemManager.h" #include "Math/SHMathHelpers.h" -#include "Physics/SHPhysicsSystem.h" +#include "Physics/System/SHPhysicsSystem.h" namespace SHADE { @@ -72,7 +72,14 @@ namespace SHADE void SHColliderComponent::OnCreate() { - system = SHSystemManager::GetSystem(); + auto* physicsSystem = SHSystemManager::GetSystem(); + if (!physicsSystem) + { + SHLOG_ERROR("Physics System does not exist to link with Physics Components!") + return; + } + + system = physicsSystem; } void SHColliderComponent::OnDestroy() @@ -88,7 +95,7 @@ namespace SHADE { case SHCollisionShape::Type::BOX: { - auto* box = reinterpret_cast(collisionShape.GetShape()); + auto* box = reinterpret_cast(collisionShape.shape); const SHVec3& RELATIVE_EXTENTS = box->GetRelativeExtents(); // Recompute world extents based on new scale and fixed relative extents @@ -99,7 +106,7 @@ namespace SHADE } case SHCollisionShape::Type::SPHERE: { - auto* sphere = reinterpret_cast(collisionShape.GetShape()); + auto* sphere = reinterpret_cast(collisionShape.shape); const float RELATIVE_RADIUS = sphere->GetRelativeRadius(); // Recompute world radius based on new scale and fixed radius @@ -132,9 +139,10 @@ namespace SHADE collider.SetBoundingBox(halfExtents); // Notify Physics System - system->AddCollisionShape(GetEID(), &collider); + const int NEW_SHAPE_INDEX = static_cast(collisionShapes.size()) - 1; - return static_cast(collisionShapes.size()) - 1; + system->AddCollisionShape(GetEID(), NEW_SHAPE_INDEX); + return NEW_SHAPE_INDEX; } int SHColliderComponent::AddBoundingSphere(float radius, const SHVec3& posOffset) noexcept @@ -154,9 +162,10 @@ namespace SHADE collider.SetBoundingSphere(radius); // Notify Physics System - system->AddCollisionShape(GetEID(), &collider); + const int NEW_SHAPE_INDEX = static_cast(collisionShapes.size()) - 1; - return static_cast(collisionShapes.size()) - 1; + system->AddCollisionShape(GetEID(), NEW_SHAPE_INDEX); + return NEW_SHAPE_INDEX; } void SHColliderComponent::RemoveCollider(int index) diff --git a/SHADE_Engine/src/Physics/Components/SHColliderComponent.h b/SHADE_Engine/src/Physics/Interface/SHColliderComponent.h similarity index 97% rename from SHADE_Engine/src/Physics/Components/SHColliderComponent.h rename to SHADE_Engine/src/Physics/Interface/SHColliderComponent.h index 5f9b7a1b..0781f3cf 100644 --- a/SHADE_Engine/src/Physics/Components/SHColliderComponent.h +++ b/SHADE_Engine/src/Physics/Interface/SHColliderComponent.h @@ -14,9 +14,9 @@ // Project Headers #include "ECS_Base/Components/SHComponent.h" -#include "Physics/SHCollisionShape.h" -#include "Math/Geometry/SHBoundingBox.h" -#include "Math/Geometry/SHBoundingSphere.h" +#include "Math/Geometry/SHBox.h" +#include "Math/Geometry/SHSphere.h" +#include "SHCollisionShape.h" //namespace SHADE //{ diff --git a/SHADE_Engine/src/Physics/SHCollisionShape.cpp b/SHADE_Engine/src/Physics/Interface/SHCollisionShape.cpp similarity index 79% rename from SHADE_Engine/src/Physics/SHCollisionShape.cpp rename to SHADE_Engine/src/Physics/Interface/SHCollisionShape.cpp index c8f8020c..e63895d5 100644 --- a/SHADE_Engine/src/Physics/SHCollisionShape.cpp +++ b/SHADE_Engine/src/Physics/Interface/SHCollisionShape.cpp @@ -13,11 +13,11 @@ // Primary Header #include "SHCollisionShape.h" // Project Headers -#include "Math/Geometry/SHBoundingBox.h" -#include "Math/Geometry/SHBoundingSphere.h" +#include "Math/Geometry/SHBox.h" +#include "Math/Geometry/SHSphere.h" #include "Math/SHMathHelpers.h" -#include "Physics/Components/SHColliderComponent.h" #include "Reflection/SHReflectionMetadata.h" +#include "SHColliderComponent.h" namespace SHADE { @@ -37,12 +37,12 @@ namespace SHADE { case Type::BOX: { - shape = new SHBoundingBox{ SHVec3::Zero, SHVec3::One }; + shape = new SHBox{ SHVec3::Zero, SHVec3::One }; break; } case Type::SPHERE: { - shape = new SHBoundingSphere{ SHVec3::Zero, 0.5f }; + shape = new SHSphere{ SHVec3::Zero, 0.5f }; break; } default: break; @@ -164,9 +164,8 @@ namespace SHADE return rotationOffset; } - SHShape* SHCollisionShape::GetShape() noexcept + const SHShape* SHCollisionShape::GetShape() const noexcept { - dirty = true; return shape; } @@ -178,30 +177,48 @@ namespace SHADE { dirty = true; - const auto* colliderComponent = SHComponentManager::GetComponent(entityID); + const auto* COLLIDER = SHComponentManager::GetComponent(entityID); + auto* box = reinterpret_cast(shape); + + SHVec3 correctedHalfExtents = halfExtents; + + // Get current relative halfExtents for error checking. 0 is ignored + const SHVec3& CURRENT_RELATIVE_EXTENTS = box->GetRelativeExtents(); + for (size_t i = 0; i < SHVec3::SIZE; ++i) + { + if (SHMath::CompareFloat(halfExtents[i], 0.0f)) + correctedHalfExtents[i] = CURRENT_RELATIVE_EXTENTS[i]; + } + // Set the half extents relative to world scale - const SHVec3 WORLD_EXTENTS = halfExtents * colliderComponent->GetScale() * 0.5f; + const SHVec3 WORLD_EXTENTS = correctedHalfExtents * COLLIDER->GetScale() * 0.5f; if (type != Type::BOX) { type = Type::BOX; delete shape; - shape = new SHBoundingBox{ positionOffset, WORLD_EXTENTS }; + shape = new SHBox{ positionOffset, WORLD_EXTENTS }; } - auto* box = reinterpret_cast(shape); box->SetWorldExtents(WORLD_EXTENTS); - box->SetRelativeExtents(halfExtents); + box->SetRelativeExtents(correctedHalfExtents); } void SHCollisionShape::SetBoundingSphere(float radius) { dirty = true; - const auto* colliderComponent = SHComponentManager::GetComponent(entityID); + auto* sphere = reinterpret_cast(shape); + const auto* COLLIDER = SHComponentManager::GetComponent(entityID); + + // Get current relative halfExtents for error checking. 0 is ignored + const float CURRENT_RELATIVE_RADIUS = sphere->GetRelativeRadius(); + if (SHMath::CompareFloat(radius, 0.0f)) + radius = CURRENT_RELATIVE_RADIUS; + // Set the radius relative to world scale - const SHVec3 WORLD_SCALE = colliderComponent->GetScale(); + const SHVec3 WORLD_SCALE = COLLIDER->GetScale(); const float MAX_SCALE = SHMath::Max({ WORLD_SCALE.x, WORLD_SCALE.y, WORLD_SCALE.z }); const float WORLD_RADIUS = radius * MAX_SCALE * 0.5f; @@ -210,11 +227,11 @@ namespace SHADE type = Type::SPHERE; delete shape; - shape = new SHBoundingSphere{ positionOffset, WORLD_RADIUS }; + shape = new SHSphere{ positionOffset, WORLD_RADIUS }; } - auto* sphere = reinterpret_cast(shape); sphere->SetWorldRadius(WORLD_RADIUS); + sphere->SetRelativeRadius(radius); } void SHCollisionShape::SetIsTrigger(bool trigger) noexcept @@ -256,12 +273,12 @@ namespace SHADE { case Type::BOX: { - reinterpret_cast(shape)->SetCenter(positionOffset); + reinterpret_cast(shape)->SetCenter(positionOffset); break; } case Type::SPHERE: { - reinterpret_cast(shape)->SetCenter(positionOffset); + reinterpret_cast(shape)->SetCenter(positionOffset); break; } default: break; @@ -284,16 +301,16 @@ namespace SHADE { case Type::BOX: { - const auto* RHS_BOX = reinterpret_cast(rhs); + const auto* RHS_BOX = reinterpret_cast(rhs); - shape = new SHBoundingBox{ positionOffset, RHS_BOX->GetWorldExtents() }; + shape = new SHBox{ positionOffset, RHS_BOX->GetWorldExtents() }; break; } case Type::SPHERE: { - const auto* RHS_SPHERE = reinterpret_cast(rhs); + const auto* RHS_SPHERE = reinterpret_cast(rhs); - shape = new SHBoundingSphere{ positionOffset, RHS_SPHERE->GetWorldRadius() }; + shape = new SHSphere{ positionOffset, RHS_SPHERE->GetWorldRadius() }; break; } default: break; diff --git a/SHADE_Engine/src/Physics/SHCollisionShape.h b/SHADE_Engine/src/Physics/Interface/SHCollisionShape.h similarity index 98% rename from SHADE_Engine/src/Physics/SHCollisionShape.h rename to SHADE_Engine/src/Physics/Interface/SHCollisionShape.h index 9c8c1d41..526428fd 100644 --- a/SHADE_Engine/src/Physics/SHCollisionShape.h +++ b/SHADE_Engine/src/Physics/Interface/SHCollisionShape.h @@ -82,7 +82,7 @@ namespace SHADE [[nodiscard]] const SHVec3& GetPositionOffset () const noexcept; [[nodiscard]] const SHVec3& GetRotationOffset () const noexcept; - [[nodiscard]] SHShape* GetShape () noexcept; + [[nodiscard]] const SHShape* GetShape () const noexcept; /*---------------------------------------------------------------------------------*/ /* Setter Functions */ diff --git a/SHADE_Engine/src/Physics/SHPhysicsMaterial.cpp b/SHADE_Engine/src/Physics/Interface/SHPhysicsMaterial.cpp similarity index 97% rename from SHADE_Engine/src/Physics/SHPhysicsMaterial.cpp rename to SHADE_Engine/src/Physics/Interface/SHPhysicsMaterial.cpp index 677e448f..95141501 100644 --- a/SHADE_Engine/src/Physics/SHPhysicsMaterial.cpp +++ b/SHADE_Engine/src/Physics/Interface/SHPhysicsMaterial.cpp @@ -44,7 +44,7 @@ namespace SHADE && SHMath::CompareFloat(density, rhs.density); } - bool SHPhysicsMaterial::operator!=(const SHPhysicsMaterial& rhs) const noexcept + bool SHPhysicsMaterial::operator!=(const SHPhysicsMaterial& rhs) const noexcept { return !SHMath::CompareFloat(friction, rhs.friction) || !SHMath::CompareFloat(bounciness, rhs.bounciness) diff --git a/SHADE_Engine/src/Physics/SHPhysicsMaterial.h b/SHADE_Engine/src/Physics/Interface/SHPhysicsMaterial.h similarity index 100% rename from SHADE_Engine/src/Physics/SHPhysicsMaterial.h rename to SHADE_Engine/src/Physics/Interface/SHPhysicsMaterial.h diff --git a/SHADE_Engine/src/Physics/Components/SHRigidBodyComponent.cpp b/SHADE_Engine/src/Physics/Interface/SHRigidBodyComponent.cpp similarity index 56% rename from SHADE_Engine/src/Physics/Components/SHRigidBodyComponent.cpp rename to SHADE_Engine/src/Physics/Interface/SHRigidBodyComponent.cpp index 369d26a5..765decd8 100644 --- a/SHADE_Engine/src/Physics/Components/SHRigidBodyComponent.cpp +++ b/SHADE_Engine/src/Physics/Interface/SHRigidBodyComponent.cpp @@ -19,7 +19,7 @@ // Project Headers #include "ECS_Base/Managers/SHSystemManager.h" #include "Math/SHMathHelpers.h" -#include "Physics/SHPhysicsSystem.h" +#include "Physics/System/SHPhysicsSystem.h" namespace SHADE { @@ -30,8 +30,17 @@ namespace SHADE SHRigidBodyComponent::SHRigidBodyComponent() noexcept : type { Type::DYNAMIC } , interpolate { true } - , rp3dBody { nullptr } - {} + , flags { 0 } + , dirtyFlags { std::numeric_limits::max() } + , mass { 1.0f } + , drag { 0.01f } + , angularDrag { 0.01f } + , system { nullptr } + { + // Initialise default flags + flags |= 1U << 0; // Gravity set to true + flags |= 1U << 1; // Sleeping allowed + } /*-----------------------------------------------------------------------------------*/ /* Getter Function Definitions */ @@ -39,24 +48,14 @@ namespace SHADE bool SHRigidBodyComponent::IsGravityEnabled() const noexcept { - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return false; - } - - return rp3dBody->isGravityEnabled(); + static constexpr int FLAG_POS = 0; + return flags & (1U << FLAG_POS); } bool SHRigidBodyComponent::IsAllowedToSleep() const noexcept { - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return false; - } - - return rp3dBody->isAllowedToSleep(); + static constexpr int FLAG_POS = 1; + return flags & (1U << FLAG_POS); } bool SHRigidBodyComponent::IsInterpolating() const noexcept @@ -71,151 +70,85 @@ namespace SHADE float SHRigidBodyComponent::GetMass() const noexcept { - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return 0.0f; - } - - return rp3dBody->getMass(); + return mass; } float SHRigidBodyComponent::GetDrag() const noexcept { - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return 0.0f; - } - - return rp3dBody->getLinearDamping(); + return drag; } float SHRigidBodyComponent::GetAngularDrag() const noexcept { - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return 0.0f; - } - - return rp3dBody->getAngularDamping(); + return angularDrag; } bool SHRigidBodyComponent::GetFreezePositionX() const noexcept { - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return false; - } - - const auto& LINEAR_CONSTRAINTS = rp3dBody->getLinearLockAxisFactor(); - return SHMath::CompareFloat(LINEAR_CONSTRAINTS.x, 0.0f); + static constexpr int FLAG_POS = 2; + return flags & (1U << FLAG_POS); } bool SHRigidBodyComponent::GetFreezePositionY() const noexcept { - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return false; - } - - const auto& LINEAR_CONSTRAINTS = rp3dBody->getLinearLockAxisFactor(); - return SHMath::CompareFloat(LINEAR_CONSTRAINTS.y, 0.0f); + static constexpr int FLAG_POS = 3; + return flags & (1U << FLAG_POS); } bool SHRigidBodyComponent::GetFreezePositionZ() const noexcept { - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return false; - } - - const auto& LINEAR_CONSTRAINTS = rp3dBody->getLinearLockAxisFactor(); - return SHMath::CompareFloat(LINEAR_CONSTRAINTS.z, 0.0f); + static constexpr int FLAG_POS = 4; + return flags & (1U << FLAG_POS); } bool SHRigidBodyComponent::GetFreezeRotationX() const noexcept { - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return false; - } - - const auto& ANGULAR_CONSTRAINTS = rp3dBody->getAngularLockAxisFactor(); - return SHMath::CompareFloat(ANGULAR_CONSTRAINTS.x, 0.0f); + static constexpr int FLAG_POS = 5; + return flags & (1U << FLAG_POS); } bool SHRigidBodyComponent::GetFreezeRotationY() const noexcept { - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return false; - } - - const auto& ANGULAR_CONSTRAINTS = rp3dBody->getAngularLockAxisFactor(); - return SHMath::CompareFloat(ANGULAR_CONSTRAINTS.y, 0.0f); + static constexpr int FLAG_POS = 6; + return flags & (1U << FLAG_POS); } bool SHRigidBodyComponent::GetFreezeRotationZ() const noexcept { - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return false; - } - - const auto& ANGULAR_CONSTRAINTS = rp3dBody->getAngularLockAxisFactor(); - return SHMath::CompareFloat(ANGULAR_CONSTRAINTS.z, 0.0f); + static constexpr int FLAG_POS = 7; + return flags & (1U << FLAG_POS); } SHVec3 SHRigidBodyComponent::GetForce() const noexcept { - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return false; - } + if (auto* physicsObject = system->GetPhysicsObject(GetEID()); physicsObject) + return physicsObject->GetRigidBody()->getForce(); - return rp3dBody->getForce(); + return SHVec3::Zero; } SHVec3 SHRigidBodyComponent::GetTorque() const noexcept { - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return SHVec3::Zero; - } + if (auto* physicsObject = system->GetPhysicsObject(GetEID()); physicsObject) + return physicsObject->GetRigidBody()->getTorque(); - return rp3dBody->getTorque(); + return SHVec3::Zero; } SHVec3 SHRigidBodyComponent::GetLinearVelocity() const noexcept { - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return SHVec3::Zero; - } + if (auto* physicsObject = system->GetPhysicsObject(GetEID()); physicsObject) + return physicsObject->GetRigidBody()->getLinearVelocity(); - return rp3dBody->getLinearVelocity(); + return SHVec3::Zero; } SHVec3 SHRigidBodyComponent::GetAngularVelocity() const noexcept { - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return SHVec3::Zero; - } + if (auto* physicsObject = system->GetPhysicsObject(GetEID()); physicsObject) + return physicsObject->GetRigidBody()->getAngularVelocity(); - return rp3dBody->getAngularVelocity(); + return SHVec3::Zero; } const SHVec3& SHRigidBodyComponent::GetPosition() const noexcept @@ -239,18 +172,13 @@ namespace SHADE void SHRigidBodyComponent::SetType(Type newType) noexcept { + static constexpr int FLAG_POS = 8; + if (type == newType) return; type = newType; - - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return; - } - - rp3dBody->setType(static_cast(type)); + dirtyFlags |= 1U << FLAG_POS; } void SHRigidBodyComponent::SetGravityEnabled(bool enableGravity) noexcept @@ -263,13 +191,8 @@ namespace SHADE return; } - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return; - } - - rp3dBody->enableGravity(enableGravity); + dirtyFlags |= 1U << FLAG_POS; + enableGravity ? flags |= 1U << FLAG_POS : flags &= ~(1U << FLAG_POS); } void SHRigidBodyComponent::SetIsAllowedToSleep(bool isAllowedToSleep) noexcept @@ -282,127 +205,92 @@ namespace SHADE return; } - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return; - } - - rp3dBody->setIsAllowedToSleep(isAllowedToSleep); + dirtyFlags |= 1U << FLAG_POS; + isAllowedToSleep ? flags |= 1U << FLAG_POS : flags &= ~(1U << FLAG_POS); } void SHRigidBodyComponent::SetFreezePositionX(bool freezePositionX) noexcept { + static constexpr int FLAG_POS = 2; + if (type == Type::STATIC) { SHLOG_WARNING("Cannot set linear constraints of a static object {}", GetEID()) return; } - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return; - } - - auto linearConstraints = rp3dBody->getLinearLockAxisFactor(); - linearConstraints.x = freezePositionX ? 0.0f : 1.0f; - rp3dBody->setLinearLockAxisFactor(linearConstraints); + dirtyFlags |= 1U << FLAG_POS; + freezePositionX ? flags |= 1U << FLAG_POS : flags &= ~(1U << FLAG_POS); } void SHRigidBodyComponent::SetFreezePositionY(bool freezePositionY) noexcept { + static constexpr int FLAG_POS = 3; + if (type == Type::STATIC) { SHLOG_WARNING("Cannot set linear constraints of a static object {}", GetEID()) return; } - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return; - } - - auto linearConstraints = rp3dBody->getLinearLockAxisFactor(); - linearConstraints.y = freezePositionY ? 0.0f : 1.0f; - rp3dBody->setLinearLockAxisFactor(linearConstraints); + dirtyFlags |= 1U << FLAG_POS; + freezePositionY ? flags |= 1U << FLAG_POS : flags &= ~(1U << FLAG_POS); } void SHRigidBodyComponent::SetFreezePositionZ(bool freezePositionZ) noexcept { + static constexpr int FLAG_POS = 4; + if (type == Type::STATIC) { SHLOG_WARNING("Cannot set linear constraints of a static object {}", GetEID()) return; } - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return; - } - - auto linearConstraints = rp3dBody->getLinearLockAxisFactor(); - linearConstraints.z = freezePositionZ ? 0.0f : 1.0f; - rp3dBody->setLinearLockAxisFactor(linearConstraints); + dirtyFlags |= 1U << FLAG_POS; + freezePositionZ ? flags |= 1U << FLAG_POS : flags &= ~(1U << FLAG_POS); } void SHRigidBodyComponent::SetFreezeRotationX(bool freezeRotationX) noexcept { + static constexpr int FLAG_POS = 5; + if (type == Type::STATIC) { SHLOG_WARNING("Cannot set angular constraints of a static object {}", GetEID()) return; } - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return; - } - - auto angularConstraints = rp3dBody->getAngularLockAxisFactor(); - angularConstraints.x = freezeRotationX ? 0.0f : 1.0f; - rp3dBody->setAngularLockAxisFactor(angularConstraints); + dirtyFlags |= 1U << FLAG_POS; + freezeRotationX ? flags |= 1U << FLAG_POS : flags &= ~(1U << FLAG_POS); } void SHRigidBodyComponent::SetFreezeRotationY(bool freezeRotationY) noexcept { + static constexpr int FLAG_POS = 6; + if (type == Type::STATIC) { SHLOG_WARNING("Cannot set angular constraints of a static object {}", GetEID()) return; } - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return; - } - - auto angularConstraints = rp3dBody->getAngularLockAxisFactor(); - angularConstraints.y = freezeRotationY ? 0.0f : 1.0f; - rp3dBody->setAngularLockAxisFactor(angularConstraints); + dirtyFlags |= 1U << FLAG_POS; + freezeRotationY ? flags |= 1U << FLAG_POS : flags &= ~(1U << FLAG_POS); } void SHRigidBodyComponent::SetFreezeRotationZ(bool freezeRotationZ) noexcept { + static constexpr int FLAG_POS = 7; + if (type == Type::STATIC) { SHLOG_WARNING("Cannot set angular constraints of a static object {}", GetEID()) return; } - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return; - } - - auto angularConstraints = rp3dBody->getAngularLockAxisFactor(); - angularConstraints.z = freezeRotationZ ? 0.0f : 1.0f; - rp3dBody->setAngularLockAxisFactor(angularConstraints); + dirtyFlags |= 1U << FLAG_POS; + freezeRotationZ ? flags |= 1U << FLAG_POS : flags &= ~(1U << FLAG_POS); } void SHRigidBodyComponent::SetInterpolate(bool allowInterpolation) noexcept @@ -412,179 +300,150 @@ namespace SHADE void SHRigidBodyComponent::SetMass(float newMass) noexcept { + static constexpr int FLAG_POS = 9; + + if (newMass < 0.0f) + return; + if (type != Type::DYNAMIC) { SHLOG_WARNING("Cannot set mass of a non-dynamic object {}", GetEID()) return; } - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return; - } - - rp3dBody->setMass(newMass); + dirtyFlags |= 1U << FLAG_POS; + mass = newMass; } void SHRigidBodyComponent::SetDrag(float newDrag) noexcept { + static constexpr int FLAG_POS = 10; + if (type != Type::DYNAMIC) { SHLOG_WARNING("Cannot set drag of a non-dynamic object {}", GetEID()) return; } - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return; - } - - rp3dBody->setLinearDamping(newDrag); + dirtyFlags |= 1U << FLAG_POS; + drag = newDrag; } void SHRigidBodyComponent::SetAngularDrag(float newAngularDrag) noexcept { + static constexpr int FLAG_POS = 11; + if (type != Type::DYNAMIC) { SHLOG_WARNING("Cannot set angular drag of a non-dynamic object {}", GetEID()) return; } - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return; - } - - rp3dBody->setLinearDamping(newAngularDrag); + dirtyFlags |= 1U << FLAG_POS; + angularDrag = newAngularDrag; } void SHRigidBodyComponent::SetLinearVelocity(const SHVec3& newLinearVelocity) noexcept { + if (type == Type::STATIC) { SHLOG_WARNING("Cannot set linear velocity of a static object {}", GetEID()) return; } - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return; - } - - rp3dBody->setLinearVelocity(newLinearVelocity); + auto* physicsObject = system->GetPhysicsObject(GetEID()); + physicsObject->GetRigidBody()->setLinearVelocity(newLinearVelocity); } void SHRigidBodyComponent::SetAngularVelocity(const SHVec3& newAngularVelocity) noexcept { + static constexpr int FLAG_POS = 13; + if (type == Type::STATIC) { SHLOG_WARNING("Cannot set angular velocity of a static object {}", GetEID()) return; } - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return; - } - - rp3dBody->setAngularVelocity(newAngularVelocity); + auto* physicsObject = system->GetPhysicsObject(GetEID()); + physicsObject->GetRigidBody()->setAngularVelocity(newAngularVelocity); } /*-----------------------------------------------------------------------------------*/ /* Public Function Member Definitions */ /*-----------------------------------------------------------------------------------*/ - void SHRigidBodyComponent::AddForce(const SHVec3& force) const noexcept + void SHRigidBodyComponent::OnCreate() { - if (rp3dBody == nullptr) + auto* physicsSystem = SHSystemManager::GetSystem(); + if (!physicsSystem) { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) + SHLOG_ERROR("Physics System does not exist to link with Physics Components!") return; } - rp3dBody->applyWorldForceAtCenterOfMass(force); + system = physicsSystem; + } + + void SHRigidBodyComponent::AddForce(const SHVec3& force) const noexcept + { + if (auto* physicsObject = system->GetPhysicsObject(GetEID()); physicsObject) + physicsObject->GetRigidBody()->applyWorldForceAtCenterOfMass(force); } void SHRigidBodyComponent::AddForceAtLocalPos(const SHVec3& force, const SHVec3& localPos) const noexcept { - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return; - } - - rp3dBody->applyWorldForceAtLocalPosition(force, localPos); + if (auto* physicsObject = system->GetPhysicsObject(GetEID()); physicsObject) + physicsObject->GetRigidBody()->applyWorldForceAtLocalPosition(force, localPos); } void SHRigidBodyComponent::AddForceAtWorldPos(const SHVec3& force, const SHVec3& worldPos) const noexcept { - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return; - } - - rp3dBody->applyWorldForceAtWorldPosition(force, worldPos); + if (auto* physicsObject = system->GetPhysicsObject(GetEID()); physicsObject) + physicsObject->GetRigidBody()->applyWorldForceAtWorldPosition(force, worldPos); } void SHRigidBodyComponent::AddRelativeForce(const SHVec3& relativeForce) const noexcept { - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return; - } - - rp3dBody->applyLocalForceAtCenterOfMass(relativeForce); + if (auto* physicsObject = system->GetPhysicsObject(GetEID()); physicsObject) + physicsObject->GetRigidBody()->applyLocalForceAtCenterOfMass(relativeForce); } void SHRigidBodyComponent::AddRelativeForceAtLocalPos(const SHVec3& relativeForce, const SHVec3& localPos) const noexcept { - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return; - } - - rp3dBody->applyLocalForceAtLocalPosition(relativeForce, localPos); + if (auto* physicsObject = system->GetPhysicsObject(GetEID()); physicsObject) + physicsObject->GetRigidBody()->applyLocalForceAtLocalPosition(relativeForce, localPos); } void SHRigidBodyComponent::AddRelativeForceAtWorldPos(const SHVec3& relativeForce, const SHVec3& worldPos) const noexcept { - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return; - } - - rp3dBody->applyLocalForceAtWorldPosition(relativeForce, worldPos); + if (auto* physicsObject = system->GetPhysicsObject(GetEID()); physicsObject) + physicsObject->GetRigidBody()->applyLocalForceAtWorldPosition(relativeForce, worldPos); } void SHRigidBodyComponent::AddTorque(const SHVec3& torque) const noexcept { - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return; - } - - rp3dBody->applyWorldTorque(torque); + if (auto* physicsObject = system->GetPhysicsObject(GetEID()); physicsObject) + physicsObject->GetRigidBody()->applyWorldTorque(torque); } void SHRigidBodyComponent::AddRelativeTorque(const SHVec3& relativeTorque) const noexcept { - if (rp3dBody == nullptr) - { - SHLOG_ERROR("Missing rp3dBody from Entity {}", GetEID()) - return; - } + if (auto* physicsObject = system->GetPhysicsObject(GetEID()); physicsObject) + physicsObject->GetRigidBody()->applyLocalTorque(relativeTorque); + } - rp3dBody->applyLocalTorque(relativeTorque); + void SHRigidBodyComponent::ClearForces() const noexcept + { + if (auto* physicsObject = system->GetPhysicsObject(GetEID()); physicsObject) + physicsObject->GetRigidBody()->resetForce(); + } + + void SHRigidBodyComponent::ClearTorque() const noexcept + { + if (auto* physicsObject = system->GetPhysicsObject(GetEID()); physicsObject) + physicsObject->GetRigidBody()->resetTorque(); } } // namespace SHADE diff --git a/SHADE_Engine/src/Physics/Components/SHRigidBodyComponent.h b/SHADE_Engine/src/Physics/Interface/SHRigidBodyComponent.h similarity index 77% rename from SHADE_Engine/src/Physics/Components/SHRigidBodyComponent.h rename to SHADE_Engine/src/Physics/Interface/SHRigidBodyComponent.h index ba7d2dd9..f7062f96 100644 --- a/SHADE_Engine/src/Physics/Components/SHRigidBodyComponent.h +++ b/SHADE_Engine/src/Physics/Interface/SHRigidBodyComponent.h @@ -17,16 +17,6 @@ #include "Math/Vector/SHVec3.h" #include "Math/SHQuaternion.h" -//namespace SHADE -//{ -// class SHPhysicsSystem; -//} - -namespace reactphysics3d -{ - class RigidBody; -} - namespace SHADE { /*-----------------------------------------------------------------------------------*/ @@ -107,55 +97,68 @@ namespace SHADE /* Setter Functions */ /*---------------------------------------------------------------------------------*/ - void SetType (Type newType) noexcept; + void SetType (Type newType) noexcept; - void SetGravityEnabled (bool enableGravity) noexcept; - void SetIsAllowedToSleep(bool isAllowedToSleep) noexcept; - void SetFreezePositionX (bool freezePositionX) noexcept; - void SetFreezePositionY (bool freezePositionY) noexcept; - void SetFreezePositionZ (bool freezePositionZ) noexcept; - void SetFreezeRotationX (bool freezeRotationX) noexcept; - void SetFreezeRotationY (bool freezeRotationY) noexcept; - void SetFreezeRotationZ (bool freezeRotationZ) noexcept; - void SetInterpolate (bool allowInterpolation) noexcept; + void SetGravityEnabled (bool enableGravity) noexcept; + void SetIsAllowedToSleep (bool isAllowedToSleep) noexcept; + void SetFreezePositionX (bool freezePositionX) noexcept; + void SetFreezePositionY (bool freezePositionY) noexcept; + void SetFreezePositionZ (bool freezePositionZ) noexcept; + void SetFreezeRotationX (bool freezeRotationX) noexcept; + void SetFreezeRotationY (bool freezeRotationY) noexcept; + void SetFreezeRotationZ (bool freezeRotationZ) noexcept; + void SetInterpolate (bool allowInterpolation) noexcept; - void SetMass (float newMass) noexcept; - void SetDrag (float newDrag) noexcept; - void SetAngularDrag (float newAngularDrag) noexcept; + void SetMass (float newMass) noexcept; + void SetDrag (float newDrag) noexcept; + void SetAngularDrag (float newAngularDrag) noexcept; - void SetLinearVelocity (const SHVec3& newLinearVelocity) noexcept; - void SetAngularVelocity (const SHVec3& newAngularVelocity) noexcept; + void SetLinearVelocity (const SHVec3& newLinearVelocity) noexcept; + void SetAngularVelocity (const SHVec3& newAngularVelocity) noexcept; /*---------------------------------------------------------------------------------*/ /* Function Members */ /*---------------------------------------------------------------------------------*/ + void OnCreate () override; + void AddForce (const SHVec3& force) const noexcept; void AddForceAtLocalPos (const SHVec3& force, const SHVec3& localPos) const noexcept; void AddForceAtWorldPos (const SHVec3& force, const SHVec3& worldPos) const noexcept; - void AddRelativeForce (const SHVec3& relativeForce) const noexcept; void AddRelativeForceAtLocalPos (const SHVec3& relativeForce, const SHVec3& localPos) const noexcept; void AddRelativeForceAtWorldPos (const SHVec3& relativeForce, const SHVec3& worldPos) const noexcept; - void AddTorque (const SHVec3& torque) const noexcept; void AddRelativeTorque (const SHVec3& relativeTorque) const noexcept; + void ClearForces () const noexcept; + void ClearTorque () const noexcept; + private: /*---------------------------------------------------------------------------------*/ /* Data Members */ /*---------------------------------------------------------------------------------*/ static constexpr size_t NUM_FLAGS = 8; - static constexpr size_t NUM_DIRTY_FLAGS = 16; + static constexpr size_t NUM_DIRTY_FLAGS = 12; - Type type; - bool interpolate; + Type type; - reactphysics3d::RigidBody* rp3dBody; + bool interpolate; + uint8_t flags; // aZ aY aX lZ lY lX slp g + uint16_t dirtyFlags; // 0 0 0 0 aD d m t aZ aY aX lZ lY lX slp g - SHVec3 position; - SHQuaternion orientation; + float mass; + float drag; + float angularDrag; + + SHVec3 linearVelocity; + SHVec3 angularVelocity; + + SHPhysicsSystem* system; + + SHVec3 position; + SHQuaternion orientation; RTTR_ENABLE() }; diff --git a/SHADE_Engine/src/Physics/PhysicsObject/SHPhysicsObject.cpp b/SHADE_Engine/src/Physics/PhysicsObject/SHPhysicsObject.cpp new file mode 100644 index 00000000..a52d3899 --- /dev/null +++ b/SHADE_Engine/src/Physics/PhysicsObject/SHPhysicsObject.cpp @@ -0,0 +1,378 @@ +/**************************************************************************************** + * \file SHPhysicsObject.cpp + * \author Diren D Bharwani, diren.dbharwani, 390002520 + * \brief Implementation for a Physics Object. + * + * \copyright Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or + * disclosure of this file or its contents without the prior written consent + * of DigiPen Institute of Technology is prohibited. +****************************************************************************************/ + +#include + +// Primary Header +#include "SHPhysicsObject.h" + +// Project Headers +#include "ECS_Base/Managers/SHSystemManager.h" +#include "ECS_Base/Managers/SHComponentManager.h" +#include "Scene/SHSceneManager.h" + + +namespace SHADE +{ + /*-----------------------------------------------------------------------------------*/ + /* Constructors & Destructor Definitions */ + /*-----------------------------------------------------------------------------------*/ + + SHPhysicsObject::SHPhysicsObject(EntityID eid, rp3d::PhysicsCommon* physicsFactory, rp3d::PhysicsWorld* physicsWorld) noexcept + : entityID { eid } + , collidersActive { true } + , factory { physicsFactory } + , world { physicsWorld } + , rp3dBody { nullptr } + { + // Implicitly create a static body. + + const auto* TRANSFORM = SHComponentManager::GetComponent(eid); + + const rp3d::Transform RP3D_TRANSFORM { TRANSFORM->GetWorldPosition(), TRANSFORM->GetWorldOrientation() }; + + rp3dBody = world->createRigidBody(RP3D_TRANSFORM); + rp3dBody->setType(rp3d::BodyType::STATIC); + } + + SHPhysicsObject::~SHPhysicsObject() noexcept + { + factory = nullptr; + world = nullptr; + rp3dBody = nullptr; + } + + /*-----------------------------------------------------------------------------------*/ + /* Getter Function Definitions */ + /*-----------------------------------------------------------------------------------*/ + + SHVec3 SHPhysicsObject::GetPosition() const noexcept + { + return rp3dBody->getTransform().getPosition(); + } + + SHQuaternion SHPhysicsObject::GetOrientation() const noexcept + { + return rp3dBody->getTransform().getOrientation(); + } + + SHVec3 SHPhysicsObject::GetRotation() const noexcept + { + return SHQuaternion{ rp3dBody->getTransform().getOrientation() }.ToEuler(); + } + + rp3d::CollisionBody* SHPhysicsObject::GetCollisionBody() const noexcept + { + return rp3dBody; + } + + rp3d::RigidBody* SHPhysicsObject::GetRigidBody() const noexcept + { + return rp3dBody; + } + + /*-----------------------------------------------------------------------------------*/ + /* Setter Function Definitions */ + /*-----------------------------------------------------------------------------------*/ + + void SHPhysicsObject::SetStaticBody() const noexcept + { + if (!rp3dBody) + return; + + rp3dBody->setType(rp3d::BodyType::STATIC); + } + + /*-----------------------------------------------------------------------------------*/ + /* Public Function Member Definitions */ + /*-----------------------------------------------------------------------------------*/ + + int SHPhysicsObject::AddCollisionShape(int index) const + { + // Get collider component + auto* colliderComponent = SHComponentManager::GetComponent_s(entityID); + if (!colliderComponent) + { + SHLOGV_ERROR("Unable to add Collision Shape to Entity {} due to Missing Collider Component!", entityID) + return -1; + } + + auto& collisionShape = colliderComponent->GetCollisionShape(index); + switch (collisionShape.GetType()) + { + // TODO(Diren): Add more collider shapes + + case SHCollisionShape::Type::BOX: addBoxShape(collisionShape); break; + case SHCollisionShape::Type::SPHERE: addSphereShape(collisionShape); break; + default: break; + } + + rp3dBody->updateLocalCenterOfMassFromColliders(); + rp3dBody->updateLocalInertiaTensorFromColliders(); + + return index; + } + + void SHPhysicsObject::RemoveCollisionShape(int index) const + { + const int NUM_COLLIDERS = static_cast(rp3dBody->getNbColliders()); + if (NUM_COLLIDERS == 0) + return; + + if (index < 0 || index >= NUM_COLLIDERS) + throw std::invalid_argument("Index out of range!"); + + auto* collider = rp3dBody->getCollider(index); + rp3dBody->removeCollider(collider); + } + + void SHPhysicsObject::RemoveAllCollisionShapes() const noexcept + { + int numColliders = static_cast(rp3dBody->getNbColliders()); + if (numColliders == 0) + return; + + while (numColliders - 1 >= 0) + { + auto* collider = rp3dBody->getCollider(numColliders - 1); + rp3dBody->removeCollider(collider); + + --numColliders; + } + } + + void SHPhysicsObject::SyncRigidBody(SHRigidBodyComponent& component) const noexcept + { + // This state is synced in the pre-update routine + if (!rp3dBody->isActive()) + return; + + if (component.dirtyFlags == 0) + return; + + for (size_t i = 0; i < SHRigidBodyComponent::NUM_DIRTY_FLAGS; ++i) + { + if (const bool IS_DIRTY = component.dirtyFlags & (1U << i); IS_DIRTY) + { + switch (i) + { + case 0: // Gravity + { + const bool IS_ENABLED = component.flags & (1U << i); + rp3dBody->enableGravity(IS_ENABLED); + + break; + } + case 1: // Sleeping + { + const bool IS_ENABLED = component.flags & (1U << i); + rp3dBody->setIsAllowedToSleep(IS_ENABLED); + + break; + } + case 2: // Lock Position X + { + const bool IS_ENABLED = component.flags & (1U << i); + + auto positionLock = rp3dBody->getLinearLockAxisFactor(); + positionLock.x = IS_ENABLED ? 0.0f : 1.0f; + rp3dBody->setLinearLockAxisFactor(positionLock); + + break; + } + case 3: // Lock Position Y + { + const bool IS_ENABLED = component.flags & (1U << i); + + auto positionLock = rp3dBody->getLinearLockAxisFactor(); + positionLock.y = IS_ENABLED ? 0.0f : 1.0f; + rp3dBody->setLinearLockAxisFactor(positionLock); + + break; + } + case 4: // Lock Position Z + { + const bool IS_ENABLED = component.flags & (1U << i); + + auto positionLock = rp3dBody->getLinearLockAxisFactor(); + positionLock.z = IS_ENABLED ? 0.0f : 1.0f; + rp3dBody->setLinearLockAxisFactor(positionLock); + + break; + } + case 5: // Lock Rotation X + { + const bool IS_ENABLED = component.flags & (1U << i); + + auto rotationLock = rp3dBody->getAngularLockAxisFactor(); + rotationLock.x = IS_ENABLED ? 0.0f : 1.0f; + rp3dBody->setAngularLockAxisFactor(rotationLock); + + break; + } + case 6: // Lock Rotation Y + { + const bool IS_ENABLED = component.flags & (1U << i); + + auto rotationLock = rp3dBody->getAngularLockAxisFactor(); + rotationLock.y = IS_ENABLED ? 0.0f : 1.0f; + rp3dBody->setAngularLockAxisFactor(rotationLock); + + break; + } + case 7: // Lock Rotation Z + { + const bool IS_ENABLED = component.flags & (1U << i); + + auto rotationLock = rp3dBody->getAngularLockAxisFactor(); + rotationLock.z = IS_ENABLED ? 0.0f : 1.0f; + rp3dBody->setAngularLockAxisFactor(rotationLock); + + break; + } + case 8: // Type + { + rp3dBody->setType(static_cast(component.type)); + + break; + } + case 9: // Mass + { + rp3dBody->setMass(component.mass); + rp3dBody->updateLocalCenterOfMassFromColliders(); + rp3dBody->updateLocalInertiaTensorFromColliders(); + + break; + } + case 10: // Drag + { + rp3dBody->setLinearDamping(component.drag); + + break; + } + case 11: // Angular Drag + { + rp3dBody->setAngularDamping(component.angularDrag); + + break; + } + default: break; + } + } + } + + component.dirtyFlags = 0; + } + + void SHPhysicsObject::SyncColliders(SHColliderComponent& component) const noexcept + { + // This state is synced in the pre-update routine + if (!rp3dBody->isActive()) + return; + + const int NUM_SHAPES = static_cast(component.collisionShapes.size()); + for (int i = 0; i < NUM_SHAPES; ++i) + { + auto& collisionShape = component.collisionShapes[i]; + + if (!collisionShape.dirty) + continue; + + switch (collisionShape.GetType()) + { + case SHCollisionShape::Type::BOX: syncBoxShape(i, collisionShape); break; + case SHCollisionShape::Type::SPHERE: syncSphereShape(i, collisionShape); break; + default: break; + } + + syncMaterial(i, collisionShape); + + collisionShape.dirty = false; + } + } + + /*-----------------------------------------------------------------------------------*/ + /* Private Function Member Definitions */ + /*-----------------------------------------------------------------------------------*/ + + void SHPhysicsObject::syncMaterial(int colliderIndex, SHCollisionShape& collisionShape) const noexcept + { + auto& rp3dMaterial = rp3dBody->getCollider(colliderIndex)->getMaterial(); + rp3dMaterial.setFrictionCoefficient(collisionShape.GetFriction()); + rp3dMaterial.setBounciness(collisionShape.GetBounciness()); + rp3dMaterial.setMassDensity(collisionShape.GetDensity()); + } + + void SHPhysicsObject::addBoxShape(SHCollisionShape& boxShape) const noexcept + { + const rp3d::Transform OFFSETS + { + boxShape.GetPositionOffset() + , boxShape.GetRotationOffset() + }; + + const auto* BOX = reinterpret_cast(boxShape.GetShape()); + rp3d::BoxShape* newBox = factory->createBoxShape(BOX->GetWorldExtents()); + + rp3dBody->addCollider(newBox, OFFSETS); + } + + void SHPhysicsObject::syncBoxShape(int index, SHCollisionShape& boxShape) const noexcept + { + const auto* BOX = reinterpret_cast(boxShape.GetShape()); + + auto* rp3dCollider = rp3dBody->getCollider(index); + auto* rp3dBox = reinterpret_cast(rp3dCollider->getCollisionShape()); + + const rp3d::Transform OFFSETS + { + boxShape.GetPositionOffset() + , boxShape.GetRotationOffset() + }; + + rp3dCollider->setIsTrigger(boxShape.IsTrigger()); + rp3dCollider->setLocalToBodyTransform(OFFSETS); + + rp3dBox->setHalfExtents(BOX->GetWorldExtents()); + } + + void SHPhysicsObject::addSphereShape(SHCollisionShape& sphereShape) const noexcept + { + const rp3d::Transform OFFSETS + { + sphereShape.GetPositionOffset() + , sphereShape.GetRotationOffset() + }; + + const auto* SPHERE = reinterpret_cast(sphereShape.GetShape()); + rp3d::SphereShape* newSphere = factory->createSphereShape(SPHERE->GetWorldRadius()); + + rp3dBody->addCollider(newSphere, OFFSETS); + } + + void SHPhysicsObject::syncSphereShape(int index, SHCollisionShape& sphereShape) const noexcept + { + const auto* SPHERE = reinterpret_cast(sphereShape.GetShape()); + + auto* rp3dCollider = rp3dBody->getCollider(index); + auto* rp3dSphere = reinterpret_cast(rp3dCollider->getCollisionShape()); + + const rp3d::Transform OFFSETS + { + sphereShape.GetPositionOffset() + , sphereShape.GetRotationOffset() + }; + + rp3dCollider->setIsTrigger(sphereShape.IsTrigger()); + rp3dCollider->setLocalToBodyTransform(OFFSETS); + + rp3dSphere->setRadius(SPHERE->GetWorldRadius()); + } +} // namespace SHADE \ No newline at end of file diff --git a/SHADE_Engine/src/Physics/SHPhysicsObject.h b/SHADE_Engine/src/Physics/PhysicsObject/SHPhysicsObject.h similarity index 66% rename from SHADE_Engine/src/Physics/SHPhysicsObject.h rename to SHADE_Engine/src/Physics/PhysicsObject/SHPhysicsObject.h index 09b70b11..5a0e62ac 100644 --- a/SHADE_Engine/src/Physics/SHPhysicsObject.h +++ b/SHADE_Engine/src/Physics/PhysicsObject/SHPhysicsObject.h @@ -14,8 +14,8 @@ // Project Headers #include "Math/Transform/SHTransformComponent.h" -#include "Components/SHRigidBodyComponent.h" -#include "Components/SHColliderComponent.h" +#include "Physics/Interface/SHRigidBodyComponent.h" +#include "Physics/Interface/SHColliderComponent.h" namespace SHADE { @@ -31,6 +31,7 @@ namespace SHADE /*---------------------------------------------------------------------------------*/ friend class SHPhysicsSystem; + friend class SHPhysicsObjectManager; public: /*---------------------------------------------------------------------------------*/ @@ -53,26 +54,29 @@ namespace SHADE /* Getter Functions */ /*---------------------------------------------------------------------------------*/ - [[nodiscard]] SHVec3 GetPosition () const noexcept; - [[nodiscard]] SHQuaternion GetOrientation () const noexcept; - [[nodiscard]] SHVec3 GetRotation () const noexcept; + [[nodiscard]] SHVec3 GetPosition () const noexcept; + [[nodiscard]] SHQuaternion GetOrientation () const noexcept; + [[nodiscard]] SHVec3 GetRotation () const noexcept; + + [[nodiscard]] rp3d::CollisionBody* GetCollisionBody () const noexcept; + [[nodiscard]] rp3d::RigidBody* GetRigidBody () const noexcept; /*---------------------------------------------------------------------------------*/ /* Setter Functions */ /*---------------------------------------------------------------------------------*/ - void SetPosition (const SHVec3& position) noexcept; - void SetOrientation (const SHQuaternion& orientation) noexcept; - void SetRotation (const SHVec3& rotation) noexcept; + void SetStaticBody () const noexcept; /*---------------------------------------------------------------------------------*/ /* Function Members */ /*---------------------------------------------------------------------------------*/ - int AddCollider (SHCollisionShape* collider); - void RemoveCollider (int index); + int AddCollisionShape (int index) const; + void RemoveCollisionShape (int index) const; + void RemoveAllCollisionShapes () const noexcept; - void SyncColliders (SHColliderComponent* c) const noexcept; + void SyncRigidBody (SHRigidBodyComponent& component) const noexcept; + void SyncColliders (SHColliderComponent& component) const noexcept; private: /*---------------------------------------------------------------------------------*/ @@ -80,10 +84,28 @@ namespace SHADE /*---------------------------------------------------------------------------------*/ EntityID entityID; + bool collidersActive; // Only used to sync with SHADE components rp3d::PhysicsCommon* factory; rp3d::PhysicsWorld* world; - rp3d::CollisionBody* rp3dBody; // Can be either a collision body or a rigid body - rp3d::Transform prevTransform; // Cached transform for interpolation + + rp3d::RigidBody* rp3dBody; + rp3d::Transform prevTransform; // Cached transform for interpolation + + /*---------------------------------------------------------------------------------*/ + /* Function Members */ + /*---------------------------------------------------------------------------------*/ + + void syncMaterial (int colliderIndex, SHCollisionShape& collisionShape) const noexcept; + + // Box Shapes + + void addBoxShape (SHCollisionShape& boxShape) const noexcept; + void syncBoxShape (int index, SHCollisionShape& boxShape) const noexcept; + + // Sphere Shapes + + void addSphereShape (SHCollisionShape& sphereShape) const noexcept; + void syncSphereShape (int index, SHCollisionShape& sphereShape) const noexcept; }; } // namespace SHADE \ No newline at end of file diff --git a/SHADE_Engine/src/Physics/PhysicsObject/SHPhysicsObjectManager.cpp b/SHADE_Engine/src/Physics/PhysicsObject/SHPhysicsObjectManager.cpp new file mode 100644 index 00000000..ffd10e0c --- /dev/null +++ b/SHADE_Engine/src/Physics/PhysicsObject/SHPhysicsObjectManager.cpp @@ -0,0 +1,312 @@ +/**************************************************************************************** + * \file SHPhysicsObjectManager.cpp + * \author Diren D Bharwani, diren.dbharwani, 390002520 + * \brief Implementation for a Physics Object Manager. + * + * \copyright Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or + * disclosure of this file or its contents without the prior written consent + * of DigiPen Institute of Technology is prohibited. +****************************************************************************************/ + +#include + +// Primary Header +#include "SHPhysicsObjectManager.h" + +// Project Headers +#include "ECS_Base/Managers/SHEntityManager.h" +#include "Tools/Utilities/SHUtilities.h" + +namespace SHADE +{ + /*-----------------------------------------------------------------------------------*/ + /* Static Data Member Definitions */ + /*-----------------------------------------------------------------------------------*/ + + SHPhysicsObjectManager::CommandFunctionPtr SHPhysicsObjectManager::componentFunc[2][3] + { + addRigidBody , addCollider + , removeRigidBody , removeCollider + , addCollisionShape , removeCollisionShape + }; + + /*-----------------------------------------------------------------------------------*/ + /* Setter Function Definitions */ + /*-----------------------------------------------------------------------------------*/ + + void SHPhysicsObjectManager::SetFactory(rp3d::PhysicsCommon& physicsFactory) noexcept + { + factory = &physicsFactory; + } + + void SHPhysicsObjectManager::SetWorld(rp3d::PhysicsWorld* physicsWorld) noexcept + { + world = physicsWorld; + } + + /*-----------------------------------------------------------------------------------*/ + /* Getter Function Definitions */ + /*-----------------------------------------------------------------------------------*/ + + SHPhysicsObject* SHPhysicsObjectManager::GetPhysicsObject(EntityID eid) noexcept + { + const auto it = physicsObjects.find(eid); + if (it == physicsObjects.end()) + return nullptr; + + return &it->second; + } + + const SHPhysicsObjectManager::PhysicsObjectEntityMap SHPhysicsObjectManager::GetPhysicsObjects() const noexcept + { + return physicsObjects; + } + + /*-----------------------------------------------------------------------------------*/ + /* Public Function Member Definitions */ + /*-----------------------------------------------------------------------------------*/ + + void SHPhysicsObjectManager::AddRigidBody(EntityID eid) noexcept + { + const QueueCommand NEW_QUEUE_COMMAND + { + .eid = eid + , .command = QueueCommand::Command::ADD + , .component = PhysicsComponents::RIGID_BODY + }; + + commandQueue.push(NEW_QUEUE_COMMAND); + } + + void SHPhysicsObjectManager::AddCollider(EntityID eid) noexcept + { + const QueueCommand NEW_QUEUE_COMMAND + { + .eid = eid + , .command = QueueCommand::Command::ADD + , .component = PhysicsComponents::COLLIDER + }; + + commandQueue.push(NEW_QUEUE_COMMAND); + } + + void SHPhysicsObjectManager::AddCollisionShape(EntityID eid, int shapeIndex) noexcept + { + const QueueCommand NEW_QUEUE_COMMAND + { + .eid = eid + , .command = QueueCommand::Command::ADD + , .component = PhysicsComponents::COLLISION_SHAPE + , .shapeIndex = shapeIndex + }; + + commandQueue.push(NEW_QUEUE_COMMAND); + } + + void SHPhysicsObjectManager::RemoveRigidBody(EntityID eid) noexcept + { + const QueueCommand NEW_QUEUE_COMMAND + { + .eid = eid + , .command = QueueCommand::Command::REMOVE + , .component = PhysicsComponents::RIGID_BODY + }; + + commandQueue.push(NEW_QUEUE_COMMAND); + } + + void SHPhysicsObjectManager::RemoveCollider(EntityID eid) noexcept + { + const QueueCommand NEW_QUEUE_COMMAND + { + .eid = eid + , .command = QueueCommand::Command::REMOVE + , .component = PhysicsComponents::COLLIDER + }; + + commandQueue.push(NEW_QUEUE_COMMAND); + } + + void SHPhysicsObjectManager::RemoveCollisionShape(EntityID eid, int shapeIndex) noexcept + { + const QueueCommand NEW_QUEUE_COMMAND + { + .eid = eid + , .command = QueueCommand::Command::REMOVE + , .component = PhysicsComponents::COLLISION_SHAPE + , .shapeIndex = shapeIndex + }; + + commandQueue.push(NEW_QUEUE_COMMAND); + } + + void SHPhysicsObjectManager::UpdateCommands() + { + if (commandQueue.empty()) + return; + + while (!commandQueue.empty()) + { + const QueueCommand COMMAND = commandQueue.front(); + commandQueue.pop(); + + // Check validity of command + if (COMMAND.command == QueueCommand::Command::INVALID || COMMAND.component == PhysicsComponents::INVALID) + continue; + + // Get physics components + const PhysicsComponentGroup COMPONENT_GROUP + { + .eid = COMMAND.eid + , .rigidBodyComponent = SHComponentManager::GetComponent_s(COMMAND.eid) + , .colliderComponent = SHComponentManager::GetComponent_s(COMMAND.eid) + }; + + // Delete any object that is missing both components + // We infer that a remove command has been pushed for these, but we will ignore those if both components have already been removed. + if (!COMPONENT_GROUP.rigidBodyComponent && !COMPONENT_GROUP.colliderComponent) + { + destroyPhysicsObject(COMMAND.eid); + wakeAllObjects(); + continue; + } + + // Find the physics Object. If none found and attempting to add, create an object. + SHPhysicsObject* physicsObject = GetPhysicsObject(COMMAND.eid); + if (!physicsObject && COMMAND.command == QueueCommand::Command::ADD) + physicsObject = createPhysicsObject(COMMAND.eid); + + componentFunc[SHUtilities::ConvertEnum(COMMAND.command)][SHUtilities::ConvertEnum(COMMAND.component)](COMMAND, physicsObject, COMPONENT_GROUP); + + // If any removal was done, wake all objects + if (COMMAND.command == QueueCommand::Command::REMOVE) + wakeAllObjects(); + } + } + + void SHPhysicsObjectManager::RemoveAllObjects() + { + // Destroy all objects and clear + for (auto& physicsObject : physicsObjects | std::views::values) + { + world->destroyRigidBody(physicsObject.GetRigidBody()); + physicsObject.rp3dBody = nullptr; + } + + physicsObjects.clear(); + } + + /*-----------------------------------------------------------------------------------*/ + /* Private Function Member Definitions */ + /*-----------------------------------------------------------------------------------*/ + + SHPhysicsObject* SHPhysicsObjectManager::createPhysicsObject(EntityID eid) noexcept + { + // Force transforms to sync + SHVec3 worldPos = SHVec3::Zero; + SHQuaternion worldRot = SHQuaternion::Identity; + + const SHTransformComponent* TRANSFORM = nullptr; + if (SHEntityManager::IsValidEID(eid)) + TRANSFORM = SHComponentManager::GetComponent_s(eid); + + if (TRANSFORM) + { + worldPos = TRANSFORM->GetWorldPosition(); + worldRot = TRANSFORM->GetWorldOrientation(); + } + + const rp3d::Transform RP3D_TRANSFORM{ worldPos, worldRot }; + + auto& newPhysicsObject = physicsObjects.emplace(eid, SHPhysicsObject{ eid, factory, world }).first->second; + newPhysicsObject.GetRigidBody()->setTransform(RP3D_TRANSFORM); + newPhysicsObject.prevTransform = RP3D_TRANSFORM; + + return &newPhysicsObject; + } + + void SHPhysicsObjectManager::destroyPhysicsObject(EntityID eid) noexcept + { + const auto ITER = physicsObjects.find(eid); + if (ITER == physicsObjects.end()) + { + // Assume the object has already been successfully destroyed + return; + } + + world->destroyRigidBody(ITER->second.GetRigidBody()); + ITER->second.rp3dBody = nullptr; + + physicsObjects.erase(eid); + } + + void SHPhysicsObjectManager::addRigidBody(const QueueCommand&, SHPhysicsObject* physicsObject, const PhysicsComponentGroup& componentGroup) + { + SHASSERT(physicsObject != nullptr, "Valid physics object required to add body!") + + if (!componentGroup.rigidBodyComponent) + { + SHLOG_ERROR("Entity {} is missing a Rigidbody Component. Unable to update physics object!", componentGroup.eid) + return; + } + + // A static rigid body is implicitly created on creation of a physics object. + // We only need to sync rigid bodies here in the event it is non-static. + + physicsObject->SyncRigidBody(*componentGroup.rigidBodyComponent); + } + + void SHPhysicsObjectManager::addCollider(const QueueCommand&, SHPhysicsObject* physicsObject, const PhysicsComponentGroup& componentGroup) + { + SHASSERT(physicsObject != nullptr, "Valid physics object required to add collider!") + + if (!componentGroup.colliderComponent) + { + SHLOG_ERROR("Entity {} is missing a Rigidbody Component. Unable to update physics object!", componentGroup.eid) + return; + } + + const int NUM_SHAPES = static_cast(componentGroup.colliderComponent->GetCollisionShapes().size()); + for (int i = 0; i < NUM_SHAPES; ++i) + physicsObject->AddCollisionShape(i); + + physicsObject->SyncColliders(*componentGroup.colliderComponent); + } + + void SHPhysicsObjectManager::removeRigidBody(const QueueCommand&, SHPhysicsObject* physicsObject, const PhysicsComponentGroup& componentGroup) + { + SHASSERT(physicsObject != nullptr, "Valid physics object required to remove body!") + + if (componentGroup.colliderComponent) + physicsObject->SetStaticBody(); + } + + void SHPhysicsObjectManager::removeCollider(const QueueCommand&, SHPhysicsObject* physicsObject, const PhysicsComponentGroup&) + { + SHASSERT(physicsObject != nullptr, "Valid physics object required to remove collider!") + + physicsObject->RemoveAllCollisionShapes(); + } + + void SHPhysicsObjectManager::addCollisionShape(const QueueCommand& command, SHPhysicsObject* physicsObject, const PhysicsComponentGroup&) + { + SHASSERT(physicsObject != nullptr, "Valid physics object required to add collision shape!") + + physicsObject->AddCollisionShape(command.shapeIndex); + } + + void SHPhysicsObjectManager::removeCollisionShape(const QueueCommand& command, SHPhysicsObject* physicsObject, const PhysicsComponentGroup&) + { + SHASSERT(physicsObject != nullptr, "Valid physics object required to remove collision shape!") + + physicsObject->RemoveCollisionShape(command.shapeIndex); + } + + void SHPhysicsObjectManager::wakeAllObjects() noexcept + { + for (auto& physicsObject : physicsObjects | std::views::values) + physicsObject.GetRigidBody()->setIsSleeping(false); + } + + +} // namespace SHADE \ No newline at end of file diff --git a/SHADE_Engine/src/Physics/PhysicsObject/SHPhysicsObjectManager.h b/SHADE_Engine/src/Physics/PhysicsObject/SHPhysicsObjectManager.h new file mode 100644 index 00000000..641fd9df --- /dev/null +++ b/SHADE_Engine/src/Physics/PhysicsObject/SHPhysicsObjectManager.h @@ -0,0 +1,181 @@ +/**************************************************************************************** + * \file SHPhysicsObjectManager.h + * \author Diren D Bharwani, diren.dbharwani, 390002520 + * \brief Interface for a Physics Object Manager. + * + * \copyright Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or + * disclosure of this file or its contents without the prior written consent + * of DigiPen Institute of Technology is prohibited. +****************************************************************************************/ + +#pragma once + +#include +#include + +#include + +// Project Headers +#include "SHPhysicsObject.h" + +namespace SHADE +{ + /*-----------------------------------------------------------------------------------*/ + /* Type Definitions */ + /*-----------------------------------------------------------------------------------*/ + + class SH_API SHPhysicsObjectManager + { + private: + /*---------------------------------------------------------------------------------*/ + /* Friends */ + /*---------------------------------------------------------------------------------*/ + + friend class SHPhysicsSystem; + + /*---------------------------------------------------------------------------------*/ + /* Type Definitions */ + /*---------------------------------------------------------------------------------*/ + + using PhysicsObjectEntityMap = std::unordered_map; + + public: + + /*---------------------------------------------------------------------------------*/ + /* Type Definitions */ + /*---------------------------------------------------------------------------------*/ + + enum class PhysicsComponents + { + RIGID_BODY + , COLLIDER + , COLLISION_SHAPE + + , TOTAL + , INVALID = -1 + }; + + /*---------------------------------------------------------------------------------*/ + /* Constructors & Destructor */ + /*---------------------------------------------------------------------------------*/ + + SHPhysicsObjectManager () = default; + ~SHPhysicsObjectManager () = default; + + SHPhysicsObjectManager (const SHPhysicsObjectManager&) = delete; + SHPhysicsObjectManager (SHPhysicsObjectManager&&) = delete; + + /*---------------------------------------------------------------------------------*/ + /* Operator Overloads */ + /*---------------------------------------------------------------------------------*/ + + SHPhysicsObjectManager& operator=(const SHPhysicsObjectManager&) = delete; + SHPhysicsObjectManager& operator=(SHPhysicsObjectManager&&) = delete; + + /*---------------------------------------------------------------------------------*/ + /* Getter Functions */ + /*---------------------------------------------------------------------------------*/ + + [[nodiscard]] SHPhysicsObject* GetPhysicsObject (EntityID eid) noexcept; + [[nodiscard]] const PhysicsObjectEntityMap GetPhysicsObjects () const noexcept; + + /*---------------------------------------------------------------------------------*/ + /* Setter Functions */ + /*---------------------------------------------------------------------------------*/ + + void SetFactory (rp3d::PhysicsCommon& physicsFactory) noexcept; + void SetWorld (rp3d::PhysicsWorld* physicsWorld) noexcept; + + /*---------------------------------------------------------------------------------*/ + /* Function Members */ + /*---------------------------------------------------------------------------------*/ + + void AddRigidBody (EntityID eid) noexcept; + void AddCollider (EntityID eid) noexcept; + void AddCollisionShape (EntityID eid, int shapeIndex) noexcept; + + void RemoveRigidBody (EntityID eid) noexcept; + void RemoveCollider (EntityID eid) noexcept; + void RemoveCollisionShape (EntityID eid, int shapeIndex) noexcept; + + void UpdateCommands (); + void RemoveAllObjects (); + + private: + /*---------------------------------------------------------------------------------*/ + /* Type Definitions */ + /*---------------------------------------------------------------------------------*/ + + struct QueueCommand + { + /*-------------------------------------------------------------------------------*/ + /* Type Definitions */ + /*-------------------------------------------------------------------------------*/ + + enum class Command + { + ADD + , REMOVE + + , INVALID = -1 + }; + + /*-------------------------------------------------------------------------------*/ + /* Data Members */ + /*-------------------------------------------------------------------------------*/ + + EntityID eid = MAX_EID; + Command command = Command::INVALID; + PhysicsComponents component = PhysicsComponents::INVALID; + int shapeIndex = -1; // Only used when adding & removing collision shapes + }; + + struct PhysicsComponentGroup + { + public: + + /*-------------------------------------------------------------------------------*/ + /* Data Members */ + /*-------------------------------------------------------------------------------*/ + + + EntityID eid = MAX_EID; + SHRigidBodyComponent* rigidBodyComponent = nullptr; + SHColliderComponent* colliderComponent = nullptr; + }; + + using CommandFunctionPtr = void(*)(const QueueCommand&, SHPhysicsObject*, const PhysicsComponentGroup&); + + /*---------------------------------------------------------------------------------*/ + /* Data Members */ + /*---------------------------------------------------------------------------------*/ + + static CommandFunctionPtr componentFunc[2][3]; // 2 commands, 3 components + + rp3d::PhysicsCommon* factory = nullptr; + rp3d::PhysicsWorld* world = nullptr; + + PhysicsObjectEntityMap physicsObjects; + std::queue commandQueue; + + /*---------------------------------------------------------------------------------*/ + /* Function Members */ + /*---------------------------------------------------------------------------------*/ + + SHPhysicsObject* createPhysicsObject (EntityID eid) noexcept; + void destroyPhysicsObject (EntityID eid) noexcept; + + void wakeAllObjects () noexcept; + + static void addRigidBody (const QueueCommand& command, SHPhysicsObject* physicsObject, const PhysicsComponentGroup& componentGroup); + static void addCollider (const QueueCommand& command, SHPhysicsObject* physicsObject, const PhysicsComponentGroup& componentGroup); + static void removeRigidBody (const QueueCommand& command, SHPhysicsObject* physicsObject, const PhysicsComponentGroup& componentGroup); + static void removeCollider (const QueueCommand& command, SHPhysicsObject* physicsObject, const PhysicsComponentGroup& componentGroup); + + static void addCollisionShape (const QueueCommand& command, SHPhysicsObject* physicsObject, const PhysicsComponentGroup& componentGroup); + static void removeCollisionShape (const QueueCommand& command, SHPhysicsObject* physicsObject, const PhysicsComponentGroup& componentGroup); + + + }; + +} // namespace SHADE \ No newline at end of file diff --git a/SHADE_Engine/src/Physics/SHPhysicsEvents.h b/SHADE_Engine/src/Physics/SHPhysicsEvents.h new file mode 100644 index 00000000..ae48a75b --- /dev/null +++ b/SHADE_Engine/src/Physics/SHPhysicsEvents.h @@ -0,0 +1,37 @@ +/**************************************************************************************** + * \file SHPhysicsUtils.h + * \author Diren D Bharwani, diren.dbharwani, 390002520 + * \brief Interface for some Physics Utilities + * + * \copyright Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or + * disclosure of this file or its contents without the prior written consent + * of DigiPen Institute of Technology is prohibited. +****************************************************************************************/ + +#pragma once + +// Project Headers +#include "Interface/SHCollisionShape.h" + + +namespace SHADE +{ + /*-----------------------------------------------------------------------------------*/ + /* Type Definitions */ + /*-----------------------------------------------------------------------------------*/ + + struct SHPhysicsColliderAddedEvent + { + EntityID entityID; + SHCollisionShape::Type colliderType; + int colliderIndex; + }; + + struct SHPhysicsColliderRemovedEvent + { + EntityID entityID; + int colliderIndex; + }; + + +} // namespace SHADE \ No newline at end of file diff --git a/SHADE_Engine/src/Physics/SHPhysicsObject.cpp b/SHADE_Engine/src/Physics/SHPhysicsObject.cpp deleted file mode 100644 index 00c6943b..00000000 --- a/SHADE_Engine/src/Physics/SHPhysicsObject.cpp +++ /dev/null @@ -1,219 +0,0 @@ -/**************************************************************************************** - * \file SHPhysicsObject.cpp - * \author Diren D Bharwani, diren.dbharwani, 390002520 - * \brief Implementation for a Physics Object. - * - * \copyright Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or - * disclosure of this file or its contents without the prior written consent - * of DigiPen Institute of Technology is prohibited. -****************************************************************************************/ - -#include - -// Primary Header -#include "SHPhysicsObject.h" - -// Project Headers -#include "ECS_Base/Managers/SHSystemManager.h" -#include "ECS_Base/Managers/SHComponentManager.h" - - -namespace SHADE -{ - /*-----------------------------------------------------------------------------------*/ - /* Constructors & Destructor Definitions */ - /*-----------------------------------------------------------------------------------*/ - - SHPhysicsObject::SHPhysicsObject(EntityID eid, rp3d::PhysicsCommon* physicsFactory, rp3d::PhysicsWorld* physicsWorld) noexcept - : entityID { eid } - , factory { physicsFactory } - , world { physicsWorld } - , rp3dBody { nullptr } - {} - - SHPhysicsObject::~SHPhysicsObject() noexcept - { - factory = nullptr; - world = nullptr; - rp3dBody = nullptr; - } - - /*-----------------------------------------------------------------------------------*/ - /* Getter Function Definitions */ - /*-----------------------------------------------------------------------------------*/ - - SHVec3 SHPhysicsObject::GetPosition() const noexcept - { - SHVec3 result; - - if (rp3dBody) - result = SHVec3{ rp3dBody->getTransform().getPosition() }; - - return result; - } - - SHQuaternion SHPhysicsObject::GetOrientation() const noexcept - { - SHQuaternion result; - - if (rp3dBody) - result = SHQuaternion{ rp3dBody->getTransform().getOrientation() }; - - return result; - } - - SHVec3 SHPhysicsObject::GetRotation() const noexcept - { - SHVec3 result; - - if (rp3dBody) - result = SHQuaternion{ rp3dBody->getTransform().getOrientation() }.ToEuler(); - - return result; - } - - /*-----------------------------------------------------------------------------------*/ - /* Setter Function Definitions */ - /*-----------------------------------------------------------------------------------*/ - - void SHPhysicsObject::SetPosition(const SHVec3& position) noexcept - { - if (!rp3dBody) - { - SHLOG_ERROR("Cannot set position of a non-existent physics body for Entity {}", entityID) - return; - } - - rp3d::Transform rp3dTF; - rp3dTF.setPosition(position); - rp3dTF.setOrientation(rp3dBody->getTransform().getOrientation()); - - rp3dBody->setTransform(rp3dTF); - prevTransform = rp3dTF; - } - - void SHPhysicsObject::SetOrientation(const SHQuaternion& orientation) noexcept - { - if (!rp3dBody) - { - SHLOG_ERROR("Cannot set orientation of a non-existent physics body for Entity {}", entityID) - return; - } - - rp3d::Transform rp3dTF; - rp3dTF.setPosition(rp3dBody->getTransform().getPosition()); - rp3dTF.setOrientation(orientation); - - rp3dBody->setTransform(rp3dTF); - prevTransform = rp3dTF; - } - - void SHPhysicsObject::SetRotation(const SHVec3& rotation) noexcept - { - if (!rp3dBody) - { - SHLOG_ERROR("Cannot set rotation of a non-existent physics body for Entity {}", entityID) - return; - } - - rp3d::Transform rp3dTF; - rp3dTF.setPosition(rp3dBody->getTransform().getPosition()); - rp3dTF.setOrientation(rotation); - - rp3dBody->setTransform(rp3dTF); - prevTransform = rp3dTF; - } - - /*-----------------------------------------------------------------------------------*/ - /* Public Function Member Definitions */ - /*-----------------------------------------------------------------------------------*/ - - int SHPhysicsObject::AddCollider(SHCollisionShape* collider) - { - const rp3d::Transform OFFSETS{ collider->GetPositionOffset(), collider->GetRotationOffset() }; - - switch (collider->GetType()) - { - case SHCollisionShape::Type::BOX: - { - const auto* box = reinterpret_cast(collider->GetShape()); - rp3d::BoxShape* newBox = factory->createBoxShape(box->GetWorldExtents()); - - rp3dBody->addCollider(newBox, OFFSETS); - break; - } - case SHCollisionShape::Type::SPHERE: - { - const auto* sphere = reinterpret_cast(collider->GetShape()); - rp3d::SphereShape* newSphere = factory->createSphereShape(sphere->GetWorldRadius()); - - rp3dBody->addCollider(newSphere, OFFSETS); - break; - } - // TODO(Diren): Add more collider shapes - default: break; - } - - return static_cast(rp3dBody->getNbColliders()) - 1; - } - - void SHPhysicsObject::RemoveCollider(int index) - { - const int NUM_COLLIDERS = static_cast(rp3dBody->getNbColliders()); - if (NUM_COLLIDERS == 0) - return; - - if (index < 0 || index >= NUM_COLLIDERS) - throw std::invalid_argument("Index out of range!"); - - auto* collider = rp3dBody->getCollider(index); - rp3dBody->removeCollider(collider); - } - - void SHPhysicsObject::SyncColliders(SHColliderComponent* c) const noexcept - { - int index = 0; - for (auto& collider : c->collisionShapes) - { - if (!collider.dirty) - continue; - - auto* rp3dCollider = rp3dBody->getCollider(index); - - // Update trigger flag - rp3dCollider->setIsTrigger(collider.IsTrigger()); - - // Update offsets - rp3dCollider->setLocalToBodyTransform(rp3d::Transform(collider.GetPositionOffset(), collider.GetRotationOffset())); - - switch (collider.GetType()) - { - case SHCollisionShape::Type::BOX: - { - const auto* box = reinterpret_cast(collider.GetShape()); - - auto* rp3dBoxShape = reinterpret_cast(rp3dCollider->getCollisionShape()); - rp3dBoxShape->setHalfExtents(box->GetWorldExtents()); - - break; - } - case SHCollisionShape::Type::SPHERE: - { - const auto* sphere = reinterpret_cast(collider.GetShape()); - - auto* rp3dSphereShape = reinterpret_cast(rp3dCollider->getCollisionShape()); - rp3dSphereShape->setRadius(sphere->GetWorldRadius()); - - break; - } - default: break; - } - - // TODO(Diren): Update Material - - collider.dirty = false; - ++index; - } - } - -} // namespace SHADE \ No newline at end of file diff --git a/SHADE_Engine/src/Physics/SHPhysicsSystem.cpp b/SHADE_Engine/src/Physics/SHPhysicsSystem.cpp deleted file mode 100644 index 437b5ff8..00000000 --- a/SHADE_Engine/src/Physics/SHPhysicsSystem.cpp +++ /dev/null @@ -1,856 +0,0 @@ -/**************************************************************************************** - * \file SHPhysicsSystem.cpp - * \author Diren D Bharwani, diren.dbharwani, 390002520 - * \brief Implementation for the Physics System - * - * \copyright Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or - * disclosure of this file or its contents without the prior written consent - * of DigiPen Institute of Technology is prohibited. -****************************************************************************************/ - -#include - -// Primary Header -#include "SHPhysicsSystem.h" - -// Project Headers -#include "ECS_Base/Managers/SHComponentManager.h" -#include "ECS_Base/Managers/SHEntityManager.h" -#include "ECS_Base/Managers/SHSystemManager.h" -#include "Graphics/MiddleEnd/Interface/SHDebugDrawSystem.h" -#include "Math/SHMathHelpers.h" -#include "Math/Transform/SHTransformComponent.h" -#include "Scene/SHSceneManager.h" -#include "Scripting/SHScriptEngine.h" -#include "Tools/SHUtilities.h" - -namespace SHADE -{ - /*-----------------------------------------------------------------------------------*/ - /* Constructors & Destructor Definitions */ - /*-----------------------------------------------------------------------------------*/ - - SHPhysicsSystem::SHPhysicsSystem() - : worldUpdated { false } - , debugDrawFlags { 0 } - , interpolationFactor { 0.0 } - , fixedDT { 60.0 } - , world { nullptr } - {} - - SHPhysicsSystem::PhysicsPreUpdate::PhysicsPreUpdate() - : SHSystemRoutine { "Physics PreUpdate", true } - {} - - SHPhysicsSystem::PhysicsFixedUpdate::PhysicsFixedUpdate() - : SHFixedSystemRoutine { DEFAULT_FIXED_STEP, "Physics FixedUpdate", false } - {} - - SHPhysicsSystem::PhysicsPostUpdate::PhysicsPostUpdate() - : SHSystemRoutine { "Physics PostUpdate", false } - {} - - SHPhysicsSystem::PhysicsDebugDraw::PhysicsDebugDraw() - : SHSystemRoutine { "Physics DebugDraw", true } - {} - - - /*-----------------------------------------------------------------------------------*/ - /* Getter Function Definitions */ - /*-----------------------------------------------------------------------------------*/ - - double SHPhysicsSystem::GetFixedDT() const noexcept - { - return fixedDT; - } - - bool SHPhysicsSystem::IsSleepingEnabled() const noexcept - { - if (world) - return world->isSleepingEnabled(); - - SHLOGV_WARNING("No physics world has been initialised!") - return false; - } - - SHVec3 SHPhysicsSystem::GetWorldGravity() const noexcept - { - SHVec3 result; - - if (world) - { - result = world->getGravity(); - } - else - { - SHLOGV_WARNING("No physics world has been initialised!") - } - - return result; - } - - uint16_t SHPhysicsSystem::GetNumberVelocityIterations() const noexcept - { - if (world) - return world->getNbIterationsVelocitySolver(); - - SHLOGV_WARNING("No physics world has been initialised!") - return 0; - } - - uint16_t SHPhysicsSystem::GetNumberPositionIterations() const noexcept - { - if (world) - return world->getNbIterationsPositionSolver(); - - SHLOGV_WARNING("No physics world has been initialised!") - return 0; - } - - bool SHPhysicsSystem::GetDrawColliders() const noexcept - { - return debugDrawFlags & SHUtilities::ConvertEnum(DebugDrawFlags::COLLIDER); - } - - bool SHPhysicsSystem::GetDrawColliderAABBs() const noexcept - { - return debugDrawFlags & SHUtilities::ConvertEnum(DebugDrawFlags::COLLIDER_AABB); - } - - bool SHPhysicsSystem::GetDrawBroadPhase() const noexcept - { - return debugDrawFlags & SHUtilities::ConvertEnum(DebugDrawFlags::BROAD_PHASE_AABB); - } - - bool SHPhysicsSystem::GetDrawContactPoints() const noexcept - { - return debugDrawFlags & SHUtilities::ConvertEnum(DebugDrawFlags::CONTACT_POINTS); - } - - bool SHPhysicsSystem::GetDrawContactNormals() const noexcept - { - return debugDrawFlags & SHUtilities::ConvertEnum(DebugDrawFlags::CONTACT_NORMALS); - } - - const SHPhysicsSystem::CollisionEvents& SHPhysicsSystem::GetCollisionInfo() const noexcept - { - return collisionInfo; - } - - const SHPhysicsSystem::CollisionEvents& SHPhysicsSystem::GetTriggerInfo() const noexcept - { - return triggerInfo; - } - - /*-----------------------------------------------------------------------------------*/ - /* Setter Function Definitions */ - /*-----------------------------------------------------------------------------------*/ - - void SHPhysicsSystem::SetFixedDT(double fixedUpdateRate) noexcept - { - fixedDT = fixedUpdateRate; - } - - void SHPhysicsSystem::SetWorldGravity(const SHVec3& gravity) const noexcept - { - if (world) - { - world->setGravity(gravity); - } - else - { - SHLOGV_WARNING("No physics world has been initialised!") - } - } - - void SHPhysicsSystem::SetNumberVelocityIterations(uint16_t numVelIterations) const noexcept - { - if (world) - { - world->setNbIterationsVelocitySolver(numVelIterations); - } - else - { - SHLOGV_WARNING("No physics world has been initialised!") - } - } - - void SHPhysicsSystem::SetNumberPositionIterations(uint16_t numPosIterations) const noexcept - { - if (world) - { - world->setNbIterationsPositionSolver(numPosIterations); - } - else - { - SHLOGV_WARNING("No physics world has been initialised!") - } - } - - void SHPhysicsSystem::SetSleepingEnabled(bool enableSleeping) const noexcept - { - if (world) - { - world->enableSleeping(enableSleeping); - } - else - { - SHLOGV_WARNING("No physics world has been initialised!") - } - } - - void SHPhysicsSystem::SetWorldSettings(const WorldSettings& settings) const noexcept - { - if (world) - { - world->setGravity(settings.gravity); - world->setNbIterationsVelocitySolver(settings.numVelocitySolverIterations); - world->setNbIterationsPositionSolver(settings.numPositionSolverIterations); - world->enableSleeping(settings.sleepingEnabled); - } - else - { - SHLOGV_WARNING("No physics world has been initialised!") - } - } - - void SHPhysicsSystem::SetDrawColliders(bool shouldDraw) noexcept - { - static constexpr auto FLAG_VALUE = SHUtilities::ConvertEnum(DebugDrawFlags::COLLIDER); - shouldDraw ? debugDrawFlags |= FLAG_VALUE : debugDrawFlags &= ~(FLAG_VALUE); - - if (world == nullptr) - { - SHLOGV_WARNING("No physics world has been initialised!") - return; - } - - world->getDebugRenderer().setIsDebugItemDisplayed - ( - rp3d::DebugRenderer::DebugItem::COLLISION_SHAPE, - shouldDraw - ); - } - - void SHPhysicsSystem::SetDrawColliderAABBs(bool shouldDraw) noexcept - { - static constexpr auto FLAG_VALUE = SHUtilities::ConvertEnum(DebugDrawFlags::COLLIDER_AABB); - shouldDraw ? debugDrawFlags |= FLAG_VALUE : debugDrawFlags &= ~(FLAG_VALUE); - - if (world == nullptr) - { - SHLOGV_WARNING("No physics world has been initialised!") - return; - } - - world->getDebugRenderer().setIsDebugItemDisplayed - ( - rp3d::DebugRenderer::DebugItem::COLLIDER_AABB, - shouldDraw - ); - } - - void SHPhysicsSystem::SetDrawBroadPhase(bool shouldDraw) noexcept - { - static constexpr auto FLAG_VALUE = SHUtilities::ConvertEnum(DebugDrawFlags::BROAD_PHASE_AABB); - shouldDraw ? debugDrawFlags |= FLAG_VALUE : debugDrawFlags &= ~(FLAG_VALUE); - - if (world == nullptr) - { - SHLOGV_WARNING("No physics world has been initialised!") - return; - } - - world->getDebugRenderer().setIsDebugItemDisplayed - ( - rp3d::DebugRenderer::DebugItem::COLLIDER_BROADPHASE_AABB, - shouldDraw - ); - } - - void SHPhysicsSystem::SetDrawContactPoints(bool shouldDraw) noexcept - { - static constexpr auto FLAG_VALUE = SHUtilities::ConvertEnum(DebugDrawFlags::CONTACT_POINTS); - shouldDraw ? debugDrawFlags |= FLAG_VALUE : debugDrawFlags &= ~(FLAG_VALUE); - - if (world == nullptr) - { - SHLOGV_WARNING("No physics world has been initialised!") - return; - } - - world->getDebugRenderer().setIsDebugItemDisplayed - ( - rp3d::DebugRenderer::DebugItem::CONTACT_POINT, - shouldDraw - ); - } - - void SHPhysicsSystem::SetDrawContactNormals(bool shouldDraw) noexcept - { - static constexpr auto FLAG_VALUE = SHUtilities::ConvertEnum(DebugDrawFlags::CONTACT_NORMALS); - shouldDraw ? debugDrawFlags |= FLAG_VALUE : debugDrawFlags &= ~(FLAG_VALUE); - - if (world == nullptr) - { - SHLOGV_WARNING("No physics world has been initialised!") - return; - } - - world->getDebugRenderer().setIsDebugItemDisplayed - ( - rp3d::DebugRenderer::DebugItem::CONTACT_NORMAL, - shouldDraw - ); - } - - /*-----------------------------------------------------------------------------------*/ - /* Public Function Member Definitions */ - /*-----------------------------------------------------------------------------------*/ - - void SHPhysicsSystem::Init() - { - // Create a physics world with the default settings - rp3d::PhysicsWorld::WorldSettings settings; - settings.gravity = SHVec3{ 0.0f, -9.81f, 0.0f }; - settings.isSleepingEnabled = true; - settings.defaultVelocitySolverNbIterations = 8; - settings.defaultPositionSolverNbIterations = 3; - settings.defaultFrictionCoefficient = 0.4f; - settings.defaultBounciness = 0.0f; - - world = factory.createPhysicsWorld(settings); - world->setEventListener(this); - world->setIsDebugRenderingEnabled(true); - - // Set up solvers - world->setContactsPositionCorrectionTechnique(rp3d::ContactsPositionCorrectionTechnique::SPLIT_IMPULSES); - - // Subscribe to component events - - const std::shared_ptr ADD_COMPONENT_RECEIVER { std::make_shared>(this, &SHPhysicsSystem::AddPhysicsComponent) }; - const ReceiverPtr ADD_COMPONENT_RECEIVER_PTR = std::dynamic_pointer_cast(ADD_COMPONENT_RECEIVER); - SHEventManager::SubscribeTo(SH_COMPONENT_ADDED_EVENT, ADD_COMPONENT_RECEIVER_PTR); - - const std::shared_ptr REMOVE_COMPONENT_RECEIVER { std::make_shared>(this, &SHPhysicsSystem::RemovePhysicsComponent) }; - const ReceiverPtr REMOVE_COMPONENT_RECEIVER_PTR = std::dynamic_pointer_cast(REMOVE_COMPONENT_RECEIVER); - SHEventManager::SubscribeTo(SH_COMPONENT_REMOVED_EVENT, REMOVE_COMPONENT_RECEIVER_PTR); - - #ifdef SHEDITOR - const std::shared_ptr EDITOR_STOP_RECEIVER { std::make_shared>(this, &SHPhysicsSystem::ResetWorld) }; - const ReceiverPtr EDITOR_STOP_RECEIVER_PTR = std::dynamic_pointer_cast(EDITOR_STOP_RECEIVER); - SHEventManager::SubscribeTo(SH_EDITOR_ON_STOP_EVENT, EDITOR_STOP_RECEIVER_PTR); - #endif - } - - void SHPhysicsSystem::Exit() - { - factory.destroyPhysicsWorld(world); - } - - void SHPhysicsSystem::AddCollisionShape(EntityID entityID, SHCollisionShape* collider) - { - auto* physicsObject = GetPhysicsObject(entityID); - - const SHPhysicsColliderAddedEvent COLLIDER_ADDED_EVENT_DATA - { - .entityID = entityID - , .colliderType = collider->GetType() - , .colliderIndex = physicsObject->AddCollider(collider) - }; - - SHEventManager::BroadcastEvent(COLLIDER_ADDED_EVENT_DATA, SH_PHYSICS_COLLIDER_ADDED_EVENT); - } - - void SHPhysicsSystem::RemoveCollisionShape(EntityID entityID, int index) - { - auto* physicsObject = GetPhysicsObject(entityID); - physicsObject->RemoveCollider(index); - - const SHPhysicsColliderRemovedEvent COLLIDER_REMOVED_EVENT_DATA - { - .entityID = entityID - , .colliderIndex = index - }; - - SHEventManager::BroadcastEvent(COLLIDER_REMOVED_EVENT_DATA, SH_PHYSICS_COLLIDER_REMOVED_EVENT); - } - - void SHPhysicsSystem::PhysicsPreUpdate::Execute(double) noexcept - { - auto* system = reinterpret_cast(GetSystem()); - - // Sync transforms - for (auto& [entityID, physicsObject] : system->map) - { - // Ensure a valid physics Object - if (physicsObject.rp3dBody == nullptr) - continue; - - const auto* transformComponent = SHComponentManager::GetComponent_s(entityID); - auto* rigidBodyComponent = SHComponentManager::GetComponent_s(entityID); - auto* colliderComponent = SHComponentManager::GetComponent_s(entityID); - - if (transformComponent && transformComponent->HasChanged()) - { - const auto WORLD_POS = transformComponent->GetWorldPosition(); - const auto WORLD_ROT = transformComponent->GetWorldOrientation(); - const auto WORLD_SCL = transformComponent->GetWorldScale(); - - physicsObject.SetPosition(WORLD_POS); - physicsObject.SetOrientation(WORLD_ROT); - - // Sync physics component transforms - - if (rigidBodyComponent) - { - rigidBodyComponent->position = WORLD_POS; - rigidBodyComponent->orientation = WORLD_ROT; - } - - if (colliderComponent) - { - colliderComponent->position = WORLD_POS; - colliderComponent->orientation = WORLD_ROT; - colliderComponent->scale = WORLD_SCL; - - colliderComponent->RecomputeCollisionShapes(); - } - } - - // Sync rigid bodies - - if (rigidBodyComponent) - { - // Sync active states - const bool COMPONENT_ACTIVE = rigidBodyComponent->isActive; - SyncActiveStates(physicsObject, COMPONENT_ACTIVE); - - if (!COMPONENT_ACTIVE) - continue; - } - - // Sync colliders - - if (colliderComponent) - { - const bool COMPONENT_ACTIVE = colliderComponent->isActive; - SyncActiveStates(physicsObject, colliderComponent->isActive); - - if (!COMPONENT_ACTIVE) - continue; - - physicsObject.SyncColliders(colliderComponent); - } - } - } - - void SHPhysicsSystem::PhysicsFixedUpdate::Execute(double dt) noexcept - { - auto* physicsSystem = reinterpret_cast(GetSystem()); - auto* scriptingSystem = SHSystemManager::GetSystem(); - if (scriptingSystem == nullptr) - { - SHLOGV_ERROR("Unable to invoke FixedUpdate() on scripts due to missing SHScriptEngine!"); - } - - fixedTimeStep = 1.0 / physicsSystem->fixedDT; - accumulatedTime += dt; - - int count = 0; - while (accumulatedTime > fixedTimeStep) - { - if (scriptingSystem != nullptr) - scriptingSystem->ExecuteFixedUpdates(); - - physicsSystem->world->update(static_cast(fixedTimeStep)); - - accumulatedTime -= fixedTimeStep; - ++count; - } - - stats.numSteps = count; - physicsSystem->worldUpdated = count > 0; - - physicsSystem->interpolationFactor = accumulatedTime / fixedTimeStep; - } - - void SHPhysicsSystem::PhysicsPostUpdate::Execute(double) noexcept - { - auto* physicsSystem = reinterpret_cast(GetSystem()); - auto* scriptingSystem = SHSystemManager::GetSystem(); - if (scriptingSystem == nullptr) - { - SHLOGV_ERROR("Unable to invoke collision and trigger script events due to missing SHScriptEngine!"); - } - - // Interpolate transforms for rendering - if (physicsSystem->worldUpdated) - { - physicsSystem->SyncTransforms(); - - // Collision & Trigger messages - if (scriptingSystem != nullptr) - scriptingSystem->ExecuteCollisionFunctions(); - - physicsSystem->ClearInvalidCollisions(); - } - } - - void SHPhysicsSystem::PhysicsDebugDraw::Execute(double) noexcept - { - const auto* PHYSICS_SYSTEM = reinterpret_cast(GetSystem()); - if (PHYSICS_SYSTEM->debugDrawFlags == 0) - return; - - auto* debugDrawSystem = SHSystemManager::GetSystem(); - if (debugDrawSystem == nullptr) - { - SHLOGV_ERROR("Unable to debug draw physics objects due to missing SHDebugDrawSystem!"); - return; - } - - const auto& RP3D_DEBUG_RENDERER = PHYSICS_SYSTEM->world->getDebugRenderer(); - - const auto& LINES = RP3D_DEBUG_RENDERER.getLines(); - const auto& TRIANGLES = RP3D_DEBUG_RENDERER.getTriangles(); - - // Draw all lines - for (uint32_t i = 0; i < RP3D_DEBUG_RENDERER.getNbLines(); ++i) - { - const auto& LINE = LINES[i]; - debugDrawSystem->DrawLine(SHColour{ LINE.color1 }, LINE.point1, LINE.point2); - } - - for (uint32_t i = 0; i < RP3D_DEBUG_RENDERER.getNbTriangles(); ++i) - { - const auto& TRIANGLE = TRIANGLES[i]; - SHColour triColour{ TRIANGLE.color1 }; - triColour.a() = 1.0f; - debugDrawSystem->DrawTri(triColour, TRIANGLE.point1, TRIANGLE.point2, TRIANGLE.point3); - } - } - - void SHPhysicsSystem::onContact(const CallbackData& callbackData) - { - for (uint32_t i = 0; i < callbackData.getNbContactPairs(); ++i) - { - const auto CONTACT_PAIR = callbackData.getContactPair(i); - const SHCollisionEvent NEW_EVENT = GenerateCollisionEvent(CONTACT_PAIR); - - UpdateEventContainers(NEW_EVENT, collisionInfo); - } - } - - void SHPhysicsSystem::onTrigger(const rp3d::OverlapCallback::CallbackData& callbackData) - { - for (uint32_t i = 0; i < callbackData.getNbOverlappingPairs(); ++i) - { - const auto& OVERLAP_PAIR = callbackData.getOverlappingPair(i); - const SHCollisionEvent NEW_EVENT = GenerateCollisionEvent(OVERLAP_PAIR); - - UpdateEventContainers(NEW_EVENT, triggerInfo); - } - } - - /*-----------------------------------------------------------------------------------*/ - /* Private Function Member Definitions */ - /*-----------------------------------------------------------------------------------*/ - - SHPhysicsObject* SHPhysicsSystem::EnsurePhysicsObject(EntityID entityID) noexcept - { - const auto it = map.find(entityID); - if (it == map.end()) - { - auto* newPhysicsObject = &map.emplace(entityID, SHPhysicsObject{entityID, &factory, world}).first->second; - return newPhysicsObject; - } - - return &(it->second); - } - - SHPhysicsObject* SHPhysicsSystem::GetPhysicsObject(EntityID entityID) noexcept - { - const auto it = map.find(entityID); - if (it == map.end()) - { - //SHLOG_ERROR("Entity {} is not in the physics system!", entityID) - return nullptr; - } - - return &(it->second); - } - - void SHPhysicsSystem::DestroyPhysicsObject(EntityID entityID) noexcept - { - map.erase(entityID); - } - - void SHPhysicsSystem::SyncActiveStates(SHPhysicsObject& physicsObject, bool componentActive) noexcept - { - const bool RP3D_ACTIVE = physicsObject.rp3dBody->isActive(); - if (RP3D_ACTIVE != componentActive) - physicsObject.rp3dBody->setIsActive(componentActive); - } - - void SHPhysicsSystem::SyncTransforms() noexcept - { - for (auto& [entityID, physicsObject] : map) - { - rp3d::Vector3 rp3dPos; - rp3d::Quaternion rp3dRot; - - const rp3d::Transform CURRENT_TF = physicsObject.rp3dBody->getTransform(); - - auto* rigidBodyComponent = SHComponentManager::GetComponent_s(entityID); - auto* colliderComponent = SHComponentManager::GetComponent_s(entityID); - - // Check if transform should be interpolated - - if (rigidBodyComponent != nullptr) - { - if (rigidBodyComponent->GetType() == SHRigidBodyComponent::Type::STATIC) - continue; - - if (rigidBodyComponent->IsInterpolating()) - { - const rp3d::Transform PREV_TF = physicsObject.prevTransform; - const rp3d::Transform INTERPOLATED_TF = rp3d::Transform::interpolateTransforms(PREV_TF, CURRENT_TF, static_cast(interpolationFactor)); - - - rp3dPos = INTERPOLATED_TF.getPosition(); - rp3dRot = INTERPOLATED_TF.getOrientation(); - } - else - { - rp3dPos = CURRENT_TF.getPosition(); - rp3dRot = CURRENT_TF.getOrientation(); - } - - rigidBodyComponent->position = CURRENT_TF.getPosition(); - rigidBodyComponent->orientation = CURRENT_TF.getOrientation(); - - if (colliderComponent != nullptr) - { - - colliderComponent->position = CURRENT_TF.getPosition(); - colliderComponent->orientation = CURRENT_TF.getOrientation(); - } - } - else - { - rp3dPos = CURRENT_TF.getPosition(); - rp3dRot = CURRENT_TF.getOrientation(); - } - - // Convert RP3D Transform to SHADE - auto* transformComponent = SHComponentManager::GetComponent_s(entityID); - - if (transformComponent != nullptr) - { - transformComponent->SetWorldPosition(rp3dPos); - transformComponent->SetWorldOrientation(rp3dRot); - } - - // Cache transforms - physicsObject.prevTransform = CURRENT_TF; - } - } - - void SHPhysicsSystem::UpdateEventContainers(const SHCollisionEvent& collisionEvent, CollisionEvents& container) noexcept - { - const auto IT = std::ranges::find_if(container.begin(), container.end(), [&](const SHCollisionEvent& e) - { - const bool ENTITY_MATCH = (e.ids[0] == collisionEvent.ids[0] && e.ids[1] == collisionEvent.ids[1]) - || (e.ids[0] == collisionEvent.ids[1] && e.ids[1] == collisionEvent.ids[0]); - const bool COLLIDERS_MATCH = (e.ids[2] == collisionEvent.ids[2] && e.ids[3] == collisionEvent.ids[3]) - || (e.ids[2] == collisionEvent.ids[3] && e.ids[3] == collisionEvent.ids[2]); - return ENTITY_MATCH && COLLIDERS_MATCH; - }); - - if (IT == container.end()) - container.emplace_back(collisionEvent); - else - IT->collisionState = collisionEvent.collisionState; - } - - void SHPhysicsSystem::ClearInvalidCollisions() noexcept - { - static const auto CLEAR = [](CollisionEvents& container) - { - for (auto eventIter = container.begin(); eventIter != container.end();) - { - const bool CLEAR_EVENT = eventIter->GetCollisionState() == SHCollisionEvent::State::EXIT - || eventIter->GetCollisionState() == SHCollisionEvent::State::INVALID; - - if (CLEAR_EVENT) - eventIter = container.erase(eventIter); - else - ++eventIter; - } - }; - - CLEAR(collisionInfo); - CLEAR(triggerInfo); - } - - SHEventHandle SHPhysicsSystem::AddPhysicsComponent(SHEventPtr addComponentEvent) - { - const auto& EVENT_DATA = reinterpret_cast*>(addComponentEvent.get()); - - static const auto RIGID_BODY_ID = ComponentFamily::GetID(); - static const auto COLLIDER_ID = ComponentFamily::GetID(); - - const auto ADDED_ID = EVENT_DATA->data->addedComponentType; - const bool IS_PHYSICS_COMPONENT = ADDED_ID == RIGID_BODY_ID || ADDED_ID == COLLIDER_ID; - if (IS_PHYSICS_COMPONENT) - { - const EntityID ENTITY_ID = EVENT_DATA->data->eid; - auto* physicsObject = EnsurePhysicsObject(ENTITY_ID); - - auto* transformComponent = SHComponentManager::GetComponent_s(ENTITY_ID); - if (transformComponent == nullptr) - { - SHLOG_ERROR("Entity {} cannot add a Physics Component without a Transform! Component not created!", ENTITY_ID) - return EVENT_DATA->handle; - } - - auto* rigidBodyComponent = SHComponentManager::GetComponent_s(ENTITY_ID); - auto* colliderComponent = SHComponentManager::GetComponent_s(ENTITY_ID); - - if (ADDED_ID == RIGID_BODY_ID) - { - if (colliderComponent != nullptr) - { - world->destroyCollisionBody(physicsObject->rp3dBody); - physicsObject->rp3dBody = nullptr; - } - - rigidBodyComponent->position = transformComponent->GetWorldPosition(); - rigidBodyComponent->orientation = transformComponent->GetWorldOrientation(); - - physicsObject->rp3dBody = world->createRigidBody - ( - rp3d::Transform{ rigidBodyComponent->position, rigidBodyComponent->orientation } - ); - - rigidBodyComponent->rp3dBody = reinterpret_cast(physicsObject->rp3dBody); - - // Add collision shapes back into the body - if (colliderComponent != nullptr) - { - for (auto& collider : colliderComponent->collisionShapes) - physicsObject->AddCollider(&collider); - } - } - - if (ADDED_ID == COLLIDER_ID) - { - SHASSERT(colliderComponent != nullptr, "Collider Component was not added to Entity " + std::to_string(ENTITY_ID) + "!"); - - colliderComponent->position = transformComponent->GetWorldPosition(); - colliderComponent->orientation = transformComponent->GetWorldOrientation(); - colliderComponent->scale = transformComponent->GetWorldScale(); - - if (physicsObject->rp3dBody == nullptr) - { - physicsObject->rp3dBody = world->createCollisionBody - ( - rp3d::Transform{ colliderComponent->position, colliderComponent->orientation } - ); - } - - // Add Collision Shapes - for (auto& collider : colliderComponent->collisionShapes) - physicsObject->AddCollider(&collider); - } - } - - return EVENT_DATA->handle; - } - - SHEventHandle SHPhysicsSystem::RemovePhysicsComponent(SHEventPtr removeComponentEvent) - { - const auto& EVENT_DATA = reinterpret_cast*>(removeComponentEvent.get()); - - static const auto RIGID_BODY_ID = ComponentFamily::GetID(); - static const auto COLLIDER_ID = ComponentFamily::GetID(); - - const auto REMOVED_ID = EVENT_DATA->data->removedComponentType; - const bool IS_PHYSICS_COMPONENT = REMOVED_ID == RIGID_BODY_ID || REMOVED_ID == COLLIDER_ID; - if (IS_PHYSICS_COMPONENT) - { - const EntityID ENTITY_ID = EVENT_DATA->data->eid; - auto* physicsObject = GetPhysicsObject(ENTITY_ID); - - auto* rigidBodyComponent = SHComponentManager::GetComponent_s(ENTITY_ID); - auto* colliderComponent = SHComponentManager::GetComponent_s(ENTITY_ID); - - // Wake up all physics objects - for (auto& [entityID, object] : map) - { - if (SHComponentManager::HasComponent(entityID)) - reinterpret_cast(object.rp3dBody)->setIsSleeping(false); - } - - if (REMOVED_ID == RIGID_BODY_ID && physicsObject != nullptr) - { - world->destroyRigidBody(reinterpret_cast(physicsObject->rp3dBody)); - physicsObject->rp3dBody = nullptr; - - if (colliderComponent != nullptr) - { - // Preserve colliders as a collision body - physicsObject->rp3dBody = world->createCollisionBody - ( - rp3d::Transform{ colliderComponent->position, colliderComponent->orientation } - ); - - for (auto& collider : colliderComponent->collisionShapes) - physicsObject->AddCollider(&collider); - } - } - - if (REMOVED_ID == COLLIDER_ID && physicsObject != nullptr) - { - // Remove all colliders - const int NUM_COLLIDERS = static_cast(physicsObject->rp3dBody->getNbColliders()); - - for (int i = NUM_COLLIDERS - 1; i >= 0; --i) - { - auto* collider = physicsObject->rp3dBody->getCollider(i); - physicsObject->rp3dBody->removeCollider(collider); - } - - // Check for a rigidbody component - if (rigidBodyComponent == nullptr) - physicsObject->rp3dBody = nullptr; - } - - if (physicsObject != nullptr && physicsObject->rp3dBody == nullptr) - DestroyPhysicsObject(ENTITY_ID); - } - - return EVENT_DATA->handle; - } - - SHEventHandle SHPhysicsSystem::ResetWorld(SHEventPtr editorStopEvent) - { - // TODO(Diren): Rebuild world based on how scene reloading is done - - for (auto& [entityID, physicsObject] : map) - { - if (SHComponentManager::HasComponent(entityID)) - { - auto* rp3dRigidBody = reinterpret_cast(physicsObject.rp3dBody); - rp3dRigidBody->resetForce(); - rp3dRigidBody->resetTorque(); - rp3dRigidBody->setLinearVelocity(SHVec3::Zero); - rp3dRigidBody->setAngularVelocity(SHVec3::Zero); - } - } - - return editorStopEvent->handle; - } - -} // namespace SHADE \ No newline at end of file diff --git a/SHADE_Engine/src/Physics/SHPhysicsSystem.h b/SHADE_Engine/src/Physics/SHPhysicsSystem.h deleted file mode 100644 index 55575c73..00000000 --- a/SHADE_Engine/src/Physics/SHPhysicsSystem.h +++ /dev/null @@ -1,207 +0,0 @@ -/**************************************************************************************** - * \file SHPhysicsSystem.h - * \author Diren D Bharwani, diren.dbharwani, 390002520 - * \brief Interface for the Physics System - * - * \copyright Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or - * disclosure of this file or its contents without the prior written consent - * of DigiPen Institute of Technology is prohibited. -****************************************************************************************/ - -#pragma once - -#include -#include - -#include - -// Project Headers -#include "Components/SHRigidBodyComponent.h" -#include "Components/SHColliderComponent.h" -#include "ECS_Base/System/SHSystemRoutine.h" -#include "ECS_Base/System/SHFixedSystemRoutine.h" -#include "Math/Transform/SHTransformComponent.h" -#include "Scene/SHSceneGraph.h" -#include "SHPhysicsObject.h" -#include "SHPhysicsUtils.h" - - -namespace SHADE -{ - - /*-----------------------------------------------------------------------------------*/ - /* Type Definitions */ - /*-----------------------------------------------------------------------------------*/ - - class SH_API SHPhysicsSystem final : public SHSystem - , public rp3d::EventListener - { - public: - /*---------------------------------------------------------------------------------*/ - /* Type Definitions */ - /*---------------------------------------------------------------------------------*/ - - struct WorldSettings - { - SHVec3 gravity; - uint16_t numVelocitySolverIterations; - uint16_t numPositionSolverIterations; - bool sleepingEnabled; - }; - - using CollisionEvents = std::vector; - - enum class DebugDrawFlags : uint8_t - { - COLLIDER = 1 - , COLLIDER_AABB = 2 - , BROAD_PHASE_AABB = 4 - , CONTACT_POINTS = 8 - , CONTACT_NORMALS = 16 - }; - - /*---------------------------------------------------------------------------------*/ - /* Constructors & Destructor */ - /*---------------------------------------------------------------------------------*/ - - SHPhysicsSystem(); - - /*---------------------------------------------------------------------------------*/ - /* Getter Functions */ - /*---------------------------------------------------------------------------------*/ - - [[nodiscard]] double GetFixedDT () const noexcept; - - [[nodiscard]] bool IsSleepingEnabled () const noexcept; - - [[nodiscard]] SHVec3 GetWorldGravity () const noexcept; - [[nodiscard]] uint16_t GetNumberVelocityIterations () const noexcept; - [[nodiscard]] uint16_t GetNumberPositionIterations () const noexcept; - - [[nodiscard]] bool GetDrawColliders () const noexcept; - [[nodiscard]] bool GetDrawColliderAABBs () const noexcept; - [[nodiscard]] bool GetDrawBroadPhase () const noexcept; - [[nodiscard]] bool GetDrawContactPoints () const noexcept; - [[nodiscard]] bool GetDrawContactNormals () const noexcept; - - [[nodiscard]] const CollisionEvents& GetCollisionInfo () const noexcept; - [[nodiscard]] const CollisionEvents& GetTriggerInfo () const noexcept; - - - /*---------------------------------------------------------------------------------*/ - /* Setter Functions */ - /*---------------------------------------------------------------------------------*/ - - void SetFixedDT (double fixedUpdateRate) noexcept; - void SetWorldGravity (const SHVec3& gravity) const noexcept; - void SetNumberVelocityIterations (uint16_t numVelIterations) const noexcept; - void SetNumberPositionIterations (uint16_t numPosIterations) const noexcept; - void SetSleepingEnabled (bool enableSleeping) const noexcept; - - void SetWorldSettings (const WorldSettings& settings) const noexcept; - - // TODO(Diren): Can the debug draw flags be done through an enum? - void SetDrawColliders (bool shouldDraw) noexcept; - void SetDrawColliderAABBs (bool shouldDraw) noexcept; - void SetDrawBroadPhase (bool shouldDraw) noexcept; - void SetDrawContactPoints (bool shouldDraw) noexcept; - void SetDrawContactNormals (bool shouldDraw) noexcept; - - /*---------------------------------------------------------------------------------*/ - /* Function Members */ - /*---------------------------------------------------------------------------------*/ - - void Init () override; - void Exit () override; - - void AddCollisionShape (EntityID entityID, SHCollisionShape* collider); - void RemoveCollisionShape (EntityID entityID, int index); - - void onContact (const rp3d::CollisionCallback::CallbackData& callbackData) override; - void onTrigger (const rp3d::OverlapCallback::CallbackData& callbackData) override; - - /*---------------------------------------------------------------------------------*/ - /* System Routines */ - /*---------------------------------------------------------------------------------*/ - - class SH_API PhysicsPreUpdate final : public SHSystemRoutine - { - public: - - PhysicsPreUpdate(); - void Execute(double dt) noexcept override; - }; - - class SH_API PhysicsFixedUpdate final : public SHFixedSystemRoutine - { - public: - - PhysicsFixedUpdate(); - void Execute (double dt) noexcept override; - }; - - class SH_API PhysicsPostUpdate final : public SHSystemRoutine - { - public: - - PhysicsPostUpdate(); - void Execute(double dt) noexcept override; - }; - - class SH_API PhysicsDebugDraw final : public SHSystemRoutine - { - public: - PhysicsDebugDraw(); - void Execute(double dt) noexcept override; - }; - - private: - /*---------------------------------------------------------------------------------*/ - /* Type Definitions */ - /*---------------------------------------------------------------------------------*/ - - using EntityObjectMap = std::unordered_map; - - /*---------------------------------------------------------------------------------*/ - /* Data Members */ - /*---------------------------------------------------------------------------------*/ - - bool worldUpdated; - uint8_t debugDrawFlags; - - double interpolationFactor; - double fixedDT; - - rp3d::PhysicsWorld* world; - rp3d::PhysicsCommon factory; - - EntityObjectMap map; - CollisionEvents collisionInfo; - CollisionEvents triggerInfo; - - /*---------------------------------------------------------------------------------*/ - /* Function Members */ - /*---------------------------------------------------------------------------------*/ - - SHPhysicsObject* EnsurePhysicsObject (EntityID entityID) noexcept; - SHPhysicsObject* GetPhysicsObject (EntityID entityID) noexcept; - void DestroyPhysicsObject (EntityID entityID) noexcept; - - static void SyncActiveStates (SHPhysicsObject& physicsObject, bool componentActive) noexcept; - void SyncTransforms () noexcept; - - static void UpdateEventContainers (const SHCollisionEvent& collisionEvent, CollisionEvents& container) noexcept; - void ClearInvalidCollisions () noexcept; - - SHEventHandle AddPhysicsComponent (SHEventPtr addComponentEvent); - SHEventHandle RemovePhysicsComponent (SHEventPtr removeComponentEvent); - SHEventHandle ResetWorld (SHEventPtr editorStopEvent); - - template - || std::is_same_v>> - SHCollisionEvent GenerateCollisionEvent (const RP3DCollisionPair& cp) noexcept; - }; -} // namespace SHADE - -#include "SHPhysicsSystem.hpp" \ No newline at end of file diff --git a/SHADE_Engine/src/Physics/SHPhysicsSystem.hpp b/SHADE_Engine/src/Physics/SHPhysicsSystem.hpp deleted file mode 100644 index 957fb3aa..00000000 --- a/SHADE_Engine/src/Physics/SHPhysicsSystem.hpp +++ /dev/null @@ -1,84 +0,0 @@ -/**************************************************************************************** - * \file SHPhysicsSystem.hpp - * \author Diren D Bharwani, diren.dbharwani, 390002520 - * \brief Implementation for templated functions the Physics System - * - * \copyright Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or - * disclosure of this file or its contents without the prior written consent - * of DigiPen Institute of Technology is prohibited. -****************************************************************************************/ - -#pragma once - -#include - -// Primary Header -#include "SHPhysicsSystem.h" - -namespace SHADE -{ - /*-----------------------------------------------------------------------------------*/ - /* Private Function Member Definitions */ - /*-----------------------------------------------------------------------------------*/ - - template - SHCollisionEvent SHPhysicsSystem::GenerateCollisionEvent(const RP3DCollisionPair& cp) noexcept - { - static const auto MATCH_COLLIDER = [] - ( - const SHPhysicsObject& physicsObject - , const rp3d::Entity colliderID - )->uint32_t - { - for (uint32_t i = 0; i < physicsObject.rp3dBody->getNbColliders(); ++i) - { - const auto* collider = physicsObject.rp3dBody->getCollider(i); - if (collider->getEntity() == colliderID) - return i; - } - - return std::numeric_limits::max(); - }; - - SHCollisionEvent cInfo; - - // Update collision state - cInfo.collisionState = static_cast(cp.getEventType()); - - // Match body and collider for collision event - const rp3d::Entity body1 = cp.getBody1()->getEntity(); - const rp3d::Entity body2 = cp.getBody2()->getEntity(); - const rp3d::Entity collider1 = cp.getCollider1()->getEntity(); - const rp3d::Entity collider2 = cp.getCollider2()->getEntity(); - - // Find and match both ids - bool matched[2] = { false, false }; - - - for (auto& [entityID, physicsObject] : map) - { - // Match body 1 - if (matched[SHCollisionEvent::ENTITY_A] == false && physicsObject.rp3dBody->getEntity() == body1) - { - cInfo.ids[SHCollisionEvent::ENTITY_A] = entityID; - cInfo.ids[SHCollisionEvent::COLLIDER_A] = MATCH_COLLIDER(physicsObject, collider1); - - matched[SHCollisionEvent::ENTITY_A] = true; - } - - // Match body 2 - if (matched[SHCollisionEvent::ENTITY_B] == false && physicsObject.rp3dBody->getEntity() == body2) - { - cInfo.ids[SHCollisionEvent::ENTITY_B] = entityID; - cInfo.ids[SHCollisionEvent::COLLIDER_B] = MATCH_COLLIDER(physicsObject, collider2); - - matched[SHCollisionEvent::ENTITY_B] = true; - } - - if (matched[SHCollisionEvent::ENTITY_A] == true && matched[SHCollisionEvent::ENTITY_B] == true) - return cInfo; - } - - return cInfo; - } -} // namespace SHADE \ No newline at end of file diff --git a/SHADE_Engine/src/Physics/SHPhysicsWorld.cpp b/SHADE_Engine/src/Physics/SHPhysicsWorld.cpp new file mode 100644 index 00000000..85e76702 --- /dev/null +++ b/SHADE_Engine/src/Physics/SHPhysicsWorld.cpp @@ -0,0 +1,71 @@ +/**************************************************************************************** + * \file SHPhysicsWorld.cpp + * \author Diren D Bharwani, diren.dbharwani, 390002520 + * \brief Implementation for a Physics World. + * + * \copyright Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or + * disclosure of this file or its contents without the prior written consent + * of DigiPen Institute of Technology is prohibited. +****************************************************************************************/ + +#include + +// Primary Header +#include "SHPhysicsWorld.h" + +namespace SHADE +{ + /*-----------------------------------------------------------------------------------*/ + /* Constructors & Destructor Definitions */ + /*-----------------------------------------------------------------------------------*/ + + SHPhysicsWorldState::SHPhysicsWorldState() noexcept + : world { nullptr } + {} + + /*-----------------------------------------------------------------------------------*/ + /* Public Function Members Definitions */ + /*-----------------------------------------------------------------------------------*/ + + void SHPhysicsWorldState::CreateWorld(rp3d::PhysicsCommon& factory) + { + rp3d::PhysicsWorld::WorldSettings rp3dWorldSettings; + rp3dWorldSettings.gravity = settings.gravity; + rp3dWorldSettings.defaultVelocitySolverNbIterations = settings.numVelocitySolverIterations; + rp3dWorldSettings.defaultPositionSolverNbIterations = settings.numPositionSolverIterations; + rp3dWorldSettings.isSleepingEnabled = settings.sleepingEnabled; + + // These are my preferred default values. QoL for modifying these. + rp3dWorldSettings.defaultBounciness = 0.0f; + rp3dWorldSettings.defaultFrictionCoefficient = 0.4f; + + world = factory.createPhysicsWorld(rp3dWorldSettings); + world->setContactsPositionCorrectionTechnique(rp3d::ContactsPositionCorrectionTechnique::SPLIT_IMPULSES); + } + + void SHPhysicsWorldState::DestroyWorld(rp3d::PhysicsCommon& factory) + { + if (!world) + return; + + factory.destroyPhysicsWorld(world); + world = nullptr; + } + + void SHPhysicsWorldState::UpdateSettings() const noexcept + { + if (!world) + { + SHLOGV_ERROR("Unable to update Physics World settings without creating a world!") + return; + } + + world->setGravity(settings.gravity); + world->setNbIterationsVelocitySolver(settings.numVelocitySolverIterations); + world->setNbIterationsPositionSolver(settings.numPositionSolverIterations); + world->enableSleeping(settings.sleepingEnabled); + } + + + +} // namespace SHADE \ No newline at end of file diff --git a/SHADE_Engine/src/Physics/SHPhysicsWorld.h b/SHADE_Engine/src/Physics/SHPhysicsWorld.h new file mode 100644 index 00000000..091ae062 --- /dev/null +++ b/SHADE_Engine/src/Physics/SHPhysicsWorld.h @@ -0,0 +1,74 @@ +/**************************************************************************************** + * \file SHPhysicsWorld.h + * \author Diren D Bharwani, diren.dbharwani, 390002520 + * \brief Interface for a Physics World. + * + * \copyright Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or + * disclosure of this file or its contents without the prior written consent + * of DigiPen Institute of Technology is prohibited. +****************************************************************************************/ + +#pragma once + +#include + +// Project Headers +#include "Math/SHMath.h" +#include "SH_API.h" + +namespace SHADE +{ + /*-----------------------------------------------------------------------------------*/ + /* Type Definitions */ + /*-----------------------------------------------------------------------------------*/ + + struct SH_API SHPhysicsWorldState + { + public: + + /*---------------------------------------------------------------------------------*/ + /* Type Definitions */ + /*---------------------------------------------------------------------------------*/ + + struct WorldSettings + { + public: + /*-------------------------------------------------------------------------------*/ + /* Data Members */ + /*-------------------------------------------------------------------------------*/ + + SHVec3 gravity = SHVec3{ 0.0f, -9.81f, 0.0f }; + uint16_t numVelocitySolverIterations = 15; + uint16_t numPositionSolverIterations = 8; + bool sleepingEnabled = true; + }; + + /*---------------------------------------------------------------------------------*/ + /* Data Members */ + /*---------------------------------------------------------------------------------*/ + + rp3d::PhysicsWorld* world; + WorldSettings settings; + + /*---------------------------------------------------------------------------------*/ + /* Constructors & Destructor */ + /*---------------------------------------------------------------------------------*/ + + SHPhysicsWorldState() noexcept; + + /*---------------------------------------------------------------------------------*/ + /* Function Members */ + /*---------------------------------------------------------------------------------*/ + + void CreateWorld (rp3d::PhysicsCommon& factory); + void DestroyWorld (rp3d::PhysicsCommon& factory); + + /** + * @brief Applies the current settings to the physics world. The world must be created + * before this is called. + */ + void UpdateSettings () const noexcept; + }; + + +} // namespace SHADE \ No newline at end of file diff --git a/SHADE_Engine/src/Physics/System/SHPhysicsDebugDrawSystem.cpp b/SHADE_Engine/src/Physics/System/SHPhysicsDebugDrawSystem.cpp new file mode 100644 index 00000000..44875289 --- /dev/null +++ b/SHADE_Engine/src/Physics/System/SHPhysicsDebugDrawSystem.cpp @@ -0,0 +1,233 @@ +/**************************************************************************************** + * \file SHPhysicsDebugDrawSystem.cpp + * \author Diren D Bharwani, diren.dbharwani, 390002520 + * \brief Implementation for the Physics Debug Draw System + * + * \copyright Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or + * disclosure of this file or its contents without the prior written consent + * of DigiPen Institute of Technology is prohibited. +****************************************************************************************/ + +#include + +// Primary Header +#include "SHPhysicsDebugDrawSystem.h" + +// Project Headers +#include "ECS_Base/Managers/SHSystemManager.h" +#include "Graphics/MiddleEnd/Interface/SHDebugDrawSystem.h" +#include "Scene/SHSceneManager.h" + +namespace SHADE +{ + /*-----------------------------------------------------------------------------------*/ + /* Static Data Member Definitions */ + /*-----------------------------------------------------------------------------------*/ + + const SHPhysicsDebugDrawSystem::DebugDrawFunction SHPhysicsDebugDrawSystem::drawFunctions[SHPhysicsDebugDrawSystem::NUM_FLAGS] = + { + SHPhysicsDebugDrawSystem::drawColliders + , SHPhysicsDebugDrawSystem::drawColliderAABBs + , SHPhysicsDebugDrawSystem::drawBroadPhaseAABBs + , SHPhysicsDebugDrawSystem::drawContactPoints + , SHPhysicsDebugDrawSystem::drawContactNormals + }; + + /*-----------------------------------------------------------------------------------*/ + /* Constructors & Destructor Definitions */ + /*-----------------------------------------------------------------------------------*/ + + SHPhysicsDebugDrawSystem::SHPhysicsDebugDrawSystem() noexcept + : debugDrawFlags { 0 } + , physicsSystem { nullptr } + , rp3dDebugRenderer { nullptr } + { + debugColours[SHUtilities::ConvertEnum(DebugDrawFlags::COLLIDER)] = + debugColours[SHUtilities::ConvertEnum(DebugDrawFlags::COLLIDER_AABB)] = SHColour::YELLOW; + debugColours[SHUtilities::ConvertEnum(DebugDrawFlags::BROAD_PHASE_AABB)] = SHColour::CYAN; + debugColours[SHUtilities::ConvertEnum(DebugDrawFlags::CONTACT_POINTS)] = SHColour::RED; + debugColours[SHUtilities::ConvertEnum(DebugDrawFlags::CONTACT_NORMALS)] = SHColour::RED; + } + + SHPhysicsDebugDrawSystem::PhysicsDebugDrawRoutine::PhysicsDebugDrawRoutine() + : SHSystemRoutine { "Physics Debug Draw", true } + {} + + /*-----------------------------------------------------------------------------------*/ + /* Getter Function Definitions */ + /*-----------------------------------------------------------------------------------*/ + + bool SHPhysicsDebugDrawSystem::GetDebugDrawFlag(DebugDrawFlags flag) const noexcept + { + const auto INT_FLAG = SHUtilities::ConvertEnum(flag); + if (INT_FLAG < 0 || INT_FLAG >= NUM_FLAGS) + { + SHLOG_ERROR("Invalid Debug Draw Flag Passed {} in. Unable to get debug draw state!", INT_FLAG) + return false; + } + + return debugDrawFlags & 1U << SHUtilities::ConvertEnum(flag); + } + + /*-----------------------------------------------------------------------------------*/ + /* Setter Function Definitions */ + /*-----------------------------------------------------------------------------------*/ + + void SHPhysicsDebugDrawSystem::SetDebugDrawFlag(DebugDrawFlags flag, bool value) noexcept + { + const auto INT_FLAG = SHUtilities::ConvertEnum(flag); + if (INT_FLAG < 0 || INT_FLAG >= NUM_FLAGS) + { + SHLOG_ERROR("Invalid Debug Draw Flag Passed {} in. Unable to set debug draw state!", INT_FLAG) + return; + } + + value ? (debugDrawFlags |= 1U << INT_FLAG) : (debugDrawFlags &= ~(1U << INT_FLAG)); + } + + /*-----------------------------------------------------------------------------------*/ + /* Public Function Member Definitions */ + /*-----------------------------------------------------------------------------------*/ + + void SHPhysicsDebugDrawSystem::Init() + { + SystemFamily::GetID(); + + SHASSERT(physicsSystem == nullptr, "Non-existent physics system attached to the physics debug draw system!") + physicsSystem = SHSystemManager::GetSystem(); + } + + void SHPhysicsDebugDrawSystem::Exit() + { + physicsSystem = nullptr; + } + + void SHPhysicsDebugDrawSystem::PhysicsDebugDrawRoutine::Execute(double) noexcept + { + auto* system = reinterpret_cast(GetSystem()); + + for (int i = 0; i < SHUtilities::ConvertEnum(DebugDrawFlags::NUM_FLAGS); ++i) + { + const bool DRAW = (system->debugDrawFlags & (1U << i)) > 0; + if (DRAW) + drawFunctions[i](system->rp3dDebugRenderer); + } + } + + /*-----------------------------------------------------------------------------------*/ + /* Private Function Member Definitions */ + /*-----------------------------------------------------------------------------------*/ + + void SHPhysicsDebugDrawSystem::drawColliders(rp3d::DebugRenderer* debugRenderer) noexcept + { + const auto& COLLIDER_SET = SHComponentManager::GetDense(); + for (const auto& COLLIDER : COLLIDER_SET) + { + // Skip inactive colliders + if (!SHSceneManager::CheckNodeAndComponentsActive(COLLIDER.GetEID())) + continue; + + for (auto& collisionShape : COLLIDER.GetCollisionShapes()) + { + switch (collisionShape.GetType()) + { + case SHCollisionShape::Type::BOX: debugDrawBox(COLLIDER, collisionShape); break; + case SHCollisionShape::Type::SPHERE: debugDrawSphere(COLLIDER, collisionShape); break; + default: break; + } + } + } + } + + void SHPhysicsDebugDrawSystem::drawColliderAABBs(rp3d::DebugRenderer* debugRenderer) noexcept + { + + } + + void SHPhysicsDebugDrawSystem::drawBroadPhaseAABBs(rp3d::DebugRenderer* debugRenderer) noexcept + { + + } + + void SHPhysicsDebugDrawSystem::drawContactPoints(rp3d::DebugRenderer* debugRenderer) noexcept + { + + } + + void SHPhysicsDebugDrawSystem::drawContactNormals(rp3d::DebugRenderer* debugRenderer) noexcept + { + + } + + void SHPhysicsDebugDrawSystem::debugDrawBox(const SHColliderComponent& colliderComponent, const SHCollisionShape& collisionShape) noexcept + { + static constexpr uint32_t NUM_BOX_VERTICES = 8; + static const SHVec3 boxVertices[NUM_BOX_VERTICES] + { + { 0.5f, 0.5f, -0.5f } // TOP_RIGHT_BACK + , { -0.5f, 0.5f, -0.5f } // TOP_LEFT_BACK + , { 0.5f, -0.5f, -0.5f } // BTM_RIGHT_BACK + , { -0.5f, -0.5f, -0.5f } // BTM_LEFT_BACK + , { 0.5f, 0.5f, 0.5f } // TOP_RIGHT_FRONT + , { -0.5f, 0.5f, 0.5f } // TOP_LEFT_FRONT + , { 0.5f, -0.5f, 0.5f } // BTM_RIGHT_FRONT + , { -0.5f, -0.5f, 0.5f } // BTM_LEFT_FRONT + }; + + auto* debugDrawSystem = SHSystemManager::GetSystem(); + if (debugDrawSystem == nullptr) + { + SHLOG_ERROR("Unable to get a debug draw system for Physics Debug Drawing!") + return; + } + + auto* BOX = reinterpret_cast(collisionShape.GetShape()); + + // Calculate final position & orientation + const SHVec3 FINAL_POS = colliderComponent.GetPosition() + collisionShape.GetPositionOffset(); + const SHQuaternion FINAL_ROT = colliderComponent.GetOrientation() * SHQuaternion::FromEuler(collisionShape.GetRotationOffset()); + + const SHMatrix BOX_TRS = SHMatrix::Scale(BOX->GetWorldExtents() * 2.0f) * SHMatrix::Rotate(FINAL_ROT) * SHMatrix::Translate(FINAL_POS); + + const SHColour COLLIDER_COLOUR = collisionShape.IsTrigger() ? SHColour::PURPLE : SHColour::GREEN; + + std::array transformedVertices; + for (uint32_t i = 0; i < NUM_BOX_VERTICES / 2; ++i) + { + const uint32_t IDX1 = i; + const uint32_t IDX2 = i + NUM_BOX_VERTICES / 2; + + transformedVertices[IDX1] = SHVec3::Transform(boxVertices[IDX1], BOX_TRS); + transformedVertices[IDX2] = SHVec3::Transform(boxVertices[IDX2], BOX_TRS); + + // Draw 4 line to connect the quads + debugDrawSystem->DrawLine(COLLIDER_COLOUR, transformedVertices[IDX1], transformedVertices[IDX2]); + } + + // A, B, C, D + std::array backQuad { transformedVertices[0], transformedVertices[1], transformedVertices[3], transformedVertices[2] }; + debugDrawSystem->DrawPoly(COLLIDER_COLOUR, backQuad.begin(), backQuad.end()); + // E, F, G, H + std::array frontQuad { transformedVertices[4], transformedVertices[5], transformedVertices[7], transformedVertices[6] }; + debugDrawSystem->DrawPoly(COLLIDER_COLOUR, frontQuad.begin(), frontQuad.end()); + } + + void SHPhysicsDebugDrawSystem::debugDrawSphere(const SHColliderComponent& colliderComponent, const SHCollisionShape& collisionShape) noexcept + { + auto* debugDrawSystem = SHSystemManager::GetSystem(); + if (debugDrawSystem == nullptr) + { + SHLOG_ERROR("Unable to get a debug draw system for Physics Debug Drawing!") + return; + } + + auto* SPHERE = reinterpret_cast(collisionShape.GetShape()); + + const SHColour COLLIDER_COLOUR = collisionShape.IsTrigger() ? SHColour::PURPLE : SHColour::GREEN; + + // Calculate final position & orientation + const SHVec3 FINAL_POS = colliderComponent.GetPosition() + collisionShape.GetPositionOffset(); + debugDrawSystem->DrawSphere(COLLIDER_COLOUR, FINAL_POS, SPHERE->GetWorldRadius()); + } + +} // namespace SHADE \ No newline at end of file diff --git a/SHADE_Engine/src/Physics/System/SHPhysicsDebugDrawSystem.h b/SHADE_Engine/src/Physics/System/SHPhysicsDebugDrawSystem.h new file mode 100644 index 00000000..390e3d69 --- /dev/null +++ b/SHADE_Engine/src/Physics/System/SHPhysicsDebugDrawSystem.h @@ -0,0 +1,123 @@ +/**************************************************************************************** + * \file SHPhysicsDebugDrawSystem.h + * \author Diren D Bharwani, diren.dbharwani, 390002520 + * \brief Interface for the Physics Debug Draw System + * + * \copyright Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or + * disclosure of this file or its contents without the prior written consent + * of DigiPen Institute of Technology is prohibited. +****************************************************************************************/ + +#pragma once + +#include + +// Project Headers +#include "ECS_Base/System/SHSystemRoutine.h" +#include "Math/SHColour.h" +#include "SHPhysicsSystem.h" +#include "Tools/Utilities/SHUtilities.h" + +namespace SHADE +{ + /*-----------------------------------------------------------------------------------*/ + /* Type Definitions */ + /*-----------------------------------------------------------------------------------*/ + + class SH_API SHPhysicsDebugDrawSystem final : public SHSystem + { + public: + /*---------------------------------------------------------------------------------*/ + /* Type Definitions */ + /*---------------------------------------------------------------------------------*/ + + enum class DebugDrawFlags + { + COLLIDER + , COLLIDER_AABB + , BROAD_PHASE_AABB + , CONTACT_POINTS + , CONTACT_NORMALS + + , NUM_FLAGS + }; + + /*---------------------------------------------------------------------------------*/ + /* Constructors & Destructor */ + /*---------------------------------------------------------------------------------*/ + + SHPhysicsDebugDrawSystem() noexcept; + + /*---------------------------------------------------------------------------------*/ + /* Getter Functions */ + /*---------------------------------------------------------------------------------*/ + + bool GetDebugDrawFlag(DebugDrawFlags flag) const noexcept; + + /*---------------------------------------------------------------------------------*/ + /* Setter Functions */ + /*---------------------------------------------------------------------------------*/ + + void SetDebugDrawFlag(DebugDrawFlags flag, bool value) noexcept; + + /*---------------------------------------------------------------------------------*/ + /* Function Members */ + /*---------------------------------------------------------------------------------*/ + + void Init() override; + void Exit() override; + + /*---------------------------------------------------------------------------------*/ + /* System Routines */ + /*---------------------------------------------------------------------------------*/ + + class SH_API PhysicsDebugDrawRoutine final : public SHSystemRoutine + { + public: + /*-------------------------------------------------------------------------------*/ + /* Constructors & Destructor */ + /*-------------------------------------------------------------------------------*/ + + PhysicsDebugDrawRoutine(); + + /*-------------------------------------------------------------------------------*/ + /* Function Members */ + /*-------------------------------------------------------------------------------*/ + void Execute(double dt) noexcept override; + }; + + private: + /*---------------------------------------------------------------------------------*/ + /* Type Definitions */ + /*---------------------------------------------------------------------------------*/ + + using DebugDrawFunction = void(*)(rp3d::DebugRenderer*) noexcept; + + /*---------------------------------------------------------------------------------*/ + /* Data Members */ + /*---------------------------------------------------------------------------------*/ + + static constexpr int NUM_FLAGS = SHUtilities::ConvertEnum(DebugDrawFlags::NUM_FLAGS); + + static const DebugDrawFunction drawFunctions[NUM_FLAGS]; + + uint8_t debugDrawFlags; + SHPhysicsSystem* physicsSystem; + rp3d::DebugRenderer* rp3dDebugRenderer; + SHColour debugColours[NUM_FLAGS]; + + /*---------------------------------------------------------------------------------*/ + /* Function Members */ + /*---------------------------------------------------------------------------------*/ + + static void drawColliders (rp3d::DebugRenderer* debugRenderer) noexcept; + static void drawColliderAABBs (rp3d::DebugRenderer* debugRenderer) noexcept; + static void drawBroadPhaseAABBs (rp3d::DebugRenderer* debugRenderer) noexcept; + static void drawContactPoints (rp3d::DebugRenderer* debugRenderer) noexcept; + static void drawContactNormals (rp3d::DebugRenderer* debugRenderer) noexcept; + + static void debugDrawBox (const SHColliderComponent& colliderComponent, const SHCollisionShape& collisionShape) noexcept; + static void debugDrawSphere (const SHColliderComponent& colliderComponent, const SHCollisionShape& collisionShape) noexcept; + }; + +} // namespace SHADE diff --git a/SHADE_Engine/src/Physics/System/SHPhysicsSystem.cpp b/SHADE_Engine/src/Physics/System/SHPhysicsSystem.cpp new file mode 100644 index 00000000..33ba88e7 --- /dev/null +++ b/SHADE_Engine/src/Physics/System/SHPhysicsSystem.cpp @@ -0,0 +1,429 @@ +/**************************************************************************************** + * \file SHPhysicsSystem.cpp + * \author Diren D Bharwani, diren.dbharwani, 390002520 + * \brief Implementation for the Physics System + * + * \copyright Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or + * disclosure of this file or its contents without the prior written consent + * of DigiPen Institute of Technology is prohibited. +****************************************************************************************/ + +#include + +// Primary Header +#include "SHPhysicsSystem.h" + +// Project Headers +#include "ECS_Base/Managers/SHComponentManager.h" +#include "ECS_Base/Managers/SHEntityManager.h" +#include "ECS_Base/Managers/SHSystemManager.h" +#include "Editor/SHEditor.h" +#include "Physics/SHPhysicsEvents.h" +#include "Scene/SHSceneManager.h" +#include "Scripting/SHScriptEngine.h" + +/*-------------------------------------------------------------------------------------*/ +/* Local Helper Functions */ +/*-------------------------------------------------------------------------------------*/ + +namespace SHADE +{ + /*-----------------------------------------------------------------------------------*/ + /* Constructors & Destructor Definitions */ + /*-----------------------------------------------------------------------------------*/ + + SHPhysicsSystem::SHPhysicsSystem() + : worldUpdated { false } + , interpolationFactor { 0.0 } + , fixedDT { DEFAULT_FIXED_STEP } + {} + + /*-----------------------------------------------------------------------------------*/ + /* Getter Function Definitions */ + /*-----------------------------------------------------------------------------------*/ + + double SHPhysicsSystem::GetFixedUpdateRate() const noexcept + { + return 1.0 / fixedDT; + } + + const SHPhysicsWorldState::WorldSettings& SHPhysicsSystem::GetWorldSettings() const noexcept + { + return worldState.settings; + } + + const std::vector& SHPhysicsSystem::GetAllCollisionInfo() const noexcept + { + return collisionListener.GetCollisionInfoContainer(); + } + + const std::vector& SHPhysicsSystem::GetAllTriggerInfo() const noexcept + { + return collisionListener.GetTriggerInfoContainer(); + } + + const SHPhysicsObject* SHPhysicsSystem::GetPhysicsObject(EntityID eid) noexcept + { + return objectManager.GetPhysicsObject(eid); + } + + + const SHPhysicsObjectManager::PhysicsObjectEntityMap& SHPhysicsSystem::GetPhysicsObjects() const noexcept + { + return objectManager.physicsObjects; + } + + /*-----------------------------------------------------------------------------------*/ + /* Setter Function Definitions */ + /*-----------------------------------------------------------------------------------*/ + + void SHPhysicsSystem::SetFixedUpdateRate(double fixedUpdateRate) noexcept + { + fixedDT = 1.0 / fixedUpdateRate; + } + + void SHPhysicsSystem::SetWorldSettings(const SHPhysicsWorldState::WorldSettings& settings) noexcept + { + worldState.settings = settings; + worldState.UpdateSettings(); + } + + /*-----------------------------------------------------------------------------------*/ + /* Public Function Member Definitions */ + /*-----------------------------------------------------------------------------------*/ + + void SHPhysicsSystem::Init() + { + // Subscribe to component events + const std::shared_ptr ADD_COMPONENT_RECEIVER { std::make_shared>(this, &SHPhysicsSystem::addPhysicsComponent) }; + const ReceiverPtr ADD_COMPONENT_RECEIVER_PTR = std::dynamic_pointer_cast(ADD_COMPONENT_RECEIVER); + SHEventManager::SubscribeTo(SH_COMPONENT_ADDED_EVENT, ADD_COMPONENT_RECEIVER_PTR); + + const std::shared_ptr REMOVE_COMPONENT_RECEIVER { std::make_shared>(this, &SHPhysicsSystem::removePhysicsComponent) }; + const ReceiverPtr REMOVE_COMPONENT_RECEIVER_PTR = std::dynamic_pointer_cast(REMOVE_COMPONENT_RECEIVER); + SHEventManager::SubscribeTo(SH_COMPONENT_REMOVED_EVENT, REMOVE_COMPONENT_RECEIVER_PTR); + + #ifdef SHEDITOR + + // Subscribe to Editor State Change Events + const std::shared_ptr ON_PLAY_RECEIVER { std::make_shared>(this, &SHPhysicsSystem::onPlay) }; + const ReceiverPtr ON_PLAY_RECEIVER_PTR = std::dynamic_pointer_cast(ON_PLAY_RECEIVER); + SHEventManager::SubscribeTo(SH_EDITOR_ON_PLAY_EVENT, ON_PLAY_RECEIVER_PTR); + + const std::shared_ptr ON_STOP_RECEIVER { std::make_shared>(this, &SHPhysicsSystem::onStop) }; + const ReceiverPtr ON_STOP_RECEIVER_PTR = std::dynamic_pointer_cast(ON_STOP_RECEIVER); + SHEventManager::SubscribeTo(SH_EDITOR_ON_STOP_EVENT, ON_STOP_RECEIVER_PTR); + + #endif + // Link Physics Object Manager with System + objectManager.SetFactory(factory); + + // Link Collision Listener with System + collisionListener.BindToSystem(this); + } + + void SHPhysicsSystem::Exit() + { + worldState.DestroyWorld(factory); + } + + void SHPhysicsSystem::ForceUpdate() + { + if (!worldState.world) + { + SHLOGV_ERROR("Unable to force update without a Physics world!") + return; + } + + auto* scriptingSystem = SHSystemManager::GetSystem(); + if (scriptingSystem == nullptr) + { + SHLOGV_ERROR("Unable to invoke FixedUpdate() on scripts due to missing SHScriptEngine!"); + } + + // Force the physics world to update once + if (scriptingSystem != nullptr) + scriptingSystem->ExecuteFixedUpdates(); + + worldState.world->update(static_cast(fixedDT)); + + // Sync transforms. No interpolation applied here + for (auto& [entityID, physicsObject] : objectManager.physicsObjects) + { + auto* transformComponent = SHComponentManager::GetComponent_s(entityID); + auto* rigidBodyComponent = SHComponentManager::GetComponent_s(entityID); + auto* colliderComponent = SHComponentManager::GetComponent_s(entityID); + + postUpdateSyncTransforms + ( + physicsObject + , transformComponent + , rigidBodyComponent + , colliderComponent + , 1.0 // We use 1.0 here to avoid any interpolation + ); + } + } + + + void SHPhysicsSystem::AddCollisionShape(EntityID eid, int shapeIndex) + { + static const auto ADD_SHAPE = [&](EntityID entityID, int index) + { + objectManager.AddCollisionShape(entityID, index); + + const SHPhysicsColliderAddedEvent COLLIDER_ADDED_EVENT_DATA + { + .entityID = entityID + , .colliderType = SHComponentManager::GetComponent(entityID)->GetCollisionShape(index).GetType() + , .colliderIndex = index + }; + + SHEventManager::BroadcastEvent(COLLIDER_ADDED_EVENT_DATA, SH_PHYSICS_COLLIDER_ADDED_EVENT); + }; + + #ifdef SHEDITOR + + const auto* EDITOR = SHSystemManager::GetSystem(); + if (EDITOR && EDITOR->editorState != SHEditor::State::STOP) + ADD_SHAPE(eid, shapeIndex); + + #else + + ADD_SHAPE(eid, shapeIndex); + + #endif + } + + void SHPhysicsSystem::RemoveCollisionShape(EntityID eid, int shapeIndex) + { + static const auto REMOVE_SHAPE = [&](EntityID entityID, int index) + { + objectManager.RemoveCollisionShape(entityID, index); + + const SHPhysicsColliderRemovedEvent COLLIDER_REMOVED_EVENT_DATA + { + .entityID = entityID + , .colliderIndex = index + }; + + SHEventManager::BroadcastEvent(COLLIDER_REMOVED_EVENT_DATA, SH_PHYSICS_COLLIDER_REMOVED_EVENT); + }; + + #ifdef SHEDITOR + + const auto* EDITOR = SHSystemManager::GetSystem(); + if (EDITOR && EDITOR->editorState != SHEditor::State::STOP) + REMOVE_SHAPE(eid, shapeIndex); + + #else + + REMOVE_SHAPE(eid, shapeIndex); + + #endif + } + + /*-----------------------------------------------------------------------------------*/ + /* Private Function Member Definitions */ + /*-----------------------------------------------------------------------------------*/ + + SHEventHandle SHPhysicsSystem::addPhysicsComponent(SHEventPtr addComponentEvent) noexcept + { + const auto& EVENT_DATA = reinterpret_cast*>(addComponentEvent.get()); + + static const auto RIGID_BODY_ID = ComponentFamily::GetID(); + static const auto COLLIDER_ID = ComponentFamily::GetID(); + + const auto ADDED_ID = EVENT_DATA->data->addedComponentType; + const bool IS_PHYSICS_COMPONENT = ADDED_ID == RIGID_BODY_ID || ADDED_ID == COLLIDER_ID; + if (IS_PHYSICS_COMPONENT) + { + const EntityID EID = EVENT_DATA->data->eid; + + // We only add tell the physics object manager to add a component if the scene is played + + #ifdef SHEDITOR + + const auto* EDITOR = SHSystemManager::GetSystem(); + + if (EDITOR && EDITOR->editorState != SHEditor::State::STOP) + ADDED_ID == RIGID_BODY_ID ? objectManager.AddRigidBody(EID) : objectManager.AddCollider(EID); + + #else + + ADDED_ID == RIGID_BODY_ID ? objectManager.AddRigidBody(EID) : objectManager.AddCollider(EID); + + #endif + } + + return EVENT_DATA->handle; + } + + SHEventHandle SHPhysicsSystem::removePhysicsComponent(SHEventPtr removeComponentEvent) noexcept + { + const auto& EVENT_DATA = reinterpret_cast*>(removeComponentEvent.get()); + + static const auto RIGID_BODY_ID = ComponentFamily::GetID(); + static const auto COLLIDER_ID = ComponentFamily::GetID(); + + const auto REMOVED_ID = EVENT_DATA->data->removedComponentType; + const bool IS_PHYSICS_COMPONENT = REMOVED_ID == RIGID_BODY_ID || REMOVED_ID == COLLIDER_ID; + if (IS_PHYSICS_COMPONENT) + { + const EntityID EID = EVENT_DATA->data->eid; + + // We only add tell the physics object manager to remove a component if the scene is played + + #ifdef SHEDITOR + + const auto* EDITOR = SHSystemManager::GetSystem(); + + if (EDITOR && EDITOR->editorState != SHEditor::State::STOP) + REMOVED_ID == RIGID_BODY_ID ? objectManager.RemoveRigidBody(EID) : objectManager.RemoveCollider(EID); + + #else + + REMOVED_ID == RIGID_BODY_ID ? objectManager.RemoveRigidBody(EID) : objectManager.RemoveCollider(EID); + + #endif + } + + return EVENT_DATA->handle; + } + + SHEventHandle SHPhysicsSystem::onPlay(SHEventPtr onPlayEvent) + { + static const auto BUILD_PHYSICS_OBJECT = [&](SHSceneNode* node) + { + const EntityID EID = node->GetEntityID(); + + if (SHComponentManager::HasComponent(EID)) + objectManager.AddRigidBody(EID); + + if (SHComponentManager::HasComponent(EID)) + objectManager.AddCollider(EID); + }; + + //////////////////////////////// + + // Create physics world + worldState.CreateWorld(factory); + + // Link Collision Listener + collisionListener.BindToWorld(worldState.world); + + // Link with object manager & create all physics objects + objectManager.SetWorld(worldState.world); + + const auto& SCENE_GRAPH = SHSceneManager::GetCurrentSceneGraph(); + SCENE_GRAPH.Traverse(BUILD_PHYSICS_OBJECT); + + return onPlayEvent->handle; + } + + SHEventHandle SHPhysicsSystem::onStop(SHEventPtr onStopEvent) + { + // Remove all physics objects + objectManager.RemoveAllObjects(); + objectManager.SetWorld(nullptr); + + // Clear all collision info + // Collision listener is automatically unbound when world is destroyed + collisionListener.ClearContainers(); + + // Destroy the world + worldState.DestroyWorld(factory); + + return onStopEvent->handle; + } + + void SHPhysicsSystem::preUpdateSyncTransform + ( + SHPhysicsObject& physicsObject + , SHTransformComponent* transformComponent + , SHRigidBodyComponent* rigidBodyComponent + , SHColliderComponent* colliderComponent + ) noexcept + { + if (!transformComponent) + return; + + const SHVec3& WORLD_POS = transformComponent->GetWorldPosition(); + const SHQuaternion& WORLD_ROT = transformComponent->GetWorldOrientation(); + const SHVec3& WORLD_SCL = transformComponent->GetWorldScale(); + + const rp3d::Transform RP3D_TRANSFORM { WORLD_POS, WORLD_ROT }; + physicsObject.GetRigidBody()->setTransform(RP3D_TRANSFORM); + + if (rigidBodyComponent && SHSceneManager::CheckNodeAndComponentsActive(physicsObject.entityID)) + { + rigidBodyComponent->position = WORLD_POS; + rigidBodyComponent->orientation = WORLD_ROT; + } + + if (colliderComponent && SHSceneManager::CheckNodeAndComponentsActive(physicsObject.entityID)) + { + colliderComponent->position = WORLD_POS; + colliderComponent->orientation = WORLD_ROT; + colliderComponent->scale = WORLD_SCL; + + colliderComponent->RecomputeCollisionShapes(); + } + } + + void SHPhysicsSystem::postUpdateSyncTransforms + ( + SHPhysicsObject& physicsObject + , SHTransformComponent* transformComponent + , SHRigidBodyComponent* rigidBodyComponent + , SHColliderComponent* colliderComponent + , double interpolationFactor + ) noexcept + { + const rp3d::Transform& CURRENT_TF = physicsObject.GetRigidBody()->getTransform(); + auto renderPos = CURRENT_TF.getPosition(); + auto renderRot = CURRENT_TF.getOrientation(); + + // Cache transforms + if (physicsObject.GetRigidBody()->isActive()) + physicsObject.prevTransform = CURRENT_TF; + + // Sync with rigid bodies + if (rigidBodyComponent && SHSceneManager::CheckNodeAndComponentsActive(physicsObject.entityID)) + { + // Skip static bodies + if (rigidBodyComponent->GetType() == SHRigidBodyComponent::Type::STATIC) + return; + + // Check if transform should be interpolated + if (rigidBodyComponent->IsInterpolating()) + { + // Interpolate transforms between current and predicted next transform + + const rp3d::Transform PREV_TF = physicsObject.prevTransform; + const rp3d::Transform INTERPOLATED_TF = rp3d::Transform::interpolateTransforms(PREV_TF, CURRENT_TF, static_cast(interpolationFactor)); + + renderPos = INTERPOLATED_TF.getPosition(); + renderRot = INTERPOLATED_TF.getOrientation(); + } + + rigidBodyComponent->position = CURRENT_TF.getPosition(); + rigidBodyComponent->orientation = CURRENT_TF.getOrientation(); + } + + // Sync with colliders + if (colliderComponent && SHSceneManager::CheckNodeAndComponentsActive(physicsObject.entityID)) + { + colliderComponent->position = CURRENT_TF.getPosition(); + colliderComponent->orientation = CURRENT_TF.getOrientation(); + } + + // Set transform for rendering + if (transformComponent) + { + transformComponent->SetWorldPosition(renderPos); + transformComponent->SetWorldOrientation(renderRot); + } + } + +} // namespace SHADE \ No newline at end of file diff --git a/SHADE_Engine/src/Physics/System/SHPhysicsSystem.h b/SHADE_Engine/src/Physics/System/SHPhysicsSystem.h new file mode 100644 index 00000000..3da7094b --- /dev/null +++ b/SHADE_Engine/src/Physics/System/SHPhysicsSystem.h @@ -0,0 +1,201 @@ +/**************************************************************************************** + * \file SHPhysicsSystem.h + * \author Diren D Bharwani, diren.dbharwani, 390002520 + * \brief Interface for the Physics System + * + * \copyright Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or + * disclosure of this file or its contents without the prior written consent + * of DigiPen Institute of Technology is prohibited. +****************************************************************************************/ + +#pragma once + +#include +#include + +// External Dependencies +#include + +// Project Headers +#include "ECS_Base/System/SHSystemRoutine.h" +#include "ECS_Base/System/SHFixedSystemRoutine.h" + +#include "Math/Transform/SHTransformComponent.h" + +#include "Physics/Collision/SHCollisionListener.h" +#include "Physics/Interface/SHRigidBodyComponent.h" +#include "Physics/Interface/SHColliderComponent.h" +#include "Physics/PhysicsObject//SHPhysicsObjectManager.h" +#include "Physics/SHPhysicsWorld.h" + + +namespace SHADE +{ + /*-----------------------------------------------------------------------------------*/ + /* Type Definitions */ + /*-----------------------------------------------------------------------------------*/ + + class SH_API SHPhysicsSystem final : public SHSystem + { + private: + /*---------------------------------------------------------------------------------*/ + /* Friends */ + /*---------------------------------------------------------------------------------*/ + + friend class SHPhysicsDebugDrawSystem; + + public: + /*---------------------------------------------------------------------------------*/ + /* Constructors & Destructor */ + /*---------------------------------------------------------------------------------*/ + + SHPhysicsSystem(); + + /*---------------------------------------------------------------------------------*/ + /* Getter Functions */ + /*---------------------------------------------------------------------------------*/ + + [[nodiscard]] double GetFixedUpdateRate () const noexcept; + [[nodiscard]] const SHPhysicsWorldState::WorldSettings& GetWorldSettings () const noexcept; + + [[nodiscard]] const std::vector& GetAllCollisionInfo () const noexcept; + [[nodiscard]] const std::vector& GetAllTriggerInfo () const noexcept; + + [[nodiscard]] const SHPhysicsObject* GetPhysicsObject (EntityID eid) noexcept; + [[nodiscard]] const SHPhysicsObjectManager::PhysicsObjectEntityMap& GetPhysicsObjects () const noexcept; + /*---------------------------------------------------------------------------------*/ + /* Setter Functions */ + /*---------------------------------------------------------------------------------*/ + + void SetFixedUpdateRate (double fixedUpdateRate) noexcept; + void SetWorldSettings (const SHPhysicsWorldState::WorldSettings& settings) noexcept; + + /*---------------------------------------------------------------------------------*/ + /* Function Members */ + /*---------------------------------------------------------------------------------*/ + + void Init () override; + void Exit () override; + + void ForceUpdate (); + + // Specific Handling for Collision Shapes as they are not under the Component System. + // This is done as events need to be sent out. + // TODO(Diren): Consider using a static method through the ColliderComponent. + + void AddCollisionShape (EntityID eid, int shapeIndex); + void RemoveCollisionShape (EntityID eid, int shapeIndex); + + /*---------------------------------------------------------------------------------*/ + /* System Routines */ + /*---------------------------------------------------------------------------------*/ + + class SH_API PhysicsPreUpdate final : public SHSystemRoutine + { + public: + /*-------------------------------------------------------------------------------*/ + /* Constructors & Destructor */ + /*-------------------------------------------------------------------------------*/ + + PhysicsPreUpdate(); + + /*-------------------------------------------------------------------------------*/ + /* Function Members */ + /*-------------------------------------------------------------------------------*/ + + void Execute(double dt) noexcept override; + + private: + /*-------------------------------------------------------------------------------*/ + /* Function Members */ + /*-------------------------------------------------------------------------------*/ + + void syncRigidBodyActive (EntityID eid, SHPhysicsObject& physicsObject) const noexcept; + void syncColliderActive (EntityID eid, SHPhysicsObject& physicsObject) const noexcept; + static void syncOnPlay (EntityID eid, SHPhysicsObject& physicsObject) noexcept; + }; + + class SH_API PhysicsFixedUpdate final : public SHFixedSystemRoutine + { + public: + /*-------------------------------------------------------------------------------*/ + /* Constructors & Destructor */ + /*-------------------------------------------------------------------------------*/ + + PhysicsFixedUpdate(); + + /*-------------------------------------------------------------------------------*/ + /* Function Members */ + /*-------------------------------------------------------------------------------*/ + + void Execute (double dt) noexcept override; + }; + + class SH_API PhysicsPostUpdate final : public SHSystemRoutine + { + public: + /*-------------------------------------------------------------------------------*/ + /* Constructors & Destructor */ + /*-------------------------------------------------------------------------------*/ + + PhysicsPostUpdate(); + + /*-------------------------------------------------------------------------------*/ + /* Function Members */ + /*-------------------------------------------------------------------------------*/ + + void Execute(double dt) noexcept override; + }; + + private: + /*---------------------------------------------------------------------------------*/ + /* Data Members */ + /*---------------------------------------------------------------------------------*/ + + // System data + + bool worldUpdated; + double interpolationFactor; + double fixedDT; + + // rp3d + + rp3d::PhysicsCommon factory; + + // Interface objects + + SHPhysicsWorldState worldState; + SHPhysicsObjectManager objectManager; + SHCollisionListener collisionListener; + + /*---------------------------------------------------------------------------------*/ + /* Function Members */ + /*---------------------------------------------------------------------------------*/ + + SHEventHandle addPhysicsComponent (SHEventPtr addComponentEvent) noexcept; + SHEventHandle removePhysicsComponent (SHEventPtr removeComponentEvent) noexcept; + + SHEventHandle onPlay (SHEventPtr onPlayEvent); + SHEventHandle onStop (SHEventPtr onStopEvent); + + + + static void preUpdateSyncTransform + ( + SHPhysicsObject& physicsObject + , SHTransformComponent* transformComponent + , SHRigidBodyComponent* rigidBodyComponent + , SHColliderComponent* colliderComponent + ) noexcept; + + static void postUpdateSyncTransforms + ( + SHPhysicsObject& physicsObject + , SHTransformComponent* transformComponent + , SHRigidBodyComponent* rigidBodyComponent + , SHColliderComponent* colliderComponent + , double interpolationFactor + ) noexcept; + + }; +} // namespace SHADE \ No newline at end of file diff --git a/SHADE_Engine/src/Physics/SHPhysicsSystemInterface.cpp b/SHADE_Engine/src/Physics/System/SHPhysicsSystemInterface.cpp similarity index 79% rename from SHADE_Engine/src/Physics/SHPhysicsSystemInterface.cpp rename to SHADE_Engine/src/Physics/System/SHPhysicsSystemInterface.cpp index 4b292340..b142d54c 100644 --- a/SHADE_Engine/src/Physics/SHPhysicsSystemInterface.cpp +++ b/SHADE_Engine/src/Physics/System/SHPhysicsSystemInterface.cpp @@ -16,35 +16,34 @@ of DigiPen Institute of Technology is prohibited. #include "SHPhysicsSystemInterface.h" // Project Includes #include "ECS_Base/Managers/SHSystemManager.h" -#include "Physics/SHPhysicsSystem.h" -#include "Physics/SHPhysicsUtils.h" +#include "Physics/System/SHPhysicsSystem.h" namespace SHADE { /*-----------------------------------------------------------------------------------*/ /* Static Usage Functions */ /*-----------------------------------------------------------------------------------*/ - const std::vector& SHPhysicsSystemInterface::GetCollisionInfo() noexcept + const std::vector& SHPhysicsSystemInterface::GetCollisionInfo() noexcept { - static std::vector emptyVec; + static std::vector emptyVec; auto phySystem = SHSystemManager::GetSystem(); if (phySystem) { - return phySystem->GetCollisionInfo(); + return phySystem->GetAllCollisionInfo(); } SHLOG_WARNING("[SHPhysicsSystemInterface] Failed to get collision events. Empty vector returned instead."); return emptyVec; } - const std::vector& SHPhysicsSystemInterface::GetTriggerInfo() noexcept + const std::vector& SHPhysicsSystemInterface::GetTriggerInfo() noexcept { - static std::vector emptyVec; + static std::vector emptyVec; auto phySystem = SHSystemManager::GetSystem(); if (phySystem) { - return phySystem->GetTriggerInfo(); + return phySystem->GetAllTriggerInfo(); } SHLOG_WARNING("[SHPhysicsSystemInterface] Failed to get trigger events. Empty vector returned instead."); @@ -56,7 +55,7 @@ namespace SHADE auto phySystem = SHSystemManager::GetSystem(); if (phySystem) { - return phySystem->GetFixedDT(); + return phySystem->GetFixedUpdateRate(); } SHLOG_WARNING("[SHPhysicsSystemInterface] Failed to get fixed delta time. 0.0 returned instead."); diff --git a/SHADE_Engine/src/Physics/SHPhysicsSystemInterface.h b/SHADE_Engine/src/Physics/System/SHPhysicsSystemInterface.h similarity index 91% rename from SHADE_Engine/src/Physics/SHPhysicsSystemInterface.h rename to SHADE_Engine/src/Physics/System/SHPhysicsSystemInterface.h index da6a0433..bdd04686 100644 --- a/SHADE_Engine/src/Physics/SHPhysicsSystemInterface.h +++ b/SHADE_Engine/src/Physics/System/SHPhysicsSystemInterface.h @@ -19,7 +19,7 @@ namespace SHADE /*-----------------------------------------------------------------------------------*/ /* Forward Declarations */ /*-----------------------------------------------------------------------------------*/ - class SHCollisionEvent; + class SHCollisionInfo; /*-----------------------------------------------------------------------------------*/ /* Type Definitions */ @@ -39,8 +39,8 @@ namespace SHADE /*---------------------------------------------------------------------------------*/ /* Static Usage Functions */ /*---------------------------------------------------------------------------------*/ - [[nodiscard]] static const std::vector& GetCollisionInfo() noexcept; - [[nodiscard]] static const std::vector& GetTriggerInfo() noexcept; + [[nodiscard]] static const std::vector& GetCollisionInfo() noexcept; + [[nodiscard]] static const std::vector& GetTriggerInfo() noexcept; [[nodiscard]] static double GetFixedDT() noexcept; }; } diff --git a/SHADE_Engine/src/Physics/System/SHPhysicsSystemRoutines.cpp b/SHADE_Engine/src/Physics/System/SHPhysicsSystemRoutines.cpp new file mode 100644 index 00000000..3e56ca14 --- /dev/null +++ b/SHADE_Engine/src/Physics/System/SHPhysicsSystemRoutines.cpp @@ -0,0 +1,265 @@ +/**************************************************************************************** + * \file SHPhysicsSystemRoutines.h + * \author Diren D Bharwani, diren.dbharwani, 390002520 + * \brief Implementation for the Physics System Routines + * + * \copyright Copyright (C) 2022 DigiPen Institute of Technology. Reproduction or + * disclosure of this file or its contents without the prior written consent + * of DigiPen Institute of Technology is prohibited. +****************************************************************************************/ + +#include + +// Primary Header +#include "SHPhysicsSystem.h" +// Project Headers +#include "ECS_Base/Managers/SHEntityManager.h" +#include "ECS_Base/Managers/SHSystemManager.h" +#include "Editor/SHEditor.h" +#include "Scene/SHSceneManager.h" +#include "Scripting/SHScriptEngine.h" + +#include "Input/SHInputManager.h" + +namespace SHADE +{ + /*-----------------------------------------------------------------------------------*/ + /* Constructors & Destructor Definitions */ + /*-----------------------------------------------------------------------------------*/ + + SHPhysicsSystem::PhysicsPreUpdate::PhysicsPreUpdate() + : SHSystemRoutine { "Physics PreUpdate", true } + {} + + SHPhysicsSystem::PhysicsFixedUpdate::PhysicsFixedUpdate() + : SHFixedSystemRoutine { DEFAULT_FIXED_STEP, "Physics FixedUpdate", false } + {} + + SHPhysicsSystem::PhysicsPostUpdate::PhysicsPostUpdate() + : SHSystemRoutine { "Physics PostUpdate", false } + {} + + /*-----------------------------------------------------------------------------------*/ + /* Public Function Member Definitions */ + /*-----------------------------------------------------------------------------------*/ + + void SHPhysicsSystem::PhysicsPreUpdate::Execute(double) noexcept + { + auto* physicsSystem = reinterpret_cast(GetSystem()); + + #ifdef SHEDITOR + + // Only Sync on Play. + // Otherwise, Components are only holding data until the world is built on play. + const auto* EDITOR = SHSystemManager::GetSystem(); + if (EDITOR && EDITOR->editorState != SHEditor::State::STOP) + { + physicsSystem->objectManager.UpdateCommands(); + + for (auto& [entityID, physicsObject] : physicsSystem->objectManager.physicsObjects) + { + // Ensure a valid physics Object + if (physicsObject.rp3dBody == nullptr) + continue; + + // Sync active states between SHADE & RP3D + syncRigidBodyActive(entityID, physicsObject); + syncColliderActive(entityID, physicsObject); + + syncOnPlay(entityID, physicsObject); + } + } + else + { + auto& rigidBodyDense = SHComponentManager::GetDense(); + auto& colliderDense = SHComponentManager::GetDense(); + + for (auto& rigidBodyComponent : rigidBodyDense) + { + const auto* TRANSFORM = SHComponentManager::GetComponent_s(rigidBodyComponent.GetEID()); + + if (TRANSFORM && TRANSFORM->HasChanged()) + { + rigidBodyComponent.position = TRANSFORM->GetWorldPosition(); + rigidBodyComponent.orientation = TRANSFORM->GetWorldOrientation(); + } + } + + for (auto& colliderComponent : colliderDense) + { + const auto* TRANSFORM = SHComponentManager::GetComponent_s(colliderComponent.GetEID()); + + if (TRANSFORM && TRANSFORM->HasChanged()) + { + colliderComponent.position = TRANSFORM->GetWorldPosition(); + colliderComponent.orientation = TRANSFORM->GetWorldOrientation(); + colliderComponent.scale = TRANSFORM->GetWorldScale(); + + colliderComponent.RecomputeCollisionShapes(); + } + } + } + + #else + + // Always sync Rigid Body & Collider Components with Physics Objects + // Do not check for an editor here + + physicsSystem->objectManager.UpdateCommands(); + + for (auto& [entityID, physicsObject] : physicsSystem->objectManager.physicsObjects) + { + // Ensure a valid physics Object + if (physicsObject.rp3dBody == nullptr) + continue; + + syncRigidBodyActive(entityID, physicsObject); + syncColliderActive(entityID, physicsObject); + + syncOnPlay(entityID, physicsObject); + } + + #endif + } + + void SHPhysicsSystem::PhysicsFixedUpdate::Execute(double dt) noexcept + { + auto* physicsSystem = reinterpret_cast(GetSystem()); + auto* scriptingSystem = SHSystemManager::GetSystem(); + if (scriptingSystem == nullptr) + { + SHLOGV_ERROR("Unable to invoke FixedUpdate() on scripts due to missing SHScriptEngine!"); + } + + const double FIXED_DT = physicsSystem->fixedDT; + accumulatedTime += dt; + + int count = 0; + while (accumulatedTime > FIXED_DT) + { + if (scriptingSystem != nullptr) + scriptingSystem->ExecuteFixedUpdates(); + + physicsSystem->worldState.world->update(static_cast(FIXED_DT)); + + accumulatedTime -= FIXED_DT; + ++count; + } + + stats.numSteps = count; + physicsSystem->worldUpdated = count > 0; + + physicsSystem->interpolationFactor = accumulatedTime / fixedTimeStep; + } + + void SHPhysicsSystem::PhysicsPostUpdate::Execute(double) noexcept + { + auto* physicsSystem = reinterpret_cast(GetSystem()); + auto* scriptingSystem = SHSystemManager::GetSystem(); + + if (scriptingSystem == nullptr) + { + SHLOGV_ERROR("Unable to invoke collision and trigger script events due to missing SHScriptEngine!"); + } + + // Interpolate transforms for rendering + if (physicsSystem->worldUpdated) + { + for (auto& [entityID, physicsObject] : physicsSystem->objectManager.physicsObjects) + { + auto* transformComponent = SHComponentManager::GetComponent_s(entityID); + auto* rigidBodyComponent = SHComponentManager::GetComponent_s(entityID); + auto* colliderComponent = SHComponentManager::GetComponent_s(entityID); + + postUpdateSyncTransforms + ( + physicsObject + , transformComponent + , rigidBodyComponent + , colliderComponent + , physicsSystem->interpolationFactor + ); + } + + // Collision & Trigger messages + if (scriptingSystem != nullptr) + scriptingSystem->ExecuteCollisionFunctions(); + + // Since this function never runs when editor in not in play, execute the function anyway + physicsSystem->collisionListener.CleanContainers(); + } + } + + /*-----------------------------------------------------------------------------------*/ + /* Private Function Member Definitions */ + /*-----------------------------------------------------------------------------------*/ + + void SHPhysicsSystem::PhysicsPreUpdate::syncRigidBodyActive(EntityID eid, SHPhysicsObject& physicsObject) const noexcept + { + if (!SHComponentManager::HasComponent(eid)) + return; + + const bool IS_ACTIVE_IN_SCENE = SHSceneManager::CheckNodeAndComponentsActive(eid); + const bool IS_RP3D_BODY_ACTIVE = physicsObject.GetRigidBody()->isActive(); + + if (IS_ACTIVE_IN_SCENE != IS_RP3D_BODY_ACTIVE) + physicsObject.GetRigidBody()->setIsActive(IS_ACTIVE_IN_SCENE); + } + + void SHPhysicsSystem::PhysicsPreUpdate::syncColliderActive(EntityID eid, SHPhysicsObject& physicsObject) const noexcept + { + const auto* COLLIDER = SHComponentManager::GetComponent_s(eid); + if (!COLLIDER) + return; + + const bool IS_ACTIVE_IN_SCENE = SHSceneManager::CheckNodeAndComponentsActive(eid); + const bool IS_RP3D_COLLIDER_ACTIVE = physicsObject.collidersActive; + + if (IS_ACTIVE_IN_SCENE != IS_RP3D_COLLIDER_ACTIVE) + { + // HACK: If active state turned off, remove all collision shapes. If turned on, add them back. + auto* physicsSystem = reinterpret_cast(GetSystem()); + + const int NUM_SHAPES = static_cast(COLLIDER->GetCollisionShapes().size()); + if (IS_ACTIVE_IN_SCENE) + { + for (int i = 0; i < NUM_SHAPES; ++i) + physicsSystem->objectManager.AddCollisionShape(eid, i); + } + else + { + for (int i = NUM_SHAPES - 1; i >= 0; --i) + physicsSystem->objectManager.RemoveCollisionShape(eid, i); + } + + physicsObject.collidersActive = IS_ACTIVE_IN_SCENE; + } + } + + void SHPhysicsSystem::PhysicsPreUpdate::syncOnPlay(EntityID eid, SHPhysicsObject& physicsObject) noexcept + { + auto* transformComponent = SHComponentManager::GetComponent_s(eid); + auto* rigidBodyComponent = SHComponentManager::GetComponent_s(eid); + auto* colliderComponent = SHComponentManager::GetComponent_s(eid); + + // Sync transforms & physics components transforms + if (transformComponent && transformComponent->HasChanged()) + { + preUpdateSyncTransform + ( + physicsObject + , transformComponent + , rigidBodyComponent + , colliderComponent + ); + } + + // Sync Rigid Bodies + if (rigidBodyComponent) + physicsObject.SyncRigidBody(*rigidBodyComponent); + + // Sync Colliders + if (colliderComponent) + physicsObject.SyncColliders(*colliderComponent); + } +} // namespace SHADE \ No newline at end of file diff --git a/SHADE_Engine/src/Resource/SHResourceManager.hpp b/SHADE_Engine/src/Resource/SHResourceManager.hpp index 01d82a7b..1e3b958d 100644 --- a/SHADE_Engine/src/Resource/SHResourceManager.hpp +++ b/SHADE_Engine/src/Resource/SHResourceManager.hpp @@ -20,7 +20,7 @@ of DigiPen Institute of Technology is prohibited. #include "Assets/Asset Types/SHAssetIncludes.h" #include "Graphics/MiddleEnd/Interface/SHGraphicsSystem.h" #include "ECS_Base/Managers/SHSystemManager.h" -#include "Tools/SHLog.h" +#include "Tools/Logger/SHLog.h" #include "Graphics/Shaders/SHVkShaderModule.h" #include "Graphics/Devices/SHVkLogicalDevice.h" #include "Graphics/MiddleEnd/Materials/SHMaterialSpec.h" diff --git a/SHADE_Engine/src/SHpch.h b/SHADE_Engine/src/SHpch.h index 7e308829..31553611 100644 --- a/SHADE_Engine/src/SHpch.h +++ b/SHADE_Engine/src/SHpch.h @@ -37,5 +37,5 @@ #include #include "Common/SHCommonTypes.h" -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" #include "Tools/SHException.h" diff --git a/SHADE_Engine/src/Scene/SHSceneManager.h b/SHADE_Engine/src/Scene/SHSceneManager.h index 23d13261..8f03b352 100644 --- a/SHADE_Engine/src/Scene/SHSceneManager.h +++ b/SHADE_Engine/src/Scene/SHSceneManager.h @@ -21,6 +21,7 @@ #include "SH_API.h" #include "ECS_Base/General/SHFamily.h" #include "Assets/SHAssetMacros.h" +#include "ECS_Base/Managers/SHComponentManager.h" namespace SHADE { @@ -116,6 +117,56 @@ namespace SHADE sceneChanged = true; } + /******************************************************************** + * \brief + * Check if the Entity's scene node is active and all the + * components specified are active. + * This does not check if the entity HasComponent. Please use + * CheckNodeAndHasComponentActive for that. + * \param eid + * EntityID of the entity to check for. + * \return + * true if scene node is active and all the components specified + * are also active. + ********************************************************************/ + template + static std::enable_if_t<(... && std::is_base_of_v), bool> CheckNodeAndComponentsActive(EntityID eid) + { + return CheckNodeActive(eid) && (... && SHComponentManager::GetComponent_s(eid)->isActive); + } + + /******************************************************************** + * \brief + * Check if the Entity's scene node is active and all the + * components specified are active. + * This also checks to verify that the entity has such components. + * \param eid + * EntityID of the entity to check for. + * \return + * true if scene node is active and all the components specified + * are also active. + ********************************************************************/ + template + static std::enable_if_t<(... && std::is_base_of_v), bool> CheckNodeAndHasComponentsActive(EntityID eid) + { + return CheckNodeActive(eid) + && (... && SHComponentManager::HasComponent(eid)) + && (... && SHComponentManager::GetComponent_s(eid)->isActive); + } + + /******************************************************************** + * \brief + * Check if Scene node is active. + * \param eid + * EntityID of the entity to check for. + * \return + * true if scene node is active + ********************************************************************/ + static bool CheckNodeActive(EntityID eid) + { + return GetCurrentSceneGraph().IsActiveInHierarchy(eid); + } + /*!************************************************************************* * \brief diff --git a/SHADE_Engine/src/Scene/SHSceneNode.cpp b/SHADE_Engine/src/Scene/SHSceneNode.cpp index b619d464..8dac20bd 100644 --- a/SHADE_Engine/src/Scene/SHSceneNode.cpp +++ b/SHADE_Engine/src/Scene/SHSceneNode.cpp @@ -136,7 +136,7 @@ namespace SHADE for (auto* child : children) { - SetActive(newActiveState); + child->SetActive(newActiveState); } } diff --git a/SHADE_Engine/src/Scripting/SHDotNetRuntime.cpp b/SHADE_Engine/src/Scripting/SHDotNetRuntime.cpp index 6226949e..955a8474 100644 --- a/SHADE_Engine/src/Scripting/SHDotNetRuntime.cpp +++ b/SHADE_Engine/src/Scripting/SHDotNetRuntime.cpp @@ -20,7 +20,7 @@ of DigiPen Institute of Technology is prohibited. #include // External Dependencies #include // PathRemoveFileSpecA -#include "Tools/SHLogger.h" +#include "Tools/Logger/SHLogger.h" namespace SHADE { diff --git a/SHADE_Engine/src/Scripting/SHScriptEngine.cpp b/SHADE_Engine/src/Scripting/SHScriptEngine.cpp index 4f3fbce6..0db11c7a 100644 --- a/SHADE_Engine/src/Scripting/SHScriptEngine.cpp +++ b/SHADE_Engine/src/Scripting/SHScriptEngine.cpp @@ -17,14 +17,17 @@ of DigiPen Institute of Technology is prohibited. #include // std::fstream #include // std::filesystem::canonical, std::filesystem::remove #include // std::shared_ptr +#include // std::this_thread::sleep_for // Project Headers -#include "Tools/SHLogger.h" -#include "Tools/SHStringUtils.h" +#include "Tools/Logger/SHLogger.h" +#include "Tools/Utilities/SHStringUtilities.h" #include "ECS_Base/Events/SHEntityDestroyedEvent.h" #include "Events/SHEvent.h" #include "Events/SHEventReceiver.h" #include "Events/SHEventManager.hpp" -#include "Physics/SHPhysicsSystem.h" +#include "Physics/System/SHPhysicsSystem.h" +#include "Physics/SHPhysicsEvents.h" +#include "Scene/SHSceneGraphEvents.h" #include "Assets/SHAssetMacros.h" @@ -177,10 +180,10 @@ namespace SHADE } // Prepare directory (delete useless files) - deleteFolder(CSPROJ_DIR + "\\net5.0"); - deleteFolder(CSPROJ_DIR + "\\ref"); - deleteFolder(CSPROJ_DIR + "\\obj"); - deleteFolder(CSPROJ_DIR + "\\bin"); + deleteFolder(CSPROJ_DIR + "/net5.0"); + deleteFolder(CSPROJ_DIR + "/ref"); + deleteFolder(CSPROJ_DIR + "/obj"); + deleteFolder(CSPROJ_DIR + "/bin"); // Attempt to build the assembly std::ostringstream oss; @@ -214,7 +217,10 @@ namespace SHADE // Clean up built files deleteFolder("./tmp"); - deleteFolder(CSPROJ_DIR + "\\obj"); + deleteFolder(CSPROJ_DIR + "/bin"); + using namespace std::chrono_literals; + std::this_thread::sleep_for(50ms); // Not sure why this works but it prevents the folders from respawning + deleteFolder(CSPROJ_DIR + "/obj"); // Read the build log and output to the console dumpBuildLog(BUILD_LOG_PATH); @@ -232,8 +238,13 @@ namespace SHADE void SHScriptEngine::GenerateScriptsCsProjFile(const std::filesystem::path& path) const { + // Compute relative path + const std::filesystem::path EXE_DIR = std::filesystem::current_path(); + const std::filesystem::path MANAGED_DLL_DIR = EXE_DIR / "SHADE_Managed.dll"; + const std::filesystem::path CS_DLL_DIR = EXE_DIR / "SHADE_CSharp.dll"; + // Sample - static std::string_view FILE_CONTENTS = + static std::string_view FILE_CONTENTS_BEGIN = "\n\ \n\ net5.0\n\ @@ -261,26 +272,30 @@ namespace SHADE \n\ \n\ \n\ + \n\ \n\ \n\ - \n\ - ..\\bin\\Debug\\SHADE_Managed.dll\n\ - ..\\bin\\Release\\SHADE_Managed.dll\n\ - \n\ - \n\ - ..\\bin\\Debug\\SHADE_CSharp.dll\n\ - ..\\bin\\Release\\SHADE_CSharp.dll\n\ - \n\ + \n"; + static std::string_view FILE_CONTENTS_MID = +" \n\ + \n"; + static std::string_view FILE_CONTENTS_END = +" \n\ \n\ "; // Attempt to create the file - std::ofstream file(path); + std::ofstream file(path, std::ios::out | std::ios::trunc); if (!file.is_open()) throw std::runtime_error("Unable to create CsProj file!"); // Fill the file - file << FILE_CONTENTS; + const std::filesystem::path CSPROJ_DIR = path.parent_path(); + file << FILE_CONTENTS_BEGIN + << " " << std::filesystem::relative(MANAGED_DLL_DIR, CSPROJ_DIR).string() << "\n" + << FILE_CONTENTS_MID + << " " << std::filesystem::relative(CS_DLL_DIR, CSPROJ_DIR).string() << "\n" + << FILE_CONTENTS_END; // Close file.close(); @@ -318,6 +333,20 @@ namespace SHADE return eventData->handle; } + SHEventHandle SHScriptEngine::onSceneNodeChildrenAdded(SHEventPtr eventPtr) + { + auto eventData = reinterpret_cast*>(eventPtr.get()); + csSceneNodeChildrenChanged(eventData->data->parent->GetEntityID()); + return eventData->handle; + } + + SHEventHandle SHScriptEngine::onSceneNodeChildrenRemoved(SHEventPtr eventPtr) + { + auto eventData = reinterpret_cast*>(eventPtr.get()); + csSceneNodeChildrenChanged(eventData->data->parent->GetEntityID()); + return eventData->handle; + } + /*-----------------------------------------------------------------------------------*/ /* Helper Functions */ /*-----------------------------------------------------------------------------------*/ @@ -442,6 +471,12 @@ namespace SHADE DEFAULT_CSHARP_NAMESPACE + ".Collider", "OnCollisionShapeRemoved" ); + csSceneNodeChildrenChanged = dotNet.GetFunctionPtr + ( + DEFAULT_CSHARP_LIB_NAME, + DEFAULT_CSHARP_NAMESPACE + ".ChildListCache", + "OnChildrenChanged" + ); csEditorRenderScripts = dotNet.GetFunctionPtr ( DEFAULT_CSHARP_LIB_NAME, @@ -464,6 +499,7 @@ namespace SHADE void SHScriptEngine::registerEvents() { + /* Entity */ // Register for entity destroyed event std::shared_ptr> destroyedEventReceiver { @@ -471,26 +507,39 @@ namespace SHADE }; SHEventManager::SubscribeTo(SH_ENTITY_DESTROYED_EVENT, std::dynamic_pointer_cast(destroyedEventReceiver)); + /* Colliders */ // Register for collider added event std::shared_ptr> addedColliderEventReceiver { std::make_shared>(this, &SHScriptEngine::onColliderAdded) }; SHEventManager::SubscribeTo(SH_PHYSICS_COLLIDER_ADDED_EVENT, std::dynamic_pointer_cast(addedColliderEventReceiver)); - // Register for collider removed event std::shared_ptr> removedColliderEventReceiver { std::make_shared>(this, &SHScriptEngine::onColliderRemoved) }; SHEventManager::SubscribeTo(SH_PHYSICS_COLLIDER_REMOVED_EVENT, std::dynamic_pointer_cast(removedColliderEventReceiver)); - // Register for collider component removed event std::shared_ptr> removedColliderComponentEventReceiver { std::make_shared>(this, &SHScriptEngine::onColliderComponentRemoved) }; SHEventManager::SubscribeTo(SH_COMPONENT_REMOVED_EVENT, std::dynamic_pointer_cast(removedColliderComponentEventReceiver)); + + /* SceneGraph */ + // Register for SceneNode child added event + std::shared_ptr> addChildEventReceiver + { + std::make_shared>(this, &SHScriptEngine::onSceneNodeChildrenAdded) + }; + SHEventManager::SubscribeTo(SH_SCENEGRAPH_ADD_CHILD_EVENT, std::dynamic_pointer_cast(addChildEventReceiver)); + // Register for SceneNode child removed event + std::shared_ptr> removeChildEventReceiver + { + std::make_shared>(this, &SHScriptEngine::onSceneNodeChildrenRemoved) + }; + SHEventManager::SubscribeTo(SH_SCENEGRAPH_REMOVE_CHILD_EVENT, std::dynamic_pointer_cast(removeChildEventReceiver)); } void SHScriptEngine::dumpBuildLog(const std::string_view& buildLogPath) @@ -567,7 +616,7 @@ namespace SHADE auto err = GetLastError(); std::ostringstream oss; oss << "[ScriptEngine] Failed to launch process. Error code: " << std::hex << err - << " (" << SHStringUtils::GetWin32ErrorMessage(err) << ")"; + << " (" << SHStringUtilities::GetWin32ErrorMessage(err) << ")"; throw std::runtime_error(oss.str()); } @@ -581,7 +630,7 @@ namespace SHADE auto err = GetLastError(); std::ostringstream oss; oss << "[ScriptEngine] Failed to query process. Error code: " << std::hex << err - << " (" << SHStringUtils::GetWin32ErrorMessage(err) << ")"; + << " (" << SHStringUtilities::GetWin32ErrorMessage(err) << ")"; throw std::runtime_error(oss.str()); } @@ -598,7 +647,7 @@ namespace SHADE std::wstring SHScriptEngine::generateBuildCommand(bool debug) { std::wostringstream oss; - oss << "dotnet build \"" << SHStringUtils::StrToWstr(CSPROJ_PATH) << "\" -c "; + oss << "dotnet build \"" << SHStringUtilities::StrToWstr(CSPROJ_PATH) << "\" -c "; oss << debug ? "Debug" : "Release"; oss << " -o \"./tmp/\" -fl -flp:LogFile=build.log;Verbosity=quiet -r \"win-x64\""; return oss.str(); diff --git a/SHADE_Engine/src/Scripting/SHScriptEngine.h b/SHADE_Engine/src/Scripting/SHScriptEngine.h index 7d83606e..ef778627 100644 --- a/SHADE_Engine/src/Scripting/SHScriptEngine.h +++ b/SHADE_Engine/src/Scripting/SHScriptEngine.h @@ -267,6 +267,7 @@ namespace SHADE // - Events CsEventRelayFuncPtr csColliderOnListChanged = nullptr; CsEventRelayFuncPtr csColliderOnRemoved = nullptr; + CsEventRelayFuncPtr csSceneNodeChildrenChanged = nullptr; // - Editor CsScriptEditorFuncPtr csEditorRenderScripts = nullptr; CsFuncPtr csEditorUndo = nullptr; @@ -279,6 +280,8 @@ namespace SHADE SHEventHandle onColliderAdded(SHEventPtr eventPtr); SHEventHandle onColliderRemoved(SHEventPtr eventPtr); SHEventHandle onColliderComponentRemoved(SHEventPtr eventPtr); + SHEventHandle onSceneNodeChildrenAdded(SHEventPtr eventPtr); + SHEventHandle onSceneNodeChildrenRemoved(SHEventPtr eventPtr); /*-----------------------------------------------------------------------------*/ /* Helper Functions */ diff --git a/SHADE_Engine/src/Serialization/SHSerialization.cpp b/SHADE_Engine/src/Serialization/SHSerialization.cpp index f2829b95..6933fbb5 100644 --- a/SHADE_Engine/src/Serialization/SHSerialization.cpp +++ b/SHADE_Engine/src/Serialization/SHSerialization.cpp @@ -14,7 +14,7 @@ #include "Camera/SHCameraComponent.h" #include "Graphics/MiddleEnd/Interface/SHRenderable.h" #include "Math/Transform/SHTransformComponent.h" -#include "Physics/Components/SHRigidBodyComponent.h" +#include "Physics/Interface/SHRigidBodyComponent.h" #include "ECS_Base/Managers/SHSystemManager.h" #include "Graphics/MiddleEnd/Lights/SHLightComponent.h" #include "Scripting/SHScriptEngine.h" @@ -61,20 +61,21 @@ namespace SHADE out << YAML::EndSeq; } - static EntityID DeserializeEntity(YAML::iterator& it, YAML::Node const& node, std::vector& createdEntities, EntityID parentEID = MAX_EID) + static EntityID DeserializeEntity(YAML::iterator& it, YAML::Node const& node, SHSerialization::CreatedEntitiesList& createdEntities, EntityID parentEID = MAX_EID) { - EntityID eid = MAX_EID; + EntityID eid{MAX_EID}, oldEID{MAX_EID}; if (!node) return eid; if (node[EIDNode]) - eid = node[EIDNode].as(); - std::string name = "Default"; + oldEID = eid = node[EIDNode].as(); + std::string name = "UnnamedEntitiy"; if (node[EntityNameNode]) name = node[EntityNameNode].as(); //Compile component IDs const auto componentIDList = SHSerialization::GetComponentIDList(node[ComponentsNode]); eid = SHEntityManager::CreateEntity(componentIDList, eid, name, parentEID); - createdEntities.push_back(eid); + createdEntities[oldEID] = eid; + //createdEntities.push_back(eid); if (node[NumberOfChildrenNode]) { if (const int numOfChildren = node[NumberOfChildrenNode].as(); numOfChildren > 0) @@ -106,7 +107,7 @@ namespace SHADE return NewSceneName.data(); } YAML::Node entities = YAML::Load(assetData->data); - std::vector createdEntities{}; + CreatedEntitiesList createdEntities{}; //Create Entities for (auto it = entities.begin(); it != entities.end(); ++it) @@ -122,14 +123,14 @@ namespace SHADE AssetQueue assetQueue; for (auto it = entities.begin(); it != entities.end(); ++it) { - SHSerializationHelper::FetchAssetsFromComponent((*it)[ComponentsNode], *entityVecIt, assetQueue); + SHSerializationHelper::FetchAssetsFromComponent((*it)[ComponentsNode], createdEntities[(*it)[EIDNode].as()], assetQueue); } LoadAssetsFromAssetQueue(assetQueue); //Initialize Entity entityVecIt = createdEntities.begin(); for (auto it = entities.begin(); it != entities.end(); ++it) { - InitializeEntity(*it, *entityVecIt++); + InitializeEntity(*it, createdEntities[(*it)[EIDNode].as()]); } return assetData->name; @@ -160,9 +161,9 @@ namespace SHADE return std::string(out.c_str()); } - void SHSerialization::SerializeEntityToFile(std::filesystem::path const& path) - { - } + //void SHSerialization::SerializeEntityToFile(std::filesystem::path const& path) + //{ + //} template, bool> = true> static void AddComponentToComponentNode(YAML::Node& componentsNode, EntityID const& eid) @@ -178,7 +179,9 @@ namespace SHADE { if (ComponentType* component = SHComponentManager::GetComponent_s(eid)) { - componentsNode[rttr::type::get().get_name().data()] = YAML::convert::encode(*component); + auto componentNode = YAML::convert::encode(*component); + componentNode[IsActive.data()] = component->isActive; + componentsNode[rttr::type::get().get_name().data()] = componentNode; } } @@ -218,13 +221,13 @@ namespace SHADE return node; } - EntityID SHSerialization::DeserializeEntitiesFromString(std::string const& data, EntityID const& parentEID) noexcept + SHSerialization::CreatedEntitiesList SHSerialization::DeserializeEntitiesFromString(std::string const& data, EntityID const& parentEID) noexcept { if (data.empty()) - return MAX_EID; + return {}; YAML::Node entities = YAML::Load(data.c_str()); EntityID eid{ MAX_EID }; - std::vector createdEntities; + CreatedEntitiesList createdEntities{}; for (auto it = entities.begin(); it != entities.end(); ++it) { eid = DeserializeEntity(it, *it, createdEntities, parentEID); @@ -232,14 +235,14 @@ namespace SHADE if (createdEntities.empty()) { SHLOG_ERROR("Failed to create entities from deserializaiton") - return MAX_EID; + return createdEntities; } - auto entityVecIt = createdEntities.begin(); + //auto entityVecIt = createdEntities.begin(); for (auto it = entities.begin(); it != entities.end(); ++it) { - InitializeEntity(*it, *entityVecIt++); + InitializeEntity(*it, createdEntities[(*it)[EIDNode].as()]); } - return eid; + return createdEntities; } template, bool> = true> @@ -290,6 +293,41 @@ namespace SHADE SHResourceManager::FinaliseChanges(); } + void ResolveSerializedEntityID(YAML::Emitter& out, YAML::iterator& it, YAML::Node const& entityNode, SHSerialization::CreatedEntitiesList const& createdEntities) + { + EntityID eid = entityNode[EIDNode].as(); + YAML::Node resolvedNode = entityNode; + resolvedNode[EIDNode] = createdEntities.at(eid); + out << resolvedNode; + if (entityNode[NumberOfChildrenNode]) + { + if (const int numOfChildren = entityNode[NumberOfChildrenNode].as(); numOfChildren > 0) + { + ++it; + for (int i = 0; i < numOfChildren; ++i) + { + ResolveSerializedEntityID(out, it, (*it), createdEntities); + //DeserializeEntity(it, (*it), createdEntities, eid); + if ((i + 1) < numOfChildren) + ++it; + } + } + } + } + + std::string SHSerialization::ResolveSerializedEntityIndices(std::string serializedEntityData, CreatedEntitiesList const& createdEntities) noexcept + { + YAML::Node entities = YAML::Load(serializedEntityData); + YAML::Emitter out; + out << YAML::BeginSeq; + for (auto it = entities.begin(); it != entities.end(); ++it) + { + ResolveSerializedEntityID(out, it, (*it), createdEntities); + } + out << YAML::EndSeq; + return out.c_str(); + } + void SHSerialization::InitializeEntity(YAML::Node const& entityNode, EntityID const& eid) { auto const componentsNode = entityNode[ComponentsNode]; diff --git a/SHADE_Engine/src/Serialization/SHSerialization.h b/SHADE_Engine/src/Serialization/SHSerialization.h index 3cb268f2..dd487662 100644 --- a/SHADE_Engine/src/Serialization/SHSerialization.h +++ b/SHADE_Engine/src/Serialization/SHSerialization.h @@ -2,7 +2,6 @@ #include "SH_API.h" #include -#include #include "ECS_Base/SHECSMacros.h" @@ -26,8 +25,12 @@ namespace SHADE constexpr const char* NumberOfChildrenNode = "NumberOfChildren"; constexpr const char* ScriptsNode = "Scripts"; - struct SH_API SHSerialization + class SH_API SHSerialization { + public: + //Original EID : New EID + using CreatedEntitiesList = std::unordered_map; + static bool SerializeSceneToFile(AssetID const& sceneAssetID); static std::string SerializeSceneToString(); static void SerializeSceneToEmitter(YAML::Emitter& out); @@ -38,15 +41,18 @@ namespace SHADE static void EmitEntity(SHSceneNode* entityNode, YAML::Emitter& out); static std::string SerializeEntitiesToString(std::vector const& entities) noexcept; - static void SerializeEntityToFile(std::filesystem::path const& path); + //static void SerializeEntityToFile(std::filesystem::path const& path); static YAML::Node SerializeEntityToNode(SHSceneNode* sceneNode); - static EntityID DeserializeEntitiesFromString(std::string const& data, EntityID const& parentEID = MAX_EID) noexcept; + static CreatedEntitiesList DeserializeEntitiesFromString(std::string const& data, EntityID const& parentEID = MAX_EID) noexcept; static std::vector GetComponentIDList(YAML::Node const& componentsNode); static void LoadAssetsFromAssetQueue(std::unordered_map& assetQueue); + + static std::string ResolveSerializedEntityIndices(std::string serializedEntityData, CreatedEntitiesList const& createdEntities) noexcept; private: + //static void ResolveSerializedEntityID(YAML::Emitter& out, YAML::iterator& it, YAML::Node const& entityNode, CreatedEntitiesList const& createdEntities); static void InitializeEntity(YAML::Node const& entityNode, EntityID const& eid); static constexpr std::string_view NewSceneName = "New Scene"; diff --git a/SHADE_Engine/src/Serialization/SHSerializationHelper.hpp b/SHADE_Engine/src/Serialization/SHSerializationHelper.hpp index b062b348..b560acae 100644 --- a/SHADE_Engine/src/Serialization/SHSerializationHelper.hpp +++ b/SHADE_Engine/src/Serialization/SHSerializationHelper.hpp @@ -9,11 +9,13 @@ #include "ECS_Base/Managers/SHComponentManager.h" #include "Graphics/MiddleEnd/Materials/SHMaterialSpec.h" -#include "Tools/SHLog.h" +#include "Tools/Logger/SHLog.h" namespace SHADE { + static constexpr std::string_view IsActive = "IsActive"; + using AssetQueue = std::unordered_map; struct SHSerializationHelper { @@ -118,9 +120,9 @@ namespace SHADE YAML::Node node{}; if (!component) return node; - auto componentType = rttr::type::get(); node = RTTRToNode(*component); + node[IsActive.data()] = component->isActive; return node; } @@ -198,6 +200,9 @@ namespace SHADE auto componentNode = componentsNode[rttrType.get_name().data()]; if (!componentNode.IsDefined()) return; + if(componentNode[IsActive.data()].IsDefined()) + component->isActive = componentNode[IsActive.data()].as(); + auto properties = rttrType.get_properties(); for (auto const& prop : properties) { @@ -227,8 +232,10 @@ namespace SHADE auto component = SHComponentManager::GetComponent_s(eid); if (componentsNode.IsNull() && !component) return; - - YAML::convert::decode(GetComponentNode(componentsNode, eid), *component); + auto componentNode = GetComponentNode(componentsNode, eid); + if (componentNode[IsActive.data()].IsDefined()) + component->isActive = componentNode[IsActive.data()].as(); + YAML::convert::decode(componentNode, *component); } template , bool> = true> diff --git a/SHADE_Engine/src/Serialization/SHYAMLConverters.h b/SHADE_Engine/src/Serialization/SHYAMLConverters.h index 1b93c63a..d66a7506 100644 --- a/SHADE_Engine/src/Serialization/SHYAMLConverters.h +++ b/SHADE_Engine/src/Serialization/SHYAMLConverters.h @@ -1,9 +1,9 @@ #pragma once #include "Graphics/MiddleEnd/Interface/SHRenderable.h" #include "Graphics/MiddleEnd/Materials/SHMaterialSpec.h" -#include "Math/Geometry/SHBoundingBox.h" -#include "Math/Geometry/SHBoundingSphere.h" -#include "Physics/SHCollisionShape.h" +#include "Math/Geometry/SHBox.h" +#include "Math/Geometry/SHSphere.h" +#include "Physics/Interface/SHCollisionShape.h" #include "Resource/SHResourceManager.h" #include "Math/Vector/SHVec2.h" #include "Math/Vector/SHVec3.h" @@ -11,7 +11,7 @@ #include "Graphics/MiddleEnd/Interface/SHMaterial.h" #include "Graphics/MiddleEnd/Interface/SHMaterialInstance.h" #include "SHSerializationTools.h" -#include "Physics/Components/SHColliderComponent.h" +#include "Physics/Interface/SHColliderComponent.h" namespace YAML { using namespace SHADE; @@ -130,14 +130,14 @@ namespace YAML { case SHCollisionShape::Type::BOX: { - auto const bb = reinterpret_cast(rhs.GetShape()); - node[HalfExtents] = bb->GetRelativeExtents(); + const auto* BOX = reinterpret_cast(rhs.GetShape()); + node[HalfExtents] = BOX->GetRelativeExtents(); } break; case SHCollisionShape::Type::SPHERE: { - auto const bs = reinterpret_cast(rhs.GetShape()); - node[Radius] = bs->GetRelativeRadius(); + const auto* SPHERE = reinterpret_cast(rhs.GetShape()); + node[Radius] = SPHERE->GetRelativeRadius(); } break; case SHCollisionShape::Type::CAPSULE: break; @@ -288,7 +288,15 @@ namespace YAML { YAML::Node node; node[MESH_YAML_TAG.data()] = SHResourceManager::GetAssetID(rhs.GetMesh()).value_or(0); - node[MAT_YAML_TAG.data()] = SHResourceManager::GetAssetID(rhs.GetMaterial()->GetBaseMaterial()).value_or(0); + auto mat = rhs.GetMaterial(); + if (mat) + { + node[MAT_YAML_TAG.data()] = SHResourceManager::GetAssetID(rhs.GetMaterial()->GetBaseMaterial()).value_or(0); + } + else + { + node[MAT_YAML_TAG.data()] = 0; + } return node; } static bool decode(YAML::Node const& node, SHRenderable& rhs) diff --git a/SHADE_Engine/src/Tools/SHLog.cpp b/SHADE_Engine/src/Tools/Logger/SHLog.cpp similarity index 93% rename from SHADE_Engine/src/Tools/SHLog.cpp rename to SHADE_Engine/src/Tools/Logger/SHLog.cpp index 30a79338..139a731e 100644 --- a/SHADE_Engine/src/Tools/SHLog.cpp +++ b/SHADE_Engine/src/Tools/Logger/SHLog.cpp @@ -44,13 +44,6 @@ namespace SHADE SHLOG_FLOOR() } -#ifdef _DEBUG - void SHLog::Trace(const std::string& msg) noexcept - { - SHLOG_TRACE(msg) - } -#endif - void SHLog_Info(const char* msg) noexcept { SHLOG_INFO(msg) diff --git a/SHADE_Engine/src/Tools/SHLog.h b/SHADE_Engine/src/Tools/Logger/SHLog.h similarity index 100% rename from SHADE_Engine/src/Tools/SHLog.h rename to SHADE_Engine/src/Tools/Logger/SHLog.h diff --git a/SHADE_Engine/src/Tools/SHLogger.cpp b/SHADE_Engine/src/Tools/Logger/SHLogger.cpp similarity index 95% rename from SHADE_Engine/src/Tools/SHLogger.cpp rename to SHADE_Engine/src/Tools/Logger/SHLogger.cpp index 9c1e76fc..72791eb1 100644 --- a/SHADE_Engine/src/Tools/SHLogger.cpp +++ b/SHADE_Engine/src/Tools/Logger/SHLogger.cpp @@ -323,34 +323,6 @@ namespace SHADE SHLOG_FLOOR() } - #ifdef _DEBUG - void SHLogger::LogTrace(const std::string& msg) noexcept - { - SHLOG_TRACE(msg) - } - - void SHLogger::LogVerboseTrace(const std::string& msg, const std::source_location& src) noexcept - { - const bool SHOW_SRC_FILE = configFlags & (1U << 3); - const bool SHOW_SRC_LINE = configFlags & (1U << 4); - - std::stringstream ss; - ss << "["; - if (SHOW_SRC_FILE) - { - ss << std::filesystem::path(src.file_name()).filename().string() << ", "; - if (SHOW_SRC_LINE) - { - ss << src.line() << ", "; - } - } - - ss << src.function_name() << "] " << msg; - - SHLOG_TRACE(ss.str()) - } - #endif - /*-----------------------------------------------------------------------------------*/ /* Private Function Member Definitions */ /*-----------------------------------------------------------------------------------*/ diff --git a/SHADE_Engine/src/Tools/SHLogger.h b/SHADE_Engine/src/Tools/Logger/SHLogger.h similarity index 88% rename from SHADE_Engine/src/Tools/SHLogger.h rename to SHADE_Engine/src/Tools/Logger/SHLogger.h index e4a4928c..1a14df9c 100644 --- a/SHADE_Engine/src/Tools/SHLogger.h +++ b/SHADE_Engine/src/Tools/Logger/SHLogger.h @@ -177,8 +177,34 @@ namespace SHADE /*-------------------------------------------------------------------------------------*/ #ifdef _DEBUG - #define SHLOG_TRACE(format, ...) SHADE::SHLogger::UseTrivialPattern(); SPDLOG_LOGGER_TRACE(spdlog::get(SHLOGGER_NAME), format, ## __VA_ARGS__); - #define SHLOGV_TRACE(format, ...) SHADE::SHLogger::UseVerbosePattern(); SPDLOG_LOGGER_TRACE(spdlog::get(SHLOGGER_NAME), format, ## __VA_ARGS__); + + #define SHLOG_INFO_D(format, ...) SHADE::SHLogger::UseTrivialPattern(); SPDLOG_LOGGER_INFO(spdlog::get(SHLOGGER_NAME), format, ## __VA_ARGS__); + #define SHLOGV_INFO_D(format, ...) SHADE::SHLogger::UseVerbosePattern(); SPDLOG_LOGGER_INFO(spdlog::get(SHLOGGER_NAME), format, ## __VA_ARGS__); + + #define SHLOG_WARNING_D(format, ...) SHADE::SHLogger::UseTrivialPattern(); SPDLOG_LOGGER_WARN(spdlog::get(SHLOGGER_NAME), format, ## __VA_ARGS__); + #define SHLOGV_WARNING_D(format, ...) SHADE::SHLogger::UseVerbosePattern(); SPDLOG_LOGGER_WARN(spdlog::get(SHLOGGER_NAME), format, ## __VA_ARGS__); + + #define SHLOG_ERROR_D(format, ...) SHADE::SHLogger::UseTrivialPattern(); SPDLOG_LOGGER_ERROR(spdlog::get(SHLOGGER_NAME), format, ## __VA_ARGS__); + #define SHLOGV_ERROR_D(format, ...) SHADE::SHLogger::UseVerbosePattern(); SPDLOG_LOGGER_ERROR(spdlog::get(SHLOGGER_NAME), format, ## __VA_ARGS__); + + #define SHLOG_CRITICAL_D(format, ...) SHADE::SHLogger::UseTrivialPattern(); SPDLOG_LOGGER_CRITICAL(spdlog::get(SHLOGGER_NAME), format, ## __VA_ARGS__); + #define SHLOGV_CRITICAL_D(format, ...) SHADE::SHLogger::UseVerbosePattern(); SPDLOG_LOGGER_CRITICAL(spdlog::get(SHLOGGER_NAME), format, ## __VA_ARGS__); + +#else + + #define SHLOG_INFO_D(format, ...) + #define SHLOGV_INFO_D(format, ...) + + #define SHLOG_WARNING_D(format, ...) + #define SHLOGV_WARNING_D(format, ...) + + #define SHLOG_ERROR_D(format, ...) + #define SHLOGV_ERROR_D(format, ...) + + #define SHLOG_CRITICAL_D(format, ...) + #define SHLOGV_CRITICAL_D(format, ...) + + #endif #define SHLOG_INFO(format, ...) SHADE::SHLogger::UseTrivialPattern(); SPDLOG_LOGGER_INFO(spdlog::get(SHLOGGER_NAME), format, ## __VA_ARGS__); diff --git a/SHADE_Engine/src/Tools/SHDeque.h b/SHADE_Engine/src/Tools/SHDeque.h new file mode 100644 index 00000000..99df910a --- /dev/null +++ b/SHADE_Engine/src/Tools/SHDeque.h @@ -0,0 +1,69 @@ +#pragma once +#pragma once + +#include "SH_API.h" +#include + +namespace SHADE +{ + template + class SH_API SHDeque + { + public: + using ValueType = T; + using Pointer = T*; + using ValueRef = T&; + using ValueConstRef = T const&; + using SizeType = uint32_t; + using ContainerType = std::deque; + using ContainerTypeConstRef = std::deque; + + SHDeque(SizeType n) : max_size(n) {} + + ContainerTypeConstRef const& GetDeque() const + { + return deque; + } + + void Push(ValueConstRef obj) + { + if (deque.size() < max_size) + deque.push_front(std::move(obj)); + else + { + deque.pop_back(); + deque.push_front(std::move(obj)); + } + } + + bool Empty() + { + return deque.empty(); + } + + void Pop() + { + deque.pop_front(); + } + + ValueConstRef Top() + { + return deque.front(); + } + + SizeType Size() const noexcept + { + return deque.size(); + } + + void Clear() + { + deque.clear(); + } + + private: + int max_size; + ContainerType deque{}; + + }; +} \ No newline at end of file diff --git a/SHADE_Engine/src/Tools/SHException.h b/SHADE_Engine/src/Tools/SHException.h index 2e0b82a9..ac6a11b7 100644 --- a/SHADE_Engine/src/Tools/SHException.h +++ b/SHADE_Engine/src/Tools/SHException.h @@ -18,7 +18,7 @@ #include // Project Headers -#include "SHLogger.h" +#include "Logger/SHLogger.h" namespace SHADE { diff --git a/SHADE_Engine/src/Tools/SHExceptionHandler.cpp b/SHADE_Engine/src/Tools/SHExceptionHandler.cpp index ff6df05c..a4892321 100644 --- a/SHADE_Engine/src/Tools/SHExceptionHandler.cpp +++ b/SHADE_Engine/src/Tools/SHExceptionHandler.cpp @@ -12,10 +12,8 @@ // Primary Header #include "SHExceptionHandler.h" - // Project Headers #include "SHException.h" -#include "SHLogger.h" namespace SHADE { diff --git a/SHADE_Engine/src/Tools/SHClipboardUtilities.cpp b/SHADE_Engine/src/Tools/Utilities/SHClipboardUtilities.cpp similarity index 100% rename from SHADE_Engine/src/Tools/SHClipboardUtilities.cpp rename to SHADE_Engine/src/Tools/Utilities/SHClipboardUtilities.cpp diff --git a/SHADE_Engine/src/Tools/SHClipboardUtilities.h b/SHADE_Engine/src/Tools/Utilities/SHClipboardUtilities.h similarity index 100% rename from SHADE_Engine/src/Tools/SHClipboardUtilities.h rename to SHADE_Engine/src/Tools/Utilities/SHClipboardUtilities.h diff --git a/SHADE_Engine/src/Tools/SHFileUtilties.cpp b/SHADE_Engine/src/Tools/Utilities/SHFileUtilties.cpp similarity index 100% rename from SHADE_Engine/src/Tools/SHFileUtilties.cpp rename to SHADE_Engine/src/Tools/Utilities/SHFileUtilties.cpp diff --git a/SHADE_Engine/src/Tools/SHFileUtilties.h b/SHADE_Engine/src/Tools/Utilities/SHFileUtilties.h similarity index 100% rename from SHADE_Engine/src/Tools/SHFileUtilties.h rename to SHADE_Engine/src/Tools/Utilities/SHFileUtilties.h diff --git a/SHADE_Engine/src/Tools/SHStringUtils.cpp b/SHADE_Engine/src/Tools/Utilities/SHStringUtilities.cpp similarity index 79% rename from SHADE_Engine/src/Tools/SHStringUtils.cpp rename to SHADE_Engine/src/Tools/Utilities/SHStringUtilities.cpp index a2594888..b1e4aa92 100644 --- a/SHADE_Engine/src/Tools/SHStringUtils.cpp +++ b/SHADE_Engine/src/Tools/Utilities/SHStringUtilities.cpp @@ -1,5 +1,5 @@ /************************************************************************************//*! -\file StringUtilities.cpp +\file SHStringUtilities.cpp \author Tng Kah Wei, kahwei.tng, 390009620 \par email: kahwei.tng\@digipen.edu \date Nov 29, 2021 @@ -12,22 +12,22 @@ of DigiPen Institute of Technology is prohibited. // Precompiled Header #include // Primary Header -#include "SHStringUtils.h" +#include "SHStringUtilities.h" namespace SHADE { /*---------------------------------------------------------------------------------*/ /* Utility Functions */ /*---------------------------------------------------------------------------------*/ - std::vector SHStringUtils::Split(const std::string& str, const char& delim) + std::vector SHStringUtilities::Split(const std::string& str, const char& delim) { return Split(str, delim); } - std::vector SHStringUtils::Split(const std::wstring& str, const wchar_t& delim) + std::vector SHStringUtilities::Split(const std::wstring& str, const wchar_t& delim) { return Split(str, delim); } - std::string SHStringUtils::WstrToStr(const std::wstring& wstr) + std::string SHStringUtilities::WstrToStr(const std::wstring& wstr) { static std::vector buffer; const int STR_SIZE = WideCharToMultiByte(CP_UTF8, 0, wstr.data(), static_cast(wstr.size()), nullptr, 0, nullptr, nullptr) + 1 /* Null Terminator */; @@ -35,7 +35,7 @@ namespace SHADE WideCharToMultiByte(CP_UTF8, 0, wstr.data(), static_cast(wstr.size()), buffer.data(), MAX_PATH, nullptr, nullptr); return std::string(buffer.data()); } - std::wstring SHStringUtils::StrToWstr(const std::string& str) + std::wstring SHStringUtilities::StrToWstr(const std::string& str) { static std::vector buffer; const int WSTR_SIZE = MultiByteToWideChar(CP_UTF8, 0, str.data(), static_cast(str.size()), nullptr, 0) + 1 /* Null Terminator */; @@ -44,7 +44,7 @@ namespace SHADE return std::wstring(buffer.data()); } - std::string SHStringUtils::GetWin32ErrorMessage(unsigned long errorCode) + std::string SHStringUtilities::GetWin32ErrorMessage(unsigned long errorCode) { return std::system_category().message(errorCode); } diff --git a/SHADE_Engine/src/Tools/SHStringUtils.h b/SHADE_Engine/src/Tools/Utilities/SHStringUtilities.h similarity index 96% rename from SHADE_Engine/src/Tools/SHStringUtils.h rename to SHADE_Engine/src/Tools/Utilities/SHStringUtilities.h index 1c895b99..bac83b07 100644 --- a/SHADE_Engine/src/Tools/SHStringUtils.h +++ b/SHADE_Engine/src/Tools/Utilities/SHStringUtilities.h @@ -1,5 +1,5 @@ /************************************************************************************//*! -\file StringUtilities.h +\file SHStringUtilities.h \author Tng Kah Wei, kahwei.tng, 390009620 \par email: kahwei.tng\@digipen.edu \date Nov 29, 2021 @@ -19,7 +19,7 @@ namespace SHADE /// /// Contains useful functions for operating on strings. /// - class SHStringUtils + class SHStringUtilities { public: /*-----------------------------------------------------------------------------*/ @@ -74,8 +74,8 @@ namespace SHADE /*-------------------------------------------------------------------------------*/ /* Constructors/Destructors */ /*-------------------------------------------------------------------------------*/ - SHStringUtils() = delete; + SHStringUtilities() = delete; }; } -#include "SHStringUtils.hpp" +#include "SHStringUtilities.hpp" diff --git a/SHADE_Engine/src/Tools/SHStringUtils.hpp b/SHADE_Engine/src/Tools/Utilities/SHStringUtilities.hpp similarity index 89% rename from SHADE_Engine/src/Tools/SHStringUtils.hpp rename to SHADE_Engine/src/Tools/Utilities/SHStringUtilities.hpp index 8b83187a..2e29c684 100644 --- a/SHADE_Engine/src/Tools/SHStringUtils.hpp +++ b/SHADE_Engine/src/Tools/Utilities/SHStringUtilities.hpp @@ -1,5 +1,5 @@ /************************************************************************************//*! -\file StringUtilities.hpp +\file SHStringUtilities.hpp \author Tng Kah Wei, kahwei.tng, 390009620 \par email: kahwei.tng\@digipen.edu \date Nov 29, 2021 @@ -12,7 +12,7 @@ of DigiPen Institute of Technology is prohibited. *//*************************************************************************************/ #pragma once // Primary Header -#include "SHStringUtils.h" +#include "SHStringUtilities.h" namespace SHADE { @@ -20,7 +20,7 @@ namespace SHADE /* Template Function Definitions */ /*-------------------------------------------------------------------------------*/ template - inline std::vector> SHStringUtils::Split(const std::basic_string& str, const T& delim) + inline std::vector> SHStringUtilities::Split(const std::basic_string& str, const T& delim) { std::vector> results; std::basic_string remaining = str; diff --git a/SHADE_Engine/src/Tools/SHUtilities.h b/SHADE_Engine/src/Tools/Utilities/SHUtilities.h similarity index 82% rename from SHADE_Engine/src/Tools/SHUtilities.h rename to SHADE_Engine/src/Tools/Utilities/SHUtilities.h index 287a827e..6cdd91ee 100644 --- a/SHADE_Engine/src/Tools/SHUtilities.h +++ b/SHADE_Engine/src/Tools/Utilities/SHUtilities.h @@ -35,22 +35,12 @@ namespace SHADE /** * @brief Converts an enum class member from it's type to any other type. * @tparam InputType Restricted to an enum class - * @tparam OutputType The type to convert the enum class member to. Defaults to int. + * @tparam OutputType The type to convert the enum class member to. Defaults to the underlying type. * @param[in] enumClassMember A member of the specified enum class. * @returns The value of the enum class member in the output type. */ template > static constexpr OutputType ConvertEnum(InputType enumClassMember) noexcept; - - /** - * @brief Converts an enum class member from it's type to the underlying type. - * @tparam Enum Restricted to an enum class - * @param[in] value A member of the specified enum class. - * @returns The value of the enum class member in the output type. - */ - template - static constexpr typename std::underlying_type_t ToUnderlying (Enum value) noexcept; - }; } // namespace SHADE diff --git a/SHADE_Engine/src/Tools/SHUtilities.hpp b/SHADE_Engine/src/Tools/Utilities/SHUtilities.hpp similarity index 83% rename from SHADE_Engine/src/Tools/SHUtilities.hpp rename to SHADE_Engine/src/Tools/Utilities/SHUtilities.hpp index e0404ea1..3f0668a2 100644 --- a/SHADE_Engine/src/Tools/SHUtilities.hpp +++ b/SHADE_Engine/src/Tools/Utilities/SHUtilities.hpp @@ -24,11 +24,4 @@ namespace SHADE { return static_cast(enumClassMember); } - - template - constexpr typename std::underlying_type_t SHUtilities::ToUnderlying(Enum value) noexcept - { - return static_cast>(value); - } - } // namespace SHADE \ No newline at end of file diff --git a/SHADE_Engine/src/UI/SHCanvasComponent.h b/SHADE_Engine/src/UI/SHCanvasComponent.h new file mode 100644 index 00000000..2e9a54f1 --- /dev/null +++ b/SHADE_Engine/src/UI/SHCanvasComponent.h @@ -0,0 +1,35 @@ +#pragma once + +#include "SH_API.h" +#include "ECS_Base/Components/SHComponent.h" + + +namespace SHADE +{ + + class SH_API SHCanvasComponent final: public SHComponent + { + using CanvasSizeType = uint32_t; + + + public: + SHCanvasComponent(); + ~SHCanvasComponent() = default; + + void SetCanvasSize(CanvasSizeType width, CanvasSizeType height) noexcept; + void SetCanvasWidth(CanvasSizeType width) noexcept; + void SetCanvasHeight(CanvasSizeType height) noexcept; + + CanvasSizeType const GetCanvasWidth() const noexcept; + CanvasSizeType const GetCanvasHeight() const noexcept; + + private: + CanvasSizeType width; + CanvasSizeType height; + + + + }; + + +} \ No newline at end of file diff --git a/SHADE_Managed/premake5.lua b/SHADE_Managed/premake5.lua index 88021071..64f6e23e 100644 --- a/SHADE_Managed/premake5.lua +++ b/SHADE_Managed/premake5.lua @@ -75,7 +75,8 @@ project "SHADE_Managed" disablewarnings { - "4275" + "4275", + "4635" } @@ -102,3 +103,15 @@ project "SHADE_Managed" optimize "On" defines{"_RELEASE"} links{"librttr_core.lib"} + + require "vstudio" + + function docsElementCPP(cfg) + _p(3,'true') + end + + premake.override(premake.vstudio.vc2010.elements, "clCompile", function (oldfn, cfg) + return table.join(oldfn(cfg), { + docsElementCPP, + }) + end) \ No newline at end of file diff --git a/SHADE_Managed/src/Components/Collider.cxx b/SHADE_Managed/src/Components/Collider.cxx index 0e916b7b..1a53f9e1 100644 --- a/SHADE_Managed/src/Components/Collider.cxx +++ b/SHADE_Managed/src/Components/Collider.cxx @@ -47,35 +47,35 @@ namespace SHADE /*---------------------------------------------------------------------------------*/ Vector3 BoxCollider::Center::get() { - return Convert::ToCLI(getNativeBoundObject().GetCenter()); + return Convert::ToCLI(getNativeBoundObject().GetCenter()); } void BoxCollider::Center::set(Vector3 value) { - getNativeBoundObject().SetCenter(Convert::ToNative(value)); + getNativeBoundObject().SetCenter(Convert::ToNative(value)); } Vector3 BoxCollider::HalfExtents::get() { - return Convert::ToCLI(getNativeBoundObject().GetWorldExtents()); + return Convert::ToCLI(getNativeBoundObject().GetWorldExtents()); } void BoxCollider::HalfExtents::set(Vector3 value) { - getNativeBoundObject().SetWorldExtents(Convert::ToNative(value)); + getNativeBoundObject().SetWorldExtents(Convert::ToNative(value)); } Vector3 BoxCollider::Min::get() { - return Convert::ToCLI(getNativeBoundObject().GetMin()); + return Convert::ToCLI(getNativeBoundObject().GetMin()); } void BoxCollider::Min::set(Vector3 value) { - getNativeBoundObject().SetMin(Convert::ToNative(value)); + getNativeBoundObject().SetMin(Convert::ToNative(value)); } Vector3 BoxCollider::Max::get() { - return Convert::ToCLI(getNativeBoundObject().GetMax()); + return Convert::ToCLI(getNativeBoundObject().GetMax()); } void BoxCollider::Max::set(Vector3 value) { - getNativeBoundObject().SetMax(Convert::ToNative(value)); + getNativeBoundObject().SetMax(Convert::ToNative(value)); } /*---------------------------------------------------------------------------------*/ @@ -83,11 +83,11 @@ namespace SHADE /*---------------------------------------------------------------------------------*/ bool BoxCollider::TestPoint(Vector3 point) { - return getNativeBoundObject().TestPoint(Convert::ToNative(point)); + return getNativeBoundObject().TestPoint(Convert::ToNative(point)); } bool BoxCollider::Raycast(Ray ray, float maxDistance) { - return getNativeBoundObject().Raycast(Convert::ToNative(ray), maxDistance); + return getNativeBoundObject().Raycast(Convert::ToNative(ray), maxDistance); } /*---------------------------------------------------------------------------------*/ @@ -95,19 +95,19 @@ namespace SHADE /*---------------------------------------------------------------------------------*/ Vector3 SphereCollider::Center::get() { - return Convert::ToCLI(getNativeBoundObject().GetCenter()); + return Convert::ToCLI(getNativeBoundObject().GetCenter()); } void SphereCollider::Center::set(Vector3 value) { - getNativeBoundObject().SetCenter(Convert::ToNative(value)); + getNativeBoundObject().SetCenter(Convert::ToNative(value)); } float SphereCollider::Radius::get() { - return getNativeBoundObject().GetWorldRadius(); + return getNativeBoundObject().GetWorldRadius(); } void SphereCollider::Radius::set(float value) { - getNativeBoundObject().SetWorldRadius(value); + getNativeBoundObject().SetWorldRadius(value); } /*---------------------------------------------------------------------------------*/ @@ -115,11 +115,11 @@ namespace SHADE /*---------------------------------------------------------------------------------*/ bool SphereCollider::TestPoint(Vector3 point) { - return getNativeBoundObject().TestPoint(Convert::ToNative(point)); + return getNativeBoundObject().TestPoint(Convert::ToNative(point)); } bool SphereCollider::Raycast(Ray ray, float maxDistance) { - return getNativeBoundObject().Raycast(Convert::ToNative(ray), maxDistance); + return getNativeBoundObject().Raycast(Convert::ToNative(ray), maxDistance); } /*---------------------------------------------------------------------------------*/ diff --git a/SHADE_Managed/src/Components/Collider.hxx b/SHADE_Managed/src/Components/Collider.hxx index dc17ae7f..1711e8b9 100644 --- a/SHADE_Managed/src/Components/Collider.hxx +++ b/SHADE_Managed/src/Components/Collider.hxx @@ -15,7 +15,7 @@ of DigiPen Institute of Technology is prohibited. #pragma once // External Dependencies -#include "Physics/Components/SHColliderComponent.h" +#include "Physics/Interface/SHColliderComponent.h" // Project Includes #include "Components/Component.hxx" #include "Math/Vector3.hxx" diff --git a/SHADE_Managed/src/Components/Component.hxx b/SHADE_Managed/src/Components/Component.hxx index e52ab3a7..a1d83eaf 100644 --- a/SHADE_Managed/src/Components/Component.hxx +++ b/SHADE_Managed/src/Components/Component.hxx @@ -110,7 +110,7 @@ namespace SHADE /// Component to check. static operator bool(BaseComponent^ c); - protected: + internal: /*-----------------------------------------------------------------------------*/ /* Constructors */ /*-----------------------------------------------------------------------------*/ @@ -193,7 +193,6 @@ namespace SHADE /// NativeComponent* GetNativeComponent(); - protected: /*-----------------------------------------------------------------------------*/ /* Constructors */ /*-----------------------------------------------------------------------------*/ diff --git a/SHADE_Managed/src/Components/RigidBody.cxx b/SHADE_Managed/src/Components/RigidBody.cxx index 12861600..cdaa296a 100644 --- a/SHADE_Managed/src/Components/RigidBody.cxx +++ b/SHADE_Managed/src/Components/RigidBody.cxx @@ -189,7 +189,17 @@ namespace SHADE { GetNativeComponent()->AddRelativeForceAtWorldPos(Convert::ToNative(relativeForce), Convert::ToNative(worldPos)); } - + + Vector3 RigidBody::GetForce() + { + return Convert::ToCLI(GetNativeComponent()->GetForce()); + } + + void RigidBody::ClearForces() + { + GetNativeComponent()->ClearForces(); + } + /*---------------------------------------------------------------------------------*/ /* Torque Functions */ /*---------------------------------------------------------------------------------*/ @@ -202,4 +212,15 @@ namespace SHADE { GetNativeComponent()->AddRelativeTorque(Convert::ToNative(relativeTorque)); } + + Vector3 RigidBody::GetTorque() + { + return Convert::ToCLI(GetNativeComponent()->GetTorque()); + } + + void RigidBody::ClearTorque() + { + GetNativeComponent()->ClearTorque(); + } + } \ No newline at end of file diff --git a/SHADE_Managed/src/Components/RigidBody.hxx b/SHADE_Managed/src/Components/RigidBody.hxx index d3a30612..8bfe34aa 100644 --- a/SHADE_Managed/src/Components/RigidBody.hxx +++ b/SHADE_Managed/src/Components/RigidBody.hxx @@ -15,7 +15,7 @@ of DigiPen Institute of Technology is prohibited. #pragma once // External Dependencies -#include "Physics/Components/SHRigidBodyComponent.h" +#include "Physics/Interface/SHRigidBodyComponent.h" // Project Includes #include "Components/Component.hxx" @@ -145,11 +145,17 @@ namespace SHADE void AddRelativeForceAtLocalPos(Vector3 relativeForce, Vector3 localPos); void AddRelativeForceAtWorldPos(Vector3 relativeForce, Vector3 worldPos); + Vector3 GetForce(); + void ClearForces(); + /*-----------------------------------------------------------------------------*/ /* Torque Functions */ /*-----------------------------------------------------------------------------*/ void AddTorque(Vector3 force); void AddRelativeTorque(Vector3 relativeForce); + + Vector3 GetTorque(); + void ClearTorque(); }; } \ No newline at end of file diff --git a/SHADE_Managed/src/Editor/Editor.cxx b/SHADE_Managed/src/Editor/Editor.cxx index 54200c1e..7b2e0982 100644 --- a/SHADE_Managed/src/Editor/Editor.cxx +++ b/SHADE_Managed/src/Editor/Editor.cxx @@ -18,12 +18,9 @@ of DigiPen Institute of Technology is prohibited. #include "Editor/Editor.hxx" // STL Includes #include -// External Dependencies -#include "Editor/SHEditorUI.h" // Project Headers #include "Components/Component.hxx" #include "Scripts/ScriptStore.hxx" -#include "Utility/Convert.hxx" #include "Utility/Debug.hxx" #include "Serialisation/ReflectionUtilities.hxx" #include "Editor/IconsMaterialDesign.h" @@ -31,98 +28,14 @@ of DigiPen Institute of Technology is prohibited. #include "Editor/Command/SHCommand.hpp" #include "TooltipAttribute.hxx" #include "RangeAttribute.hxx" +#include "Math/Vector2.hxx" +#include "Math/Vector3.hxx" +#include // Using Directives using namespace System; using namespace System::Collections::Generic; -/*-------------------------------------------------------------------------------------*/ -/* Macro Functions */ -/*-------------------------------------------------------------------------------------*/ -/// -/// Macro expansion that is used in renderFieldInInspector() to check the type of a field -/// named "field" against the specified type and if it matches, retrieves the value of -/// that field from an object named "object" and pass it into the specified SHEditorUI:: -/// function named "FUNC" by casting it into the NATIVE_TYPE specified. -///
-/// This only works for primitive types that have the same types for managed and native. -/// -/// The managed type of the object to edit. -/// The native type of the object to edit. -/// The SHEditorUI:: function to use for editing. -#define RENDER_FIELD(MANAGED_TYPE, NATIVE_TYPE, FUNC) \ -(field->FieldType == MANAGED_TYPE::typeid) \ -{ \ - NATIVE_TYPE val = safe_cast(field->GetValue(object)); \ - NATIVE_TYPE oldVal = val; \ - if (SHEditorUI::FUNC(Convert::ToNative(field->Name), val, &isHovered))\ - { \ - field->SetValue(object, val); \ - registerUndoAction(object, field, val, oldVal); \ - } \ -} \ -/// -/// Alternative to RENDER_FIELD that checks for RangeAttribute and switches to a slider -/// instead. -/// -/// The managed type of the object to edit. -/// The native type of the object to edit. -/// The SHEditorUI:: function to use for editing. -#define RENDER_FIELD_RANGE(MANAGED_TYPE, NATIVE_TYPE, FUNC) \ -(field->FieldType == MANAGED_TYPE::typeid) \ -{ \ - NATIVE_TYPE val = safe_cast(field->GetValue(object)); \ - NATIVE_TYPE oldVal = val; \ - \ - RangeAttribute^ rangeAttrib = hasAttribute(field);\ - const std::string FIELD_NAME = Convert::ToNative(field->Name); \ - bool changed = false; \ - if (rangeAttrib) \ - { \ - changed = SHEditorUI::InputSlider \ - ( \ - FIELD_NAME, \ - static_cast(rangeAttrib->Min), \ - static_cast(rangeAttrib->Max), \ - val, &isHovered \ - ); \ - } \ - else \ - { \ - changed = SHEditorUI::FUNC(FIELD_NAME, val, &isHovered); \ - } \ - \ - if (changed) \ - { \ - field->SetValue(object, val); \ - registerUndoAction(object, field, val, oldVal); \ - } \ -} \ -/// -/// Macro expansion that is used in renderFieldInInspector() to check the type of a field -/// named "field" against the specified type and if it matches, retrieves the value of -/// that field from an object named "object" and pass it into the specified SHEditorUI:: -/// function named "FUNC" by casting it into the NATIVE_TYPE specified. -///
-/// This only works for types that have an implementation of Convert::ToNative and -/// Convert::ToCLI. -/// -/// The managed type of the object to edit. -/// The native type of the object to edit. -/// The SHEditorUI:: function to use for editing. -#define RENDER_FIELD_CASTED(MANAGED_TYPE, NATIVE_TYPE, FUNC) \ -(field->FieldType == MANAGED_TYPE::typeid) \ -{ \ - NATIVE_TYPE val = Convert::ToNative(safe_cast(field->GetValue(object))); \ - NATIVE_TYPE oldVal = val; \ - \ - if (SHEditorUI::FUNC(Convert::ToNative(field->Name), val, &isHovered)) \ - { \ - field->SetValue(object, Convert::ToCLI(val)); \ - registerUndoAction(object, field, Convert::ToCLI(val), Convert::ToCLI(oldVal)); \ - } \ -} \ - /*-------------------------------------------------------------------------------------*/ /* Function Definitions */ /*-------------------------------------------------------------------------------------*/ @@ -166,7 +79,10 @@ namespace SHADE if (SHEditorUI::Selectable(Convert::ToNative(type->Name))) { // Add the script - ScriptStore::AddScriptViaName(entity, type->Name); + Script^ script; + ScriptStore::AddScriptViaNameWithRef(entity, type->Name, script); + registerUndoScriptAddAction(entity, script); + break; } } @@ -207,7 +123,7 @@ namespace SHADE SHEditorUI::Indent(); { // Right Click Menu - renderScriptContextMenu(entity, script); + renderScriptContextMenu(entity, script, index); // Go through all fields and output them auto fields = ReflectionUtilities::GetInstanceFields(script); @@ -230,146 +146,141 @@ namespace SHADE } else { - renderScriptContextMenu(entity, script); + renderScriptContextMenu(entity, script, index); } SHEditorUI::PopID(); } - void Editor::renderFieldInInspector(Reflection::FieldInfo^ field, Object^ object) + + void Editor::renderFieldInInspector(Reflection::FieldInfo^ field, System::Object^ object) { bool isHovered = false; - if RENDER_FIELD_RANGE (Int16, int, InputInt) - else if RENDER_FIELD_RANGE (Int32, int, InputInt) - else if RENDER_FIELD_RANGE (Int64, int, InputInt) - else if RENDER_FIELD_RANGE (UInt16, unsigned int, InputUnsignedInt) - else if RENDER_FIELD_RANGE (UInt32, unsigned int, InputUnsignedInt) - else if RENDER_FIELD_RANGE (UInt64, unsigned int, InputUnsignedInt) - else if RENDER_FIELD_RANGE (Byte, int, InputInt) - else if RENDER_FIELD (bool, bool, InputCheckbox) - else if RENDER_FIELD_RANGE (float, float, InputFloat) - else if RENDER_FIELD_RANGE (double, double, InputDouble) - else if (field->FieldType->IsSubclassOf(Enum::typeid)) - { - // Get all the names of the enums - const array^ ENUM_NAMES = field->FieldType->GetEnumNames(); - std::vector nativeEnumNames; - for each (String^ str in ENUM_NAMES) - { - nativeEnumNames.emplace_back(Convert::ToNative(str)); - } + const bool MODIFIED_PRIMITIVE = + renderSpecificField(field, object, SHEditorUI::InputInt , &isHovered) || + renderSpecificField(field, object, SHEditorUI::InputInt , &isHovered) || + renderSpecificField(field, object, SHEditorUI::InputInt , &isHovered) || + renderSpecificField(field, object, SHEditorUI::InputInt , &isHovered) || + renderSpecificField(field, object, SHEditorUI::InputInt , &isHovered) || + renderSpecificField(field, object, SHEditorUI::InputInt , &isHovered) || + renderSpecificField(field, object, SHEditorUI::InputInt , &isHovered) || + renderSpecificField(field, object, SHEditorUI::InputCheckbox, &isHovered) || + renderSpecificField(field, object, SHEditorUI::InputFloat , &isHovered) || + renderSpecificField(field, object, SHEditorUI::InputDouble , &isHovered) || + renderSpecificField(field, object, SHEditorUI::InputVec2 , &isHovered) || + renderSpecificField(field, object, SHEditorUI::InputVec3 , &isHovered) || + renderSpecificField(field, object, nullptr , &isHovered) || + renderSpecificField(field, object, nullptr , &isHovered) || + renderSpecificField(field, object, nullptr , &isHovered); - int val = safe_cast(field->GetValue(object)); - int oldVal = val; - if (SHEditorUI::InputEnumCombo(Convert::ToNative(field->Name), val, nativeEnumNames, &isHovered)) - { - field->SetValue(object, val); - registerUndoAction(object, field, val, oldVal); - } - } - else if RENDER_FIELD_CASTED(Vector2, SHVec2, InputVec2) - else if RENDER_FIELD_CASTED(Vector3, SHVec3, InputVec3) - else if (field->FieldType == String::typeid) + if (!MODIFIED_PRIMITIVE) { - // Prevent issues where String^ is null due to being empty - String^ stringVal = safe_cast(field->GetValue(object)); - if (stringVal == nullptr) + // Any List + if (ReflectionUtilities::FieldIsList(field)) { - stringVal = ""; - } + System::Type^ listType = field->FieldType->GenericTypeArguments[0]; + RangeAttribute^ rangeAttrib = hasAttribute(field); + System::Collections::IList^ iList = safe_cast(field->GetValue(object)); - // Actual Field - std::string val = Convert::ToNative(stringVal); - std::string oldVal = val; - if (SHEditorUI::InputTextField(Convert::ToNative(field->Name), val, &isHovered)) - { - field->SetValue(object, Convert::ToCLI(val)); - registerUndoAction(object, field, Convert::ToCLI(val), Convert::ToCLI(oldVal)); - } - } - else if (field->FieldType == GameObject::typeid) - { - GameObject gameObj = safe_cast(field->GetValue(object)); - uint32_t entityId = gameObj.GetEntity(); - if (SHEditorUI::InputGameObjectField(Convert::ToNative(field->Name), entityId, &isHovered, !gameObj)) - { - GameObject newVal = GameObject(entityId); - if (entityId != MAX_EID) + if (SHEditorUI::CollapsingHeader(Convert::ToNative(field->Name), &isHovered)) { - // Null GameObject set - newVal = GameObject(entityId); - } - field->SetValue(object, newVal); - registerUndoAction(object, field, newVal, gameObj); - } - } - else - { - array^ interfaces = field->FieldType->GetInterfaces(); - if (interfaces->Length > 0 && interfaces[0] == ICallbackEvent::typeid) - { - array^ typeArgs = field->FieldType->GenericTypeArguments; - System::String^ title = field->Name + " : CallbackEvent<"; - for (int i = 0; i < typeArgs->Length; ++i) - { - title += typeArgs[i]->Name; - if (i < typeArgs->Length - 1) - title += ", "; - } - title += ">"; - if (SHEditorUI::CollapsingHeader(Convert::ToNative(title))) - { - // Constants - const std::string LABEL = Convert::ToNative(field->Name); - SHEditorUI::PushID(LABEL); - - ICallbackEvent^ callbackEvent = safe_cast(field->GetValue(object)); - if (callbackEvent == nullptr) + if (SHEditorUI::Button("Add Item")) { - // Construct one since it was not constructed before - callbackEvent = safe_cast(System::Activator::CreateInstance(field->FieldType)); + System::Object^ obj = System::Activator::CreateInstance(listType); + iList->Add(obj); + registerUndoListAddAction(listType, iList, iList->Count - 1, obj); } - for each (ICallbackAction ^ action in callbackEvent->Actions) + for (int i = 0; i < iList->Count; ++i) { - if (action->IsRuntimeAction) - continue; - - // Attempt to get the object if any - int entityId = static_cast(-1); - if (action->TargetObject) + SHEditorUI::PushID(i); + System::Object^ obj = iList[i]; + System::Object^ oldObj = iList[i]; + if (renderFieldEditor(std::to_string(i), obj, rangeAttrib)) { - Script^ script = safe_cast(action->TargetObject); - if (script) - { - entityId = static_cast(script->Owner.GetEntity()); - } + iList[i] = obj; + registerUndoListChangeAction(listType, iList, i, obj, oldObj); } - SHEditorUI::InputInt("", entityId); - SHEditorUI::SameLine(); - System::String^ methodName = ""; - if (action->TargetMethodName != nullptr) - { - methodName = action->TargetMethodName; - } - std::string methodNameNative = Convert::ToNative(methodName); - SHEditorUI::InputTextField("", methodNameNative); SHEditorUI::SameLine(); if (SHEditorUI::Button("-")) { - callbackEvent->DeregisterAction(action); + System::Object^ obj = iList[i]; + iList->RemoveAt(i); + registerUndoListRemoveAction(listType, iList, i, obj); + SHEditorUI::PopID(); break; } + SHEditorUI::PopID(); } - if (SHEditorUI::Button("Add Action")) - { - callbackEvent->RegisterAction(); - } - - SHEditorUI::PopID(); } } else { - return; + array^ interfaces = field->FieldType->GetInterfaces(); + if (interfaces->Length > 0 && interfaces[0] == ICallbackEvent::typeid) + { + array^ typeArgs = field->FieldType->GenericTypeArguments; + System::String^ title = field->Name + " : CallbackEvent<"; + for (int i = 0; i < typeArgs->Length; ++i) + { + title += typeArgs[i]->Name; + if (i < typeArgs->Length - 1) + title += ", "; + } + title += ">"; + if (SHEditorUI::CollapsingHeader(Convert::ToNative(title))) + { + // Constants + const std::string LABEL = Convert::ToNative(field->Name); + SHEditorUI::PushID(LABEL); + + ICallbackEvent^ callbackEvent = safe_cast(field->GetValue(object)); + if (callbackEvent == nullptr) + { + // Construct one since it was not constructed before + callbackEvent = safe_cast(System::Activator::CreateInstance(field->FieldType)); + } + for each (ICallbackAction ^ action in callbackEvent->Actions) + { + if (action->IsRuntimeAction) + continue; + + // Attempt to get the object if any + int entityId = static_cast(-1); + if (action->TargetObject) + { + Script^ script = safe_cast(action->TargetObject); + if (script) + { + entityId = static_cast(script->Owner.GetEntity()); + } + } + SHEditorUI::InputInt("", entityId); + SHEditorUI::SameLine(); + System::String^ methodName = ""; + if (action->TargetMethodName != nullptr) + { + methodName = action->TargetMethodName; + } + std::string methodNameNative = Convert::ToNative(methodName); + SHEditorUI::InputTextField("", methodNameNative); + SHEditorUI::SameLine(); + if (SHEditorUI::Button("-")) + { + callbackEvent->DeregisterAction(action); + break; + } + } + if (SHEditorUI::Button("Add Action")) + { + callbackEvent->RegisterAction(); + } + + SHEditorUI::PopID(); + } + } + else + { + return; + } } } @@ -383,7 +294,52 @@ namespace SHADE } } - void Editor::renderScriptContextMenu(Entity entity, Script^ script) + bool Editor::renderFieldEditor(const std::string& fieldName, System::Object^% object, RangeAttribute^ rangeAttrib) + { + bool modified; + + const bool RENDERED = + renderFieldEditor(fieldName, object, SHEditorUI::InputInt , nullptr, rangeAttrib, modified) || + renderFieldEditor(fieldName, object, SHEditorUI::InputInt , nullptr, rangeAttrib, modified) || + renderFieldEditor(fieldName, object, SHEditorUI::InputInt , nullptr, rangeAttrib, modified) || + renderFieldEditor(fieldName, object, SHEditorUI::InputInt , nullptr, rangeAttrib, modified) || + renderFieldEditor(fieldName, object, SHEditorUI::InputInt , nullptr, rangeAttrib, modified) || + renderFieldEditor(fieldName, object, SHEditorUI::InputInt , nullptr, rangeAttrib, modified) || + renderFieldEditor(fieldName, object, SHEditorUI::InputInt , nullptr, rangeAttrib, modified) || + renderFieldEditor(fieldName, object, SHEditorUI::InputCheckbox, nullptr, rangeAttrib, modified) || + renderFieldEditor(fieldName, object, SHEditorUI::InputFloat , nullptr, rangeAttrib, modified) || + renderFieldEditor(fieldName, object, SHEditorUI::InputDouble , nullptr, rangeAttrib, modified) || + renderFieldEditor(fieldName, object, SHEditorUI::InputVec2 , nullptr, rangeAttrib, modified) || + renderFieldEditor(fieldName, object, SHEditorUI::InputVec3 , nullptr, rangeAttrib, modified) || + renderFieldEditor(fieldName, object, nullptr , nullptr, rangeAttrib, modified) || + renderFieldEditor(fieldName, object, nullptr , nullptr, rangeAttrib, modified) || + renderFieldEditor(fieldName, object, nullptr , nullptr, rangeAttrib, modified); + + return modified; + } + + bool Editor::renderEnumEditor(const std::string& fieldName, System::Object^% object, bool* isHovered) + { + // Get all the names of the enums + const array^ ENUM_NAMES = object->GetType()->GetEnumNames(); + std::vector nativeEnumNames; + for each (String ^ str in ENUM_NAMES) + { + nativeEnumNames.emplace_back(Convert::ToNative(str)); + } + + int val = safe_cast(object); + int oldVal = val; + if (SHEditorUI::InputEnumCombo(fieldName, val, nativeEnumNames, isHovered)) + { + object = val; + return true; + } + + return false; + } + + void Editor::renderScriptContextMenu(Entity entity, Script^ script, int scriptIndex) { // Right Click Menu if (SHEditorUI::BeginPopupContextItem("scriptContextMenu")) @@ -392,6 +348,7 @@ namespace SHADE { // Mark script for removal ScriptStore::RemoveScript(entity, script); + registerUndoScriptRemoveAction(entity, script, scriptIndex); } SHEditorUI::EndPopup(); } @@ -400,12 +357,62 @@ namespace SHADE void Editor::registerUndoAction(System::Object^ object, System::Reflection::FieldInfo^ field, System::Object^ newData, System::Object^ oldData) { // Create command and add it into the undo stack - UndoRedoStack::Command cmd; - cmd.Field = field; - cmd.Object = object; - cmd.NewData = newData; - cmd.OldData = oldData; - actionStack.Add(cmd); + actionStack.Add(gcnew FieldChangeCommand(object, field, newData, oldData)); + + // Inform the C++ Undo-Redo stack + SHCommandManager::RegisterCommand(std::reinterpret_pointer_cast(std::make_shared())); + } + + void Editor::registerUndoListChangeAction(System::Type^ type, System::Collections::IList^ list, int index, System::Object^ newData, System::Object^ oldData) + { + if (list == nullptr) + return; + + actionStack.Add(gcnew ListElementChangeCommand(list, index, newData, oldData)); + + // Inform the C++ Undo-Redo stack + SHCommandManager::RegisterCommand(std::reinterpret_pointer_cast(std::make_shared())); + } + + void Editor::registerUndoListAddAction(System::Type^ type, System::Collections::IList^ list, int index, System::Object^ data) + { + if (list == nullptr) + return; + + actionStack.Add(gcnew ListElementAddCommand(list, index, data)); + + // Inform the C++ Undo-Redo stack + SHCommandManager::RegisterCommand(std::reinterpret_pointer_cast(std::make_shared())); + } + + void Editor::registerUndoListRemoveAction(System::Type^ type, System::Collections::IList^ list, int index, System::Object^ data) + { + if (list == nullptr) + return; + + actionStack.Add(gcnew ListElementRemoveCommand(list, index, data)); + + // Inform the C++ Undo-Redo stack + SHCommandManager::RegisterCommand(std::reinterpret_pointer_cast(std::make_shared())); + } + + void Editor::registerUndoScriptAddAction(EntityID id, Script^ script) + { + if (script == nullptr) + return; + + actionStack.Add(gcnew ScriptAddCommand(id, script)); + + // Inform the C++ Undo-Redo stack + SHCommandManager::RegisterCommand(std::reinterpret_pointer_cast(std::make_shared())); + } + + void Editor::registerUndoScriptRemoveAction(EntityID id, Script^ script, int originalIndex) + { + if (script == nullptr) + return; + + actionStack.Add(gcnew ScriptRemoveCommand(id, script, originalIndex)); // Inform the C++ Undo-Redo stack SHCommandManager::RegisterCommand(std::reinterpret_pointer_cast(std::make_shared())); diff --git a/SHADE_Managed/src/Editor/Editor.h++ b/SHADE_Managed/src/Editor/Editor.h++ new file mode 100644 index 00000000..a186d7ea --- /dev/null +++ b/SHADE_Managed/src/Editor/Editor.h++ @@ -0,0 +1,203 @@ +/************************************************************************************//*! +\file Editor.h++ +\author Tng Kah Wei, kahwei.tng, 390009620 +\par email: kahwei.tng\@digipen.edu +\date Nov 10, 2022 +\brief Contains the definition of templated functions for the managed Editor + static class. + + Note: This file is written in C++17/CLI. + +Copyright (C) 2022 DigiPen Institute of Technology. +Reproduction or disclosure of this file or its contents without the prior written consent +of DigiPen Institute of Technology is prohibited. +*//*************************************************************************************/ +#pragma once + +// Primary Include +#include "Editor.hxx" +// External Dependencies +#include "Editor/SHEditorUI.h" +// Project Includes +#include "Utility/Convert.hxx" + +namespace SHADE +{ + template + bool Editor::renderSpecificField(System::Reflection::FieldInfo^ fieldInfo, System::Object^ object, EditorFieldFunc fieldEditor, bool* isHovered) + { + if constexpr (std::is_same_v) + { + if (fieldInfo->FieldType->IsSubclassOf(Enum::typeid)) + { + System::Object^ enumObj = fieldInfo->GetValue(object); + int oldVal = safe_cast(enumObj); + int val = oldVal; + if (renderEnumEditor + ( + Convert::ToNative(fieldInfo->Name), + enumObj, + isHovered + )) + { + fieldInfo->SetValue(object, safe_cast(enumObj)); + registerUndoAction(object, fieldInfo, fieldInfo->GetValue(object), oldVal); + } + + return true; + } + } + else + { + if (fieldInfo->FieldType == ManagedType::typeid) + { + RangeAttribute^ rangeAttrib; + if constexpr (std::is_arithmetic_v && !std::is_same_v) + { + rangeAttrib = hasAttribute(fieldInfo); + } + + ManagedType oldVal = safe_cast(fieldInfo->GetValue(object)); + ManagedType val = oldVal; + if (renderFieldEditorInternal + ( + Convert::ToNative(fieldInfo->Name), + &val, + fieldEditor, + isHovered, + rangeAttrib + )) + { + fieldInfo->SetValue(object, val); + registerUndoAction(object, fieldInfo, fieldInfo->GetValue(object), oldVal); + } + + return true; + } + } + + return false; + } + + template + bool Editor::renderFieldEditor(const std::string& fieldName, System::Object^% object, EditorFieldFunc fieldEditor, bool* isHovered, RangeAttribute^ rangeAttrib, bool& modified) + { + modified = false; + + if constexpr (std::is_same_v) + { + if (object->GetType()->IsSubclassOf(Enum::typeid)) + { + modified = renderEnumEditor(fieldName, object, isHovered); + return true; + } + } + else + { + if (object->GetType() == ManagedType::typeid) + { + ManagedType managedVal = safe_cast(object); + cli::interior_ptr managedValPtr = &managedVal; + if (renderFieldEditorInternal(fieldName, managedValPtr, fieldEditor, isHovered, rangeAttrib)) + { + object = managedVal; + modified = true; + return true; + } + return false; + } + } + + return false; + } + + + template + bool Editor::renderFieldEditorInternal(const std::string& fieldName, interior_ptr managedValPtr, EditorFieldFunc fieldEditor, bool* isHovered, RangeAttribute^ rangeAttrib) + { + // Retrieve the native version of the object + NativeType val; + if constexpr (IsPrimitiveTypeMatches_V) + { + val = safe_cast(*managedValPtr); + } + else + { + val = Convert::ToNative(*managedValPtr); + } + + // Throw into the SHEditorUI function + NativeType oldVal = val; + bool changed = false; + if (rangeAttrib) + { + // Do not allow bools for Sliders just in case + if constexpr (std::is_arithmetic_v && !std::is_same_v) + { + changed = SHEditorUI::InputSlider + ( + fieldName, + static_cast(rangeAttrib->Min), + static_cast(rangeAttrib->Max), + val, isHovered + ); + } + } + else + { + changed = fieldEditor(fieldName, val, isHovered); + } + + if (changed) + { + if constexpr (IsPrimitiveTypeMatches_V) + { + *managedValPtr = val; + } + else + { + + *managedValPtr = Convert::ToCLI(val); + } + + return true; + } + + return false; + } + template<> + bool Editor::renderFieldEditorInternal(const std::string& fieldName, interior_ptr managedValPtr, EditorFieldFunc, bool* isHovered, RangeAttribute^) + { + // Prevent issues where String^ is null due to being empty + if (*managedValPtr == nullptr) + *managedValPtr = ""; + + // Actual Field + std::string val = Convert::ToNative(*managedValPtr); + if (SHEditorUI::InputTextField(fieldName, val, isHovered)) + { + *managedValPtr = Convert::ToCLI(val); + return true; + } + + return false; + } + template<> + bool Editor::renderFieldEditorInternal(const std::string& fieldName, interior_ptr managedValPtr, EditorFieldFunc, bool* isHovered, RangeAttribute^) + { + uint32_t entityId = managedValPtr->GetEntity(); + if (SHEditorUI::InputGameObjectField(fieldName, entityId, isHovered, !(*managedValPtr))) + { + GameObject newVal = GameObject(entityId); + if (entityId != MAX_EID) + { + // Null GameObject set + newVal = GameObject(entityId); + } + *managedValPtr = newVal; + return true; + } + + return false; + } +} diff --git a/SHADE_Managed/src/Editor/Editor.hxx b/SHADE_Managed/src/Editor/Editor.hxx index 109842b5..79625274 100644 --- a/SHADE_Managed/src/Editor/Editor.hxx +++ b/SHADE_Managed/src/Editor/Editor.hxx @@ -17,9 +17,14 @@ of DigiPen Institute of Technology is prohibited. #include "Engine/Entity.hxx" #include "Scripts/Script.hxx" #include "UndoRedoStack.hxx" +#include "RangeAttribute.hxx" namespace SHADE { + + template + using EditorFieldFunc = bool(*)(const std::string& label, NativeType& val, bool* isHovered); + /// /// Static class for Editor-related functions /// @@ -64,7 +69,7 @@ namespace SHADE static UndoRedoStack actionStack; /*-----------------------------------------------------------------------------*/ - /* Helper Functions */ + /* Helper Functions - Inspector Rendering */ /*-----------------------------------------------------------------------------*/ /// /// Renders a single specified Script's inspector. @@ -84,15 +89,114 @@ namespace SHADE /// /// The object that contains the data of the field to render. /// - static void renderFieldInInspector(System::Reflection::FieldInfo^ field, Object^ object); + static void renderFieldInInspector(System::Reflection::FieldInfo^ field, System::Object^ object); + /// + /// Renders a raw editor for a single value. + /// + /// The name of the field to render. + /// Tracking reference to the object to modify. + /// + /// If specified, will be used to constrain values. + /// + /// True if the value was modified. + static bool renderFieldEditor(const std::string& fieldName, System::Object^% object, RangeAttribute^ rangeAttrib); + /// + /// Renders a ImGui field editor based on the type of parameters specified if the + /// type matches. + /// + /// Native type of the field. + /// Managed type of the field. + /// Label to use for the field editor. + /// + /// Tracking reference for the managed variable to modify. + /// + /// ImGui field editor function to use. + /// + /// Pointer to a bool that stores if the field editor was hovered over. + /// + /// + /// If provided and the type supports it, the field will be rendered with a + /// slider instead. + /// + /// + /// True if the field was rendered.. + template + static bool renderFieldEditor(const std::string& fieldName, System::Object^% object, EditorFieldFunc fieldEditor, bool* isHovered, RangeAttribute^ rangeAttrib, bool& modified); + /// + /// Renders a raw editor for a single enum value. + /// + /// The name of the field to render. + /// + /// Tracking reference to the object to modify. Must be an enum. + /// + /// + /// Pointer to a bool that stores if the field editor was hovered over. + /// + /// True if the value was modified. + static bool renderEnumEditor(const std::string& fieldName, System::Object^% object, bool* isHovered); + /// + /// Checks if the specified field is of the specified native and managed type + /// equivalent and renders a ImGui field editor based on the specified field + /// editor function. Also handles fields that contain a RangeAttribute. + /// + /// Native type of the field. + /// Managed type of the field. + /// Describes the field to modify. + /// Object to modify that has the specified field. + /// ImGui field editor function to use. + /// + /// Pointer to a bool that stores if the field editor was hovered over. + /// + /// True if the field is modified. + template + static bool renderSpecificField(System::Reflection::FieldInfo^ fieldInfo, System::Object^ object, EditorFieldFunc fieldEditor, bool* isHovered); + /// + /// Renders a ImGui field editor based on the type of parameters specified. + /// + /// Native type of the field. + /// Managed type of the field. + /// Label to use for the field editor. + /// + /// Tracking reference for the managed variable to modify. + /// + /// ImGui field editor function to use. + /// + /// Pointer to a bool that stores if the field editor was hovered over. + /// + /// + /// If provided and the type supports it, the field will be rendered with a + /// slider instead. + /// + /// True if the field is modified. + template + static bool renderFieldEditorInternal(const std::string& fieldName, interior_ptr managedValPtr, EditorFieldFunc fieldEditor, bool* isHovered, RangeAttribute^ rangeAttrib); /// /// Renders a context menu when right clicked for the scripts /// /// The Entity to render the Scripts of. /// The Script to render the inspector for. - static void renderScriptContextMenu(Entity entity, Script^ script); + /// Index at which the Script is stored. + static void renderScriptContextMenu(Entity entity, Script^ script, int scriptIndex); + /*-----------------------------------------------------------------------------*/ + /* Helper Functions - Undo */ + /*-----------------------------------------------------------------------------*/ static void registerUndoAction(System::Object^ object, System::Reflection::FieldInfo^ field, System::Object^ newData, System::Object^ oldData); + static void registerUndoListChangeAction(System::Type^ type, System::Collections::IList^ list, int index, System::Object^ newData, System::Object^ oldData); + static void registerUndoListAddAction(System::Type^ type, System::Collections::IList^ list, int index, System::Object^ data); + static void registerUndoListRemoveAction(System::Type^ type, System::Collections::IList^ list, int index, System::Object^ data); + static void registerUndoScriptAddAction(EntityID id, Script^ script); + static void registerUndoScriptRemoveAction(EntityID id, Script^ script, int originalIndex); + /*-----------------------------------------------------------------------------*/ + /* Helper Functions - Others */ + /*-----------------------------------------------------------------------------*/ + /// + /// Checks if a specific field has the specified attribute + /// + /// Type of Attribute to check for. + /// The field to check. + /// The attribute to check for if it exists. Null otherwise. generic where Attribute : System::Attribute static Attribute hasAttribute(System::Reflection::FieldInfo^ field); }; } +#include "Editor.h++" diff --git a/SHADE_Managed/src/Editor/UndoRedoStack.cxx b/SHADE_Managed/src/Editor/UndoRedoStack.cxx index 08e289cc..3d1f04e9 100644 --- a/SHADE_Managed/src/Editor/UndoRedoStack.cxx +++ b/SHADE_Managed/src/Editor/UndoRedoStack.cxx @@ -19,9 +19,15 @@ of DigiPen Institute of Technology is prohibited. // External Dependencies #include "Editor/SHEditorUI.h" // Project Headers +#include "Utility/Debug.hxx" +#include "Utility/Convert.hxx" +#include "Scripts/ScriptStore.hxx" namespace SHADE { + /*---------------------------------------------------------------------------------*/ + /* UndoRedoStack - Properties */ + /*---------------------------------------------------------------------------------*/ bool UndoRedoStack::UndoActionPresent::get() { return commandStack->Count > 0 && latestActionIndex >= 0; @@ -29,10 +35,14 @@ namespace SHADE bool UndoRedoStack::RedoActionPresent::get() { - return latestActionIndex >= 0 && latestActionIndex < commandStack->Count - 1; + const int REDO_ACTION_INDEX = latestActionIndex + 1; + return REDO_ACTION_INDEX >= 0 && REDO_ACTION_INDEX < commandStack->Count; } - - void UndoRedoStack::Add(Command command) + + /*---------------------------------------------------------------------------------*/ + /* UndoRedoStack - Usage Functions */ + /*---------------------------------------------------------------------------------*/ + void UndoRedoStack::Add(ICommand^ command) { // Erase any other actions ahead of the current action if (latestActionIndex >= 0 && latestActionIndex < commandStack->Count - 1) @@ -52,8 +62,8 @@ namespace SHADE if (!UndoActionPresent) return; - Command cmd = commandStack[latestActionIndex]; - cmd.Field->SetValue(cmd.Object, cmd.OldData); + ICommand^ cmd = commandStack[latestActionIndex]; + cmd->Unexceute(); --latestActionIndex; } @@ -61,9 +71,249 @@ namespace SHADE { if (!RedoActionPresent) return; - - Command cmd = commandStack[latestActionIndex]; - cmd.Field->SetValue(cmd.Object, cmd.NewData); + + const int REDO_ACTION_INDEX = latestActionIndex + 1; + ICommand^ cmd = commandStack[REDO_ACTION_INDEX]; + cmd->Execute(); ++latestActionIndex; } + + /*---------------------------------------------------------------------------------*/ + /* FieldChangeCommand - Constructor */ + /*---------------------------------------------------------------------------------*/ + FieldChangeCommand::FieldChangeCommand(System::Object^ obj, System::Reflection::FieldInfo^ field, System::Object^ newData, System::Object^ oldData) + : objectToChange { obj } + , field { field } + , newData { newData } + , oldData { oldData } + {} + + /*---------------------------------------------------------------------------------*/ + /* FieldChangeCommand - ICommand Functions */ + /*---------------------------------------------------------------------------------*/ + bool FieldChangeCommand::Execute() + { + if (field && objectToChange) + { + field->SetValue(objectToChange, newData); + return true; + } + + return false; + } + + bool FieldChangeCommand::Unexceute() + { + if (field && objectToChange) + { + field->SetValue(objectToChange, oldData); + return true; + } + + return false; + } + + bool FieldChangeCommand::Merge(ICommand^ command) + { + FieldChangeCommand^ otherCommand = safe_cast(command); + if (otherCommand == nullptr) + { + Debug::LogWarning("[Field Change Command] Attempted to merge two incompatible commands!"); + return false; + } + + // Only merge if they are workng on the same object and field + if (field == otherCommand->field && objectToChange == otherCommand->objectToChange) + { + newData = otherCommand->newData; + return true; + } + + return false; + } + + /*---------------------------------------------------------------------------------*/ + /* ListElementChangeCommand - Constructor */ + /*---------------------------------------------------------------------------------*/ + ListElementChangeCommand::ListElementChangeCommand(System::Collections::IList^ list, int index, System::Object^ newData, System::Object^ oldData) + : list { list } + , index { index } + , newData { newData } + , oldData { oldData } + {} + + /*---------------------------------------------------------------------------------*/ + /* ListElementChangeCommand - ICommand Functions */ + /*---------------------------------------------------------------------------------*/ + bool ListElementChangeCommand::Execute() + { + if (list && index < list->Count) + { + list[index] = newData; + return true; + } + + return false; + } + + bool ListElementChangeCommand::Unexceute() + { + if (list && index < list->Count) + { + list[index] = oldData; + return true; + } + + return false; + } + bool ListElementChangeCommand::Merge(ICommand^ command) + { + ListElementChangeCommand^ otherCommand = safe_cast(command); + if (otherCommand == nullptr) + { + Debug::LogWarning("[Field Change Command] Attempted to merge two incompatible commands!"); + return false; + } + + if (command && list == otherCommand->list && index == otherCommand->index) + { + newData = otherCommand->newData; + return true; + } + } + + /*---------------------------------------------------------------------------------*/ + /* ListElementAddCommand - Constructor */ + /*---------------------------------------------------------------------------------*/ + ListElementAddCommand::ListElementAddCommand(System::Collections::IList^ list, int addIndex, System::Object^ data) + : list { list } + , addIndex { addIndex } + , data { data } + {} + + /*---------------------------------------------------------------------------------*/ + /* ListElementAddCommand - ICommand Functions */ + /*---------------------------------------------------------------------------------*/ + bool ListElementAddCommand::Execute() + { + if (list) + { + list->Insert(addIndex, data); + return true; + } + + return false; + } + + bool ListElementAddCommand::Unexceute() + { + if (list && addIndex < list->Count) + { + list->RemoveAt(addIndex); + return true; + } + + return false; + } + + bool ListElementAddCommand::Merge(ICommand^) + { + // Not allowed + return false; + } + + /*---------------------------------------------------------------------------------*/ + /* ListElementRemoveCommand - Constructor */ + /*---------------------------------------------------------------------------------*/ + ListElementRemoveCommand::ListElementRemoveCommand(System::Collections::IList^ list, int removeIndex, System::Object^ data) + : list { list } + , removeIndex { removeIndex } + , data { data } + {} + + /*---------------------------------------------------------------------------------*/ + /* ListElementRemoveCommand - ICommand Functions */ + /*---------------------------------------------------------------------------------*/ + bool ListElementRemoveCommand::Execute() + { + if (list && removeIndex < list->Count) + { + list->RemoveAt(removeIndex); + return true; + } + + return false; + } + + bool ListElementRemoveCommand::Unexceute() + { + if (list) + { + list->Insert(removeIndex, data); + return true; + } + + return false; + } + + bool ListElementRemoveCommand::Merge(ICommand^) + { + // Not allowed + return false; + } + + /*---------------------------------------------------------------------------------*/ + /* ScriptAddCommand - Constructor */ + /*---------------------------------------------------------------------------------*/ + ScriptAddCommand::ScriptAddCommand(EntityID id, Script^ script) + : entity { id } + , addedScript { script } + {} + + /*---------------------------------------------------------------------------------*/ + /* ScriptAddCommand - ICommand Functions */ + /*---------------------------------------------------------------------------------*/ + bool ScriptAddCommand::Execute() + { + return ScriptStore::AddScript(entity, addedScript) != nullptr; + } + + bool ScriptAddCommand::Unexceute() + { + return ScriptStore::RemoveScript(entity, addedScript); + } + + bool ScriptAddCommand::Merge(ICommand^) + { + // Not allowed + return false; + } + + /*---------------------------------------------------------------------------------*/ + /* ScriptRemoveCommand - Constructor */ + /*---------------------------------------------------------------------------------*/ + ScriptRemoveCommand::ScriptRemoveCommand(EntityID id, Script^ script, int index) + : entity { id } + , removedScript { script } + , originalIndex { index } + {} + + /*---------------------------------------------------------------------------------*/ + /* ScriptRemoveCommand - ICommand Functions */ + /*---------------------------------------------------------------------------------*/ + bool ScriptRemoveCommand::Execute() + { + return ScriptStore::RemoveScript(entity, removedScript); + } + + bool ScriptRemoveCommand::Unexceute() + { + return ScriptStore::AddScript(entity, removedScript, originalIndex) != nullptr; + } + + bool ScriptRemoveCommand::Merge(ICommand^) + { + // Not allowed + return false; + } } diff --git a/SHADE_Managed/src/Editor/UndoRedoStack.hxx b/SHADE_Managed/src/Editor/UndoRedoStack.hxx index 4c525228..c377e2b7 100644 --- a/SHADE_Managed/src/Editor/UndoRedoStack.hxx +++ b/SHADE_Managed/src/Editor/UndoRedoStack.hxx @@ -12,30 +12,132 @@ Reproduction or disclosure of this file or its contents without the prior writte of DigiPen Institute of Technology is prohibited. *//*************************************************************************************/ #pragma once +#include "Scripts/Script.hxx" namespace SHADE { + /// + /// Interface for command that fits into the UndoRedoStack which can perform + /// undo-able and redo-able operations. + /// + private interface class ICommand + { + /// + /// Executes an action. This is called when a "Redo" is performed. + /// + /// Whether the action was successful or not. + bool Execute(); + /// + /// Undoes an action. This is called when an "Undo" is performed. + /// + /// Whether the action was successful or not. + bool Unexceute(); + /// + /// Merges this command with another command. + /// + /// + /// Whether the merge was successful or not. + bool Merge(ICommand^ command); + }; + + private ref class FieldChangeCommand sealed : public ICommand + { + public: + FieldChangeCommand(System::Object^ obj, System::Reflection::FieldInfo^ field, System::Object^ newData, System::Object^ oldData); + + bool Execute() override; + bool Unexceute() override; + bool Merge(ICommand^ command) override; + + private: + System::Object^ objectToChange; + System::Reflection::FieldInfo^ field; + System::Object^ newData; + System::Object^ oldData; + }; + + + private ref class ListElementChangeCommand sealed : public ICommand + { + public: + ListElementChangeCommand(System::Collections::IList^ list, int index, System::Object^ newData, System::Object^ oldData); + + bool Execute() override; + bool Unexceute() override; + bool Merge(ICommand^ command) override; + + private: + System::Collections::IList^ list; + int index; + System::Object^ newData; + System::Object^ oldData; + }; + + private ref class ListElementAddCommand sealed : public ICommand + { + public: + ListElementAddCommand(System::Collections::IList^ list, int addIndex, System::Object^ data); + + bool Execute() override; + bool Unexceute() override; + bool Merge(ICommand^ command) override; + + private: + System::Collections::IList^ list; + int addIndex; // New index of the added element + System::Object^ data; + }; + + private ref class ListElementRemoveCommand sealed : public ICommand + { + public: + ListElementRemoveCommand(System::Collections::IList^ list, int removeIndex, System::Object^ data); + + bool Execute() override; + bool Unexceute() override; + bool Merge(ICommand^ command) override; + + private: + System::Collections::IList^ list; + int removeIndex; // Index of the element to remove at + System::Object^ data; + }; + + private ref class ScriptAddCommand sealed : public ICommand + { + public: + ScriptAddCommand(EntityID id, Script^ script); + + bool Execute() override; + bool Unexceute() override; + bool Merge(ICommand^ command) override; + + private: + EntityID entity; + Script^ addedScript; + }; + + private ref class ScriptRemoveCommand sealed : public ICommand + { + public: + ScriptRemoveCommand(EntityID id, Script^ script, int index); + + bool Execute() override; + bool Unexceute() override; + bool Merge(ICommand^ command) override; + + private: + EntityID entity; + Script^ removedScript; + int originalIndex; + }; + /// /// Class that is able to store a stack of actions that can be done and redone. /// private ref class UndoRedoStack sealed { public: - /*-----------------------------------------------------------------------------*/ - /* Type Definitions */ - /*-----------------------------------------------------------------------------*/ - /// - /// Command for the stack that represents a data modification. - /// - value struct Command - { - public: - System::Object^ Object; - System::Reflection::FieldInfo^ Field; - System::Object^ NewData; - System::Object^ OldData; - }; - /*-----------------------------------------------------------------------------*/ /* Properties */ /*-----------------------------------------------------------------------------*/ @@ -55,7 +157,7 @@ namespace SHADE /// Adds a command onto the stack. /// /// - void Add(Command command); + void Add(ICommand^ command); /// /// Undos the last added command if it exists. /// @@ -70,6 +172,6 @@ namespace SHADE /* Data Members */ /*-----------------------------------------------------------------------------*/ int latestActionIndex = -1; - System::Collections::Generic::List^ commandStack = gcnew System::Collections::Generic::List(); + System::Collections::Generic::List^ commandStack = gcnew System::Collections::Generic::List(); }; } diff --git a/SHADE_Managed/src/Engine/ChildListCache.cxx b/SHADE_Managed/src/Engine/ChildListCache.cxx new file mode 100644 index 00000000..b183646f --- /dev/null +++ b/SHADE_Managed/src/Engine/ChildListCache.cxx @@ -0,0 +1,89 @@ +/************************************************************************************//*! +\file ChildListCache.cxx +\author Tng Kah Wei, kahwei.tng, 390009620 +\par email: kahwei.tng\@digipen.edu +\date Nov 11, 2022 +\brief Contains the definition of the functions for the ChildListCache managed + class. + + Note: This file is written in C++17/CLI. + +Copyright (C) 2022 DigiPen Institute of Technology. +Reproduction or disclosure of this file or its contents without the prior written consent +of DigiPen Institute of Technology is prohibited. +*//*************************************************************************************/ +// Precompiled Headers +#include "SHpch.h" +// Primary Header +#include "ChildListCache.hxx" +// External Dependencies +#include "Scene/SHSceneManager.h" +// Project Headers +#include "Utility/Debug.hxx" + +namespace SHADE +{ + /*---------------------------------------------------------------------------------*/ + /* Static Usage Functions */ + /*---------------------------------------------------------------------------------*/ + ChildListCache::ChildEnumerable^ ChildListCache::GetChildList(Entity entity) + { + // Ignore if invalid + if (entity == MAX_EID) + return nullptr; + + // Check if in cache + if (cachedLists->ContainsKey(entity)) + return cachedLists[entity]; + + // Grab the native child list + auto node = GameObject(entity).GetSceneNode(); + if (!node || node->GetChildren().empty()) + return nullptr; + + // Otherwise + // - Create the list + ChildList^ list = gcnew ChildList(); + updateChildList(list, node); + // - Cache it + cachedLists[entity] = list; + + return list; + } + + void ChildListCache::UpdateChildList(Entity entity) + { + // Ignore if invalid + if (entity == MAX_EID) + return; + + // Check if in cache + if (!cachedLists->ContainsKey(entity)) + return; + + // Update + updateChildList(cachedLists[entity], GameObject(entity).GetSceneNode()); + } + + /*---------------------------------------------------------------------------------*/ + /* Event Handling Functions */ + /*---------------------------------------------------------------------------------*/ + void ChildListCache::OnChildrenChanged(EntityID entity) + { + SAFE_NATIVE_CALL_BEGIN + UpdateChildList(entity); + SAFE_NATIVE_CALL_END_N("SHADE_Managed.ChildListCache") + } + + /*---------------------------------------------------------------------------------*/ + /* Helper Functions */ + /*---------------------------------------------------------------------------------*/ + void ChildListCache::updateChildList(ChildList^ list, const SHSceneNode* sceneNode) + { + list->Clear(); + for (auto node : sceneNode->GetChildren()) + { + list->Add(GameObject(node->GetEntityID())); + } + } +} diff --git a/SHADE_Managed/src/Engine/ChildListCache.hxx b/SHADE_Managed/src/Engine/ChildListCache.hxx new file mode 100644 index 00000000..1a2637d3 --- /dev/null +++ b/SHADE_Managed/src/Engine/ChildListCache.hxx @@ -0,0 +1,80 @@ +/************************************************************************************//*! +\file ChildListCache.hxx +\author Tng Kah Wei, kahwei.tng, 390009620 +\par email: kahwei.tng\@digipen.edu +\date Nov 11, 2022 +\brief Contains the definition of the ChildListCache managed class. + + Note: This file is written in C++17/CLI. + +Copyright (C) 2022 DigiPen Institute of Technology. +Reproduction or disclosure of this file or its contents without the prior written consent +of DigiPen Institute of Technology is prohibited. +*//*************************************************************************************/ +#pragma once + +// Project Includes +#include "GameObject.hxx" + +namespace SHADE { } + +namespace SHADE +{ + /*---------------------------------------------------------------------------------*/ + /* Forward Declarations */ + /*---------------------------------------------------------------------------------*/ + class SHSceneNode; + + /*---------------------------------------------------------------------------------*/ + /* Type Definitions */ + /*---------------------------------------------------------------------------------*/ + /// + /// Static class that caches all the lists of children for GameObjects. + /// + private ref class ChildListCache abstract sealed + { + public: + /*-----------------------------------------------------------------------------*/ + /* Type Definitions */ + /*-----------------------------------------------------------------------------*/ + using ChildList = System::Collections::Generic::List; + using ChildEnumerable = System::Collections::Generic::IEnumerable; + using ListMap = System::Collections::Generic::Dictionary; + + internal: + /*-----------------------------------------------------------------------------*/ + /* Static Usage Functions */ + /*-----------------------------------------------------------------------------*/ + /// + /// Retrieves the children list for the specified Entity. + /// + /// + /// Enumerable read only list of an Entity's children. Null if entity is invalid + /// or there are no children. + /// + static ChildEnumerable^ GetChildList(Entity entity); + /// + /// Updates the children list for the specified Entity if it exists. + /// + static void UpdateChildList(Entity entity); + + /*-----------------------------------------------------------------------------*/ + /* Event Handling Functions */ + /*-----------------------------------------------------------------------------*/ + /// + /// To be + /// + static void OnChildrenChanged(EntityID entity); + + private: + /*-----------------------------------------------------------------------------*/ + /* Static Data Members */ + /*-----------------------------------------------------------------------------*/ + static ListMap^ cachedLists = gcnew ListMap(); + + /*-----------------------------------------------------------------------------*/ + /* Helper Functions */ + /*-----------------------------------------------------------------------------*/ + static void updateChildList(ChildList^ list, const SHSceneNode* sceneNode); + }; +} \ No newline at end of file diff --git a/SHADE_Managed/src/Engine/ECS.cxx b/SHADE_Managed/src/Engine/ECS.cxx index 00c3c182..ffdffd12 100644 --- a/SHADE_Managed/src/Engine/ECS.cxx +++ b/SHADE_Managed/src/Engine/ECS.cxx @@ -22,11 +22,12 @@ of DigiPen Institute of Technology is prohibited. // External Dependencies #include "ECS_Base/Managers/SHEntityManager.h" #include "Math/Transform/SHTransformComponent.h" -#include "Physics/Components/SHColliderComponent.h" -#include "Physics/Components/SHRigidBodyComponent.h" +#include "Physics/Interface/SHColliderComponent.h" +#include "Physics/Interface/SHRigidBodyComponent.h" #include "Scene/SHSceneManager.h" #include "Scene/SHSceneGraph.h" -#include "Tools/SHLog.h" +#include "Tools/Logger/SHLog.h" +#include "Graphics\MiddleEnd\Interface\SHRenderable.h" // Project Headers #include "Utility/Convert.hxx" #include "Utility/Debug.hxx" @@ -36,6 +37,7 @@ of DigiPen Institute of Technology is prohibited. #include "Components/Camera.hxx" #include "Components/CameraArm.hxx" #include "Components/Light.hxx" +#include "Components\Renderable.hxx" namespace SHADE { @@ -166,6 +168,70 @@ namespace SHADE return T(); } + generic + System::Collections::Generic::IEnumerable^ ECS::GetComponentsInChildren(EntityID entity) + { + System::Type^ componentType = T::typeid; + + // Check if entity is correct + if (!SHEntityManager::IsValidEID(entity)) + { + std::ostringstream oss; + oss << "[ECS] Attempted to retrieve Component \"" + << Convert::ToNative(componentType->Name) + << "\" from invalid Entity."; + Debug::LogError(oss.str()); + return nullptr; + } + + // Search all elements via a iterative breadth first search + System::Collections::Generic::List^ results; + System::Collections::Generic::Queue^ searchSpace = gcnew System::Collections::Generic::Queue(); + // Start off with direct children + SHSceneNode* entityNode = SHSceneManager::GetCurrentSceneGraph().GetNode(entity); + if (entityNode == nullptr) + { + std::ostringstream oss; + oss << "[ScriptStore] Failed to retrieve SceneGraphNode of entity #" << entity << ". This should not happen!"; + SHLog::Warning(oss.str()); + } + for (const auto& child : entityNode->GetChildren()) + { + searchSpace->Enqueue(child->GetEntityID()); + } + // Continue with all subsequent children + while (searchSpace->Count > 0) + { + // Check if this entity has the component we need + Entity curr = searchSpace->Dequeue(); + T component = GetComponent(curr); + if (component != nullptr) + { + // We only construct if we need to + if (results == nullptr) + results = gcnew System::Collections::Generic::List(); + results->Add(component); + } + + // Add children to the queue + SHSceneNode* sceneGraphNode = SHSceneManager::GetCurrentSceneGraph().GetNode(curr); + if (sceneGraphNode == nullptr) + { + std::ostringstream oss; + oss << "[ECS_CLI] Failed to retrieve SceneGraphNode of entity #" << entity << ". This should not happen!"; + SHLog::Warning(oss.str()); + continue; + } + for (const auto& child : sceneGraphNode->GetChildren()) + { + searchSpace->Enqueue(child->GetEntityID()); + } + } + + // None here + return results; + } + generic T ECS::EnsureComponent(EntityID entity) { @@ -249,6 +315,7 @@ namespace SHADE static ECS::ECS() { componentMap.Add(createComponentSet()); + componentMap.Add(createComponentSet()); componentMap.Add(createComponentSet()); componentMap.Add(createComponentSet()); componentMap.Add(createComponentSet()); diff --git a/SHADE_Managed/src/Engine/ECS.hxx b/SHADE_Managed/src/Engine/ECS.hxx index 0563f678..18acf30d 100644 --- a/SHADE_Managed/src/Engine/ECS.hxx +++ b/SHADE_Managed/src/Engine/ECS.hxx @@ -51,9 +51,9 @@ namespace SHADE /// specified Component. /// generic where T : BaseComponent - static T GetComponent(EntityID entity); + static T GetComponent(EntityID entity); /// - /// Retrieves the first Component from the specified GameObjectt's children that + /// Retrieves the first Component from the specified GameObject's children that /// matches the specified type. /// /// Type of the Component to get. @@ -65,6 +65,20 @@ namespace SHADE generic where T : BaseComponent static T GetComponentInChildren(EntityID entity); /// + /// Retrieves a list of Components from the specified GameObject's children that + /// matches the specified type. + /// This function performs allocations. If expecting only 1 component, use + /// GetComponentInChildren() instead. + /// This does not search the specified entity. + /// + /// Type of the Component to get. + /// Entity object to get the Component from. + /// + /// Newly allocated List of components. Will be null if no components are found. + /// + generic where T : BaseComponent + static System::Collections::Generic::IEnumerable^ GetComponentsInChildren(EntityID entity); + /// /// Ensures a Component on the specified Entity. /// /// Type of the Component to ensure. diff --git a/SHADE_Managed/src/Engine/GameObject.cxx b/SHADE_Managed/src/Engine/GameObject.cxx index bc17be8b..200b2079 100644 --- a/SHADE_Managed/src/Engine/GameObject.cxx +++ b/SHADE_Managed/src/Engine/GameObject.cxx @@ -23,6 +23,7 @@ of DigiPen Institute of Technology is prohibited. #include "Utility/Convert.hxx" #include "Scripts/ScriptStore.hxx" #include "Utility/Debug.hxx" +#include "ChildListCache.hxx" namespace SHADE { @@ -87,30 +88,43 @@ namespace SHADE throw gcnew System::NullReferenceException(); return entity; } - GameObject^ GameObject::Parent::get() + GameObject GameObject::Parent::get() { if (!valid) throw gcnew System::NullReferenceException(); + const auto& SCENE_GRAPH = SHSceneManager::GetCurrentSceneGraph(); const auto* ROOT = SCENE_GRAPH.GetRoot(); - const auto* NODE = SCENE_GRAPH.GetNode(entity); if (NODE == nullptr) throw gcnew System::InvalidOperationException("Unable to retrieve SceneGraphNode for Entity " + entity.ToString()); const auto* PARENT = NODE->GetParent(); - return PARENT != ROOT ? gcnew GameObject(PARENT->GetEntityID()) : nullptr; + return PARENT != ROOT ? GameObject(PARENT->GetEntityID()) : GameObject(); } - void GameObject::Parent::set(GameObject^ newParent) + void GameObject::Parent::set(GameObject newParent) { if (!valid) throw gcnew System::NullReferenceException(); auto& SCENE_GRAPH = SHSceneManager::GetCurrentSceneGraph(); - if (newParent == nullptr) - SCENE_GRAPH.SetParent(entity, nullptr); + if (newParent) + SCENE_GRAPH.SetParent(entity, newParent.EntityId); else - SCENE_GRAPH.SetParent(entity, newParent->EntityId); + SCENE_GRAPH.SetParent(entity, nullptr); + } + int GameObject::ChildCount::get() + { + if (!valid) + throw gcnew System::NullReferenceException(); + + const auto& SCENE_GRAPH = SHSceneManager::GetCurrentSceneGraph(); + const auto* ROOT = SCENE_GRAPH.GetRoot(); + const auto* NODE = SCENE_GRAPH.GetNode(entity); + if (NODE == nullptr) + throw gcnew System::InvalidOperationException("Unable to retrieve SceneGraphNode for Entity " + entity.ToString()); + + return static_cast(NODE->GetChildren().size()); } /*---------------------------------------------------------------------------------*/ @@ -156,6 +170,14 @@ namespace SHADE return ECS::GetComponentInChildren(entity); } + generic + System::Collections::Generic::IEnumerable^ GameObject::GetComponentsInChildren() + { + if (!valid) + throw gcnew System::NullReferenceException(); + return ECS::GetComponentsInChildren(entity); + } + generic T GameObject::EnsureComponent() { @@ -198,6 +220,13 @@ namespace SHADE throw gcnew System::NullReferenceException(); return ScriptStore::GetScriptInChildren(entity); } + generic + System::Collections::Generic::IEnumerable^ GameObject::GetScriptsInChildren() + { + if (!valid) + throw gcnew System::NullReferenceException(); + return ScriptStore::GetScriptsInChildren(entity); + } generic System::Collections::Generic::IEnumerable^ GameObject::GetScripts() @@ -215,6 +244,90 @@ namespace SHADE ScriptStore::RemoveScript(entity); } + /*---------------------------------------------------------------------------------*/ + /* Scene Graph Functions */ + /*---------------------------------------------------------------------------------*/ + void GameObject::DetachChildren() + { + // Validity Checks + if (!valid) + throw gcnew System::NullReferenceException(); + auto node = GetSceneNode(); + if (!node) + throw gcnew System::NullReferenceException(); + + // Unparent all children to the root + for (auto child : node->GetChildren()) + { + SHSceneManager::GetCurrentSceneGraph().SetParent(child->GetEntityID(), nullptr); + } + ChildListCache::UpdateChildList(entity); + } + + GameObject GameObject::GetChild(int index) + { + // Validity Checks + if (!valid) + throw gcnew System::NullReferenceException(); + auto node = GetSceneNode(); + if (!node) + throw gcnew System::NullReferenceException(); + + auto child = node->GetChild(index); + return child ? GameObject(child->GetEntityID()) : GameObject(); + } + + System::Collections::Generic::IEnumerable^ GameObject::GetChildren() + { + // Validity Checks + if (!valid) + throw gcnew System::NullReferenceException(); + return ChildListCache::GetChildList(entity); + } + + int GameObject::GetSiblingIndex() + { + throw gcnew System::NotImplementedException(); + } + + bool GameObject::IsChildOf(GameObject gameObj) + { + // Search parents recursively + auto node = GetSceneNode(); + while (node != nullptr) + { + if (node->GetEntityID() == gameObj.entity) + return true; + + // Go up higher + node = node->GetParent(); + } + return false; + } + + void GameObject::SetAsFirstSibling() + { + throw gcnew System::NotImplementedException(); + } + + void GameObject::SetAsLastSibling() + { + throw gcnew System::NotImplementedException(); + } + + void GameObject::SetSiblingIndex(int index) + { + throw gcnew System::NotImplementedException(); + } + + /*---------------------------------------------------------------------------------*/ + /* Operator Overloads */ + /*---------------------------------------------------------------------------------*/ + GameObject::operator bool(GameObject gameObj) + { + return gameObj.valid; + } + /*---------------------------------------------------------------------------------*/ /* Constructors */ /*---------------------------------------------------------------------------------*/ @@ -245,11 +358,15 @@ namespace SHADE } /*---------------------------------------------------------------------------------*/ - /* Operator Overloads */ + /* Helper Functions */ /*---------------------------------------------------------------------------------*/ - GameObject::operator bool(GameObject gameObj) + SHSceneNode* GameObject::GetSceneNode() { - return gameObj.valid; + const auto& SCENE_GRAPH = SHSceneManager::GetCurrentSceneGraph(); + const auto* ROOT = SCENE_GRAPH.GetRoot(); + if (!ROOT) + return nullptr; + return SCENE_GRAPH.GetNode(entity); } /*---------------------------------------------------------------------------------*/ @@ -290,4 +407,21 @@ namespace SHADE { return !(lhs == rhs); } + + /*---------------------------------------------------------------------------------*/ + /* IEnummerable */ + /*---------------------------------------------------------------------------------*/ + System::Collections::Generic::IEnumerator^ GameObject::GetEnumerator() + { + System::Collections::Generic::IEnumerable^ childList = GetChildren(); + if (childList == nullptr) + return System::Linq::Enumerable::Empty()->GetEnumerator(); + else + return childList->GetEnumerator(); + } + + System::Collections::IEnumerator^ GameObject::GetEnumeratorNonGeneric() + { + return GetEnumerator(); + } } diff --git a/SHADE_Managed/src/Engine/GameObject.hxx b/SHADE_Managed/src/Engine/GameObject.hxx index 02a0ed4f..64d1b428 100644 --- a/SHADE_Managed/src/Engine/GameObject.hxx +++ b/SHADE_Managed/src/Engine/GameObject.hxx @@ -20,7 +20,7 @@ of DigiPen Institute of Technology is prohibited. namespace SHADE { /*---------------------------------------------------------------------------------*/ - /* Forward Declarations */ + /* Forward Declarations */ /*---------------------------------------------------------------------------------*/ ref class Script; ref class BaseComponent; @@ -32,8 +32,9 @@ namespace SHADE /// Lightweight object for an Entity that allows for easy access to Component and /// Script operations. /// Can be set to a invalid/null GameObject by default construction. + /// Can also be iterated to access children. /// - public value class GameObject : public System::IEquatable + public value class GameObject : public System::IEquatable, public System::Collections::Generic::IEnumerable { public: /*-----------------------------------------------------------------------------*/ @@ -97,10 +98,17 @@ namespace SHADE /// /// The parent entity for this GameObject. /// - property GameObject^ Parent + property GameObject Parent { - GameObject^ get(); - void set(GameObject^); + GameObject get(); + void set(GameObject); + } + /// + /// Number of Children held by this GameObject + /// + property int ChildCount + { + int get(); } /*-----------------------------------------------------------------------------*/ @@ -120,8 +128,7 @@ namespace SHADE /// /// Whether to activate or deactivate this GameObject. /// - void SetActive(bool active); - + void SetActive(bool active); /*-----------------------------------------------------------------------------*/ /* Component Access Functions */ @@ -146,6 +153,7 @@ namespace SHADE /// /// Retrieves the first Component from this GameObject's children that matches /// the specified type. + /// Unlike Unity, we do not search this GameObject, only the children. /// /// Type of the Component to get. /// @@ -155,6 +163,19 @@ namespace SHADE generic where T : BaseComponent T GetComponentInChildren(); /// + /// Retrieves a list of Components from this GameObject's children that matches + /// the specified type. + /// This function performs allocations. If expecting only 1 component, use + /// GetComponentInChildren() instead. + /// Unlike Unity, we do not search this GameObject, only the children. + /// + /// Type of the Component to get. + /// + /// Newly allocated List of components. Will be null if no components are found. + /// + generic where T : BaseComponent + System::Collections::Generic::IEnumerable^ GetComponentsInChildren(); + /// /// Ensures a Component on this GameObject. /// /// Type of the Component to ensure. @@ -194,12 +215,26 @@ namespace SHADE /// Retrieves a Script of the specified type from child GameObjects. /// If multiple Scripts of the same specified type are added on the same /// child GameObject, this will retrieve the first one added. + /// Unlike Unity, we do not search this GameObject, only the children. /// /// Type of Script to retrieve. /// Reference to the Script to retrieve. generic where T : ref class, Script T GetScriptInChildren(); /// + /// Retrieves a list of Scripts from this GameObject's children that matches + /// the specified type. + /// This function performs allocations. If expecting only 1 component, use + /// GetComponentInChildren() instead. + /// Unlike Unity, we do not search this GameObject, only the children. + /// + /// Type of the Component to get. + /// + /// Newly allocated List of components. Will be null if no components are found. + /// + generic where T : ref class, Script + System::Collections::Generic::IEnumerable^ GetScriptsInChildren(); + /// /// Retrieves a immutable list of Scripts of the specified type from this /// GameObject. /// @@ -214,6 +249,82 @@ namespace SHADE generic where T : ref class, Script void RemoveScript(); + /*-----------------------------------------------------------------------------*/ + /* Scene Graph Functions */ + /*-----------------------------------------------------------------------------*/ + /// + /// Unparents all children. Useful if you want to destroy the root of a hierarchy + /// without destroying the children. + /// + void DetachChildren(); + /// + /// Returns a child by index. + /// + /// Index of the child GameObject to retrieve. + /// + /// Handle to the GameObject if the index is valid. Invalid GameObject otherwise. + /// + GameObject GetChild(int index); + /// + /// Returns a cached enumerable container of child GameObjects of this + /// GameObject. + /// + /// + /// Enumerable container of child GameObjects of this GameObject. Null if + /// ChildCount is 0. + /// + System::Collections::Generic::IEnumerable^ GetChildren(); + /// + /// Gets the sibling index. Use GetSiblingIndex to find out the GameObject’s + /// place in this hierarchy. When the sibling index of a GameObject is changed, + /// its order in the Hierarchy window will also change. + /// + /// + /// Index of this GameObject among the parent GameObject's children. + /// + [System::ObsoleteAttribute("Not yet implemented.", true)] + int GetSiblingIndex(); + /// + /// Checks if this GameObject a direct or indirect child of the specified + /// GameObject. + /// + /// + /// True if this GameObject is a child, deep child (child of a child) or + /// identical to this GameObject, otherwise false. + /// + bool IsChildOf(GameObject gameObj); + /// + /// Move the GameObject to the start of the parent GameObject's children list. + /// + [System::ObsoleteAttribute("Not yet implemented.", true)] + void SetAsFirstSibling(); + /// + /// Move the GameObject to the end of the parent GameObject's children list. + /// + [System::ObsoleteAttribute("Not yet implemented.", true)] + void SetAsLastSibling(); + /// + /// Move the GameObject to the specified position in the parent GameObject's + /// children list. An existing object at that position if any, will be pushed + /// to the next index (existing element will be at index + 1). + /// + /// + /// Position to place this GameObject at in the hierarchy. Clamped to between + /// [0, parent.ChildCount]. + /// + [System::ObsoleteAttribute("Not yet implemented.", true)] + void SetSiblingIndex(int index); + + /*-----------------------------------------------------------------------------*/ + /* Operator Overloads */ + /*-----------------------------------------------------------------------------*/ + /// + /// Implicit conversion operator to enable checking if a GameObject is valid. + /// + /// GameObjects to check. + /// True if the GameObject is valid. + static operator bool(GameObject gameObj); + internal: /*-----------------------------------------------------------------------------*/ /* Constructors */ @@ -249,13 +360,13 @@ namespace SHADE SHEntity& GetNativeEntity(); /*-----------------------------------------------------------------------------*/ - /* Operator Overloads */ + /* Helper Functions */ /*-----------------------------------------------------------------------------*/ /// - /// Implicit conversion operator to enable checking if a GameObject is valid. + /// Retrieves the SceneNode for this GameObject's referenced entity. /// - /// GameObjects to check. - static operator bool(GameObject gameObj); + /// Pointer to the SceneNode for this GameObject.. + SHSceneNode* GetSceneNode(); private: /*-----------------------------------------------------------------------------*/ @@ -304,6 +415,14 @@ namespace SHADE /// Another GameObject to check with. /// True if both Components are different. static bool operator!=(GameObject lhs, GameObject rhs); + + /*-----------------------------------------------------------------------------*/ + /* IEnummerable */ + /*-----------------------------------------------------------------------------*/ + /// + System::Collections::Generic::IEnumerator^ GetEnumerator() override; + /// + System::Collections::IEnumerator^ GetEnumeratorNonGeneric() override = System::Collections::IEnumerable::GetEnumerator; }; } diff --git a/SHADE_Managed/src/Engine/GenericHandle.hxx b/SHADE_Managed/src/Engine/GenericHandle.hxx index 3f8e395f..3d77f54d 100644 --- a/SHADE_Managed/src/Engine/GenericHandle.hxx +++ b/SHADE_Managed/src/Engine/GenericHandle.hxx @@ -21,7 +21,7 @@ namespace SHADE /// /// Managed version of the generic Handle. /// - public value struct GenericHandle + private value struct GenericHandle { public: /*-----------------------------------------------------------------------------*/ diff --git a/SHADE_Managed/src/Engine/Time.cxx b/SHADE_Managed/src/Engine/Time.cxx index 36032e00..8784ec90 100644 --- a/SHADE_Managed/src/Engine/Time.cxx +++ b/SHADE_Managed/src/Engine/Time.cxx @@ -16,7 +16,7 @@ of DigiPen Institute of Technology is prohibited. #include "SHpch.h" // External Dependencies #include "FRC/SHFramerateController.h" -#include "Physics/SHPhysicsSystemInterface.h" +#include "Physics/System/SHPhysicsSystemInterface.h" // Primary Header #include "Time.hxx" diff --git a/SHADE_Managed/src/Scripts/Script.cxx b/SHADE_Managed/src/Scripts/Script.cxx index 9d6cadb8..a2af38a3 100644 --- a/SHADE_Managed/src/Scripts/Script.cxx +++ b/SHADE_Managed/src/Scripts/Script.cxx @@ -42,6 +42,12 @@ namespace SHADE return owner.GetComponentInChildren(); } + generic + System::Collections::Generic::IEnumerable^ Script::GetComponentsInChildren() + { + return owner.GetComponentsInChildren(); + } + generic T Script::EnsureComponent() { @@ -72,6 +78,11 @@ namespace SHADE { return ScriptStore::GetScriptInChildren(owner.GetEntity()); } + generic + System::Collections::Generic::IEnumerable^ Script::GetScriptsInChildren() + { + return ScriptStore::GetScriptsInChildren(owner.GetEntity()); + } generic System::Collections::Generic::IEnumerable^ Script::GetScripts() @@ -93,6 +104,11 @@ namespace SHADE /*---------------------------------------------------------------------------------*/ /* "All-time" Lifecycle Functions */ /*---------------------------------------------------------------------------------*/ + void Script::Initialize(GameObject newOwner) + { + owner = newOwner; + } + void Script::OnAttached() { SAFE_NATIVE_CALL_BEGIN @@ -198,9 +214,8 @@ namespace SHADE /*---------------------------------------------------------------------------------*/ /* Constructors */ /*---------------------------------------------------------------------------------*/ - Script::Script(GameObject gameObj) - : owner { gameObj } - , OnGizmosDrawOverriden { false } + Script::Script() + : OnGizmosDrawOverriden { false } {} /*---------------------------------------------------------------------------------*/ diff --git a/SHADE_Managed/src/Scripts/Script.hxx b/SHADE_Managed/src/Scripts/Script.hxx index bbe36784..46736245 100644 --- a/SHADE_Managed/src/Scripts/Script.hxx +++ b/SHADE_Managed/src/Scripts/Script.hxx @@ -69,6 +69,7 @@ namespace SHADE /// /// Retrieves the first Component from this GameObject's children that matches /// the specified type. + /// Unlike Unity, we do not search this GameObject, only the children. /// /// /// Type of the Component to get. Must be derived from BaseComponent. @@ -77,6 +78,19 @@ namespace SHADE generic where T : BaseComponent T GetComponentInChildren(); /// + /// Retrieves a list of Components from this GameObject's children that + /// matches the specified type. + /// This function performs allocations. If expecting only 1 component, use + /// GetComponentInChildren() instead. + /// Unlike Unity, we do not search this GameObject, only the children. + /// + /// Type of the Component to get. + /// + /// Newly allocated List of components. Will be null if no components are found. + /// + generic where T : BaseComponent + System::Collections::Generic::IEnumerable^ GetComponentsInChildren(); + /// /// Ensures a Component on the GameObject that this Script belongs to. /// /// @@ -121,6 +135,7 @@ namespace SHADE /// /// Retrieves the first Script from this GameObject's children that matches the /// specified type. + /// Unlike Unity, we do not search this GameObject, only the children. /// /// /// Type of script to get. @@ -130,6 +145,19 @@ namespace SHADE generic where T : ref class, Script T GetScriptInChildren(); /// + /// Retrieves a list of Scripts from this GameObject's children that matches + /// the specified type. + /// This function performs allocations. If expecting only 1 component, use + /// GetComponentInChildren() instead. + /// Unlike Unity, we do not search this GameObject, only the children. + /// + /// Type of the Component to get. + /// + /// Newly allocated List of components. Will be null if no components are found. + /// + generic where T : ref class, Script + System::Collections::Generic::IEnumerable^ GetScriptsInChildren(); + /// /// Retrieves a immutable list of scripts from the specified Entity that /// matches the specified type. ///
@@ -165,7 +193,7 @@ namespace SHADE internal: /*-----------------------------------------------------------------------------*/ - /* Properties */ + /* Fields */ /*-----------------------------------------------------------------------------*/ /// /// If true, the OnGizmosDraw function was overridden. @@ -176,6 +204,10 @@ namespace SHADE /* "All-Time" Lifecycle Functions */ /*-----------------------------------------------------------------------------*/ /// + /// Used to initialize a Script with a GameObject. + /// + void Initialize(GameObject newOwner); + /// /// Used to call onAttached(). This is called immediately when this script is /// attached to a GameObject. /// @@ -272,13 +304,9 @@ namespace SHADE /* Constructors */ /*-----------------------------------------------------------------------------*/ /// - /// Constructor for Script to tie it to a specific GameObject. - /// Constructors of derived Scripts should call this Constructor. + /// Default Constructor /// - /// - /// GameObject that this Script will be tied to. - /// - Script(GameObject gameObj); + Script(); /*-----------------------------------------------------------------------------*/ /* Virtual "All-Time" Lifecycle Functions */ diff --git a/SHADE_Managed/src/Scripts/ScriptStore.cxx b/SHADE_Managed/src/Scripts/ScriptStore.cxx index a90b4f12..d57122ee 100644 --- a/SHADE_Managed/src/Scripts/ScriptStore.cxx +++ b/SHADE_Managed/src/Scripts/ScriptStore.cxx @@ -20,16 +20,17 @@ of DigiPen Institute of Technology is prohibited. #include // External Dependencies #include "ECS_Base/Managers/SHEntityManager.h" -#include "Tools/SHLog.h" +#include "Tools/Logger/SHLog.h" // Project Headers #include "Utility/Debug.hxx" #include "Utility/Convert.hxx" #include "Script.hxx" #include "Engine/Entity.hxx" -#include "Serialisation/ReflectionUtilities.hxx" +#include "Serialisation/SerialisationUtilities.hxx" #include "Engine/Application.hxx" -#include "Physics/SHPhysicsSystemInterface.h" -#include "Physics/SHPhysicsUtils.h" +#include "Physics/System/SHPhysicsSystemInterface.h" +#include "Physics/SHPhysicsEvents.h" +#include "Physics/Collision/SHCollisionInfo.h" namespace SHADE { @@ -38,6 +39,19 @@ namespace SHADE /*---------------------------------------------------------------------------------*/ generic T ScriptStore::AddScript(Entity entity) + { + // Create the script and add it in + Script^ script = safe_cast(System::Activator::CreateInstance(T::typeid)); + + return safe_cast(AddScript(entity, script)); + } + + Script^ ScriptStore::AddScript(Entity entity, Script^ script) + { + return AddScript(entity, script, System::Int32::MaxValue); + } + + Script^ ScriptStore::AddScript(Entity entity, Script^ script, int index) { // Check if entity exists if (!EntityUtils::IsValid(entity)) @@ -57,15 +71,22 @@ namespace SHADE entityScriptList = scripts[entity]; } - // Create the script and add it in - array^ params = gcnew array{GameObject(entity)}; - Script^ script = safe_cast(System::Activator::CreateInstance(T::typeid, params)); - entityScriptList->Add(script); - awakeList.Add(script); - startList.Add(script); + // Add the script in + script->Initialize(GameObject(entity)); + entityScriptList->Insert(System::Math::Clamp(index, 0, entityScriptList->Count), script); + if (Application::IsPlaying) + { + script->Awake(); + script->Start(); + } + else + { + awakeList.Add(script); + startList.Add(script); + } script->OnAttached(); - return safe_cast(script); + return script; } bool ScriptStore::AddScriptViaName(Entity entity, System::String^ scriptName) @@ -110,6 +131,7 @@ namespace SHADE std::ostringstream oss; oss << "[ScriptStore] Failed to add Script named \"" << Convert::ToNative(scriptName) << "\" to Entity #" << entity << "! (" << Convert::ToNative(e->GetType()->Name) << ")"; + oss << Convert::ToNative(e->ToString()); Debug::LogError(oss.str()); return false; } @@ -189,6 +211,70 @@ namespace SHADE return T(); } + generic + System::Collections::Generic::IEnumerable^ ScriptStore::GetScriptsInChildren(Entity entity) + { + System::Type^ componentType = T::typeid; + + // Check if entity is correct + if (!SHEntityManager::IsValidEID(entity)) + { + std::ostringstream oss; + oss << "[ScriptStore] Attempted to retrieve Script \"" + << Convert::ToNative(componentType->Name) + << "\" from invalid Entity."; + Debug::LogError(oss.str()); + return nullptr; + } + + // Search all elements via a iterative breadth first search + System::Collections::Generic::List^ results; + System::Collections::Generic::Queue^ searchSpace = gcnew System::Collections::Generic::Queue(); + // Start off with direct children + SHSceneNode* entityNode = SHSceneManager::GetCurrentSceneGraph().GetNode(entity); + if (entityNode == nullptr) + { + std::ostringstream oss; + oss << "[ScriptStore] Failed to retrieve SceneGraphNode of entity #" << entity << ". This should not happen!"; + SHLog::Warning(oss.str()); + } + for (const auto& child : entityNode->GetChildren()) + { + searchSpace->Enqueue(child->GetEntityID()); + } + // Continue with all subsequent children + while (searchSpace->Count > 0) + { + // Check if this entity has the component we need + Entity curr = searchSpace->Dequeue(); + T script = GetScript(curr); + if (script != nullptr) + { + // We only construct if we need to + if (results == nullptr) + results = gcnew System::Collections::Generic::List(); + results->Add(script); + } + + // Add children to the queue + SHSceneNode* sceneGraphNode = SHSceneManager::GetCurrentSceneGraph().GetNode(curr); + if (sceneGraphNode == nullptr) + { + std::ostringstream oss; + oss << "[ScriptStore] Failed to retrieve SceneGraphNode of entity #" << entity << ". This should not happen!"; + SHLog::Warning(oss.str()); + continue; + } + for (const auto& child : sceneGraphNode->GetChildren()) + { + searchSpace->Enqueue(child->GetEntityID()); + } + } + + // None here + return results; + } + generic System::Collections::Generic::IEnumerable^ ScriptStore::GetScripts(Entity entity) { @@ -364,7 +450,10 @@ namespace SHADE } } startList.Clear(); - startList.AddRange(%inactiveStartList); + for each (Script ^ script in startList) + { + startList.Add(script); + } inactiveStartList.Clear(); SAFE_NATIVE_CALL_END_N("SHADE_Managed.ScriptStore") @@ -373,9 +462,8 @@ namespace SHADE { SAFE_NATIVE_CALL_BEGIN // Clear the queue - while (disposalQueue.Count > 0) - { - Script^ script = disposalQueue.Dequeue(); + for each (Script^ script in disposalQueue) + {; if (Application::IsPlaying) { script->OnDestroy(); @@ -388,6 +476,7 @@ namespace SHADE scripts.Remove(entity); } } + disposalQueue.Clear(); SAFE_NATIVE_CALL_END_N("SHADE_Managed.ScriptStore") } void ScriptStore::Exit() @@ -436,9 +525,10 @@ namespace SHADE continue; // Update each script - for each (Script^ script in entity.Value) + ScriptList^ scripts = entity.Value; + for (int i = 0; i < scripts->Count; ++i) { - script->FixedUpdate(); + scripts[i]->FixedUpdate(); } } SAFE_NATIVE_CALL_END_N("SHADE_Managed.ScriptStore") @@ -453,9 +543,10 @@ namespace SHADE continue; // Update each script - for each (Script^ script in entity.Value) + ScriptList^ scripts = entity.Value; + for (int i = 0; i < scripts->Count; ++i) { - script->Update(); + scripts[i]->Update(); } } SAFE_NATIVE_CALL_END_N("SHADE_Managed.ScriptStore") @@ -470,9 +561,10 @@ namespace SHADE continue; // Update each script - for each (Script^ script in entity.Value) + ScriptList^ scripts = entity.Value; + for (int i = 0; i < scripts->Count; ++i) { - script->LateUpdate(); + scripts[i]->LateUpdate(); } } SAFE_NATIVE_CALL_END_N("SHADE_Managed.ScriptStore") @@ -488,9 +580,10 @@ namespace SHADE continue; // Update each script - for each (Script^ script in entity.Value) + ScriptList^ scripts = entity.Value; + for (int i = 0; i < scripts->Count; ++i) { - script->OnDrawGizmos(); + scripts[i]->OnDrawGizmos(); } } SAFE_NATIVE_CALL_END_N("SHADE_Managed.ScriptStore") @@ -522,17 +615,18 @@ namespace SHADE auto entityScripts = scripts[entity.first]; if (entityScripts->Count > 0) { - for each (Script ^ script in entityScripts) + for (int i = 0; i < entityScripts->Count; ++i) { + Script^ script = entityScripts[i]; switch (collisionInfo.GetCollisionState()) { - case SHCollisionEvent::State::ENTER: + case SHCollisionInfo::State::ENTER: script->OnCollisionEnter(info); break; - case SHCollisionEvent::State::STAY: + case SHCollisionInfo::State::STAY: script->OnCollisionStay(info); break; - case SHCollisionEvent::State::EXIT: + case SHCollisionInfo::State::EXIT: script->OnCollisionExit(info); break; } @@ -563,17 +657,18 @@ namespace SHADE auto entityScripts = scripts[entity.first]; if (entityScripts->Count > 0) { - for each (Script ^ script in entityScripts) + for (int i = 0; i < entityScripts->Count; ++i) { + Script^ script = entityScripts[i]; switch (triggerInfo.GetCollisionState()) { - case SHCollisionEvent::State::ENTER: + case SHCollisionInfo::State::ENTER: script->OnTriggerEnter(info); break; - case SHCollisionEvent::State::STAY: + case SHCollisionInfo::State::STAY: script->OnTriggerStay(info); break; - case SHCollisionEvent::State::EXIT: + case SHCollisionInfo::State::EXIT: script->OnTriggerExit(info); break; } @@ -613,7 +708,7 @@ namespace SHADE System::Collections::Generic::List^ scriptList = scripts[entity]; for each (Script^ script in scriptList) { - ReflectionUtilities::Serialise(script, *yamlNode); + SerialisationUtilities::Serialise(script, *yamlNode); } return true; @@ -658,7 +753,7 @@ namespace SHADE if (AddScriptViaNameWithRef(entity, typeName, script)) { // Copy the data in - ReflectionUtilities::Deserialise(script, node); + SerialisationUtilities::Deserialise(script, node); } else { @@ -677,9 +772,9 @@ namespace SHADE void ScriptStore::removeScript(Script^ script) { // Prepare for disposal - disposalQueue.Enqueue(script); + disposalQueue.Add(script); - // Also remove it fromm awake and start queues if they were created but not initialised + // Also remove it from awake and start queues if they were created but not initialised awakeList.Remove(script); startList.Remove(script); script->OnDetached(); @@ -749,7 +844,8 @@ namespace SHADE void ScriptStore::getGenericMethods() { - addScriptMethod = ScriptStore::typeid->GetMethod("AddScript"); + array^ paramTypes = gcnew array{ Entity::typeid }; + addScriptMethod = ScriptStore::typeid->GetMethod("AddScript", paramTypes); if (addScriptMethod == nullptr) { Debug::LogError("[ScriptStore] Failed to get MethodInfo of \"AddScript()\". Adding of scripts from native code will fail."); diff --git a/SHADE_Managed/src/Scripts/ScriptStore.hxx b/SHADE_Managed/src/Scripts/ScriptStore.hxx index 23440f3d..78f8c787 100644 --- a/SHADE_Managed/src/Scripts/ScriptStore.hxx +++ b/SHADE_Managed/src/Scripts/ScriptStore.hxx @@ -25,7 +25,7 @@ namespace SHADE /// Responsible for managing all scripts attached to Entities as well as executing /// all lifecycle functions of scripts. /// - public ref class ScriptStore abstract sealed + private ref class ScriptStore abstract sealed { public: /*-----------------------------------------------------------------------------*/ @@ -46,6 +46,27 @@ namespace SHADE generic where T : ref class, Script static T AddScript(Entity entity); /// + /// Adds a specified pre-constructed Script to a specified Entity. + /// + /// The entity to add a script to. + /// The pre-constructed Script to add. + /// Reference to the script added. + /// + /// If the specified Entity is invalid. + /// + static Script^ AddScript(Entity entity, Script^ script); + /// + /// Adds a specified pre-constructed Script to a specified Entity. + /// + /// The entity to add a script to. + /// The pre-constructed Script to add. + /// Location in the script list to add. + /// Reference to the script added. + /// + /// If the specified Entity is invalid. + /// + static Script^ AddScript(Entity entity, Script^ script, int index); + /// /// Adds a Script to a specified Entity. ///
/// This function is meant for consumption from native code. If you are writing @@ -116,6 +137,29 @@ namespace SHADE generic where T : ref class, Script static T GetScriptInChildren(Entity entity); /// + /// Retrieves the list of Scripts from the specified Entity and the Entity's + /// children that matches the specified type. + /// This function performs allocations. If expecting only 1 component, use + /// GetScriptInChildren() instead. + /// This does not search the specified entity. + /// + /// + /// Type of script to get. + /// This needs to be a default constructable Script. + /// + /// + /// The entity which the script to retrieve is attached. + /// + /// + /// Reference to the script. This can be null if no script of the specified + /// type is attached. + /// + /// + /// If the specified Entity is invalid. + /// + generic where T : ref class, Script + static System::Collections::Generic::IEnumerable^ GetScriptsInChildren(Entity entity); + /// /// Retrieves a immutable list of scripts from the specified Entity that /// matches the specified type. ///
@@ -281,16 +325,16 @@ namespace SHADE /*-----------------------------------------------------------------------------*/ using ScriptList = System::Collections::Generic::List; using ScriptDictionary = System::Collections::Generic::Dictionary; - using ScriptQueue = System::Collections::Generic::Queue; + using ScriptSet = System::Collections::Generic::HashSet; /*-----------------------------------------------------------------------------*/ /* Static Data Members */ /*-----------------------------------------------------------------------------*/ static ScriptDictionary scripts; - static ScriptList awakeList; - static ScriptList startList; - static ScriptList inactiveStartList; - static ScriptQueue disposalQueue; + static ScriptSet awakeList; + static ScriptSet startList; + static ScriptSet inactiveStartList; + static ScriptSet disposalQueue; static System::Collections::Generic::IEnumerable^ scriptTypeList; static System::Reflection::MethodInfo^ addScriptMethod; diff --git a/SHADE_Managed/src/Serialisation/ReflectionUtilities.cxx b/SHADE_Managed/src/Serialisation/ReflectionUtilities.cxx index 651afb73..f371686c 100644 --- a/SHADE_Managed/src/Serialisation/ReflectionUtilities.cxx +++ b/SHADE_Managed/src/Serialisation/ReflectionUtilities.cxx @@ -18,31 +18,6 @@ of DigiPen Institute of Technology is prohibited. #include "Serialisation/ReflectionUtilities.hxx" // Project Includes #include "SerializeFieldAttribute.hxx" -#include "Utility/Convert.hxx" -#include "Math/Vector2.hxx" -#include "Math/Vector3.hxx" -#include "Utility/Debug.hxx" -#include "Engine/GameObject.hxx" - -/*-------------------------------------------------------------------------------------*/ -/* Macro Functions */ -/*-------------------------------------------------------------------------------------*/ -/// -/// Macro expansion that is used in RapidJsonValueToField() to retrieve the specified -/// member of a Vector type that is stored into a Vector named "vec". -/// -/// The name of the member to retrieve. -#define PRIMITIVE_VECTOR_FIELD_ASSIGN(MEMBER) \ -iter = jsonValue.FindMember(#MEMBER); \ -if (iter != jsonValue.MemberEnd()) \ -{ \ - vec.MEMBER = iter->value.GetDouble(); \ -} \ - -/*-------------------------------------------------------------------------------------*/ -/* File-Level Constants */ -/*-------------------------------------------------------------------------------------*/ -static const std::string_view SCRIPT_TYPE_YAMLTAG = "Type"; /*-------------------------------------------------------------------------------------*/ /* Function Definitions */ @@ -64,202 +39,14 @@ namespace SHADE return fieldInfo->IsPublic || fieldInfo->GetCustomAttributes(SerializeField::typeid, true)->Length > 0; } - /*---------------------------------------------------------------------------------*/ - /* Serialisation Functions */ - /*---------------------------------------------------------------------------------*/ - void ReflectionUtilities::Serialise(System::Object^ object, YAML::Node& scriptListNode) + bool ReflectionUtilities::FieldIsList(System::Reflection::FieldInfo^ fieldInfo) { - using namespace System::Reflection; - - // Create YAML object - YAML::Node scriptNode; - scriptNode.SetStyle(YAML::EmitterStyle::Block); - scriptNode[SCRIPT_TYPE_YAMLTAG.data()] = Convert::ToNative(object->GetType()->FullName); - - // Get all fields - System::Collections::Generic::IEnumerable^ fields = GetInstanceFields(object); - for each (FieldInfo^ field in fields) - { - // Ignore private and non-SerialiseField - if (!FieldIsSerialisable(field)) - continue; - - // Serialise - writeFieldIntoYaml(field, object, scriptNode); - } - - scriptListNode.push_back(scriptNode); - } - void ReflectionUtilities::Deserialise(Object^ object, YAML::Node& yamlNode) - { - using namespace System::Reflection; - - // Load the YAML - if (!yamlNode.IsMap()) - { - // Invalid - Debug::LogError - ( - System::String::Format("[ReflectionUtilities] Invalid YAML Node provided for deserialization of \"{0}\" script.", - object->GetType()->FullName) - ); - return; - } - // Get all fields - System::Collections::Generic::IEnumerable^ fields = GetInstanceFields(object); - for each (FieldInfo^ field in fields) - { - // Ignore private and non-SerialiseField - if (!FieldIsSerialisable(field)) - continue; - - // Deserialise - const std::string FIELD_NAME = Convert::ToNative(field->Name); - if (yamlNode[FIELD_NAME]) - { - writeYamlIntoField(field, object, yamlNode[FIELD_NAME]); - } - } - } - /*---------------------------------------------------------------------------------*/ - /* Serialization Helper Functions */ - /*---------------------------------------------------------------------------------*/ - void ReflectionUtilities::writeFieldIntoYaml(System::Reflection::FieldInfo^ fieldInfo, Object^ object, YAML::Node& yamlNode) - { - // Field YAML Node - YAML::Node fieldNode; - - // Retrieve string for the YAML - const bool PRIMITIVE_SERIALIZED = fieldInsertYaml(fieldInfo, object, fieldNode) || - fieldInsertYaml(fieldInfo, object, fieldNode) || - fieldInsertYaml(fieldInfo, object, fieldNode) || - fieldInsertYaml(fieldInfo, object, fieldNode) || - fieldInsertYaml(fieldInfo, object, fieldNode) || - fieldInsertYaml(fieldInfo, object, fieldNode) || - fieldInsertYaml(fieldInfo, object, fieldNode) || - fieldInsertYaml(fieldInfo, object, fieldNode) || - fieldInsertYaml(fieldInfo, object, fieldNode) || - fieldInsertYaml(fieldInfo, object, fieldNode); - - // Serialization of more complex types - if (!PRIMITIVE_SERIALIZED) - { - if (fieldInfo->FieldType->IsSubclassOf(System::Enum::typeid)) - { - fieldNode = std::to_string(safe_cast(fieldInfo->GetValue(object))); - } - else if (fieldInfo->FieldType == System::String::typeid) - { - System::String^ str = safe_cast(fieldInfo->GetValue(object)); - fieldNode = Convert::ToNative(str); - } - else if (fieldInfo->FieldType == Vector2::typeid) - { - Vector2 vec = safe_cast(fieldInfo->GetValue(object)); - fieldNode.SetStyle(YAML::EmitterStyle::Flow); - fieldNode.push_back(vec.x); - fieldNode.push_back(vec.y); - } - else if (fieldInfo->FieldType == Vector3::typeid) - { - Vector3 vec = safe_cast(fieldInfo->GetValue(object)); - fieldNode.SetStyle(YAML::EmitterStyle::Flow); - fieldNode.push_back(vec.x); - fieldNode.push_back(vec.y); - fieldNode.push_back(vec.z); - } - else if (fieldInfo->FieldType == GameObject::typeid) - { - GameObject gameObj = safe_cast(fieldInfo->GetValue(object)); - fieldNode = gameObj ? gameObj.GetEntity() : MAX_EID; - } - else // Not any of the supported types - { - Debug::LogWarning(Convert::ToNative(System::String::Format - ( - "[ReflectionUtilities] Failed to parse \"{0}\" of \"{1}\" type for serialization.", - fieldInfo->Name, fieldInfo->FieldType) - )); - return; - } - } - - // Store the field into YAML - yamlNode[Convert::ToNative(fieldInfo->Name)] = fieldNode; + return IsList(fieldInfo->FieldType); } - void ReflectionUtilities::writeYamlIntoField(System::Reflection::FieldInfo^ fieldInfo, Object^ object, YAML::Node& node) + bool ReflectionUtilities::IsList(System::Type^ type) { - if (fieldAssignYaml (fieldInfo, object, node) || - fieldAssignYaml (fieldInfo, object, node) || - fieldAssignYaml (fieldInfo, object, node) || - fieldAssignYaml(fieldInfo, object, node) || - fieldAssignYaml(fieldInfo, object, node) || - fieldAssignYaml(fieldInfo, object, node) || - fieldAssignYaml (fieldInfo, object, node) || - fieldAssignYaml (fieldInfo, object, node) || - fieldAssignYaml (fieldInfo, object, node) || - fieldAssignYaml (fieldInfo, object, node)) - { - return; - } - else if (fieldInfo->FieldType->IsSubclassOf(System::Enum::typeid)) - { - fieldInfo->SetValue(object, node.as()); - } - else if (fieldInfo->FieldType == System::String::typeid) - { - fieldInfo->SetValue(object, Convert::ToCLI(node.as())); - } - else if (fieldInfo->FieldType == Vector2::typeid) - { - if (node.IsSequence() && node.size() == 2) - { - Vector2 vec; - vec.x = node[0].as(); - vec.y = node[1].as(); - fieldInfo->SetValue(object, vec); - } - else - { - Debug::LogWarning - ( - System::String::Format("[ReflectionUtilities] Invalid YAML Node provided for deserialization of a Vector2 \"{0}\" field in \"{1}\" script.", - fieldInfo->Name, object->GetType()->FullName) - ); - } - } - else if (fieldInfo->FieldType == Vector3::typeid) - { - if (node.IsSequence() && node.size() == 3) - { - Vector3 vec; - vec.x = node[0].as(); - vec.y = node[1].as(); - vec.z = node[2].as(); - fieldInfo->SetValue(object, vec); - } - else - { - Debug::LogWarning - ( - System::String::Format("[ReflectionUtilities] Invalid YAML Node provided for deserialization of a Vector3 \"{0}\" field in \"{1}\" script.", - fieldInfo->Name, object->GetType()->FullName) - ); - } - } - else if (fieldInfo->FieldType == GameObject::typeid) - { - const uint32_t EID = node.as(); - fieldInfo->SetValue(object, EID == MAX_EID ? GameObject() : GameObject(EID)); - } - else // Not any of the supported types - { - Debug::LogWarning(Convert::ToNative(System::String::Format - ( - "[ReflectionUtilities] Failed to parse \"{0}\" of \"{1}\" type for deserialisation.", - fieldInfo->Name, fieldInfo->FieldType) - )); - } + return type->IsGenericType + && type->GetGenericTypeDefinition() == System::Collections::Generic::List::typeid->GetGenericTypeDefinition(); } } diff --git a/SHADE_Managed/src/Serialisation/ReflectionUtilities.h++ b/SHADE_Managed/src/Serialisation/ReflectionUtilities.h++ deleted file mode 100644 index 7c39232a..00000000 --- a/SHADE_Managed/src/Serialisation/ReflectionUtilities.h++ +++ /dev/null @@ -1,55 +0,0 @@ -/************************************************************************************//*! -\file ReflectionUtilities.h++ -\author Tng Kah Wei, kahwei.tng, 390009620 -\par email: kahwei.tng\@digipen.edu -\date Sep 16, 2022 -\brief Contains the definition of the template functions of the managed - ReflectionUtilities static class. - - Note: This file is written in C++17/CLI. - -Copyright (C) 2022 DigiPen Institute of Technology. -Reproduction or disclosure of this file or its contents without the prior written consent -of DigiPen Institute of Technology is prohibited. -*//*************************************************************************************/ -#pragma once - -// Primary Header -#include "ReflectionUtilities.hxx" - -namespace SHADE -{ - /*---------------------------------------------------------------------------------*/ - /* Serialization Helper Functions */ - /*---------------------------------------------------------------------------------*/ - template - bool ReflectionUtilities::fieldInsertYaml(System::Reflection::FieldInfo^ fieldInfo, System::Object^ object, YAML::Node& fieldNode) - { - if (fieldInfo->FieldType == FieldType::typeid) - { - const FieldType VALUE = safe_cast(fieldInfo->GetValue(object)); - fieldNode = static_cast(VALUE); - return true; - } - - return false; - } - - template - bool ReflectionUtilities::fieldAssignYaml(System::Reflection::FieldInfo^ fieldInfo, Object^ object, YAML::Node& node) - { - return fieldAssignYaml>(fieldInfo, object, node); - } - - template - bool ReflectionUtilities::fieldAssignYaml(System::Reflection::FieldInfo^ fieldInfo, Object^ object, YAML::Node& node) - { - if (fieldInfo->FieldType == FieldType::typeid) - { - fieldInfo->SetValue(object, node.as()); - return true; - } - - return false; - } -} diff --git a/SHADE_Managed/src/Serialisation/ReflectionUtilities.hxx b/SHADE_Managed/src/Serialisation/ReflectionUtilities.hxx index 403c913c..ae66cc34 100644 --- a/SHADE_Managed/src/Serialisation/ReflectionUtilities.hxx +++ b/SHADE_Managed/src/Serialisation/ReflectionUtilities.hxx @@ -13,9 +13,6 @@ of DigiPen Institute of Technology is prohibited. *//*************************************************************************************/ #pragma once -// External Dependencies -#include - namespace SHADE { /// @@ -42,40 +39,17 @@ namespace SHADE /// True if the specified field is a candidate for serialisation. /// static bool FieldIsSerialisable(System::Reflection::FieldInfo^ fieldInfo); - - /*-----------------------------------------------------------------------------*/ - /* Serialisation Functions */ - /*-----------------------------------------------------------------------------*/ /// - /// Creates a JSON node that represents the specified object and its associated - /// serialisable fields. Public fields and fields marked with the SerialiseField - /// attribute will be serialised. + /// Checks if the specified field is a generic List. /// - /// The object to serialise. - static void Serialise(System::Object^ object, YAML::Node& yamlNode); + /// The field to check. + /// True if fieldInfo is describing a generic List. + static bool FieldIsList(System::Reflection::FieldInfo^ fieldInfo); /// - /// Deserialises a YAML node that contains a map of Scripts and copies the - /// deserialised data into the specified object if there are matching fields. + /// Checks if the specified type is a generic List type. /// - /// - /// The JSON string that contains the data to copy into this Script object. - /// - /// The object to copy deserialised data into. - static void Deserialise(System::Object^ object, YAML::Node& yamlNode); - - private: - /*-----------------------------------------------------------------------------*/ - /* Serialization Helper Functions */ - /*-----------------------------------------------------------------------------*/ - static void writeFieldIntoYaml(System::Reflection::FieldInfo^ fieldInfo, Object^ object, YAML::Node& yamlNode); - template - static bool fieldInsertYaml(System::Reflection::FieldInfo^ fieldInfo, System::Object^ object, YAML::Node& fieldNode); - static void writeYamlIntoField(System::Reflection::FieldInfo^ fieldInfo, Object^ object, YAML::Node& node); - template - static bool fieldAssignYaml(System::Reflection::FieldInfo^ fieldInfo, Object^ object, YAML::Node& node); - template - static bool fieldAssignYaml(System::Reflection::FieldInfo^ fieldInfo, Object^ object, YAML::Node& node); + /// The type to check. + /// True if type is a generic List. + static bool IsList(System::Type^ type); }; -} - -#include "ReflectionUtilities.h++" \ No newline at end of file +} \ No newline at end of file diff --git a/SHADE_Managed/src/Serialisation/SerialisationUtilities.cxx b/SHADE_Managed/src/Serialisation/SerialisationUtilities.cxx new file mode 100644 index 00000000..147591a5 --- /dev/null +++ b/SHADE_Managed/src/Serialisation/SerialisationUtilities.cxx @@ -0,0 +1,263 @@ +/************************************************************************************//*! +\file SerialisationUtilities.cxx +\author Tng Kah Wei, kahwei.tng, 390009620 +\par email: kahwei.tng\@digipen.edu +\date Nov 6, 2021 +\brief Contains the definition of the functions for the SerialisationUtilities + managed static class. + + Note: This file is written in C++17/CLI. + +Copyright (C) 2021 DigiPen Institute of Technology. +Reproduction or disclosure of this file or its contents without the prior written consent +of DigiPen Institute of Technology is prohibited. +*//*************************************************************************************/ +// Precompiled Headers +#include "SHpch.h" +// Primary Header +#include "Serialisation/SerialisationUtilities.hxx" +// Project Includes +#include "ReflectionUtilities.hxx" + +/*-------------------------------------------------------------------------------------*/ +/* File-Level Constants */ +/*-------------------------------------------------------------------------------------*/ +static const std::string_view SCRIPT_TYPE_YAMLTAG = "Type"; + +/*-------------------------------------------------------------------------------------*/ +/* Function Definitions */ +/*-------------------------------------------------------------------------------------*/ +namespace SHADE +{ + /*---------------------------------------------------------------------------------*/ + /* Serialisation Functions */ + /*---------------------------------------------------------------------------------*/ + void SerialisationUtilities::Serialise(System::Object^ object, YAML::Node& scriptListNode) + { + using namespace System::Reflection; + + // Create YAML object + YAML::Node scriptNode; + scriptNode.SetStyle(YAML::EmitterStyle::Block); + scriptNode[SCRIPT_TYPE_YAMLTAG.data()] = Convert::ToNative(object->GetType()->FullName); + + // Get all fields + System::Collections::Generic::IEnumerable^ fields = ReflectionUtilities::GetInstanceFields(object); + for each (FieldInfo^ field in fields) + { + // Ignore private and non-SerialiseField + if (!ReflectionUtilities::FieldIsSerialisable(field)) + continue; + + // Serialise + writeFieldIntoYaml(field, object, scriptNode); + } + + scriptListNode.push_back(scriptNode); + } + void SerialisationUtilities::Deserialise(Object^ object, YAML::Node& yamlNode) + { + using namespace System::Reflection; + + // Load the YAML + if (!yamlNode.IsMap()) + { + // Invalid + Debug::LogError + ( + System::String::Format("[SerialisationUtilities] Invalid YAML Node provided for deserialization of \"{0}\" script.", + object->GetType()->FullName) + ); + return; + } + // Get all fields + System::Collections::Generic::IEnumerable^ fields = ReflectionUtilities::GetInstanceFields(object); + for each (FieldInfo^ field in fields) + { + // Ignore private and non-SerialiseField + if (!ReflectionUtilities::FieldIsSerialisable(field)) + continue; + + // Deserialise + const std::string FIELD_NAME = Convert::ToNative(field->Name); + if (yamlNode[FIELD_NAME]) + { + writeYamlIntoField(field, object, yamlNode[FIELD_NAME]); + } + } + } + /*---------------------------------------------------------------------------------*/ + /* Serialization Helper Functions */ + /*---------------------------------------------------------------------------------*/ + void SerialisationUtilities::writeFieldIntoYaml(System::Reflection::FieldInfo^ fieldInfo, Object^ object, YAML::Node& yamlNode) + { + // Field YAML Node + YAML::Node fieldNode; + + // Retrieve string for the YAML + const bool PRIMITIVE_SERIALIZED = fieldInsertYaml(fieldInfo, object, fieldNode) || + fieldInsertYaml(fieldInfo, object, fieldNode) || + fieldInsertYaml(fieldInfo, object, fieldNode) || + fieldInsertYaml(fieldInfo, object, fieldNode) || + fieldInsertYaml(fieldInfo, object, fieldNode) || + fieldInsertYaml(fieldInfo, object, fieldNode) || + fieldInsertYaml(fieldInfo, object, fieldNode) || + fieldInsertYaml(fieldInfo, object, fieldNode) || + fieldInsertYaml(fieldInfo, object, fieldNode) || + fieldInsertYaml(fieldInfo, object, fieldNode) || + fieldInsertYaml(fieldInfo, object, fieldNode) || + fieldInsertYaml(fieldInfo, object, fieldNode) || + fieldInsertYaml(fieldInfo, object, fieldNode) || + fieldInsertYaml(fieldInfo, object, fieldNode) || + fieldInsertYaml(fieldInfo, object, fieldNode); + + // Serialization of more complex types + if (!PRIMITIVE_SERIALIZED) + { + if (ReflectionUtilities::FieldIsList(fieldInfo)) + { + System::Type^ listType = fieldInfo->FieldType->GenericTypeArguments[0]; + System::Collections::IList^ iList = safe_cast(fieldInfo->GetValue(object)); + + + fieldNode.SetStyle(YAML::EmitterStyle::Block); + for (int i = 0; i < iList->Count; ++i) + { + YAML::Node elemNode; + if (varInsertYaml(iList[i], elemNode)) + { + fieldNode.push_back(elemNode); + } + else + { + Debug::LogWarning(Convert::ToNative(System::String::Format + ( + "[SerialisationUtilities] Failed to parse element # {2} of \"{0}\" of \"{1}\" type for serialization.", + fieldInfo->Name, fieldInfo->FieldType, i) + )); + } + } + } + else // Not any of the supported types + { + Debug::LogWarning(Convert::ToNative(System::String::Format + ( + "[SerialisationUtilities] Failed to parse \"{0}\" of \"{1}\" type for serialization.", + fieldInfo->Name, fieldInfo->FieldType) + )); + return; + } + } + + // Store the field into YAML + yamlNode[Convert::ToNative(fieldInfo->Name)] = fieldNode; + } + + bool SerialisationUtilities::varInsertYaml(System::Object^ object, YAML::Node& fieldNode) + { + const bool INSERTED = + varInsertYamlInternal(object, fieldNode) || + varInsertYamlInternal(object, fieldNode) || + varInsertYamlInternal(object, fieldNode) || + varInsertYamlInternal(object, fieldNode) || + varInsertYamlInternal(object, fieldNode) || + varInsertYamlInternal(object, fieldNode) || + varInsertYamlInternal(object, fieldNode) || + varInsertYamlInternal(object, fieldNode) || + varInsertYamlInternal(object, fieldNode) || + varInsertYamlInternal(object, fieldNode) || + varInsertYamlInternal(object, fieldNode) || + varInsertYamlInternal(object, fieldNode) || + varInsertYamlInternal(object, fieldNode) || + varInsertYamlInternal(object, fieldNode) || + varInsertYamlInternal(object, fieldNode); + return INSERTED; + } + + /*---------------------------------------------------------------------------------*/ + /* Deserialization Helper Functions */ + /*---------------------------------------------------------------------------------*/ + bool SerialisationUtilities::writeYamlIntoField(System::Reflection::FieldInfo^ fieldInfo, Object^ object, YAML::Node& node) + { + const bool ASSIGNED = + fieldAssignYaml (fieldInfo, object, node) || + fieldAssignYaml (fieldInfo, object, node) || + fieldAssignYaml (fieldInfo, object, node) || + fieldAssignYaml(fieldInfo, object, node) || + fieldAssignYaml(fieldInfo, object, node) || + fieldAssignYaml(fieldInfo, object, node) || + fieldAssignYaml (fieldInfo, object, node) || + fieldAssignYaml (fieldInfo, object, node) || + fieldAssignYaml (fieldInfo, object, node) || + fieldAssignYaml (fieldInfo, object, node) || + fieldAssignYaml (fieldInfo, object, node) || + fieldAssignYaml(fieldInfo, object, node) || + fieldAssignYaml (fieldInfo, object, node) || + fieldAssignYaml (fieldInfo, object, node) || + fieldAssignYaml (fieldInfo, object, node); + if (!ASSIGNED) + { + if (ReflectionUtilities::FieldIsList(fieldInfo)) + { + System::Type^ elemType = fieldInfo->FieldType->GenericTypeArguments[0]; + System::Collections::IList^ iList = safe_cast(fieldInfo->GetValue(object)); + if (node.IsSequence()) + { + // Get list size + const int LIST_SIZE = static_cast(node.size()); + if (LIST_SIZE > 0) + { + // Get list type + array^ typeList = gcnew array{ elemType }; + System::Type^ listType = System::Collections::Generic::List::typeid->GetGenericTypeDefinition()->MakeGenericType(typeList); + // Create a list of the specified type + array^ params = gcnew array{ node.size() }; + System::Collections::IList^ list = safe_cast + ( + System::Activator::CreateInstance(listType, params) + ); + + // Populate the list + for (int i = 0; i < LIST_SIZE; ++i) + { + // Create the object + System::Object^ obj = System::Activator::CreateInstance(elemType); + + // Set it's value + if (varAssignYaml(obj, node[i])) + { + list->Add(obj); + } + } + fieldInfo->SetValue(object, list); + } + } + + return true; + } + } + + return ASSIGNED; + } + + bool SerialisationUtilities::varAssignYaml(System::Object^% object, YAML::Node& node) + { + const bool DESERIALISED = + varAssignYamlInternal (object, node) || + varAssignYamlInternal (object, node) || + varAssignYamlInternal (object, node) || + varAssignYamlInternal(object, node) || + varAssignYamlInternal(object, node) || + varAssignYamlInternal(object, node) || + varAssignYamlInternal (object, node) || + varAssignYamlInternal (object, node) || + varAssignYamlInternal (object, node) || + varAssignYamlInternal (object, node) || + varAssignYamlInternal (object, node) || + varAssignYamlInternal(object, node) || + varAssignYamlInternal (object, node) || + varAssignYamlInternal (object, node) || + varAssignYamlInternal (object, node); + return DESERIALISED; + } +} diff --git a/SHADE_Managed/src/Serialisation/SerialisationUtilities.h++ b/SHADE_Managed/src/Serialisation/SerialisationUtilities.h++ new file mode 100644 index 00000000..dde6705a --- /dev/null +++ b/SHADE_Managed/src/Serialisation/SerialisationUtilities.h++ @@ -0,0 +1,217 @@ +/************************************************************************************//*! +\file SerialisationUtilities.h++ +\author Tng Kah Wei, kahwei.tng, 390009620 +\par email: kahwei.tng\@digipen.edu +\date Sep 16, 2022 +\brief Contains the definition of the template functions of the managed + ReflectionUtilities static class. + + Note: This file is written in C++17/CLI. + +Copyright (C) 2022 DigiPen Institute of Technology. +Reproduction or disclosure of this file or its contents without the prior written consent +of DigiPen Institute of Technology is prohibited. +*//*************************************************************************************/ +#pragma once + +// Primary Header +#include "SerialisationUtilities.hxx" +// Project Includes +#include "Utility/Convert.hxx" +#include "Utility/Debug.hxx" + +namespace SHADE +{ + /*---------------------------------------------------------------------------------*/ + /* Serialization Helper Functions */ + /*---------------------------------------------------------------------------------*/ + template + bool SerialisationUtilities::fieldInsertYaml(System::Reflection::FieldInfo^ fieldInfo, System::Object^ object, YAML::Node& fieldNode) + { + // Handle null objects + System::Object^ fieldObject = fieldInfo->GetValue(object); + if (fieldObject == nullptr) + { + // Default construct if null + if (fieldInfo->FieldType == FieldType::typeid) + { + if constexpr (std::is_same_v) + { + fieldNode = 0; + } + else if constexpr (std::is_same_v) + { + fieldNode = ""; + } + else if constexpr (std::is_same_v) + { + fieldNode.SetStyle(YAML::EmitterStyle::Flow); + fieldNode.push_back(0.0f); + fieldNode.push_back(0.0f); + } + else if constexpr (std::is_same_v) + { + fieldNode.SetStyle(YAML::EmitterStyle::Flow); + fieldNode.push_back(0.0f); + fieldNode.push_back(0.0f); + fieldNode.push_back(0.0f); + } + else if constexpr (std::is_same_v) + { + fieldNode = MAX_EID; + } + else + { + fieldNode = FieldType(); + } + return true; + } + return false; + } + return varInsertYamlInternal(fieldObject, fieldNode); + } + template + bool SerialisationUtilities::varInsertYamlInternal(System::Object^ object, YAML::Node& fieldNode) + { + if constexpr (std::is_same_v) + { + if (object->GetType()->IsSubclassOf(System::Enum::typeid)) + { + fieldNode = std::to_string(safe_cast(object)); + return true; + } + } + else if constexpr (std::is_same_v) + { + if (object->GetType() == System::String::typeid) + { + System::String^ str = safe_cast(object); + fieldNode = Convert::ToNative(str); + return true; + } + } + else if constexpr (std::is_same_v) + { + if (object->GetType() == Vector2::typeid) + { + Vector2 vec = safe_cast(object); + fieldNode.SetStyle(YAML::EmitterStyle::Flow); + fieldNode.push_back(vec.x); + fieldNode.push_back(vec.y); + return true; + } + } + else if constexpr (std::is_same_v) + { + if (object->GetType() == Vector3::typeid) + { + Vector3 vec = safe_cast(object); + fieldNode.SetStyle(YAML::EmitterStyle::Flow); + fieldNode.push_back(vec.x); + fieldNode.push_back(vec.y); + fieldNode.push_back(vec.z); + return true; + } + } + else if constexpr (std::is_same_v) + { + if (object->GetType() == GameObject::typeid) + { + GameObject gameObj = safe_cast(object); + fieldNode = gameObj ? gameObj.GetEntity() : MAX_EID; + return true; + } + } + else + { + if (object->GetType() == FieldType::typeid) + { + FieldType value = safe_cast(object); + fieldNode = static_cast(value); + return true; + } + } + + return false; + } + + /*---------------------------------------------------------------------------------*/ + /* Deserialization Helper Functions */ + /*---------------------------------------------------------------------------------*/ + template + bool SerialisationUtilities::fieldAssignYaml(System::Reflection::FieldInfo^ fieldInfo, Object^ object, YAML::Node& node) + { + System::Object^ valueObj = fieldInfo->GetValue(object); + if (varAssignYamlInternal(valueObj, node)) + { + fieldInfo->SetValue(object, valueObj); + return true; + } + + return false; + } + + template + bool SerialisationUtilities::varAssignYamlInternal(System::Object^% object, YAML::Node& node) + { + if constexpr (std::is_same_v) + { + if (object->GetType()->IsSubclassOf(System::Enum::typeid)) + { + object = node.as(); + return true; + } + } + else + { + if (object->GetType() == FieldType::typeid) + { + if constexpr (std::is_same_v) + { + object = Convert::ToCLI(node.as()); + } + else if constexpr (std::is_same_v) + { + if (node.IsSequence() && node.size() == 2) + { + Vector2 vec; + vec.x = node[0].as(); + vec.y = node[1].as(); + object = vec; + } + else + { + return false; + } + } + else if constexpr (std::is_same_v) + { + if (node.IsSequence() && node.size() == 3) + { + Vector3 vec; + vec.x = node[0].as(); + vec.y = node[1].as(); + vec.z = node[2].as(); + object = vec; + } + else + { + return false; + } + } + else if constexpr (std::is_same_v) + { + const uint32_t EID = node.as(); + object = (EID == MAX_EID ? GameObject() : GameObject(EID)); + } + else + { + object = node.as(); + } + return true; + } + } + + return false; + } +} diff --git a/SHADE_Managed/src/Serialisation/SerialisationUtilities.hxx b/SHADE_Managed/src/Serialisation/SerialisationUtilities.hxx new file mode 100644 index 00000000..5b6fc69e --- /dev/null +++ b/SHADE_Managed/src/Serialisation/SerialisationUtilities.hxx @@ -0,0 +1,75 @@ +/************************************************************************************//*! +\file SerialisationUtilities.hxx +\author Tng Kah Wei, kahwei.tng, 390009620 +\par email: kahwei.tng\@digipen.edu +\date Nov 6, 2021 +\brief Contains the definition of the managed SerialisationUtilities static + class. + + Note: This file is written in C++17/CLI. + +Copyright (C) 2021 DigiPen Institute of Technology. +Reproduction or disclosure of this file or its contents without the prior written consent +of DigiPen Institute of Technology is prohibited. +*//*************************************************************************************/ +#pragma once + +// External Dependencies +#include +// Project Includes +#include "Math/Vector2.hxx" +#include "Math/Vector3.hxx" +#include "Engine/GameObject.hxx" + +namespace SHADE +{ + /// + /// Contains useful static functions for working with Serialisation of Managed data. + /// + private ref class SerialisationUtilities abstract sealed + { + public: + /*-----------------------------------------------------------------------------*/ + /* Serialisation Functions */ + /*-----------------------------------------------------------------------------*/ + /// + /// Creates a JSON node that represents the specified object and its associated + /// serialisable fields. Public fields and fields marked with the SerialiseField + /// attribute will be serialised. + /// + /// The object to serialise. + static void Serialise(System::Object^ object, YAML::Node& yamlNode); + /// + /// Deserialises a YAML node that contains a map of Scripts and copies the + /// deserialised data into the specified object if there are matching fields. + /// + /// + /// The JSON string that contains the data to copy into this Script object. + /// + /// The object to copy deserialised data into. + static void Deserialise(System::Object^ object, YAML::Node& yamlNode); + + private: + /*-----------------------------------------------------------------------------*/ + /* Serialization Helper Functions */ + /*-----------------------------------------------------------------------------*/ + static void writeFieldIntoYaml(System::Reflection::FieldInfo^ fieldInfo, Object^ object, YAML::Node& yamlNode); + template + static bool fieldInsertYaml(System::Reflection::FieldInfo^ fieldInfo, System::Object^ object, YAML::Node& fieldNode); + static bool varInsertYaml(System::Object^ object, YAML::Node& fieldNode); + template + static bool varInsertYamlInternal(System::Object^ object, YAML::Node& fieldNode); + + /*-----------------------------------------------------------------------------*/ + /* Deserialization Helper Functions */ + /*-----------------------------------------------------------------------------*/ + static bool writeYamlIntoField(System::Reflection::FieldInfo^ fieldInfo, Object^ object, YAML::Node& node); + template + static bool fieldAssignYaml(System::Reflection::FieldInfo^ fieldInfo, Object^ object, YAML::Node& node); + static bool varAssignYaml(System::Object^% object, YAML::Node& node); + template> + static bool varAssignYamlInternal(System::Object^% object, YAML::Node& node); + }; +} + +#include "SerialisationUtilities.h++" \ No newline at end of file diff --git a/SHADE_Managed/src/Utility/Convert.hxx b/SHADE_Managed/src/Utility/Convert.hxx index 666b5062..4d0c5b59 100644 --- a/SHADE_Managed/src/Utility/Convert.hxx +++ b/SHADE_Managed/src/Utility/Convert.hxx @@ -152,6 +152,40 @@ namespace SHADE }; + /// + /// Checks if the specified type is matching between native C++ and the managed type. + /// + /// Type to check. + template + struct IsPrimitiveTypeMatches : public std::integral_constant + < + bool, + std::is_same_v> || + std::is_same_v> || + std::is_same_v> || + std::is_same_v> || + std::is_same_v> || + std::is_same_v> || + std::is_same_v> || + std::is_same_v> || + std::is_same_v> || + std::is_same_v> || + std::is_same_v> || + std::is_same_v> || + std::is_same_v> || + std::is_same_v> || + std::is_same_v> || + std::is_same_v> || + std::is_same_v> + > + {}; + /// + /// Short hand for IsPrimitiveTypeMatches::value + /// + /// Type to check. + template + inline constexpr bool IsPrimitiveTypeMatches_V = IsPrimitiveTypeMatches::value; + /// /// Type Transformer for managed types to native types. /// @@ -163,6 +197,7 @@ namespace SHADE { public: using Value = void; + static bool IsDefined() { return is_same_v; } }; template<> struct ToNativeType { using Value = int16_t; }; template<> struct ToNativeType { using Value = int32_t; }; @@ -193,19 +228,20 @@ namespace SHADE template struct ToManagedType { - public: + public: using Value = void; + static bool IsDefined() { return is_same_v; } }; - template<> struct ToManagedType { using Value = System::Byte; }; - template<> struct ToManagedType { using Value = System::Int16; }; - template<> struct ToManagedType { using Value = System::Int32; }; - template<> struct ToManagedType { using Value = System::Int64; }; + template<> struct ToManagedType { using Value = System::Byte; }; + template<> struct ToManagedType { using Value = System::Int16; }; + template<> struct ToManagedType { using Value = System::Int32; }; + template<> struct ToManagedType { using Value = System::Int64; }; template<> struct ToManagedType { using Value = System::UInt16; }; template<> struct ToManagedType { using Value = System::UInt32; }; template<> struct ToManagedType { using Value = System::UInt64; }; - template<> struct ToManagedType { using Value = bool; }; - template<> struct ToManagedType { using Value = double; }; - template<> struct ToManagedType { using Value = float; }; + template<> struct ToManagedType { using Value = bool; }; + template<> struct ToManagedType { using Value = double; }; + template<> struct ToManagedType { using Value = float; }; /// /// Alias for ToManagedType::Value diff --git a/SHADE_Managed/src/Utility/Debug.cxx b/SHADE_Managed/src/Utility/Debug.cxx index 8a107ab3..cdc19df0 100644 --- a/SHADE_Managed/src/Utility/Debug.cxx +++ b/SHADE_Managed/src/Utility/Debug.cxx @@ -19,7 +19,7 @@ of DigiPen Institute of Technology is prohibited. // Standard Libraries #include // External Libraries -#include "Tools/SHLog.h" +#include "Tools/Logger/SHLog.h" // Project Headers #include "Convert.hxx"