Untitled

struct RelationData {
	__m128 temp_2;
	__m128i temp_0;
	__m128 temp_1;
};

int boneOneProfiling;
int boneTwoProfiling;

Vector3 get_position(int playerIndex) {
	auto start1 = std::chrono::high_resolution_clock::now();

	auto it = cachedPointers.find(playerIndex);
	if (it == cachedPointers.end()) {
		printf("No cached pointers for player index %d\n", playerIndex);
		return Vector3();
	}
	const PlayerPointers& pointers = it->second;

	DWORD_PTR some_ptr = pointers.some_ptr;
	int32_t index;
	DMA::MemRead(pointers.FinalTransform + 0x40, &index, sizeof(int32_t));

	DWORD_PTR relation_array = pointers.relation_array;
	DWORD_PTR dependency_index_array = pointers.dependency_index_array;

	__m128i temp_0;
	__m128 xmmword_1410D1340 = { -2.f, 2.f, -2.f, 0.f };
	__m128 xmmword_1410D1350 = { 2.f, -2.f, -2.f, 0.f };
	__m128 xmmword_1410D1360 = { -2.f, -2.f, 2.f, 0.f };
	__m128 temp_1;
	__m128 temp_2;
	__m128 temp_main;
	DMA::MemRead(relation_array + index * 48, &temp_main, sizeof(__m128));
	int32_t dependency_index;
	DMA::MemRead(dependency_index_array + 4 * index, &dependency_index, sizeof(int32_t));

	auto stop1 = std::chrono::high_resolution_clock::now();
	auto duration1 = std::chrono::duration_cast<std::chrono::microseconds>(stop1 - start1);

	boneOneProfiling = duration1.count();

	int32_t max_relation_index = 0;
	int32_t max_dependency_index = 0;

	auto start2 = std::chrono::high_resolution_clock::now();
	RelationData relationData;
	while (dependency_index >= 0) {
		auto relation_index = 6 * dependency_index;

		max_relation_index = (std::max)(max_relation_index, relation_index);
		max_dependency_index = (std::max)(max_dependency_index, dependency_index);

		DMA::MemRead(relation_array + 8 * relation_index, &relationData, sizeof(RelationData));

		__m128i temp_0 = relationData.temp_0;
		__m128 temp_1 = relationData.temp_1;
		__m128 temp_2 = relationData.temp_2;

		__m128 v10 = _mm_mul_ps(temp_1, temp_main);
		__m128 v11 = _mm_castsi128_ps(_mm_shuffle_epi32(temp_0, 0));
		__m128 v12 = _mm_castsi128_ps(_mm_shuffle_epi32(temp_0, 85));
		__m128 v13 = _mm_castsi128_ps(_mm_shuffle_epi32(temp_0, -114));
		__m128 v14 = _mm_castsi128_ps(_mm_shuffle_epi32(temp_0, -37));
		__m128 v15 = _mm_castsi128_ps(_mm_shuffle_epi32(temp_0, -86));
		__m128 v16 = _mm_castsi128_ps(_mm_shuffle_epi32(temp_0, 113));
		__m128 v17 = _mm_add_ps(
			_mm_add_ps(
				_mm_add_ps(
					_mm_mul_ps(
						_mm_sub_ps(
							_mm_mul_ps(_mm_mul_ps(v11, xmmword_1410D1350), v13),
							_mm_mul_ps(_mm_mul_ps(v12, xmmword_1410D1360), v14)),
						_mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(v10), -86))),
					_mm_mul_ps(
						_mm_sub_ps(
							_mm_mul_ps(_mm_mul_ps(v15, xmmword_1410D1360), v14),
							_mm_mul_ps(_mm_mul_ps(v11, xmmword_1410D1340), v16)),
						_mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(v10), 85)))),
				_mm_add_ps(
					_mm_mul_ps(
						_mm_sub_ps(
							_mm_mul_ps(_mm_mul_ps(v12, xmmword_1410D1340), v16),
							_mm_mul_ps(_mm_mul_ps(v15, xmmword_1410D1350), v13)),
						_mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(v10), 0))),
					v10)),
			temp_2);

		temp_main = v17;
		DMA::MemRead(dependency_index_array + 4 * dependency_index, &dependency_index, sizeof(int32_t));
		printf("Dependency index: %d\n", dependency_index);
	}

	printf("Maximum relation_index: %d\n", max_relation_index);
	printf("Size of relation_array: %d\n", (max_relation_index + 1) * 8); // Adding 1 because it is 0-based index

	printf("Maximum dependency_index: %d\n", max_dependency_index);
	printf("Size of dependency_index_array: %d\n", (max_dependency_index + 1) * 4); // Adding 1 because it is 0-based index

	Vector3* resultPtr = reinterpret_cast<Vector3*>(&temp_main);
	auto stop2 = std::chrono::high_resolution_clock::now();
	auto duration2 = std::chrono::duration_cast<std::chrono::microseconds>(stop2 - start2);

	boneTwoProfiling = duration2.count();
	return *resultPtr;
}