private bool IsPrimitiveNullOrEmpty(RadElement element)
        {
            if (element == null || element.Visibility == ElementVisibility.Collapsed)
            {
                return(true);
            }
            BasePrimitive basePrimitive = element as BasePrimitive;

            if (basePrimitive != null)
            {
                return(basePrimitive.IsEmpty);
            }
            return(false);
        }
        private static void DecodeSource(
            Source src,
            ESemantic semantic,
            int offset,
            int set,
            int maxSets,
            BasePrimitive prim,
            int[] indices,
            Vertex[][] vertices,
            InfluenceDef[] infList,
            Matrix4 bindMatrix,
            Matrix4 invTranspBindMatrix)
        {
            var acc = src.TechniqueCommonElement.AccessorElement;
            int stride = (int)acc.Stride;
            int startIndex, pointIndex;

            float[] list = src.GetArrayElement <FloatArray>().StringContent.Values;
            for (int i = 0, x = 0; i < prim.PointCount; ++i, x += prim.InputElements.Length)
            {
                if (vertices[i] == null)
                {
                    vertices[i] = new Vertex[maxSets];
                }

                startIndex = (pointIndex = indices[x + offset]) * stride;

                Vertex vtx = vertices[i][set];
                if (vtx == null)
                {
                    vtx = new Vertex();
                }

                switch (semantic)
                {
                case ESemantic.POSITION:
                    Vec3 position = new Vec3(
                        list[startIndex],
                        list[startIndex + 1],
                        list[startIndex + 2]);
                    position     = Vec3.TransformPosition(position, bindMatrix);
                    vtx.Position = position;
                    if (infList != null)
                    {
                        vtx.Influence = infList[pointIndex];
                    }
                    break;

                case ESemantic.NORMAL:
                    Vec3 normal = new Vec3(
                        list[startIndex],
                        list[startIndex + 1],
                        list[startIndex + 2]);
                    vtx.Normal = Vec3.TransformVector(normal, invTranspBindMatrix);
                    break;

                case ESemantic.BINORMAL:
                case ESemantic.TEXBINORMAL:
                    Vec3 binormal = new Vec3(
                        list[startIndex],
                        list[startIndex + 1],
                        list[startIndex + 2]);
                    vtx.Binormal = Vec3.TransformVector(binormal, invTranspBindMatrix);
                    break;

                case ESemantic.TANGENT:
                case ESemantic.TEXTANGENT:
                    Vec3 tangent = new Vec3(
                        list[startIndex],
                        list[startIndex + 1],
                        list[startIndex + 2]);
                    vtx.Tangent = Vec3.TransformVector(tangent, invTranspBindMatrix);
                    break;

                case ESemantic.TEXCOORD:
                    vtx.TexCoord = new Vec2(
                        list[startIndex],
                        ImportOptions.InvertTexCoordY ?
                        1.0f - list[startIndex + 1] : list[startIndex + 1]);
                    break;

                case ESemantic.COLOR:
                    vtx.Color = new ColorF4(
                        list[startIndex],
                        list[startIndex + 1],
                        list[startIndex + 2],
                        list[startIndex + 3]);
                    break;
                }
                vertices[i][set] = vtx;
            }
        }