// Use this for initialization
    void Start()
    {
        GameObject  surface = GameObject.Find("wall1");
        dataStorage data    = GameObject.Find("dataHandler").GetComponent <dataStorage>();
        int         i       = 0;

        i       = data.libraryCount;
        tex     = new Texture[data.libraryCount];
        tex[0]  = t1;
        tex[1]  = t2;
        tex[2]  = t3;
        tex[3]  = t4;
        tex[4]  = t5;
        tex[5]  = t6;
        tex[6]  = t7;
        tex[7]  = t8;
        tex[8]  = t9;
        tex[9]  = t10;
        tex[10] = t11;
        tex[11] = t12;


        Debug.Log(tex.Length);
        surface.GetComponent <Renderer>().material.mainTexture = tex [menu.value];
        //	menu1.onValueChanged.AddListener (delegate {
        //		surfaceUpdate (menu1);
        Debug.Log(surface.name);

        //	});
    }
    public void unitUpdate()
    {
        dataStorage dataStorage = dataDump.GetComponent <dataStorage>();

        if (unit)
        {
            sliderL.value = roomLength / 3.2808399f;
            sliderW.value = roomWidth / 3.2808399f;
            sliderH.value = roomHeight / 3.2808399f;
            unit1.text    = "m";
            unit2.text    = "m";
            unit3.text    = "m";
            unit          = false;
            dataStorage.setUnit(unit);
        }
        else
        {
            sliderL.value = roomLength * 3.2808399f;
            sliderW.value = roomWidth * 3.2808399f;
            sliderH.value = roomHeight * 3.2808399f;
            unit1.text    = "ft.";
            unit2.text    = "ft.";
            unit3.text    = "ft.";
            unit          = true;
            dataStorage.setUnit(unit);
        }
    }
