internal void ValidateIndices(VALIDATIONCTX result, uint vertexCount, PrimitiveType drawingType)
        {
            result = result.GetContext(this);

            SourceBufferView.ValidateBufferUsageGPU(result, BufferMode.ELEMENT_ARRAY_BUFFER);
            result.CheckLinkMustBeAnyOf(nameof(Normalized), Normalized, false);
            result.CheckLinkMustBeAnyOf(nameof(Encoding), Encoding, EncodingType.UNSIGNED_BYTE, EncodingType.UNSIGNED_SHORT, EncodingType.UNSIGNED_INT);
            result.CheckLinkMustBeAnyOf(nameof(Dimensions), Dimensions, DimensionType.SCALAR);

            uint restart_value = 0xff;

            if (this.Encoding == EncodingType.UNSIGNED_SHORT)
            {
                restart_value = 0xffff;
            }
            if (this.Encoding == EncodingType.UNSIGNED_INT)
            {
                restart_value = 0xffffffff;
            }

            var indices = this.AsIndicesArray();

            for (int i = 0; i < indices.Count; ++i)
            {
                result.CheckVertexIndex(i, indices[i], vertexCount, restart_value);
            }
        }
        private void _ValidateNormals(VALIDATIONCTX result)
        {
            result = result.GetContext(this);

            SourceBufferView.ValidateBufferUsageGPU(result, BufferMode.ARRAY_BUFFER);
            result.CheckLinkMustBeAnyOf(nameof(Dimensions), Dimensions, DimensionType.VEC3);
            if (!this.LogicalParent.MeshQuantizationAllowed)
            {
                result.CheckLinkMustBeAnyOf(nameof(Normalized), Normalized, false);
                result.CheckLinkMustBeAnyOf(nameof(Encoding), Encoding, EncodingType.FLOAT);
            }
            else
            {
                if (Normalized)
                {
                    result.CheckLinkMustBeAnyOf(nameof(Encoding), Encoding, EncodingType.BYTE, EncodingType.SHORT);
                }
                else
                {
                    result.CheckLinkMustBeAnyOf(nameof(Encoding), Encoding, EncodingType.FLOAT);
                }
            }

            var normals = this.AsVector3Array();

            for (int i = 0; i < normals.Count; ++i)
            {
                if (result.TryFixUnitLengthOrError(i, normals[i]))
                {
                    normals[i] = normals[i].SanitizeNormal();
                }
            }
        }
        private void _ValidateWeights(VALIDATIONCTX result)
        {
            result = result.GetContext(this);

            SourceBufferView.ValidateBufferUsageGPU(result, BufferMode.ARRAY_BUFFER);
            result.CheckLinkMustBeAnyOf(nameof(Encoding), Encoding, EncodingType.UNSIGNED_BYTE, EncodingType.UNSIGNED_SHORT, EncodingType.FLOAT);
            result.CheckLinkMustBeAnyOf(nameof(Dimensions), Dimensions, DimensionType.VEC4);
        }
