public Color3 illuminate(RayContext rayContext, BRDF brdf)
        {
            Color3 finalColor = new Color3();

            BRDFTypes brdfType = brdf.getType();

            if (brdf.matchTypes(BRDFTypes.Diffuse) || brdf.matchTypes(BRDFTypes.Glossy))
            {
                if (null != m_directLightIntegrator)
                    finalColor += m_directLightIntegrator.illuminate(rayContext, brdf);

                if (brdf.matchTypes(BRDFTypes.Diffuse) && null != m_diffuseIntegrator)
                    finalColor += m_diffuseIntegrator.illuminate(rayContext, brdf);
            }

            if (brdf.matchTypes(BRDFTypes.Specular))
            {
                if (rayContext.traceLevel < m_maxTraceLevel)
                    if (null != m_specularIntegrator)
                        finalColor += m_specularIntegrator.illuminate(rayContext, brdf);
            }

            return finalColor;
        }
 public Color3 evalLight(BRDF brdf)
 {
     return m_renderer.illuminate(this, brdf);
 }
        public Color3 illuminate(RayContext rayContext, BRDF brdf)
        {
            //вземаме списък с всички светлини в сцената
            List<Light> lights = rayContext.scene.getLights();
            //в sumColor ще сумираме тяхната енергия
            Color3 sumColor = new Color3();
            foreach (Light light in lights)
            {
                Color3 color = new Color3();
                //задаваме максималната бройка лъчи
                //с които ще проследяваме към всяка светлина
                int numSamples = 25;
                int curSample = 0; //номер на текущ лъч
                LightSample lightSample;

                rayContext.randomIndex = 0;

                do
                {
                    curSample++;
                    //генерирме двойка случайни числа (ru, rv)
                    double ru = rayContext.getRandom(0, curSample);
                    double rv = rayContext.getRandom(1, curSample);
                    //искаме от светлината да върне сонда за сянка
                    lightSample = light.getSample(rayContext, ru, rv);

                    rayContext.randomIndex++;

                    if (null == lightSample)
                        continue;
                    //пресмятаме косинуса между нормалата на повърхността и лъча към лампата
                    double cosT = rayContext.hitData.hitNormal * (lightSample.shadowRay.dir);
                    if (cosT < 0.00001) cosT = 0.0;

                    //проверяваме за засенчване
                    if (rayContext.scene.traceShadowRay(lightSample.shadowRay, rayContext))
                        continue;

                    double pdf = 1.0;
                    //пресмятаме, каква част от светлината ще отрази BRFD-a
                    Color3 brdfCol = brdf.eval(rayContext, lightSample.shadowRay.dir, out pdf);

                    color += brdfCol * pdf * lightSample.color * cosT;

                    //ако светлината е точкова ни е нужен само един лъч
                    if (light.isSingular())
                        break;

                } while (curSample < numSamples);

                if (curSample < 1)
                    curSample = 1;

                //сумираме резултата от всички сампъли
                color *= 1.0 / (double)curSample;
                sumColor += color;
            }

            int lightsCount = lights.Count;
            if (lightsCount < 1)
                lightsCount = 1;

            //сумираме енергията от всички светлини
            sumColor *= 1.0 / (double)lightsCount;
            return sumColor;
        }
        public Color3 illuminate(RayContext rayContext, BRDF brdf)
        {
            Ray newRay = new Ray();

            double invPdf = 0;

            //във finalColor ще сумираме резултатния цвят
            Color3 finalColor = new Color3();

            //задаваме максималната бройка лъчи
            //с които ще проследяваме грапави отражения
            int numSamples = 10;
            int curSample = 0;  //номер на текущ лъч

            for (curSample = 0; curSample < numSamples; curSample++)
            {
                //генерирме двойка случайни числа (ru, rv)
                double ru = rayContext.getRandom(0, curSample);
                double rv = rayContext.getRandom(1, curSample);

                //искаме brdf да конструира лъч използвайки (ru, rv)
                bool isValidSample = brdf.getSample(rayContext, ru, rv, out newRay.dir, out invPdf);

                if (!isValidSample)
                    continue;

                //конструираме нов лъч от текущата точка
                //и го обвиваме във собствен контекст
                newRay.p = rayContext.hitData.hitPos;
                RayContext newContext = RayContext.createNewContext(rayContext, newRay);
                //извикваме функцията shade, която проследява
                //лъча в сцената и го осветява
                rayContext.scene.shade(newContext);

                double cosT = rayContext.hitData.hitNormal * (newRay.dir);
                if (cosT < 0.0) cosT *= -1.0;

                double pdf;

                Color3 w = new Color3(1, 1, 1);
                //пресмятаме, каква част от светлината ще отрази BRFD-a
                w = brdf.eval(rayContext, newRay.dir, out pdf);

                if (!brdf.isSingular())
                {
                    w *= cosT * invPdf;
                }
                //добавяме енергията на новия лъч
                finalColor += newContext.resultColor * w;

                //if (Double.IsNaN(finalColor.getIntensity()))
                //    break;

                if (brdf.isSingular())
                    break;
            }

            //сумираме енергията от всички лъчи
            if (curSample > 0)
                finalColor *= 1.0 / (double)curSample;

            return finalColor;
        }
 public Color3 illuminate(RayContext rayContext, BRDF brdf)
 {
     return new Color3();
 }