Перейти к содержанию
Авторизация  
XAMAC

[C++] DrawLine d3d9 в WorldToScreen

Рекомендуемые сообщения

Пытаюсь отрисовать динамичные линии от объекта до объекта внутри игры league of legends

Со статичными линиями я разобрался. но как только потребовалось использовать world to screen началось самое интересное

Рисовать собираюсь с помощью следующего кода
Статичное изображение с помощью аналогичного кода отрисовать не проблема

DrawLine(myScreenPos.x, myScreenPos.y, enemyScreenPos.x, enemyScreenPos.y, 1.0f, Colors.White)

 

Однако когда я пытаюсь взаимодействовать с W2S таким образом

	Vector2D myScreenPos = WorldToScreen(me.pos.x, me.pos.y, me.pos.z)
	Vector2D enemyScreenPos = WorldToScreen(enemy.pos.x, enemy.pos.y, enemy.pos.z)

 

получаю следующего рода ошибку:

 


"не существует подходящего определяемого пользователем преобразования из D3DXVECTOR2 в Vector2D"

Изображение ошибки

 

worldtoscreen

Спойлер


	D3DXMATRIX* D3DXMatrixMultiply(D3DXMATRIX* pOut, const D3DXMATRIX* pM1, const D3DXMATRIX* pM2)
	{
		if (pOut == NULL) {
			pOut = D3DXMatrixIdentity(pOut);
		}

		pOut->_11 = pM1->_11 * pM2->_11 + pM1->_12 * pM2->_21 + pM1->_13 * pM2->_31 + pM1->_14 * pM2->_41;
		pOut->_12 = pM1->_11 * pM2->_12 + pM1->_12 * pM2->_22 + pM1->_13 * pM2->_32 + pM1->_14 * pM2->_42;
		pOut->_13 = pM1->_11 * pM2->_13 + pM1->_12 * pM2->_23 + pM1->_13 * pM2->_33 + pM1->_14 * pM2->_43;
		pOut->_14 = pM1->_11 * pM2->_14 + pM1->_12 * pM2->_24 + pM1->_13 * pM2->_34 + pM1->_14 * pM2->_44;
		pOut->_21 = pM1->_21 * pM2->_11 + pM1->_22 * pM2->_21 + pM1->_23 * pM2->_31 + pM1->_24 * pM2->_41;
		pOut->_22 = pM1->_21 * pM2->_12 + pM1->_22 * pM2->_22 + pM1->_23 * pM2->_32 + pM1->_24 * pM2->_42;
		pOut->_23 = pM1->_21 * pM2->_13 + pM1->_22 * pM2->_23 + pM1->_23 * pM2->_33 + pM1->_24 * pM2->_43;
		pOut->_24 = pM1->_21 * pM2->_14 + pM1->_22 * pM2->_24 + pM1->_23 * pM2->_34 + pM1->_24 * pM2->_44;
		pOut->_31 = pM1->_31 * pM2->_11 + pM1->_32 * pM2->_21 + pM1->_33 * pM2->_31 + pM1->_34 * pM2->_41;
		pOut->_32 = pM1->_31 * pM2->_12 + pM1->_32 * pM2->_22 + pM1->_33 * pM2->_32 + pM1->_34 * pM2->_42;
		pOut->_33 = pM1->_31 * pM2->_13 + pM1->_32 * pM2->_23 + pM1->_33 * pM2->_33 + pM1->_34 * pM2->_43;
		pOut->_34 = pM1->_31 * pM2->_14 + pM1->_32 * pM2->_24 + pM1->_33 * pM2->_34 + pM1->_34 * pM2->_44;
		pOut->_41 = pM1->_41 * pM2->_11 + pM1->_42 * pM2->_21 + pM1->_43 * pM2->_31 + pM1->_44 * pM2->_41;
		pOut->_42 = pM1->_41 * pM2->_12 + pM1->_42 * pM2->_22 + pM1->_43 * pM2->_32 + pM1->_44 * pM2->_42;
		pOut->_43 = pM1->_41 * pM2->_13 + pM1->_42 * pM2->_23 + pM1->_43 * pM2->_33 + pM1->_44 * pM2->_43;
		pOut->_44 = pM1->_41 * pM2->_14 + pM1->_42 * pM2->_24 + pM1->_43 * pM2->_34 + pM1->_44 * pM2->_44;

		return pOut;
	}


	D3DXVECTOR2 WorldToScreen(D3DXVECTOR3 pos)
	{
		Renderer* ritorender = (Renderer*) * (DWORD*)(baseAddr + oRenderer);
		D3DXMATRIX viewMatrix = ritorender->viewMatrix(); //1
		D3DXMATRIX projMatrix = ritorender->projMatrix(); //2

		D3DXVECTOR2 returnVec = D3DXVECTOR2();
		D3DXVECTOR2 screen = D3DXVECTOR2(1280, 720);

		D3DXMATRIX* matrix = new D3DXMATRIX();
		D3DXMatrixMultiply(matrix, &viewMatrix, &projMatrix);


		D3DXVECTOR4 clipCoords = D3DXVECTOR4();

		clipCoords.x = pos.x * matrix->_11 + pos.y * matrix->_21 + pos.z * matrix->_31 + matrix->_41;
		clipCoords.y = pos.x * matrix->_12 + pos.y * matrix->_22 + pos.z * matrix->_32 + matrix->_42;
		clipCoords.z = pos.x * matrix->_13 + pos.y * matrix->_23 + pos.z * matrix->_33 + matrix->_43;
		clipCoords.w = pos.x * matrix->_14 + pos.y * matrix->_24 + pos.z * matrix->_34 + matrix->_44;


		if (clipCoords[3] < 0.1f)
			return returnVec;

		D3DXVECTOR3 M = D3DXVECTOR3();
		M.x = clipCoords.x / clipCoords.w;
		M.y = clipCoords.y / clipCoords.w;
		M.z = clipCoords.z / clipCoords.w;

		returnVec.x = (screen.x / 2 * M.x) + (M.x + screen.x / 2);
		returnVec.y = -(screen.y / 2 * M.y) + (M.y + screen.y / 2);
		return returnVec;
	
		
	
	}

 

 