Beispiel #4
0
        private void _ValidateWeights(VALIDATIONCTX validate)
        {
            validate = validate.GetContext(this);

            SourceBufferView.ValidateBufferUsageGPU(validate, BufferMode.ARRAY_BUFFER);

            validate.IsAnyOf(nameof(Format), Format, (DimensionType.VEC4, EncodingType.UNSIGNED_BYTE, true), (DimensionType.VEC4, EncodingType.UNSIGNED_SHORT, true), DimensionType.VEC4);
        }
        private void ValidateBounds(VALIDATIONCTX result)
        {
            result = result.GetContext(this);

            if (_min.Count != _max.Count)
            {
                result.AddDataError("Max", $"Min and Max bounds dimension mismatch Min:{_min.Count} Max:{_max.Count}");
            }

            if (_min.Count == 0 && _max.Count == 0)
            {
                return;
            }

            var dimensions = this.Dimensions.DimCount();

            if (_min.Count != dimensions)
            {
                result.AddLinkError("Min", $"size mismatch; expected {dimensions} but found {_min.Count}"); return;
            }
            if (_max.Count != dimensions)
            {
                result.AddLinkError("Max", $"size mismatch; expected {dimensions} but found {_max.Count}"); return;
            }

            for (int i = 0; i < _min.Count; ++i)
            {
                // if (_min[i] > _max[i]) result.AddError(this, $"min[{i}] is larger than max[{i}]");
            }

            if (this.Encoding != EncodingType.FLOAT)
            {
                return;
            }

            var current = new float[dimensions];
            var minimum = this._min.ConvertAll(item => (float)item);
            var maximum = this._max.ConvertAll(item => (float)item);

            var array = new MultiArray(this.SourceBufferView.Content, this.ByteOffset, this.Count, this.SourceBufferView.ByteStride, dimensions, this.Encoding, false);

            for (int i = 0; i < array.Count; ++i)
            {
                array.CopyItemTo(i, current);

                for (int j = 0; j < current.Length; ++j)
                {
                    var v = current[j];

                    // if (!v._IsFinite()) result.AddError(this, $"Item[{j}][{i}] is not a finite number: {v}");

                    var min = minimum[j];
                    var max = maximum[j];

                    // if (v < min || v > max) result.AddError(this, $"Item[{j}][{i}] is out of bounds. {min} <= {v} <= {max}");
                }
            }
        }
        private static void _ValidateWeights(VALIDATIONCTX result, Accessor weights0, Accessor weights1)
        {
            weights0?._ValidateWeights(result);
            weights1?._ValidateWeights(result);

            var memory0 = weights0?._GetMemoryAccessor("WEIGHTS_0");
            var memory1 = weights1?._GetMemoryAccessor("WEIGHTS_1");

            MemoryAccessor.ValidateWeightsSum(result, memory0, memory1);
        }
Beispiel #7
0
        private void _ValidateJoints(VALIDATIONCTX validate, string attributeName, int skinsMaxJointCount)
        {
            validate = validate.GetContext(this);

            SourceBufferView.ValidateBufferUsageGPU(validate, BufferMode.ARRAY_BUFFER);

            validate
            .IsAnyOf(nameof(Format), Format, (DimensionType.VEC4, EncodingType.UNSIGNED_BYTE), (DimensionType.VEC4, EncodingType.UNSIGNED_SHORT), DimensionType.VEC4)
            .AreJoints(attributeName, this.AsVector4Array(), skinsMaxJointCount);
        }
Beispiel #8
0
        private static void _ValidateWeights(VALIDATIONCTX validate, Accessor weights0, Accessor weights1)
        {
            weights0?._ValidateWeights(validate);
            weights1?._ValidateWeights(validate);

            var memory0 = weights0?._GetMemoryAccessor("WEIGHTS_0");
            var memory1 = weights1?._GetMemoryAccessor("WEIGHTS_1");

            validate.That(() => MemoryAccessor.VerifyWeightsSum(memory0, memory1));
        }
Beispiel #9
0
        protected override void OnValidateReferences(VALIDATIONCTX validate)
        {
            base.OnValidateReferences(validate);

            validate
            .IsDefined(nameof(_bufferView), _bufferView)
            .NonNegative(nameof(_byteOffset), _byteOffset)
            .IsGreaterOrEqual(nameof(_count), _count, _countMinimum)
            .IsNullOrIndex(nameof(_bufferView), _bufferView, this.LogicalParent.LogicalBufferViews);
        }
Beispiel #10
0
        protected override void OnValidateContent(VALIDATIONCTX validate)
        {
            base.OnValidateContent(validate);

            BufferView.VerifyAccess(validate, this.SourceBufferView, this.ByteOffset, this.Format, this.Count);

            validate.That(() => MemoryAccessor.VerifyAccessorBounds(_GetMemoryAccessor(), _min, _max));

            // at this point we don't know which kind of data we're accessing, so it's up to the components
            // using this accessor to validate the data.
        }
