public static void DestroyOcclusion(Vive3DSPAudioOcclusion occObj)
 {
     if (occObj.OcclusionObject != IntPtr.Zero)
     {
         vive_3dsp_occlusion_destroy_object_plugin(occObj.OcclusionObject);
     }
     occList.Remove(occObj);
     occObj.OcclusionObject = IntPtr.Zero;
 }
 public static void UpdateOcclusion(Vive3DSPAudioOcclusion occ)
 {
     if (occ.OcclusionObject == IntPtr.Zero)
     {
         return;
     }
     vive_3dsp_occlusion_enable_plugin(occ.OcclusionObject, occ.OcclusionEffect);
     vive_3dsp_occlusion_set_property_plugin(occ.OcclusionObject, occ.OcclusionPorperty);
 }
        // Occlusion
        public static IntPtr CreateOcclusion(Vive3DSPAudioOcclusion occObj)
        {
            IntPtr occobj = IntPtr.Zero;

            occobj = vive_3dsp_occlusion_create_object_plugin();
            if (occobj != IntPtr.Zero)
            {
                vive_3dsp_occlusion_set_material_plugin(occobj, occObj.OcclusionMaterial);
                occList.Add(occObj);
            }

            return(occobj);
        }
        private static float getRaycastOcclusionRatio(Vector3 srcPos, Vector3 direction, Vive3DSPAudioOcclusion occ)
        {
            float ratio = 0f;
            int   ListenerColliderNumber = 0, SourceColliderNumber = 0;
            var   dist = direction.magnitude;

            RaycastHit[] hit;
            hit = Physics.RaycastAll(srcPos, direction, dist);
            for (int i = 0; i < hit.Length; i++)
            {
                if (hit[i].transform == occ.transform)
                {
                    SourceColliderNumber++;
                    ListenerColliderNumber++;
                }
            }
            if (occ.raycastQuality == RaycastQuality.Low)
            {
                if (SourceColliderNumber == 0)
                {
                    return(0.0f);
                }
                else
                {
                    return(1.0f);
                }
            }
            var max_direct_forward_up = Quaternion.AngleAxis(MaxRayBiasAngle, Vector3.up) * direction;
            var max_direct_up         = max_direct_forward_up - direction;
            var min_direct_forward_up = Quaternion.AngleAxis(MinRayBiasAngle, Vector3.up) * direction;
            var min_direct_up         = min_direct_forward_up - direction;

            float maxmin_direct_up_mag_ratio = max_direct_up.magnitude / min_direct_up.magnitude;

            Vector3 rot_up, direct_up, direct_forward_up;

            for (int i = 0; i < RayEmitLayer; ++i)
            {
                direct_up = (i * (maxmin_direct_up_mag_ratio - 1) / RayEmitLayer + 1) * min_direct_up;

                for (int j = 0; j < RayDisperseOrder; ++j)
                {
                    // source part
                    rot_up            = Quaternion.AngleAxis(RayDisperseAngle * j, direction) * direct_up;
                    direct_forward_up = direction + rot_up;
                    //Debug.DrawRay(srcPos, rot_up, Color.green);
                    //Debug.DrawRay(srcPos, direct_forward_up, Color.blue);
                    hit = Physics.RaycastAll(srcPos, direct_forward_up, direct_forward_up.magnitude);
                    for (int h = 0; h < hit.Length; h++)
                    {
                        if (hit[h].transform == occ.transform)
                        {
                            ListenerColliderNumber++;
                        }
                    }

                    // listener part
                    direct_forward_up = -direction + rot_up;
                    //Debug.DrawRay(MainListener.transform.position, rot_up, Color.green);
                    //Debug.DrawRay(MainListener.transform.position, direct_forward_up, Color.blue);
                    hit = Physics.RaycastAll(srcPos + direction, direct_forward_up, direct_forward_up.magnitude);
                    for (int h = 0; h < hit.Length; h++)
                    {
                        if (hit[h].transform == occ.transform)
                        {
                            SourceColliderNumber++;
                        }
                    }
                }
            }

            ratio = (float)Math.Max(SourceColliderNumber, ListenerColliderNumber) / totalRays;
            return(ratio);
        }