Esempio n. 1
0
 private static void CheckMirrorCapable(List <DBOnlineMirror> mirrorList, TypeMask mask)
 {
     for (int i = 0; i < mirrorList.Count; i++)
     {
         if (mirrorList[i][cTypeMask] == null || !ContainsTypeMask((TypeMask)(int)mirrorList[i][cTypeMask], mask))
         {
             mirrorList.RemoveAt(i--);
         }
     }
 }
Esempio n. 2
0
    TypeContainer GetContainer(TypeMask typeMask)
    {
        TypeContainer value;

        if (dict == null)
        {
            dict = new Dictionary <TypeMask, TypeContainer>();
        }
        if (!dict.TryGetValue(typeMask, out value))
        {
            var types = SubTypes.GetSubTypes(typeMask.baseType);
            value = new TypeContainer(types);
            dict.Add(typeMask, value);
        }
        return(value);
    }
Esempio n. 3
0
    public WorldObject GetObjectByTypeMask(WorldObject p, ObjectGuid guid, TypeMask typemask)
    {
        switch (guid.GetHigh())
        {
        case HighGuid.Item:
            if (typemask.HasAnyFlag(TypeMask.Item) && p.IsTypeId(TypeId.Player))
            {
                return(((Player)p).GetItemByGuid(guid));
            }
            break;

        case HighGuid.Player:
            if (typemask.HasAnyFlag(TypeMask.Player))
            {
                return(GetPlayer(p, guid));
            }
            break;

        case HighGuid.Transport:
        case HighGuid.GameObject:
            if (typemask.HasAnyFlag(TypeMask.GameObject))
            {
                return(GetGameObject(p, guid));
            }
            break;

        case HighGuid.Creature:
        case HighGuid.Vehicle:
            if (typemask.HasAnyFlag(TypeMask.Unit))
            {
                return(GetCreature(p, guid));
            }
            break;

        case HighGuid.Pet:
            if (typemask.HasAnyFlag(TypeMask.Unit))
            {
                return(GetPet(p, guid));
            }
            break;

        case HighGuid.DynamicObject:
            if (typemask.HasAnyFlag(TypeMask.DynamicObject))
            {
                return(GetDynamicObject(p, guid));
            }
            break;

        case HighGuid.AreaTrigger:
            if (typemask.HasAnyFlag(TypeMask.AreaTrigger))
            {
                return(GetAreaTrigger(p, guid));
            }
            break;

        case HighGuid.Conversation:
            if (typemask.HasAnyFlag(TypeMask.Conversation))
            {
                return(GetConversation(p, guid));
            }
            break;

        case HighGuid.Corpse:
            break;
        }

        return(null);
    }
Esempio n. 4
0
 private static extern bool VerifyVersionInfo(ref OSVERSIONINFOEX lpVersionInfo, TypeMask dwTypeMask, ulong dwlConditionMask);
Esempio n. 5
0
 private static extern ulong VerSetConditionMask(ulong dwlConditionMask, TypeMask dwTypeBitMask, ConditionMask dwConditionMask);
Esempio n. 6
0
 private static bool ContainsTypeMask(TypeMask combined, TypeMask checkagainst)
 {
     return ((combined & checkagainst) == checkagainst);
 }
Esempio n. 7
0
 private static void checkMirrorCapable(List<DBOnlineMirror> mirrorList, TypeMask mask)
 {
     for (int i = 0; i < mirrorList.Count; i++)
     {
         if (mirrorList[i][cTypeMask] == null || !ContainsTypeMask((TypeMask)(int)mirrorList[i][cTypeMask], mask))
             mirrorList.RemoveAt(i--);
     }
 }
Esempio n. 8
0
 public static extern NtStatus RtlVerifyVersionInfo(
     ref OsVersionInfoEXW versionInfo,
     TypeMask typeMask,
     ulong conditionMask
     );
Esempio n. 9
0
 public static extern ulong VerSetConditionMask(
     ulong conditionMask,
     TypeMask typeMask,
     Condition condition
     );