Beispiel #11
0
        internal void ValidateIndices(VALIDATIONCTX validate, uint vertexCount, PrimitiveType drawingType)
        {
            validate = validate.GetContext(this);

            SourceBufferView.ValidateBufferUsageGPU(validate, BufferMode.ELEMENT_ARRAY_BUFFER);
            validate.IsAnyOf("Format", Format, (DimensionType.SCALAR, EncodingType.UNSIGNED_BYTE), (DimensionType.SCALAR, EncodingType.UNSIGNED_SHORT), (DimensionType.SCALAR, EncodingType.UNSIGNED_INT));

            validate.AreEqual(nameof(SourceBufferView.ByteStride), SourceBufferView.ByteStride, 0); // "bufferView.byteStride must not be defined for indices accessor.";

            validate.That(() => MemoryAccessor.VerifyVertexIndices(_GetMemoryAccessor(), vertexCount));
        }
        protected override void OnValidateReferences(VALIDATIONCTX result)
        {
            base.OnValidateReferences(result);

            result.CheckSchemaIsDefined("BufferView", _bufferView);
            result.CheckArrayIndexAccess("BufferView", _bufferView, this.LogicalParent.LogicalBufferViews);

            result.CheckSchemaNonNegative("ByteOffset", _byteOffset);
            result.CheckSchemaIsInRange("Count", _count, _countMinimum, int.MaxValue);

            _sparse?.ValidateReferences(result);
        }
        protected override void OnValidate(VALIDATIONCTX result)
        {
            base.OnValidate(result);

            _sparse?.Validate(result);

            BufferView.CheckAccess(result, this.SourceBufferView, this.ByteOffset, this.Dimensions, this.Encoding, this.Normalized, this.Count);

            ValidateBounds(result);

            // at this point we don't know which kind of data we're accessing, so it's up to the components
            // using this accessor to validate the data.
        }
        internal void ValidateMatrices(VALIDATIONCTX result)
        {
            result = result.GetContext(this);

            SourceBufferView.ValidateBufferUsagePlainData(result);
            result.CheckLinkMustBeAnyOf(nameof(Dimensions), Dimensions, DimensionType.MAT4);

            var matrices = this.AsMatrix4x4Array();

            for (int i = 0; i < matrices.Count; ++i)
            {
                result.CheckIsMatrix(i, matrices[i]);
            }
        }
Beispiel #15
0
        internal void ValidateMatrices(VALIDATIONCTX validate)
        {
            validate = validate.GetContext(this);

            SourceBufferView.ValidateBufferUsagePlainData(validate);

            validate.IsAnyOf(nameof(Format), Format, (DimensionType.MAT4, EncodingType.BYTE, true), (DimensionType.MAT4, EncodingType.SHORT, true), DimensionType.MAT4);

            var matrices = this.AsMatrix4x4Array();

            for (int i = 0; i < matrices.Count; ++i)
            {
                validate.IsNullOrMatrix("Matrices", matrices[i]);
            }
        }
        internal static void ValidateVertexAttributes(VALIDATIONCTX result, IReadOnlyDictionary <string, Accessor> attributes, int skinsMaxJointCount)
        {
            if (result.TryFix)
            {
                foreach (var kvp in attributes.Where(item => item.Key != "POSITION"))
                {
                    // remove unnecessary bounds
                    kvp.Value._min.Clear();
                    kvp.Value._max.Clear();
                }
            }

            if (attributes.TryGetValue("POSITION", out Accessor positions))
            {
                positions._ValidatePositions(result);
            }
            else
            {
                result.AddSemanticWarning("No POSITION attribute found.");
            }

            if (attributes.TryGetValue("NORMAL", out Accessor normals))
            {
                normals._ValidateNormals(result);
            }
            if (attributes.TryGetValue("TANGENT", out Accessor tangents))
            {
                tangents._ValidateTangents(result);
            }
            if (normals == null && tangents != null)
            {
                result.AddSemanticWarning("TANGENT", "attribute without NORMAL found.");
            }

            if (attributes.TryGetValue("JOINTS_0", out Accessor joints0))
            {
                joints0._ValidateJoints(result, "JOINTS_0", skinsMaxJointCount);
            }
            if (attributes.TryGetValue("JOINTS_1", out Accessor joints1))
            {
                joints0._ValidateJoints(result, "JOINTS_1", skinsMaxJointCount);
            }

            attributes.TryGetValue("WEIGHTS_0", out Accessor weights0);
            attributes.TryGetValue("WEIGHTS_1", out Accessor weights1);
            _ValidateWeights(result, weights0, weights1);
        }
