Beispiel #1
0
    private void RaycastBlockEvaluator(float[] mapToModify, CombiningMethod combiningMethod,
                                       Vector3 origin, float radius)
    {
        int count = mapToModify.Length;

        Vector3[] directions = ContextMap.GetDiscreteUnitCircleDirections(count);

        RaycastHit hit;

        for (int i = 0; i < count; i++)
        {
            bool  didHit = Physics.Raycast(origin, directions [i], out hit, radius);
            float hitFraction;
            if (!didHit)
            {
                hitFraction = 1f;
            }
            else
            {
                hitFraction = hit.distance / radius;
            }

            ContextMap.CombineMapValues(mapToModify, hitFraction * hitFraction, i, combiningMethod);
        }
    }
Beispiel #2
0
        public static void ConstantEvaluator(float[] mapToModify, CombiningMethod combiningMethod, float value = 1f)
        {
            int count = mapToModify.Length;

            for (int i = 0; i < count; i++)
            {
                ContextMap.CombineMapValues(mapToModify, value, i, combiningMethod);
            }
        }
Beispiel #3
0
        public static void TargetEvaluator(float[] mapToModify, CombiningMethod combiningMethod,
                                           Vector3 origin, Vector3 target)
        {
            int count = mapToModify.Length;

            Vector3[] directions = ContextMap.GetDiscreteUnitCircleDirections(count);
            for (int i = 0; i < count; i++)
            {
                float newVal = Vector3.Dot(directions[i].normalized, (target - origin).normalized);
                newVal = Mathf.Clamp(newVal, 0.3f, 1f);
                ContextMap.CombineMapValues(mapToModify, newVal, i, combiningMethod);
            }
            ContextMap.NormalizeMap(mapToModify);
        }
Beispiel #4
0
        public static void CombineMapValues(float[] mapToModify, float newValue, int slotIndex, CombiningMethod method)
        {
            switch (method)
            {
            case CombiningMethod.Add:
                mapToModify [slotIndex] += newValue;
                break;

            case CombiningMethod.Average:
                mapToModify [slotIndex] = (newValue + mapToModify [slotIndex]) / 2f;
                break;

            case CombiningMethod.KeepLargest:
                mapToModify [slotIndex] = Mathf.Max(newValue, mapToModify [slotIndex]);
                break;

            case CombiningMethod.KeepSmallest:
                mapToModify [slotIndex] = Mathf.Min(newValue, mapToModify [slotIndex]);
                break;

            case CombiningMethod.Multiply:
                mapToModify [slotIndex] *= newValue;
                break;

            case CombiningMethod.Set:
                mapToModify [slotIndex] = newValue;
                break;
            }
        }