Is my mesh generated causing issues with Recast/Detour? menu

User Tag List

Results 1 to 8 of 8
  1. #1
    scizzydo's Avatar Active Member
    Reputation
    17
    Join Date
    Oct 2019
    Posts
    23
    Thanks G/R
    2/10
    Trade Feedback
    0 (0%)
    Mentioned
    1 Post(s)
    Tagged
    0 Thread(s)

    Is my mesh generated causing issues with Recast/Detour?

    The past two weeks I've spent quite a bit of time trying to get a navigation system going for my little project, but have been facing many issues that I seem to not be able to fix. I've used the settings recommended from posts made by namreeb, xalcons settings, I've even tried to replicate the settings from other projects like meshReader or the settings from RivalFR's "guide" to get wowmapper and recast/detour to work together.

    Long story short, the only time I'm able to get a navigation to work is when I generate a mesh from the sample tool slightly modified with the settings to match the ones off of the old post from namreeb. Although I can get the 1 tile to work, I'm not able to load multiple tiles together (i.e. the image is 40_28, I can't load 40_29 or 40_27 with it). Here's an example image of Orgrimmar that's generated from how I've gathered the geometry.

    Orgimmar tile - Album on Imgur

    Whenever I've seen any picture of any other examples from others, they seem to have the recast bounds directly up against the edge of those tiles, however I can't seem to figure out why mine gets like that. When I gather the data of all the doodads/wmos/terrain/liquids I filter the indices to check if the vertices are within the bounds of the tile, and if not then I don't include them in the indices passed to creating that tile.

    (I'm testing this on MoP 5.4.8 by the way if that is in any relevance to anything)

    These ads disappear when you log in.

  2. #2
    air999's Avatar Contributor
    Reputation
    108
    Join Date
    Nov 2014
    Posts
    87
    Thanks G/R
    6/57
    Trade Feedback
    0 (0%)
    Mentioned
    0 Post(s)
    Tagged
    0 Thread(s)
    Looks like you missing something when filtering.

    Same tile, i don't filter anything.

    Imgur: The magic of the Internet

  3. #3
    scizzydo's Avatar Active Member
    Reputation
    17
    Join Date
    Oct 2019
    Posts
    23
    Thanks G/R
    2/10
    Trade Feedback
    0 (0%)
    Mentioned
    1 Post(s)
    Tagged
    0 Thread(s)
    Originally Posted by air999 View Post
    Looks like you missing something when filtering.

    Same tile, i don't filter anything.

    Imgur: The magic of the Internet
    Thanks for the reply, but you see more because like you said you’re not filtering anything there... I see the same terrain and everything, I just excluded all the vertices that are outside of the tile bounds

    All those wmos that show in yours extra are technically out of the bounds of the 40 28 tile. If you look at the terrains ground in yours you can see where the square just ends and all the others extend past it
    Last edited by scizzydo; 08-09-2020 at 07:03 PM.

  4. #4
    scizzydo's Avatar Active Member
    Reputation
    17
    Join Date
    Oct 2019
    Posts
    23
    Thanks G/R
    2/10
    Trade Feedback
    0 (0%)
    Mentioned
    1 Post(s)
    Tagged
    0 Thread(s)
    Maybe this is a better example to my problem... This image here is one generated from Xalcon posted on the forums in february of 2014.

    Imgur: The magic of the Internet

    If you notice the bounds of the RecastDemo of the box are right along the side of his mesh. Now here's an example of the tile dumped by me just right now:

    Imgur: The magic of the Internet

    What I'm trying to ask, is why do I still have the bounds extending so far past it when I'm trying to exclude the vertices that fall outside of the tiles bounds

  5. #5
    air999's Avatar Contributor
    Reputation
    108
    Join Date
    Nov 2014
    Posts
    87
    Thanks G/R
    6/57
    Trade Feedback
    0 (0%)
    Mentioned
    0 Post(s)
    Tagged
    0 Thread(s)
    Originally Posted by scizzydo View Post
    All those wmos that show in yours extra are technically out of the bounds of the 40 28 tile.
    Sure.

    Trying to rephrase : there is still some unneeded geometry in your mesh, because bounding box sets by min and max vertices in all dimensions.

  6. #6
    scizzydo's Avatar Active Member
    Reputation
    17
    Join Date
    Oct 2019
    Posts
    23
    Thanks G/R
    2/10
    Trade Feedback
    0 (0%)
    Mentioned
    1 Post(s)
    Tagged
    0 Thread(s)
    Originally Posted by air999 View Post
    Sure.

    Trying to rephrase : there is still some unneeded geometry in your mesh, because bounding box sets by min and max vertices in all dimensions.
    That's part of why I'm here I'm not sure how to trim out those vertices that don't have an index to them. I've tried to set the vectors to float NaN's and then attempted to reindex but I can't seem to figure out the correct way to do it. If I was to just delete all the vertices that aren't indexed, it would screw up the indices to where they don't match to the correct vector
    Last edited by scizzydo; 08-10-2020 at 01:30 AM.

  7. #7
    air999's Avatar Contributor
    Reputation
    108
    Join Date
    Nov 2014
    Posts
    87
    Thanks G/R
    6/57
    Trade Feedback
    0 (0%)
    Mentioned
    0 Post(s)
    Tagged
    0 Thread(s)
    You don't need to trim out vertices, just pass bmin bmax in parameters to recast.
    Also,
    Originally Posted by caytchen View Post
    Detour will automatically connect tiles - but only if you pass to Recast geometry for the border, i.e. you will have to load the surrounding ADTs of the one ADT whose tile you want to create. You have to specify a border area in the config or regions will be cut off one agent radius short of the tile bounds.

  8. #8
    air999's Avatar Contributor
    Reputation
    108
    Join Date
    Nov 2014
    Posts
    87
    Thanks G/R
    6/57
    Trade Feedback
    0 (0%)
    Mentioned
    0 Post(s)
    Tagged
    0 Thread(s)
    To trim boundaries you can use
    Code:
    typedef union
    {
    	struct
    	{
    		float x, y, z;
    	};
    	float data[3];
    } Vector3;
    
    typedef union
    {
    	struct
    	{
    		float x, y;
    	};
    	float data[2];
    } Vector2;
    
    class Mesh
    {
    public:
    	Vector3* vertices;
    	int* indices;
    	Vector3* vertexNormals;
    	Vector2* texCoords;
    
    	int vertexCount;
    	int indexCount;
    };
    
    void sub3(const Vector3* first, const Vector3* second, Vector3* result)
    {
    	result->x = first->x - second->x;
    	result->y = first->y - second->y;
    	result->z = first->z - second->z;
    }
    
    float dot3(const Vector3* first, const Vector3* second)
    {
    	int i;
    	float dot = 0;
    
    	for (i = 0; i < 3; ++i)
    	{
    		dot += first->data[i] * second->data[i];
    	}
    
    	return dot;
    }
    
    void lerp3(const Vector3* from, const Vector3* to, float t, Vector3* result)
    {
    	result->x = from->x + t * (to->x - from->x);
    	result->y = from->y + t * (to->y - from->y);
    	result->z = from->z + t * (to->z - from->z);
    }
    
    float linePlaneCoefficient(const Vector3* linePoint, const Vector3* lineDir, const Vector3* planeNormal, const Vector3* planePoint)
    {
    	Vector3 diff;
    	float dot1;
    	float dot2;
    	float result;
    
    	sub3(planePoint, linePoint, &diff);
    	dot1 = dot3(planeNormal, &diff);
    	dot2 = dot3(planeNormal, lineDir);
    	result = dot1 / dot2;
    
    	return result;
    }
    
    
    void rcTrimBoudaries(float minX, float minY, float maxX, float maxY)
    {
    	Mesh *source = new Mesh;
    	Mesh *left = new Mesh;
    	Mesh *right = new Mesh;
    
    	Vector3 planePointA { maxX,maxY,0 };
    	Vector3 planePointB { minX,minY,0 };
    	Vector3 planeNormal1{ 1,1,0 };
    	Vector3 planeNormal2{ 1,-1,0 };
    	Vector3 planeNormal3{ -1,1,0 };
    	Vector3 planeNormal4{ -1,-1,0 };
    
    	rcCutMesh(source, left, right, planePointA, planeNormal1);
    	rcCutMesh(source, left, right, planePointA, planeNormal2);
    	rcCutMesh(source, left, right, planePointB, planeNormal3);
    	rcCutMesh(source, left, right, planePointB, planeNormal4);
    }
    
    void rcCutMesh(Mesh* source, Mesh* left, Mesh* right, Vector3 planePoint, Vector3 planeNormal)
    {
    	int faceCount = source->indexCount / 3;
    
    	// The maximum number of vertices for the new meshes is vertexCount + faceCount * 2
    	// (two points of intersection for each face)
    	int newVertexCount = source->vertexCount;
    	int newVertexMax = source->vertexCount + faceCount * 2;
    
    	Vector3* newVertices = new Vector3[newVertexMax];
    	Vector3* newNormals = new Vector3[newVertexMax];
    
    	memcpy(newVertices, source->vertices, source->vertexCount * sizeof(Vector3));
    	memcpy(newNormals, source->vertexNormals, source->vertexCount * sizeof(Vector3));
    
    	// The maximum number of indices for the new meshes is indexCount + faceCount * 9
    	// (each face could be split up into three faces)
    	int newIndexCount = source->indexCount;
    	int newIndexMax = source->indexCount + faceCount * 9;
    
    	int leftIndexCount = 0;
    	int* leftIndices = new int[newIndexMax];
    
    	int rightIndexCount = 0;
    	int* rightIndices = new int[newIndexMax];
    
    	// Iterate through each face and decide which list to put it in and whether to divide it
    	for (int i = 0; i < faceCount; ++i)
    	{
    		int i1 = source->indices[i * 3 + 0];
    		int i2 = source->indices[i * 3 + 1];
    		int i3 = source->indices[i * 3 + 2];
    
    		Vector3* v1 = &source->vertices[i1];
    		Vector3* v2 = &source->vertices[i2];
    		Vector3* v3 = &source->vertices[i3];
    
    		// Check if each vertex is to the left of the plane
    		Vector3 v1ToPlane;
    		Vector3 v2ToPlane;
    		Vector3 v3ToPlane;
    
    		sub3(&planePoint, v1, &v1ToPlane);
    		sub3(&planePoint, v2, &v2ToPlane);
    		sub3(&planePoint, v3, &v3ToPlane);
    
    		bool v1Left = dot3(&v1ToPlane, &planeNormal) < 0;
    		bool v2Left = dot3(&v2ToPlane, &planeNormal) < 0;
    		bool v3Left = dot3(&v3ToPlane, &planeNormal) < 0;
    
    		int pointsToLeft = (v1Left ? 1 : 0) + (v2Left ? 1 : 0) + (v3Left ? 1 : 0);
    
    		// All vertices to left
    		if (pointsToLeft == 3)
    		{
    			// Add all vertices to left
    			leftIndices[leftIndexCount++] = i1;
    			leftIndices[leftIndexCount++] = i2;
    			leftIndices[leftIndexCount++] = i3;
    		}
    		// All vertices to right
    		else if (pointsToLeft == 0)
    		{
    			// Add all vertices to right
    			rightIndices[rightIndexCount++] = i1;
    			rightIndices[rightIndexCount++] = i2;
    			rightIndices[rightIndexCount++] = i3;
    		}
    		// One vertex to left
    		else if (pointsToLeft == 1)
    		{
    			if (v1Left)
    			{
    				Vector3 line1, line2;
    				Vector3 intersect1, intersect2;
    
    				int intersect1index, intersect2index;
    				float intersect1coeff, intersect2coeff;
    
    				int ia = i1;
    				int ib = i2;
    				int ic = i3;
    
    				const Vector3* a = &newVertices[ia];
    				const Vector3* b = &newVertices[ib];
    				const Vector3* c = &newVertices[ic];
    
    				sub3(b, a, &line1);
    				sub3(c, a, &line2);
    
    				// Calculate lerp coefficient for intersections
    				intersect1coeff = linePlaneCoefficient(a, &line1, &planeNormal, &planePoint);
    				intersect2coeff = linePlaneCoefficient(a, &line2, &planeNormal, &planePoint);
    
    				// Calculate intersections
    				lerp3(a, b, intersect1coeff, &intersect1);
    				lerp3(a, c, intersect2coeff, &intersect2);
    
    				intersect1index = newVertexCount++;
    				intersect2index = newVertexCount++;
    
    				// Save intersections as new vertices
    				newVertices[intersect1index] = intersect1;
    				newVertices[intersect2index] = intersect2;
    
    				lerp3(&source->vertexNormals[ia], &source->vertexNormals[ib], intersect1coeff, &newNormals[intersect1index]);
    				lerp3(&source->vertexNormals[ia], &source->vertexNormals[ic], intersect2coeff, &newNormals[intersect2index]);
    
    				// Add triangles
    				// Left
    				leftIndices[leftIndexCount++] = i1;
    				leftIndices[leftIndexCount++] = intersect1index;
    				leftIndices[leftIndexCount++] = intersect2index;
    
    				// Right
    				rightIndices[rightIndexCount++] = intersect1index;
    				rightIndices[rightIndexCount++] = i2;
    				rightIndices[rightIndexCount++] = i3;
    
    				rightIndices[rightIndexCount++] = intersect1index;
    				rightIndices[rightIndexCount++] = i3;
    				rightIndices[rightIndexCount++] = intersect2index;
    			}
    			else if (v2Left)
    			{
    				Vector3 line1, line2;
    				Vector3 intersect1, intersect2;
    				int intersect1index, intersect2index;
    				float intersect1coeff, intersect2coeff;
    
    				int ia = i2;
    				int ib = i1;
    				int ic = i3;
    
    				const Vector3* a = &newVertices[ia];
    				const Vector3* b = &newVertices[ib];
    				const Vector3* c = &newVertices[ic];
    
    				sub3(b, a, &line1);
    				sub3(c, a, &line2);
    
    				// Calculate lerp coefficient for intersections
    				intersect1coeff = linePlaneCoefficient(a, &line1, &planeNormal, &planePoint);
    				intersect2coeff = linePlaneCoefficient(a, &line2, &planeNormal, &planePoint);
    
    				// Calculate intersections
    				lerp3(a, b, intersect1coeff, &intersect1);
    				lerp3(a, c, intersect2coeff, &intersect2);
    
    				intersect1index = newVertexCount++;
    				intersect2index = newVertexCount++;
    
    				// Save intersections as new vertices
    				newVertices[intersect1index] = intersect1;
    				newVertices[intersect2index] = intersect2;
    
    				lerp3(&source->vertexNormals[ia], &source->vertexNormals[ib], intersect1coeff, &newNormals[intersect1index]);
    				lerp3(&source->vertexNormals[ia], &source->vertexNormals[ic], intersect2coeff, &newNormals[intersect2index]);
    
    				// Add triangles
    				// Left
    				leftIndices[leftIndexCount++] = i2;
    				leftIndices[leftIndexCount++] = intersect2index;
    				leftIndices[leftIndexCount++] = intersect1index;
    
    				// Right
    				rightIndices[rightIndexCount++] = intersect1index;
    				rightIndices[rightIndexCount++] = intersect2index;
    				rightIndices[rightIndexCount++] = i3;
    
    				rightIndices[rightIndexCount++] = intersect1index;
    				rightIndices[rightIndexCount++] = i3;
    				rightIndices[rightIndexCount++] = i1;
    			}
    			else
    			{
    				Vector3 line1, line2;
    				Vector3 intersect1, intersect2;
    				int intersect1index, intersect2index;
    				float intersect1coeff, intersect2coeff;
    
    				int ia = i3;
    				int ib = i1;
    				int ic = i2;
    
    				const Vector3* a = &newVertices[ia];
    				const Vector3* b = &newVertices[ib];
    				const Vector3* c = &newVertices[ic];
    
    				sub3(b, a, &line1);
    				sub3(c, a, &line2);
    
    				// Calculate lerp coefficient for intersections
    				intersect1coeff = linePlaneCoefficient(a, &line1, &planeNormal, &planePoint);
    				intersect2coeff = linePlaneCoefficient(a, &line2, &planeNormal, &planePoint);
    
    				// Calculate intersections
    				lerp3(a, b, intersect1coeff, &intersect1);
    				lerp3(a, c, intersect2coeff, &intersect2);
    
    				intersect1index = newVertexCount++;
    				intersect2index = newVertexCount++;
    
    				// Save intersections as new vertices
    				newVertices[intersect1index] = intersect1;
    				newVertices[intersect2index] = intersect2;
    
    				lerp3(&source->vertexNormals[ia], &source->vertexNormals[ib], intersect1coeff, &newNormals[intersect1index]);
    				lerp3(&source->vertexNormals[ia], &source->vertexNormals[ic], intersect2coeff, &newNormals[intersect2index]);
    
    				// Add triangles
    				// Left
    				leftIndices[leftIndexCount++] = intersect1index;
    				leftIndices[leftIndexCount++] = intersect2index;
    				leftIndices[leftIndexCount++] = i3;
    
    				// Right
    				rightIndices[rightIndexCount++] = i2;
    				rightIndices[rightIndexCount++] = intersect2index;
    				rightIndices[rightIndexCount++] = intersect1index;
    
    				rightIndices[rightIndexCount++] = i2;
    				rightIndices[rightIndexCount++] = intersect1index;
    				rightIndices[rightIndexCount++] = i1;
    			}
    		}
    		// Two vertices to left
    		else if (pointsToLeft == 2)
    		{
    			if (!v1Left)
    			{
    				Vector3 line1, line2;
    				Vector3 intersect1, intersect2;
    				int intersect1index, intersect2index;
    				float intersect1coeff, intersect2coeff;
    
    				int ia = i1;
    				int ib = i2;
    				int ic = i3;
    
    				const Vector3* a = &newVertices[ia];
    				const Vector3* b = &newVertices[ib];
    				const Vector3* c = &newVertices[ic];
    
    				sub3(b, a, &line1);
    				sub3(c, a, &line2);
    
    				// Calculate lerp coefficient for intersections
    				intersect1coeff = linePlaneCoefficient(a, &line1, &planeNormal, &planePoint);
    				intersect2coeff = linePlaneCoefficient(a, &line2, &planeNormal, &planePoint);
    
    				// Calculate intersections
    				lerp3(a, b, intersect1coeff, &intersect1);
    				lerp3(a, c, intersect2coeff, &intersect2);
    
    				intersect1index = newVertexCount++;
    				intersect2index = newVertexCount++;
    
    				// Save intersections as new vertices
    				newVertices[intersect1index] = intersect1;
    				newVertices[intersect2index] = intersect2;
    
    				lerp3(&source->vertexNormals[ia], &source->vertexNormals[ib], intersect1coeff, &newNormals[intersect1index]);
    				lerp3(&source->vertexNormals[ia], &source->vertexNormals[ic], intersect2coeff, &newNormals[intersect2index]);
    
    				// Add triangles
    				// Right
    				rightIndices[rightIndexCount++] = i1;
    				rightIndices[rightIndexCount++] = intersect1index;
    				rightIndices[rightIndexCount++] = intersect2index;
    
    				// Left
    				leftIndices[leftIndexCount++] = intersect1index;
    				leftIndices[leftIndexCount++] = i2;
    				leftIndices[leftIndexCount++] = i3;
    
    				leftIndices[leftIndexCount++] = intersect1index;
    				leftIndices[leftIndexCount++] = i3;
    				leftIndices[leftIndexCount++] = intersect2index;
    			}
    			else if (!v2Left)
    			{
    				Vector3 line1, line2;
    				Vector3 intersect1, intersect2;
    				int intersect1index, intersect2index;
    				float intersect1coeff, intersect2coeff;
    
    				int ia = i2;
    				int ib = i1;
    				int ic = i3;
    
    				const Vector3* a = &newVertices[ia];
    				const Vector3* b = &newVertices[ib];
    				const Vector3* c = &newVertices[ic];
    
    				sub3(b, a, &line1);
    				sub3(c, a, &line2);
    
    				// Calculate lerp coefficient for intersections
    				intersect1coeff = linePlaneCoefficient(a, &line1, &planeNormal, &planePoint);
    				intersect2coeff = linePlaneCoefficient(a, &line2, &planeNormal, &planePoint);
    
    				// Calculate intersections
    				lerp3(a, b, intersect1coeff, &intersect1);
    				lerp3(a, c, intersect2coeff, &intersect2);
    
    				intersect1index = newVertexCount++;
    				intersect2index = newVertexCount++;
    
    				// Save intersections as new vertices
    				newVertices[intersect1index] = intersect1;
    				newVertices[intersect2index] = intersect2;
    
    				lerp3(&source->vertexNormals[ia], &source->vertexNormals[ib], intersect1coeff, &newNormals[intersect1index]);
    				lerp3(&source->vertexNormals[ia], &source->vertexNormals[ic], intersect2coeff, &newNormals[intersect2index]);
    
    				// Add triangles
    				// Right
    				rightIndices[rightIndexCount++] = i2;
    				rightIndices[rightIndexCount++] = intersect2index;
    				rightIndices[rightIndexCount++] = intersect1index;
    
    				// Left
    				leftIndices[leftIndexCount++] = intersect1index;
    				leftIndices[leftIndexCount++] = intersect2index;
    				leftIndices[leftIndexCount++] = i3;
    
    				leftIndices[leftIndexCount++] = intersect1index;
    				leftIndices[leftIndexCount++] = i3;
    				leftIndices[leftIndexCount++] = i1;
    			}
    			else if (!v3Left)
    			{
    				Vector3 line1, line2;
    				Vector3 intersect1, intersect2;
    				int intersect1index, intersect2index;
    				float intersect1coeff, intersect2coeff;
    
    				int ia = i3;
    				int ib = i1;
    				int ic = i2;
    
    				const Vector3* a = &newVertices[ia];
    				const Vector3* b = &newVertices[ib];
    				const Vector3* c = &newVertices[ic];
    
    				sub3(b, a, &line1);
    				sub3(c, a, &line2);
    
    				// Calculate lerp coefficient for intersections
    				intersect1coeff = linePlaneCoefficient(a, &line1, &planeNormal, &planePoint);
    				intersect2coeff = linePlaneCoefficient(a, &line2, &planeNormal, &planePoint);
    
    				// Calculate intersections
    				lerp3(a, b, intersect1coeff, &intersect1);
    				lerp3(a, c, intersect2coeff, &intersect2);
    
    				intersect1index = newVertexCount++;
    				intersect2index = newVertexCount++;
    
    				// Save intersections as new vertices
    				newVertices[intersect1index] = intersect1;
    				newVertices[intersect2index] = intersect2;
    
    				lerp3(&source->vertexNormals[ia], &source->vertexNormals[ib], intersect1coeff, &newNormals[intersect1index]);
    				lerp3(&source->vertexNormals[ia], &source->vertexNormals[ic], intersect2coeff, &newNormals[intersect2index]);
    
    				// Add triangles
    				// Right
    				rightIndices[rightIndexCount++] = intersect1index;
    				rightIndices[rightIndexCount++] = intersect2index;
    				rightIndices[rightIndexCount++] = i3;
    
    				// Left
    				leftIndices[leftIndexCount++] = i2;
    				leftIndices[leftIndexCount++] = intersect2index;
    				leftIndices[leftIndexCount++] = intersect1index;
    
    				leftIndices[leftIndexCount++] = i2;
    				leftIndices[leftIndexCount++] = intersect1index;
    				leftIndices[leftIndexCount++] = i1;
    			}
    		}
    		else
    		{
    			int j = 0;
    		}
    	}
    
    	delete left->vertices;
    	delete left->vertexNormals;
    	delete left->indices;
    
    	delete right->vertices;
    	delete right->vertexNormals;
    	delete right->indices;
    
    	left->vertices = new Vector3[newVertexCount];
    	left->vertexNormals = new Vector3[newVertexCount];
    	left->indices = new int[leftIndexCount];
    
    	left->vertexCount = newVertexCount;
    	left->indexCount = leftIndexCount;
    
    	memcpy(left->vertices, newVertices, left->vertexCount * sizeof(Vector3));
    	memcpy(left->vertexNormals, newNormals, left->vertexCount * sizeof(Vector3));
    	memcpy(left->indices, leftIndices, left->indexCount * sizeof(int));
    
    	right->vertices = new Vector3[newVertexCount];
    	right->vertexNormals = new Vector3[newVertexCount];
    	right->indices = new int[rightIndexCount];
    
    	right->vertexCount = newVertexCount;
    	right->indexCount = rightIndexCount;
    
    	memcpy(right->vertices, newVertices, right->vertexCount * sizeof(Vector3));
    	memcpy(right->vertexNormals, newNormals, right->vertexCount * sizeof(Vector3));
    	memcpy(right->indices, rightIndices, right->indexCount * sizeof(int));
    
    	delete newVertices;
    	delete newNormals;
    	delete leftIndices;
    	delete rightIndices;
    }

Similar Threads

  1. [Question] Pathfinding with Recast/Detours and NPC on different Level
    By hjalplos in forum WoW Bots Questions & Requests
    Replies: 5
    Last Post: 06-30-2020, 09:39 AM
  2. Stuck with Recast/Detour C# (3.3.5)
    By haku43 in forum WoW Memory Editing
    Replies: 6
    Last Post: 06-09-2012, 08:00 AM
  3. Replies: 1
    Last Post: 12-12-2011, 02:31 AM
  4. My "issue" with JULT Repack
    By Death1949 in forum WoW EMU Questions & Requests
    Replies: 3
    Last Post: 07-18-2009, 12:59 PM
  5. Here is my speech2 file with the fixed Night Elf -> Blood Elf replacement...
    By grampa5000 in forum World of Warcraft Model Editing
    Replies: 5
    Last Post: 09-06-2006, 08:22 PM
All times are GMT -5. The time now is 11:56 AM. Powered by vBulletin® Version 4.2.3
Copyright © 2020 vBulletin Solutions, Inc. All rights reserved. User Alert System provided by Advanced User Tagging (Pro) - vBulletin Mods & Addons Copyright © 2020 DragonByte Technologies Ltd.
Digital Point modules: Sphinx-based search