Beispiel #17
0
        private void _ValidatePositions(VALIDATIONCTX validate)
        {
            validate = validate.GetContext(this);

            SourceBufferView.ValidateBufferUsageGPU(validate, BufferMode.ARRAY_BUFFER);

            if (!this.LogicalParent.MeshQuantizationAllowed)
            {
                validate.IsAnyOf(nameof(Format), Format, DimensionType.VEC3);
            }
            else
            {
                validate.IsAnyOf(nameof(Dimensions), Dimensions, DimensionType.VEC3);
            }

            validate.ArePositions("POSITION", this.AsVector3Array());
        }
        private void _ValidatePositions(VALIDATIONCTX result)
        {
            result = result.GetContext(this);

            SourceBufferView.ValidateBufferUsageGPU(result, BufferMode.ARRAY_BUFFER);
            result.CheckLinkMustBeAnyOf(nameof(Dimensions), Dimensions, DimensionType.VEC3);
            if (!this.LogicalParent.MeshQuantizationAllowed)
            {
                result.CheckLinkMustBeAnyOf(nameof(Normalized), Normalized, false);
                result.CheckLinkMustBeAnyOf(nameof(Encoding), Encoding, EncodingType.FLOAT);
            }

            var positions = this.AsVector3Array();

            for (int i = 0; i < positions.Count; ++i)
            {
                result.CheckIsFinite(i, positions[i]);
            }
        }
        private void _ValidateJoints(VALIDATIONCTX result, string attributeName, int skinsMaxJointCount)
        {
            result = result.GetContext(this);

            SourceBufferView.ValidateBufferUsageGPU(result, BufferMode.ARRAY_BUFFER);
            result.CheckLinkMustBeAnyOf(nameof(Normalized), Normalized, false);
            result.CheckLinkMustBeAnyOf(nameof(Encoding), Encoding, EncodingType.UNSIGNED_BYTE, EncodingType.UNSIGNED_SHORT, EncodingType.FLOAT);
            result.CheckLinkMustBeAnyOf(nameof(Dimensions), Dimensions, DimensionType.VEC4);

            var joints = this.AsVector4Array();

            for (int i = 0; i < joints.Count; ++i)
            {
                var jidx = joints[i];

                result.CheckIsFinite(i, jidx);
                result.CheckIsInRange(i, jidx, 0, skinsMaxJointCount);
            }
        }