Example #3
0
 // Use this for initialization
 void Awake()
 {
     DontDestroyOnLoad(gameObject);
     _data = new dataStorage();
     loadData();
     faceCheck();
 }
    public void UpdateW(float y)
    {
        roomWidth  = sliderW.value;
        roomLength = sliderL.value;
        dataStorage dataStorage = dataDump.GetComponent <dataStorage>();

        dataStorage.setWidth(roomWidth);
        //cameraScaling (roomLength,roomWidth,roomHeight);
        //camera1.transform.localRotation = new Quaternion (-18+roomLength,207+roomWidth,0,0);

        wall2.transform.position   = new Vector3(-20, 5, ((roomWidth / 2) - 10));
        wall2.transform.localScale = new Vector3((roomWidth / 10), 1, (roomHeight / 10));

        wall3.transform.position   = new Vector3(((roomLength / 2) - 20), 5, roomWidth - 10);
        wall3.transform.localScale = new Vector3((roomLength / 10), 1, (roomHeight / 10));

        wall4.transform.position   = new Vector3(roomLength - 20, 5, ((roomWidth / 2) - 10));
        wall4.transform.localScale = new Vector3((roomWidth / 10), 1, (roomHeight / 10));

        floor.transform.position   = new Vector3(((roomLength / 2) - 20), (5 - (roomHeight / 2)), ((roomWidth / 2) - 10));
        floor.transform.localScale = new Vector3((roomLength / 10), 1, (roomWidth / 10));

        ceiling.transform.position   = new Vector3(((roomLength / 2) - 20), (5 + (roomHeight / 2)), ((roomWidth / 2) - 10));
        ceiling.transform.localScale = new Vector3((roomLength / 10), 1, (roomWidth / 10));
    }
    public void UpdateH(float z)
    {
        roomHeight = sliderH.value;
        dataStorage dataStorage = dataDump.GetComponent <dataStorage>();

        dataStorage.setHeight(roomHeight);

        floor.transform.position   = new Vector3(((roomLength / 2) - 20), (5 - (roomHeight / 2)), ((roomWidth / 2) - 10));
        ceiling.transform.position = new Vector3(((roomLength / 2) - 20), (5 + (roomHeight / 2)), ((roomWidth / 2) - 10));
        wall1.transform.localScale = new Vector3((roomLength / 10), 1, (roomHeight / 10));
        wall2.transform.localScale = new Vector3((roomWidth / 10), 1, (roomHeight / 10));
        wall3.transform.localScale = new Vector3((roomLength / 10), 1, (roomHeight / 10));
        wall4.transform.localScale = new Vector3((roomWidth / 10), 1, (roomHeight / 10));

        camera1.transform.localPosition = new Vector3(103.7f, roomHeight + 18.1f, 94.4f);;
    }
    // Update is called once per frame
    void Update()
    {
        //Dropdown menu = GameObject.Find ("surfaceMenu1");
        dataStorage data = GameObject.Find("dataHandler").GetComponent <dataStorage>();

        Debug.Log(menu.value);
        Debug.Log(tex.Length);
        switch (menu.value)
        {
        case 0:
            surface.GetComponent <Renderer>().material.mainTexture = tex[0]; break;

        case 1:
            surface.GetComponent <Renderer>().material.mainTexture = tex[1]; break;

        case 2:
            surface.GetComponent <Renderer>().material.mainTexture = tex[2]; break;

        default: break;
        }
    }
    public void UpdateL(float x)
    {
        roomLength = sliderL.value;
        dataStorage dataStorage = dataDump.GetComponent <dataStorage>();

        dataStorage.setLength(roomLength);
        //cameraScaling (roomLength,roomWidth,roomHeight);

        wall1.transform.position   = new Vector3(((roomLength / 2) - 20), 5, -10);
        wall1.transform.localScale = new Vector3((roomLength / 10), 1, (roomHeight / 10));

        wall3.transform.position   = new Vector3(((roomLength / 2) - 20), 5, roomWidth - 10);
        wall3.transform.localScale = new Vector3((roomLength / 10), 1, (roomHeight / 10));

        wall4.transform.position   = new Vector3(roomLength - 20, 5, ((roomWidth / 2) - 10));
        wall4.transform.localScale = new Vector3((roomWidth / 10), 1, (roomHeight / 10));

        floor.transform.position   = new Vector3(((roomLength / 2) - 20), (5 - (roomHeight / 2)), ((roomWidth / 2) - 10));
        floor.transform.localScale = new Vector3((roomLength / 10), 1, (roomWidth / 10));

        ceiling.transform.position   = new Vector3(((roomLength / 2) - 20), (5 + (roomHeight / 2)), ((roomWidth / 2) - 10));
        ceiling.transform.localScale = new Vector3((roomLength / 10), 1, (roomWidth / 10));
    }
    public void Calculate()
    {
        //first order
        Vector3 W1R1 = new Vector3(source.transform.position.x, source.transform.position.y, source.transform.position.z - (2 * w1Dist));

        W1R1D = Vector3.Distance(W1R1, listener.transform.position);

        Vector3 W2R1 = new Vector3(source.transform.position.x - (2 * w2Dist), source.transform.position.y, source.transform.position.z);

        W2R1D = Vector3.Distance(W2R1, listener.transform.position);

        Vector3 W3R1 = new Vector3(source.transform.position.x, source.transform.position.y, source.transform.position.z + (2 * w3Dist));

        W3R1D = Vector3.Distance(W3R1, listener.transform.position);

        Vector3 W4R1 = new Vector3(source.transform.position.x + (2 * w4Dist), source.transform.position.y, source.transform.position.z);

        W4R1D = Vector3.Distance(W4R1, listener.transform.position);

        Vector3 CR1 = new Vector3(source.transform.position.x, source.transform.position.y + (2 * cDist), source.transform.position.z);

        CR1D = Vector3.Distance(CR1, listener.transform.position);

        Vector3 FR1 = new Vector3(source.transform.position.x, source.transform.position.y - (2 * fDist), source.transform.position.z);

        FR1D = Vector3.Distance(FR1, listener.transform.position);

        //second order
        Vector3 W1W2R2 = new Vector3(source.transform.position.x - (2 * w2Dist), source.transform.position.y, source.transform.position.z - (2 * w1Dist));

        W1W2R2D = Vector3.Distance(W1W2R2, listener.transform.position);

        Vector3 W1W3R2 = new Vector3(source.transform.position.x, source.transform.position.y, source.transform.position.z + (2 * w3Dist) + (2 * w1Dist));

        W1W3R2D = Vector3.Distance(W1W3R2, listener.transform.position);

        Vector3 W1W4R2 = new Vector3(source.transform.position.x + (2 * w4Dist), source.transform.position.y, source.transform.position.z - (2 * w1Dist));

        W1W4R2D = Vector3.Distance(W1W4R2, listener.transform.position);

        Vector3 W2W3R2 = new Vector3(source.transform.position.x - (2 * w2Dist), source.transform.position.y, source.transform.position.z + (2 * w3Dist));

        W2W3R2D = Vector3.Distance(W2W3R2, listener.transform.position);

        Vector3 W2W4R2 = new Vector3(source.transform.position.x + (2 * w4Dist) + (2 * w2Dist), source.transform.position.y, source.transform.position.z);

        W2W4R2D = Vector3.Distance(W2W4R2, listener.transform.position);

        Vector3 W3W4R2 = new Vector3(source.transform.position.x + (2 * w4Dist), source.transform.position.y, source.transform.position.z + (2 * w3Dist));

        W3W4R2D = Vector3.Distance(W3W4R2, listener.transform.position);

        Vector3 W1CR2 = new Vector3(source.transform.position.x, source.transform.position.y + (2 * cDist), source.transform.position.z - (2 * w1Dist));

        W1CR2D = Vector3.Distance(W1CR2, listener.transform.position);

        Vector3 W1FR2 = new Vector3(source.transform.position.x, source.transform.position.y - (2 * fDist), source.transform.position.z - (2 * w1Dist));

        W1FR2D = Vector3.Distance(W1FR2, listener.transform.position);

        Vector3 W2CR2 = new Vector3(source.transform.position.x - (2 * w2Dist), source.transform.position.y + (2 * cDist), source.transform.position.z);

        W2CR2D = Vector3.Distance(W2CR2, listener.transform.position);

        Vector3 W2FR2 = new Vector3(source.transform.position.x - (2 * w2Dist), source.transform.position.y - (2 * fDist), source.transform.position.z);

        W2FR2D = Vector3.Distance(W2FR2, listener.transform.position);

        Vector3 W3CR2 = new Vector3(source.transform.position.x, source.transform.position.y + (2 * cDist), source.transform.position.z + (2 * w3Dist));

        W3CR2D = Vector3.Distance(W3CR2, listener.transform.position);

        Vector3 W3FR2 = new Vector3(source.transform.position.x, source.transform.position.y - (2 * fDist), source.transform.position.z + (2 * w3Dist));

        W3FR2D = Vector3.Distance(W3FR2, listener.transform.position);

        Vector3 W4CR2 = new Vector3(source.transform.position.x + (2 * w4Dist), source.transform.position.y + (2 * cDist), source.transform.position.z);

        W4CR2D = Vector3.Distance(W4CR2, listener.transform.position);

        Vector3 W4FR2 = new Vector3(source.transform.position.x + (2 * w4Dist), source.transform.position.y - (2 * fDist), source.transform.position.z);

        W4FR2D = Vector3.Distance(W4FR2, listener.transform.position);

        Vector3 CFR2 = new Vector3(source.transform.position.x, source.transform.position.y + (2 * cDist) + (2 * fDist), source.transform.position.z);

        CFR2D = Vector3.Distance(CFR2, listener.transform.position);



        R1     = new float[6];
        R1preD = new float[6];
        R1[0]  = W1R1D;
        R1[1]  = W2R1D;
        R1[2]  = W3R1D;
        R1[3]  = W4R1D;
        R1[4]  = CR1D;
        R1[5]  = FR1D;

        R2     = new float[15];
        R2preD = new float[15];
        R2[0]  = W1W2R2D;
        R2[1]  = W1W3R2D;
        R2[2]  = W1W4R2D;
        R2[3]  = W2W3R2D;
        R2[4]  = W2W4R2D;
        R2[5]  = W3W4R2D;
        R2[6]  = W1CR2D;
        R2[7]  = W1FR2D;
        R2[8]  = W2CR2D;
        R2[9]  = W2FR2D;
        R2[10] = W3CR2D;
        R2[11] = W3FR2D;
        R2[12] = W4CR2D;
        R2[13] = W4FR2D;
        R2[14] = CFR2D;

        dataStorage data = dataObj.GetComponent <dataStorage>();

        time = new float();
        R1L  = new float[6];
        for (int i = 0; i < R1.Length; i++)        //converts distance to time
        {
            R1preD[i] = R1[i];
            time      = R1[i] / data.sos;
            R1[i]     = time;
        }
        time = 0;
        R2L  = new float[15];
        for (int i = 0; i < R2.Length; i++)
        {
            R2preD[i] = R2[i];
            time      = R2[i] / data.sos;
            R2[i]     = time;
        }
        time = DirectSound / data.sos;
        dsL  = new float();
        dsL  = calc.distanceLoss(dbSPL, DirectSound, data.unit);

        R1preL        = new float[6];
        R2preL        = new float[15];
        surfaceAbs    = new float[6];
        surfaceAbs[0] = data.w1avg;
        surfaceAbs[1] = data.w2avg;
        surfaceAbs[2] = data.w3avg;
        surfaceAbs[3] = data.w4avg;
        surfaceAbs[4] = data.cavg;
        surfaceAbs[5] = data.favg;

        //first order
        for (int i = 0; i < R1preL.Length; i++)
        {
            R1preL[i] = calc.surfaceAbsoprtion(surfaceAbs[i], dbSPL);
        }

        //second order
        R2preL[0]  = calc.surfaceAbsoprtionSecondOrder(surfaceAbs[0], surfaceAbs[1], dbSPL);
        R2preL[1]  = calc.surfaceAbsoprtionSecondOrder(surfaceAbs[0], surfaceAbs[2], dbSPL);
        R2preL[2]  = calc.surfaceAbsoprtionSecondOrder(surfaceAbs[0], surfaceAbs[3], dbSPL);
        R2preL[3]  = calc.surfaceAbsoprtionSecondOrder(surfaceAbs[1], surfaceAbs[2], dbSPL);
        R2preL[4]  = calc.surfaceAbsoprtionSecondOrder(surfaceAbs[1], surfaceAbs[3], dbSPL);
        R2preL[5]  = calc.surfaceAbsoprtionSecondOrder(surfaceAbs[2], surfaceAbs[3], dbSPL);
        R2preL[6]  = calc.surfaceAbsoprtionSecondOrder(surfaceAbs[0], surfaceAbs[4], dbSPL);
        R2preL[7]  = calc.surfaceAbsoprtionSecondOrder(surfaceAbs[0], surfaceAbs[5], dbSPL);
        R2preL[8]  = calc.surfaceAbsoprtionSecondOrder(surfaceAbs[1], surfaceAbs[4], dbSPL);
        R2preL[9]  = calc.surfaceAbsoprtionSecondOrder(surfaceAbs[1], surfaceAbs[5], dbSPL);
        R2preL[10] = calc.surfaceAbsoprtionSecondOrder(surfaceAbs[2], surfaceAbs[4], dbSPL);
        R2preL[11] = calc.surfaceAbsoprtionSecondOrder(surfaceAbs[2], surfaceAbs[5], dbSPL);
        R2preL[12] = calc.surfaceAbsoprtionSecondOrder(surfaceAbs[3], surfaceAbs[4], dbSPL);
        R2preL[13] = calc.surfaceAbsoprtionSecondOrder(surfaceAbs[3], surfaceAbs[5], dbSPL);
        R2preL[14] = calc.surfaceAbsoprtionSecondOrder(surfaceAbs[4], surfaceAbs[5], dbSPL);


        //first order
        for (int i = 0; i < R1L.Length; i++)
        {
            R1L[i] = calc.distanceLoss(R1preL[i], R1preD[i], data.unit);
        }
        //second order
        for (int i = 0; i < R2L.Length; i++)
        {
            R2L[i] = calc.distanceLoss(R2preL[i], R2preD[i], data.unit);
        }

        float Maxtime  = new float();
        float Maxlevel = new float();
        float MinLevel = new float();

        Maxtime  = 0f;
        minLevel = 0f;
        Maxlevel = dbSPL;
        MinLevel = dbSPL;

        for (int i = 0; i < R1.Length; i++)        //find the max time first order
        {
            if (R1[i] > Maxtime)
            {
                Maxtime = R1[i];
            }
        }
        for (int i = 0; i < R2.Length; i++)        //find the max time second order
        {
            if (R2[i] > Maxtime)
            {
                Maxtime = R2[i];
            }
        }
        for (int i = 0; i < R1L.Length; i++)        //find the min SPL first order
        {
            if (R1L[i] < MinLevel)
            {
                MinLevel = R1L[i];
            }
        }
        for (int i = 0; i < R2L.Length; i++)        //find the min SPL second order
        {
            if (R2L[i] < MinLevel)
            {
                MinLevel = R2L[i];
            }
        }
        Debug.Log(Maxtime);
        Debug.Log(MinLevel);
        max.text          = ((Maxtime + .005f) * 1000).ToString("f2");
        min.text          = "0";
        half.text         = (((Maxtime + .005f) * 1000) / 2).ToString("f2");
        quarter.text      = (((Maxtime + .005f) * 1000) / 4).ToString("f2");
        threeQuarter.text = ((((Maxtime + .005f) * 1000) / 4) * 3).ToString("f2");

        maxTime  = Maxtime;
        minLevel = MinLevel;

        lvlmax.text          = dbSPL.ToString();
        lvlmin.text          = (MinLevel - 5).ToString("f0");
        lvlhalf.text         = (((dbSPL - (MinLevel - 5)) / 2) + (MinLevel - 5)).ToString("f0");
        lvlquarter.text      = (((dbSPL - (MinLevel - 5)) / 4) + (MinLevel - 5)).ToString("f0");
        lvlthreeQuarter.text = (((((dbSPL - (MinLevel - 5)) / 4)) * 3 + (MinLevel - 5))).ToString("f0");
        barXHandler();
    }