Esempio n. 10
0
    protected bool CreateSide(Volume volume, bool partialBuild)
    {
        bool flat = TypeMask.HasFlag(VolumeFaceMask.Flat);

        SculptType  sculptStitching         = volume.Parameters.SculptType;
        SculptFlags sculptFlags             = volume.Parameters.SculptFlags;
        bool        sculptInvert            = sculptFlags.HasFlag(SculptFlags.Invert);
        bool        sculptMirror            = sculptFlags.HasFlag(SculptFlags.Mirror);
        bool        sculptReverseHorizontal = (sculptInvert ? !sculptMirror : sculptMirror);   // XOR

        int numVertices, numIndices;

        List <Vector3>        mesh     = volume.Points;
        List <Vector3>        profile  = volume.Profile.Points;
        List <Path.PathPoint> pathData = volume.Path.Points;

        int maxS = volume.Profile.PointCount;

        int   s, t, i;
        float ss, tt;

        numVertices = NumS * NumT;
        numIndices  = (NumS - 1) * (NumT - 1) * 6;

        // TODO: How does partial builds work?
        //partial_build = (num_vertices > NumVertices || num_indices > NumIndices) ? false : partial_build;

        //if (!partial_build)
        //{
        //	resizeVertices(num_vertices);
        //	resizeIndices(num_indices);

        //	if (!volume->isMeshAssetLoaded())
        //	{
        //		mEdge.resize(num_indices);
        //	}
        //}
        Positions.Clear();
        Normals.Clear();
        Indices.Clear();
        Edge.Clear();


        float beginStex = Mathf.Floor(profile[BeginS][2]);
        bool  test      = TypeMask.HasFlag(VolumeFaceMask.Inner | VolumeFaceMask.Flat) && NumS > 2;
        int   numS      = test ? NumS / 2 : NumS;

        int curVertex = 0;
        int endT      = BeginT + NumT;

        // Copy the vertices into the array
        for (t = BeginT; t < endT; t++)
        {
            tt = pathData[t].ExtrusionT;
            for (s = 0; s < numS; s++)
            {
                if (TypeMask.HasFlag(VolumeFaceMask.End))
                {
                    ss = s > 0 ? 1f : 0f;
                }
                else
                {
                    // Get s value for tex-coord.
                    if (!flat)
                    {
                        ss = profile[BeginS + s][2];
                    }
                    else
                    {
                        ss = profile[BeginS + s][2] - beginStex;
                    }
                }

                if (sculptReverseHorizontal)
                {
                    ss = 1f - ss;
                }

                // Check to see if this triangle wraps around the array.
                if (BeginS + s >= maxS)
                {
                    // We're wrapping
                    i = BeginS + s + maxS * (t - 1);
                }
                else
                {
                    i = BeginS + s + maxS * t;
                }

                Positions.Add(mesh[i]);
                Normals.Add(Vector3.zero);                  // This will be calculated later
                TexCoords.Add(new Vector2(ss, tt));

                curVertex++;

                if (test && s > 0)
                {
                    Positions.Add(mesh[i]);
                    Normals.Add(Vector3.zero); // This will be calculated later
                    TexCoords.Add(new Vector2(ss, tt));
                    curVertex++;
                }
            }

            if (test)
            {
                s = TypeMask.HasFlag(VolumeFaceMask.Open) ? numS - 1 : 0;

                i  = BeginS + s + maxS * t;
                ss = profile[BeginS + s][2] - beginStex;

                Positions.Add(mesh[i]);
                Normals.Add(Vector3.zero); // This will be calculated later
                TexCoords.Add(new Vector2(ss, tt));

                curVertex++;
            }
        }

        Centre = Vector3.zero;

        int curPos = 0;
        int endPos = Positions.Count;

        //get bounding box for this side
        Vector3 faceMin;
        Vector3 faceMax;

        faceMin = faceMax = Positions[curPos++];

        while (curPos < endPos)
        {
            UpdateMinMax(ref faceMin, ref faceMax, Positions[curPos++]);
        }
        // VFExtents change
        ExtentsMin = faceMin;
        ExtentsMax = faceMax;

        int tcCount = NumVertices;

        if (tcCount % 2 == 1)
        {         //odd number of texture coordinates, duplicate last entry to padded end of array
            tcCount++;
            TexCoords.Add(TexCoords[NumVertices - 1]);
        }

        int curTc = 0;
        int endTc = TexCoords.Count;

        Vector3 tcMin;
        Vector3 tcMax;

        tcMin = tcMax = TexCoords[curTc++];

        while (curTc < endTc)
        {
            UpdateMinMax(ref tcMin, ref tcMax, TexCoords[curTc++]);
        }

        //TODO: TexCoordExtents are weird this assumes Vector4
        //TexCoordExtentsMin.x = llmin(minp[0], minp[2]);
        //TexCoordExtentsMin.y = llmin(minp[1], minp[3]);
        //TexCoordExtentsMax.x = llmax(maxp[0], maxp[2]);
        //TexCoordExtentsMax.y = llmax(maxp[1], maxp[3]);

        Centre = (faceMin + faceMax) * 0.5f;

        bool flatFace = TypeMask.HasFlag(VolumeFaceMask.Flat); //(TypeMask & VolumeFaceMask.Flat) != 0;

        if (!partialBuild)
        {
            // Now we generate the indices.
            for (t = 0; t < (NumT - 1); t++)
            {
                for (s = 0; s < (NumS - 1); s++)
                {
                    Indices.Add(s + NumS * t);                                 //bottom left
                    Indices.Add(s + 1 + NumS * (t + 1));                       //top right
                    Indices.Add(s + NumS * (t + 1));                           //top left
                    Indices.Add(s + NumS * t);                                 //bottom left
                    Indices.Add(s + 1 + NumS * t);                             //bottom right
                    Indices.Add(s + 1 + NumS * (t + 1));                       //top right

                    Edge.Add((NumS - 1) * 2 * t + s * 2 + 1);                  //bottom left/top right neighbor face
                    if (t < NumT - 2)
                    {                                                          //top right/top left neighbor face
                        Edge.Add((NumS - 1) * 2 * (t + 1) + s * 2 + 1);
                    }
                    else if (NumT <= 3 || volume.Path.IsOpen == true)
                    {                     //no neighbor
                        Edge.Add(-1);
                    }
                    else
                    {                     //wrap on T
                        Edge.Add(s * 2 + 1);
                    }
                    if (s > 0)
                    {                                                                       //top left/bottom left neighbor face
                        Edge.Add((NumS - 1) * 2 * t + s * 2 - 1);
                    }
                    else if (flatFace || volume.Profile.IsOpen == true)
                    {                     //no neighbor
                        Edge.Add(-1);
                    }
                    else
                    {                       //wrap on S
                        Edge.Add((NumS - 1) * 2 * t + (NumS - 2) * 2 + 1);
                    }

                    if (t > 0)
                    {                                                                       //bottom left/bottom right neighbor face
                        Edge.Add((NumS - 1) * 2 * (t - 1) + s * 2);
                    }
                    else if (NumT <= 3 || volume.Path.IsOpen == true)
                    {                     //no neighbor
                        Edge.Add(-1);
                    }
                    else
                    {                     //wrap on T
                        Edge.Add((NumS - 1) * 2 * (NumT - 2) + s * 2);
                    }
                    if (s < NumS - 2)
                    {                                                                   //bottom right/top right neighbor face
                        Edge.Add((NumS - 1) * 2 * t + (s + 1) * 2);
                    }
                    else if (flatFace || volume.Profile.IsOpen == true)
                    {                     //no neighbor
                        Edge.Add(-1);
                    }
                    else
                    {                     //wrap on S
                        Edge.Add((NumS - 1) * 2 * t);
                    }
                    Edge.Add((NumS - 1) * 2 * t + s * 2);                                                 //top right/bottom left neighbor face
                }
            }
        }



        //      //clear normals
        //int dst = Normals.Count;
        //int end = dst + NumVertices;
        //Vector3 zero = Vector3.zero;

        //while (dst < end)
        //      {
        //          Normals.Add(zero);
        //	dst++;
        //}

        //generate normals

        // Compute triangle normals:
        int            count           = Indices.Count / 3;
        List <Vector3> triangleNormals = new List <Vector3>();
        int            idx             = 0;

        for (int triangleIndex = 0; triangleIndex < count; triangleIndex++)
        {
            Vector3 p0 = Positions[Indices[idx + 0]];
            Vector3 p1 = Positions[Indices[idx + 1]];
            Vector3 p2 = Positions[Indices[idx + 2]];

            //calculate triangle normal
            Vector3 a = p1 - p0;
            Vector3 b = p2 - p0;

            Vector3 normal = Vector3.Cross(a, b);

            if (Vector3.Dot(normal, normal) > 0.00001f)
            {
                normal.Normalize();
            }
            else
            {
                //degenerate, make up a value
                normal = normal.z >= 0 ? new Vector3(0f, 0f, 1f) : new Vector3(0f, 0f, -1f);
            }

            // This is probably an optimised way to calculate this:
            //LLQuad & vector1 = *((LLQuad*)&v1);
            //LLQuad & vector2 = *((LLQuad*)&v2);

            //LLQuad & amQ = *((LLQuad*)&a);
            //LLQuad & bmQ = *((LLQuad*)&b);

            // Vectors are stored in memory in w, z, y, x order from high to low
            // Set vector1 = { a[W], a[X], a[Z], a[Y] }
            //vector1 = _mm_shuffle_ps(amQ, amQ, _MM_SHUFFLE(3, 0, 2, 1));
            // Set vector2 = { b[W], b[Y], b[X], b[Z] }
            //vector2 = _mm_shuffle_ps(bmQ, bmQ, _MM_SHUFFLE(3, 1, 0, 2));
            // mQ = { a[W]*b[W], a[X]*b[Y], a[Z]*b[X], a[Y]*b[Z] }
            //vector2 = _mm_mul_ps(vector1, vector2);
            // vector3 = { a[W], a[Y], a[X], a[Z] }
            //amQ = _mm_shuffle_ps(amQ, amQ, _MM_SHUFFLE(3, 1, 0, 2));
            // vector4 = { b[W], b[X], b[Z], b[Y] }
            //bmQ = _mm_shuffle_ps(bmQ, bmQ, _MM_SHUFFLE(3, 0, 2, 1));
            // mQ = { 0, a[X]*b[Y] - a[Y]*b[X], a[Z]*b[X] - a[X]*b[Z], a[Y]*b[Z] - a[Z]*b[Y] }
            //vector1 = _mm_sub_ps(vector2, _mm_mul_ps(amQ, bmQ));

            //llassert(v1.isFinite3());

            triangleNormals.Add(normal);
            idx += 3;
        }

        // Add triangle normal contributions from each triangle to the vertex normals:
        idx = 0;
        for (int triangleIndex = 0; triangleIndex < count; triangleIndex++) //for each triangle
        {
            Vector3 c = triangleNormals[triangleIndex];

            Vector3 n0 = Normals[Indices[idx + 0]];
            Vector3 n1 = Normals[Indices[idx + 1]];
            Vector3 n2 = Normals[Indices[idx + 2]];

            n0 += c;
            n1 += c;
            n2 += c;

            //llassert(c.isFinite3());

            //even out quad contributions
            switch (triangleIndex % 2 + 1)
            {
            case 0: n0 += c; break;

            case 1: n1 += c; break;

            case 2: n2 += c; break;
            }
            ;

            Normals[Indices[idx + 0]] = n0;
            Normals[Indices[idx + 1]] = n1;
            Normals[Indices[idx + 2]] = n2;

            idx += 3;
        }

        // adjust normals based on wrapping and stitching

        Vector3 top = (Positions[0] - Positions[NumS * (NumT - 2)]);
        bool    s_bottom_converges = Vector3.Dot(top, top) < 0.000001f;

        top = Positions[NumS - 1] - Positions[NumS * (NumT - 2) + NumS - 1];
        bool s_top_converges = Vector3.Dot(top, top) < 0.000001f;

        if (sculptStitching == SculptType.None)          // logic for non-sculpt volumes
        {
            if (volume.Path.IsOpen == false)
            {             //wrap normals on T
                for (int j = 0; j < NumS; j++)
                {
                    Vector3 n = Normals[j] + Normals[NumS * (NumT - 1) + j];
                    Normals[j] = n;
                    Normals[NumS * (NumT - 1) + j] = n;
                }
            }

            if ((volume.Profile.IsOpen == false) && !(s_bottom_converges))
            {             //wrap normals on S
                for (int j = 0; j < NumT; j++)
                {
                    Vector3 n = Normals[NumS * j] + Normals[NumS * j + NumS - 1];
                    Normals[NumS * j]            = n;
                    Normals[NumS * j + NumS - 1] = n;
                }
            }

            if (volume.Parameters.PathParameters.PathType == PathType.Circle &&
                volume.Parameters.ProfileParameters.ProfileType == ProfileType.CircleHalf)
            {
                if (s_bottom_converges)
                {                 //all lower S have same normal
                    for (int j = 0; j < NumT; j++)
                    {
                        Normals[NumS * j] = new Vector3(1f, 0f, 0f);
                    }
                }

                if (s_top_converges)
                {                 //all upper S have same normal
                    for (int j = 0; j < NumT; j++)
                    {
                        Normals[NumS * j + NumS - 1] = new Vector3(-1f, 0f, 0f);
                    }
                }
            }
        }
        //else  // logic for sculpt volumes
        //{
        //BOOL average_poles = FALSE;
        //BOOL wrap_s = FALSE;
        //BOOL wrap_t = FALSE;

        //if (sculpt_stitching == LL_SCULPT_TYPE_SPHERE)
        //	average_poles = TRUE;

        //if ((sculpt_stitching == LL_SCULPT_TYPE_SPHERE) ||
        //	(sculpt_stitching == LL_SCULPT_TYPE_TORUS) ||
        //	(sculpt_stitching == LL_SCULPT_TYPE_CYLINDER))
        //	wrap_s = TRUE;

        //if (sculpt_stitching == LL_SCULPT_TYPE_TORUS)
        //	wrap_t = TRUE;


        //if (average_poles)
        //{
        //	// average normals for north pole

        //	LLVector4a average;
        //	average.clear();

        //	for (S32 i = 0; i < mNumS; i++)
        //	{
        //		average.add(norm[i]);
        //	}

        //	// set average
        //	for (S32 i = 0; i < mNumS; i++)
        //	{
        //		norm[i] = average;
        //	}

        //	// average normals for south pole

        //	average.clear();

        //	for (S32 i = 0; i < mNumS; i++)
        //	{
        //		average.add(norm[i + mNumS * (mNumT - 1)]);
        //	}

        //	// set average
        //	for (S32 i = 0; i < mNumS; i++)
        //	{
        //		norm[i + mNumS * (mNumT - 1)] = average;
        //	}
        //         }

        //if (wrap_s)
        //{
        //	for (S32 i = 0; i < mNumT; i++)
        //	{
        //		LLVector4a n;
        //		n.setAdd(norm[mNumS * i], norm[mNumS * i + mNumS - 1]);
        //		norm[mNumS * i] = n;
        //		norm[mNumS * i + mNumS - 1] = n;
        //	}
        //}

        //if (wrap_t)
        //{
        //	for (S32 i = 0; i < mNumS; i++)
        //	{
        //		LLVector4a n;
        //		n.setAdd(norm[i], norm[mNumS * (mNumT - 1) + i]);
        //		norm[i] = n;
        //		norm[mNumS * (mNumT - 1) + i] = n;
        //	}
        //}
        //}

        // Normalise normals:
        for (int normalIndex = 0; normalIndex < Normals.Count; normalIndex++)
        {
            Normals[normalIndex] = Normals[normalIndex].normalized;
        }

        return(true);
    }
Esempio n. 11
0
 static MapPtsProc GetMapPtsProc(TypeMask mask)
 {
     D.assert(((int)mask & ~kAllMasks) == 0);
     return(gMapPtsProcs[(int)mask & kAllMasks]);
 }
Esempio n. 12
0
 private static bool ContainsTypeMask(TypeMask combined, TypeMask checkagainst)
 {
     return((combined & checkagainst) == checkagainst);
 }