world to screen

[mnbvc]

im referring to this thread: http://www.mmowned.com/forums/wow-me...ordinates.html

This Thread is more than 490 days old, you can't reply to it.

:confused:

im currently trying to gets this working under c#
thats what my code looks like:

    static class WtS
    {
        public static Point WowOrigin = new Point(0, 0);
        public static Point WowSize = new Point(1024, 768);
        public static Point WowCenter = new Point(512, 384);
        // windowed wow at 1024x768 moved to top left corner

        public struct strCamera
        {
            public float X;
            public float Y;
            public float Z;
            public float Facing;
            public float Tilt;
        }
        public static strCamera Camera = new strCamera();
        // set this to the camera location/rotation

        public static Point GameCoordsToScreenCoords(double X, double Y, double Z)
        {
            // Convert game coordinates to screen coordinates.
            // Returns -1,-1 if not onscreen.

            // The following transform was taken from Wikipedia's page on "3D Projection".
            //
            // Setup was a little tricky since WoW and the transform coordinate and rotation
            // systems were different, thus all the odd assignments.
            //
            // point location
            double ax = -X;
            double ay = -Z;
            double az = Y;
            // camera location
            double cx = -Camera.X;
            double cy = -Camera.Z;
            double cz = Camera.Y;
            // camera rotation
            double Facing2 = Camera.Facing;
            if (Facing2 > Math.PI) Facing2 -= 2 * Math.PI;
            double ox = Camera.Tilt;
            double oy = -Facing2;
            double oz = 0;
            // Perform the transform to generate X,Y,Z of the point relative to the current
            // camera position and rotation.
            double dx = 0;
            double dy = 0;
            double dz = 0;
            dx = Math.Cos(oy) * (Math.Sin(oz) * (ay - cy) + Math.Cos(oz) * (ax - cx)) - Math.Sin(oy) * (az - cz);
            dy = Math.Sin(ox) * (Math.Cos(oy) * (az - cz) + Math.Sin(oy) * (Math.Sin(oz) * (ay - cy) + Math.Cos(oz) * (ax - cx))) + Math.Cos(ox) * (Math.Cos(oz) * (ay - cy) - Math.Sin(oz) * (ax - cx));
            dz = Math.Cos(ox) * (Math.Cos(oy) * (az - cz) + Math.Sin(oy) * (Math.Sin(oz) * (ay - cy) + Math.Cos(oz) * (ax - cx))) - Math.Sin(ox) * (Math.Cos(oz) * (ay - cy) - Math.Sin(oz) * (ax - cx));
            // Check to make sure it's not behind the camera.
            if (dz <= 0) return new Point(-1, -1);

            // Project the point to a screen location.
            //
            // This wasn't taken from Wiki, it came from somewhere else.  I forget where.
            // FOV1 - The distance between the virtual eye, and the camera plane.
            //        If this is too large, you'll find the conversion works great at
            //        long distances, but falls short (towards the center of the screen)
            //        at short distances.  Not sure what this really is in WoW, but it's
            //        something small and 0.1 works just fine.
            double FOV1 = 0.1;
            // FOV2 - Scaling to the screen.  This was found experimentally, at long (>20 yard)
            //        distance to avoid any potential errors from FOV1.  This must be changed
            //        if FOV1 changes!
            double FOV2 = 7.4 * WowSize.X;
            int SX = (int)(dx * (FOV1 / (dz + FOV1)) * FOV2 + WowCenter.X);
            int SY = (int)(dy * (FOV1 / (dz + FOV1)) * FOV2 + WowCenter.Y);
            // Final check to make sure it's on-screen.
            if (SX < WowOrigin.X || SY < WowOrigin.Y || SX >= (WowOrigin.X + WowSize.X) || SY >= (WowOrigin.Y + WowSize.Y)) return new Point(-1, -1);
            // Return the result.
            return new Point(SX, SY);
        }

        public static string get(Memory wow)
        {
            uint camBase = wow.ReadUInt(wow.ReadUInt(0x10e1824) + 0x7da0);

            Camera.X = wow.ReadFloat(camBase + 0x8); // from http://www.madx.dk/wowdev/wiki/index.php?title=Camera
            Camera.Y = wow.ReadFloat(camBase + 0xC);
            Camera.Z = wow.ReadFloat(camBase + 0x10);

            Camera.Facing = wow.ReadFloat(camBase + 0x1d0);
            // was cCameraInfo+&h24: Facing (single-precision float)
            // for my base 0x2c, well it actually looks like tilt but with strange values
            // i took just one of many player facing offsets, the only "camera only" offset
            // i could find is +0x260, but this resets to 0 after turning,

            Camera.Tilt = wow.ReadFloat(camBase + 0x120);
            // was cCameraInfo+&h20: Tilt (single-precision float)
            // for my base +0x24, thats just 0 ...
            // so i took the yaw from the site above, i think thats what the author meant ???
            // value looks ok, do i still have to take the asin() of this?

            Point p = GameCoordsToScreenCoords(-6214.787, 328.0742, 383.4916);
            // location of the first quest giver in gnome/dwarf starting area you want to test it...

            return p.ToString();
        }

it does never return the right coordinates, normally just -1,-1 :P
i was testing around with the values i read, but i think they should be right, at least they fit to the original authors description.
is there anything else wrong?
i hope anybody can help me

[YetiHunter]

hi, i did this projection a while ago. because i'm not playing wow anymore i'm too lazy to check all the things for you =P but i can post you my version and you can compare (the offsets are out of date of cause)
the coding style is probably bad =P but it should work with the right offsets (at least is did when i tried it last)

using System;
using System.Runtime.InteropServices;
using System.Drawing;
using Bot.Misc;

namespace Bot.KeyMouse
{
    class KeyMouse
    {
        public struct Rect
        {
            public int left;
            public int top;
            public int right;
            public int bottom;
        }
        [DllImport("user32.dll")]
        private static extern bool GetClientRect(IntPtr hWnd, ref Rect rect);

        public const float Deg2Rad = 0.01745329251f;

        private struct CameraInfo
        {
            public Vector Pos;
            public Matrix ViewMat;
            public float Foc;
        };

        public static bool MoveMouseToWoWCoords(float x, float y, float z)
        {
            var pseudoVec = new Vector(x, y, z);     //not really a vector. its the location we want to click
            IntPtr hwnd = Mem.Wow.WindowHandle;
            var camera = new CameraInfo();
            //Read information
            uint pAddr2 = Mem.Wow.ReadUInt((Mem.Wow.ReadUInt((uint)Offsets.Static.cameraPointer)) + (uint)Offsets.Static.cameraOffset);
            byte[] bCamera = Mem.Wow.ReadBytes(pAddr2, 68);
            //Convert bytes to usable data
            camera.Pos = new Vector(BitConverter.ToSingle(bCamera, 8), BitConverter.ToSingle(bCamera, 12), BitConverter.ToSingle(bCamera, 16));
            camera.ViewMat = new Matrix(BitConverter.ToSingle(bCamera, 20), BitConverter.ToSingle(bCamera, 24), BitConverter.ToSingle(bCamera, 28),
                BitConverter.ToSingle(bCamera, 32), BitConverter.ToSingle(bCamera, 36), BitConverter.ToSingle(bCamera, 40),
                BitConverter.ToSingle(bCamera, 44), BitConverter.ToSingle(bCamera, 48), BitConverter.ToSingle(bCamera, 52));
            camera.Foc = BitConverter.ToSingle(bCamera, 64);
            //Get windoesize
            var rc = new Rect();
            GetClientRect(hwnd, ref rc);

            //Vector camera -> object
            var diff = pseudoVec - camera.Pos;

            if ((diff * camera.ViewMat.GetFirstColumn) < 0)
                return false;

            var view = diff * camera.ViewMat.Inverse();
            var cam = new Vector( -view.Y, -view.Z, view.X);

            float fScreenX = (rc.right - rc.left) / 2.0f;
            float fScreenY = (rc.bottom - rc.top) / 2.0f;
            //Aspect ratio
            float fTmpX = fScreenX / (float)Math.Tan(((camera.Foc * 44.0f) / 2.0f) * Deg2Rad);
            float fTmpY = fScreenY / (float)Math.Tan(((camera.Foc * 35.0f) / 2.0f) * Deg2Rad);

            var pctMouse = new Point
                               {
                                   X = (int) (fScreenX + cam.X*fTmpX/cam.Z),
                                   Y = (int) (fScreenY + cam.Y*fTmpY/cam.Z)
                               };
            if (pctMouse.X < 0 || pctMouse.Y < 0 || pctMouse.X > rc.right || pctMouse.Y > rc.bottom)
                return false;

            InputControl.MoveMouse(pctMouse.X, pctMouse.Y);
            return true;
        }
    }
}

vector-library:

namespace Bot.Misc
{
    public class Vector
    {
        private float _x, _y, _z;
        public Vector()
        {
            _x = 0;
            _y = 0;
            _z = 0;
        }
        public Vector(float x, float y, float z)
        {
            _x = x;
            _y = y;
            _z = z;
        }
        public Vector(Vector v)
        {
            _x = v._x;
            _y = v._y;
            _z = v._z;
        }

        public void SetVec(Vector v)
        {
            _x = v._x;
            _y = v._y;
            _z = v._z;
        }
        public void SetVec(float x, float y, float z)
        {
            _x = x;
            _y = y;
            _z = z;
        }

        public float X
        {
            get { return _x; }
            set { _x = value; }
        }
        public float Y
        {
            get { return _y; }
            set { _y = value; }
        }
        public float Z
        {
            get { return _z; }
            set { _z = value; }
        }

        public static Vector operator +(Vector v1, Vector v2)
        {
            var v3 = new Vector((v1._x + v2._x), (v1._y + v2._y), (v1._z + v2._z));
            return v3;
        }
        public static Vector operator -(Vector v1, Vector v2)
        {
            var v3 = new Vector((v1._x - v2._x), (v1._y - v2._y), (v1._z - v2._z));
            return v3;
        }
        public static float operator *(Vector v1, Vector v2)
        {
            var f = v1._x * v2._x + v1._y * v2._y + v1._z * v2._z;
            return f;
        }
    }
}

matrix - library

namespace Bot.Misc
{
    class Matrix
    {
        private float _x1, _x2, _x3, _y1, _y2, _y3, _z1, _z2, _z3;
        public Matrix(float x1, float x2, float x3, float y1, float y2, float y3, float z1, float z2, float z3)
        {
            _x1 = x1;
            _x2 = x2;
            _x3 = x3;
            _y1 = y1;
            _y2 = y2;
            _y3 = y3;
            _z1 = z1;
            _z2 = z2;
            _z3 = z3;
        }
        public Matrix()
        { }
        public Vector GetFirstColumn
        {
            get { return new Vector(_x1, _y1, _z1); }
        }
        public Matrix Inverse()
        {
            var d = 1 / Det();
            var inv = new Matrix(d * (_y2 * _z3 - _y3 * _z2), d * (_x3 * _z2 - _x2 * _z3), d * (_x2 * _y3 - _x3 * _y2),
                                    d * (_y3 * _z1 - _y1 * _z3), d * (_x1 * _z3 - _x3 * _z1), d * (_x3 * _y1 - _x1 * _y3),
                                    d * (_y1 * _z2 - _y2 * _z1), d * (_x2 * _z1 - _x1 * _z2), d * (_x1 * _y2 - _x2 * _y1));
            return inv;
        }
        public float Det()
        {
            float det = (_x1 * _y2 * _z3) + (_x2 * _y3 * _z1) + (_x3 * _y1 * _z2) 
                            - (_x3 * _y2 * _z1) - (_x2 * _y1 * _z3) - (_x1 * _y3 * _z2);
            return det;
        }

        public static Vector operator *(Vector v, Matrix m)
        {
            var res = new Vector(m._x1 * v.X + m._y1 * v.Y + m._z1 * v.Z,
                                    m._x2 * v.X + m._y2 * v.Y + m._z2 * v.Z,
                                    m._x3 * v.X + m._y3 * v.Y + m._z3 * v.Z);
            return res;
        }

    }
}

if you have problems understanding the code feel free to ask. ^^

[mnbvc]

wow, nice, this works
thanks alot

the offsets, at least until tomorrow :P
#define WOW_CAMERA_PTR1 0x10e1824 //0x10CB7EC //0x11780B4 //0x117108C
#define WOW_CAMERA_OFFSET 0x7da0 //0x7a1c //0x7834 // 0x000782C
(uint)Offsets.Static.cameraPointer = WOW_CAMERA_PTR1
(uint)Offsets.Static.cameraOffset = WOW_CAMERA_OFFSET


now i just need to figure out how it works



remove this:
if ((diff * camera.ViewMat.GetFirstColumn) < 0)
return false;

i dont know why it causes problems, but it sometimes does :P

[a.blackthorn]

I have a few question regarding how the code works.

What are the values that go into the ViewMat?

I understand that the 44 & 35 values represent a 5:4 aspect ratio. Why did you use those particular values (how did you come up with them)? Is there not a way to scale by the width and height of the screen?

Thanks.

[a.blackthorn]

Ok, I figured out the ViewMat.

zaxis = normal(cameraTarget - cameraPosition)
xaxis = normal(cross(cameraUpVector, zaxis))
yaxis = cross(zaxis, xaxis)

xaxis.x           yaxis.x           zaxis.x
xaxis.y           yaxis.y           zaxis.y
xaxis.z           yaxis.z           zaxis.z

[AchmetG]

nice

but its very inaccurate when the point isnt near by the middle of the screen :O

[pendra]

You guys are making it needlessly complicated by doing all the trig yourself. Jut ask the gfx api for the necessary matrix and use it?

Here's some examples for OpenGL. If you're on windows using d3d, you can use GetTransform() to get the current transform, and then you need to find an implementation on the internet of gluProject/gluUnproject for D3D [hint use the google], or just multiply the matrix by the vector yourself.

To convert a world space point into a screen space point:

GLdouble proj[16];
GLdouble model[16];
GLint      view[4];

glGetDoublev(GL_PROJECTION_MATRIX,proj);
glGetDoublev(GL_MODELVIEW_MATRIX,model);
glGetIntegerv(GL_VIEWPORT, view);

// convert <x,y,z> in world space into <wx,wy,wz> in screen coordinates
gluProject(x,y,z,model,proj,view,&wx,&wy,&wz);

To convert a point in screen space into a ray in world space, as needed for a picker, etc.

GLdouble  proj[16];
GLdouble  model[16];
GLint       view[4];

glGetDoublev(GL_PROJECTION_MATRIX,proj);
glGetDoublev(GL_MODELVIEW_MATRIX,model);
glGetIntegerv(GL_VIEWPORT, view);

// convert <wx,wy> on screen into ray <x1,y1,z1> -> <x2,y2,z2> in world space
gluUnproject(wx,view[3]-wy,0.0,model,proj,view,&x1,&y1,&z1);
gluUnproject(wx,view[3]-wy,1.0,model,proj,view,&x2,&y2,&z2);

// we now have two points on a ray <x1,y1,z1> which is in the camera lens, so to speak, and <x2,y2,z2> which is 1.0f away from the camera in the direction of the projection.

No need to do your own math, just make sure you retrieve the matrices when wow is in game so you get the right ones.

[flo8464]

pendra, I really like your postings, a high level of information quality everywhere...too bad I can't rep you again.
That was very helpfull, thanks.

[a.blackthorn]

In D3D you need a handle to the IDirect3DDevice9 in order to use GetTransform to get the required matrices. I can't figure out how to get this handle, but otherwise the code would be

D3DXVECTOR3 target(x, y, z);
D3DXVECTOR3 screen;
D3DXMATRIX view_matrix, proj_matrix, world_matrix;
D3DVIEWPORT9 d3dvp;
 
pD3DDevice->GetTransform( D3DTS_VIEW, &view_matrix );
pD3DDevice->GetTransform( D3DTS_PROJECTION, &proj_matrix );
pD3DDevice->GetTransform( D3DTS_WORLD, &world_matrix );
pD3DDevice->GetViewport( &d3dvp );

D3DXVec3Project( &screen, &target, &d3dvp, &proj_matrix,&view_matrix, &world_matrix );

[pendra]

Most people seem to hook EndScene to get the D3D device, search on these forums and you can find some examples. It should be quite safe to do that, FRAPS and such do it.

[Flowerew]

In D3D you need a handle to the IDirect3DDevice9 in order to use GetTransform to get the required matrices. I can't figure out how to get this handle, but otherwise the code would be

IDirect3DDevice9 *pD3Ddev = [[0x0C76668]+0x397C]; //as of WoW 3.3.0a (11159)

It's what I use in my sample bot here. If you want to find it yourself use D3D debug version from your control panel, start wow in your fav debugger and now you can look for the string "EndScene" in the d3d9.dll module and see where it get's called from.

[kynox]

You guys are making it needlessly complicated by doing all the trig yourself. Jut ask the gfx api for the necessary matrix and use it?

Here's some examples for OpenGL. If you're on windows using d3d, you can use GetTransform() to get the current transform, and then you need to find an implementation on the internet of gluProject/gluUnproject for D3D [hint use the google], or just multiply the matrix by the vector yourself.

To convert a world space point into a screen space point:

GLdouble proj[16];
GLdouble model[16];
GLint      view[4];

glGetDoublev(GL_PROJECTION_MATRIX,proj);
glGetDoublev(GL_MODELVIEW_MATRIX,model);
glGetIntegerv(GL_VIEWPORT, view);

// convert <x,y,z> in world space into <wx,wy,wz> in screen coordinates
gluProject(x,y,z,model,proj,view,&wx,&wy,&wz);

To convert a point in screen space into a ray in world space, as needed for a picker, etc.

GLdouble  proj[16];
GLdouble  model[16];
GLint       view[4];

glGetDoublev(GL_PROJECTION_MATRIX,proj);
glGetDoublev(GL_MODELVIEW_MATRIX,model);
glGetIntegerv(GL_VIEWPORT, view);

// convert <wx,wy> on screen into ray <x1,y1,z1> -> <x2,y2,z2> in world space
gluUnproject(wx,view[3]-wy,0.0,model,proj,view,&x1,&y1,&z1);
gluUnproject(wx,view[3]-wy,1.0,model,proj,view,&x2,&y2,&z2);

// we now have two points on a ray <x1,y1,z1> which is in the camera lens, so to speak, and <x2,y2,z2> which is 1.0f away from the camera in the direction of the projection.

No need to do your own math, just make sure you retrieve the matrices when wow is in game so you get the right ones.

That would normally work in most situations, however WoW uses vertex buffering to communicate the transforms. You need to create the matrixes yourself.

[pendra]

That would normally work in most situations, however WoW uses vertex buffering to communicate the transforms. You need to create the matrixes yourself.

The approach I posted has always worked for me, but I now realize that it only works for me because I run under wine and disable all the OpenGL ARB extensions, so WoW falls back on the old school method. For people playing with sane graphics settings, Kynox is right, forget what I said.

Apologies for the confusion.

[kynox]

The approach I posted has always worked for me, but I now realize that it only works for me because I run under wine and disable all the OpenGL ARB extensions, so WoW falls back on the old school method. For people playing with sane graphics settings, Kynox is right, forget what I said.

Apologies for the confusion.

How does WoW perform under Wine?

[pendra]

If your GPU has good linux drivers, WoW should work great under wine. When I have had problems they've never been wine specific, just due to buggy drivers for the GPU. Some people complain about mouse lag but I've never had a problem.