Vector.h

Спойлер

#pragma once
#include <Windows.h>
#include <math.h>
#include <cmath>

struct Vector
{
	float X, Y, Z;

	inline Vector(void) {};
	inline Vector(const float x, const float y, const float z)
	{
		X = x; Y = y; Z = z;
	}



	inline Vector operator + (const Vector& A) const
	{
		return Vector(X + A.X, Y + A.Y, Z + A.Z);
	}

	inline Vector operator + (const float A) const
	{
		return Vector(X + A, Y + A, Z + A);
	}

	inline Vector operator * (const float A) const
	{
		return Vector(A * X, A * Y, A * Z);
	}

	inline Vector operator * (const Vector& A) const
	{
		return Vector(A.X * X, A.Y * Y, A.Z * Z);
	}

	inline Vector operator - (const float A) const
	{
		return Vector(A * X, A * Y, A * Z);
	}

	inline Vector operator - (const Vector& A) const
	{
		return Vector(A.X - X, A.Y - Y, A.Z - Z);
	}

	inline Vector operator / (const float A) const
	{
		return Vector(A / X, A / Y, A / Z);
	}

	inline Vector operator / (const Vector& A) const
	{
		return Vector(A.X / X, A.Y / Y, A.Z / Z);
	}

	float dot(const Vector& vec) const
	{
		return X * vec.X + Y * vec.Y + Z * vec.Z;
	}

	inline float lengthSquared()
	{
		return X * X + Y * Y + Z * Z;
	}

	float lengthSquared() const
	{
		return X * X + Y * Y + Z * Z;
	}

	inline float length()
	{
		return (float)sqrt(lengthSquared());
	}

	float length() const
	{
		return (float)sqrt(lengthSquared());
	}

	Vector perpendicularTo()
	{
		return Vector(Z, Y, -X);
	}

	inline Vector Normalize()
	{
		float length = this->length();
		if (length != 0)
		{
			float inv = 1.0f / length;
			X *= inv;
			Y *= inv;
			Z *= inv;
		}
		return Vector(X, Y, Z);
	}

	inline float DistTo(const Vector& A) {
		float out = sqrtf(powf(X - A.X, 2) + powf(Y - A.Y, 2) + powf(Z - A.Z, 2));
		return out < 0 ? out * -1 : out;
	}

	float Dot(const Vector& vOther) const
	{
		return (X * vOther.X + Y * vOther.Y + Z * vOther.Z);
	}

	Vector Normalized() const
	{
		float length = this->length();
		float x, y, z;
		if (length != 0)
		{
			float inv = 1.0f / length;
			x *= inv;
			y *= inv;
			z *= inv;
		}
		return Vector(x, y, z);
	}