Beispiel #20
0
        internal static void ValidateVertexAttributes(VALIDATIONCTX validate, IReadOnlyDictionary <string, Accessor> attributes, int skinsMaxJointCount)
        {
            if (validate.TryFix)
            {
                foreach (var kvp in attributes.Where(item => item.Key != "POSITION"))
                {
                    // remove unnecessary bounds
                    kvp.Value._min.Clear();
                    kvp.Value._max.Clear();
                }
            }

            if (attributes.TryGetValue("POSITION", out Accessor positions))
            {
                positions._ValidatePositions(validate);
            }

            if (attributes.TryGetValue("NORMAL", out Accessor normals))
            {
                normals._ValidateNormals(validate);
            }
            if (attributes.TryGetValue("TANGENT", out Accessor tangents))
            {
                tangents._ValidateTangents(validate);
            }

            if (attributes.TryGetValue("JOINTS_0", out Accessor joints0))
            {
                joints0._ValidateJoints(validate, "JOINTS_0", skinsMaxJointCount);
            }
            if (attributes.TryGetValue("JOINTS_1", out Accessor joints1))
            {
                joints0._ValidateJoints(validate, "JOINTS_1", skinsMaxJointCount);
            }

            attributes.TryGetValue("WEIGHTS_0", out Accessor weights0);
            attributes.TryGetValue("WEIGHTS_1", out Accessor weights1);
            _ValidateWeights(validate, weights0, weights1);
        }
        private void _ValidateTangents(VALIDATIONCTX result)
        {
            result = result.GetContext(this);

            SourceBufferView.ValidateBufferUsageGPU(result, BufferMode.ARRAY_BUFFER);
            result.CheckLinkMustBeAnyOf(nameof(Dimensions), Dimensions, DimensionType.VEC3, DimensionType.VEC4);
            if (!this.LogicalParent.MeshQuantizationAllowed)
            {
                result.CheckLinkMustBeAnyOf(nameof(Normalized), Normalized, false);
                result.CheckLinkMustBeAnyOf(nameof(Encoding), Encoding, EncodingType.FLOAT);
            }
            else
            {
                if (Normalized)
                {
                    result.CheckLinkMustBeAnyOf(nameof(Encoding), Encoding, EncodingType.BYTE, EncodingType.SHORT);
                }
                else
                {
                    result.CheckLinkMustBeAnyOf(nameof(Encoding), Encoding, EncodingType.FLOAT);
                }
            }

            // when Dimensions == VEC3, its morph target tangent deltas

            if (Dimensions == DimensionType.VEC4)
            {
                var tangents = this.AsVector4Array();

                for (int i = 0; i < tangents.Count; ++i)
                {
                    if (result.TryFixTangentOrError(i, tangents[i]))
                    {
                        tangents[i] = tangents[i].SanitizeTangent();
                    }
                }
            }
        }
Beispiel #22
0
        private void _ValidateTangents(VALIDATIONCTX validate)
        {
            validate = validate.GetContext(this);

            SourceBufferView.ValidateBufferUsageGPU(validate, BufferMode.ARRAY_BUFFER);

            if (!this.LogicalParent.MeshQuantizationAllowed)
            {
                validate.IsAnyOf(nameof(Format), Format, DimensionType.VEC3, DimensionType.VEC4);
            }
            else
            {
                validate.IsAnyOf(nameof(Dimensions), Dimensions, DimensionType.VEC3, DimensionType.VEC4);
            }

            if (validate.TryFix)
            {
                if (Dimensions == DimensionType.VEC3)
                {
                    this.AsVector3Array().SanitizeNormals();
                }
                if (Dimensions == DimensionType.VEC4)
                {
                    this.AsVector4Array().SanitizeTangents();
                }
            }

            if (Dimensions == DimensionType.VEC3)
            {
                validate.AreNormals("TANGENT", this.AsVector3Array());
            }
            if (Dimensions == DimensionType.VEC4)
            {
                validate.AreTangents("TANGENT", this.AsVector4Array());
            }
        }
Beispiel #23
0
        internal void ValidateAnimationOutput(VALIDATIONCTX validate)
        {
            SourceBufferView.ValidateBufferUsagePlainData(validate);

            validate.IsAnyOf(nameof(Dimensions), Dimensions, DimensionType.SCALAR, DimensionType.VEC3, DimensionType.VEC4);
        }
 internal void ValidateAnimationOutput(VALIDATIONCTX result)
 {
     SourceBufferView.ValidateBufferUsagePlainData(result);
     result.CheckLinkMustBeAnyOf(nameof(Dimensions), Dimensions, DimensionType.SCALAR, DimensionType.VEC3, DimensionType.VEC4);
 }