Перейти к содержанию

[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.

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

  • Xipho закрыл тема
Гость
Эта тема закрыта для публикации ответов.
×
×
  • Создать...

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

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