	static Vector crossProduct(Vector a, Vector b)
	{
		Vector n;

		n.X = a.X * b.Z - a.Z * b.Y;
		n.Y = a.Z * b.X - a.X * b.Z;
		n.Z = a.X * b.Y - a.Y * b.X;

		return n;
	}

	Vector ProjectionOn(const Vector& vOther) const
	{
		Vector toProject = Vector(X, Y, Z);
		float scale = (toProject.Dot(vOther)) / (vOther.Dot(vOther));
		return vOther * scale;
	}

	Vector sameDirectionAs(const Vector& vOther)
	{
		return vOther.Normalized() * this->length();
	}

	Vector to2D()
	{
		return Vector(this->X, 0, this->Z);
	}

	static float angleBetween(Vector u, Vector v)
	{
		u.Normalized();
		v.Normalized();
		return std::acos(u.Dot(v));
	}
	float x = this->X;
	float y = this->Y;
	float z = this->Z;

};
struct Vector2D
{
	float X, Y, Z;

	inline Vector2D(void) {}
	inline Vector2D(const float x, const float y, const float z) {
		X = x;
		Y = y;
		Z = z;
	}


	inline Vector2D operator+(const Vector& A) const {
		return Vector2D(X + A.X, Y + A.Y, Z + A.Z);
	}

	inline Vector2D operator+(const float A) const {
		return Vector2D(X + A, Y + A, Z + A);
	}

	inline Vector2D operator*(const float A) const {
		return Vector2D(A * X, A * Y, A * Z);
	}

	inline Vector2D operator*(const Vector& A) const {
		return Vector2D(A.X * X, A.Y * Y, A.Z * Z);
	}

	inline Vector2D operator-(const float A) const {
		return Vector2D(A * X, A * Y, A * Z);
	}

	inline Vector2D operator-(const Vector& A) const {
		return Vector2D(A.X - X, A.Y - Y, A.Z - Z);
	}

	inline Vector2D operator/(const float A) const {
		return Vector2D(A / X, A / Y, A / Z);
	}

	inline Vector2D operator/(const Vector& A) const {
		return Vector2D(A.X / X, A.Y / Y, A.Z / Z);
	}

	float dot(const Vector2D& vec) const {
		return X * vec.X + Y * vec.Y + Z * vec.Z;
	}

	inline float lengthSquared() {
		return X * X + Y * Y + Z * Z;
	}

	inline float length() {
		return (float)sqrt(lengthSquared());
	}

	inline Vector2D perpendicularTo() {
		return Vector2D(Z, Y, -X);
	}

	inline Vector2D Normalize() {
		float length = this->length();
		if (length != 0) {
			float inv = 1.0f / length;
			X *= inv;
			Y *= inv;
			Z *= inv;
		}
		return Vector2D(X, Y, Z);
	}
};

 

 

 

Собственно вопрос как это поправить, уже пару дней голову ломаю а годных материалов так и не нашел, хотя по логике понимаю что ошибка пустяковая

Тапками не  кидайте, learncpp уже в 3х браузерах по 40 вкладок :D 

 

Поделиться сообщением


Ссылка на сообщение
Поделиться на другие сайты

Это тебе студия говорит, что компилятор не знает, как преобразовать тип D3DXVECTOR2 в Vector2D. Тебе либо нужно написать такое преобразование самому, либо использовать только один из типов.

Поделиться сообщением


Ссылка на сообщение
Поделиться на другие сайты
13 часов назад, XAMAC сказал:

D3DXVECTOR2 WorldToScreen(D3DXVECTOR3 pos)

 

13 часов назад, XAMAC сказал:

WorldToScreen(me.pos.x, me.pos.y, me.pos.z)

 

Функция принимает D3DXVECTOR3, а ты передаешь ей float

Так же, твой Vector2D является Vec3, а возвращаемое значение WorldToScreen имеет тип D3DXVECTOR2.

 

13 часов назад, XAMAC сказал:

вопрос как это поправить

Написать перегрузку WorldToScreen, судя по исходникам с этим не должно возникнуть проблем. Или написать шаблон WorldToScreen.

Поделиться сообщением


Ссылка на сообщение
Поделиться на другие сайты

Для публикации сообщений создайте учётную запись или авторизуйтесь

Вы должны быть пользователем, чтобы оставить комментарий

Создать учетную запись

Зарегистрируйте новую учётную запись в нашем сообществе. Это очень просто!

Регистрация нового пользователя

Войти

Уже есть аккаунт? Войти в систему.

Войти
Авторизация  

×

Важная информация

Находясь на нашем сайте, Вы автоматически соглашаетесь соблюдать наши Условия использования.