public void Simulate(double[] result)
        {
            var imageSourceCount = ImageSourcePositionCalculator.GetImageSourceCount(maxReflection);

            if (imageSourcePositionBuffer == null || imageSourcePositionBuffer.Length < imageSourceCount)
            {
                imageSourcePositionBuffer = new Vector3[imageSourceCount];
            }

            ImageSourcePositionCalculator.GetImageSourcePositions(sourcePosition, room, maxReflection,
                                                                  imageSourcePositionBuffer);

            for (var i = 0; i < result.Length; i++)
            {
                result[i] = 0.0f;
            }

            for (var i = 0; i < imageSourceCount; i++)
            {
                var imageSourcePosition = imageSourcePositionBuffer[i];
                var distance            = Vector3.Distance(imageSourcePosition, listenerPosition);
                var delay        = distance / room.speedOfSound;
                var delaySamples = Mathf.RoundToInt(delay * samplingFrequency);

                if (delaySamples >= result.Length)
                {
                    continue;
                }

                result[delaySamples] += 1.0 / (4.0f * Mathf.PI * distance);
            }
        }
        private void Update()
        {
            var previousImageSourcePosition = source.position;

            for (var reflect = 0; reflect < reflectCount; reflect++)
            {
                var imageSource = imageSources[reflect];

                var realPlane  = room.GetPlane(currentCubeFace);
                var imagePlane = new Plane()
                {
                    position = realPlane.position * (reflect + 1),
                    normal   = realPlane.normal,
                };
                imageSource.position        = ImageSourcePositionCalculator.GetImageSourcePosition(previousImageSourcePosition, imagePlane);
                previousImageSourcePosition = imageSource.position;

                var imageRoom = imageRooms[reflect];
                imageRoom.position             = realPlane.position * (reflect + 1) + room.size / 2.0f;
                imageRoom.transform.localScale = room.size;
            }
        }
Ejemplo n.º 3
0
        private void Update()
        {
            if (reflectCount == 0)
            {
                return;
            }

            ImageSourcePositionCalculator.GetImageSourcePositions(source.position, room, reflectCount,
                                                                  this.imageSourcePositions);
            for (var x = -reflectCount; x <= reflectCount; x++)
            {
                for (var y = -reflectCount; y <= reflectCount; y++)
                {
                    for (var z = -reflectCount; z <= reflectCount; z++)
                    {
                        var imageRoomIndex = (z + reflectCount) +
                                             (y + reflectCount) * (reflectCount * 2 + 1) +
                                             (x + reflectCount) * (int)Math.Pow((reflectCount * 2 + 1), 2);

                        if (x == 0 && y == 0 && z == 0)
                        {
                            imageRooms[imageRoomIndex].gameObject.SetActive(false);
                            imageSources[imageRoomIndex].gameObject.SetActive(false);
                            continue;
                        }

                        imageRooms[imageRoomIndex].position   = new Vector3(room.size.x * x, room.size.y * y, room.size.z * z) + room.size / 2.0f;
                        imageRooms[imageRoomIndex].localScale = room.size;

                        imageSources[imageRoomIndex].position = imageSourcePositions[imageRoomIndex];

                        if (showPath)
                        {
                            Debug.DrawLine(imageSourcePositions[imageRoomIndex], listener.position, Color.cyan);
                        }
                    }
                }
            }
        }