LDCad POVray export - Printable Version

Code:

// this methoid is slower

#macro BlurredReflectionMicroNormals(InPigment, InFinish, InNormal, BlurAmount, BlurSamples)

//    texture

//    {

        average

        texture_map

        {

            #declare iCount = 0;

            #declare S = seed(0);

            #while (iCount < BlurSamples)

                [

                    1 // The pigment of the object:

                    pigment { InPigment }

                    // The surface finish:

                    finish { InFinish }

                    // This is the actual trick:

                    normal

                    {

                        average

                        normal_map

                        {

                            [1 bumps BlurAmount translate <rand(S),rand(S),rand(S)>*100 scale 0.001]

                            [1 InNormal]

                        }

                    }

                ]

                #declare iCount = iCount + 1;

            #end

        }

//    }

#end







// this method is faster, but requires a focal blur and/or extra antialiasing to smooth out the pixelation

#macro BlurredReflectionSingleNormals(InPigment, InFinish, InNormal, BlurAmount)

//    texture

//    {

        pigment { InPigment }

        finish { InFinish }

        normal { InNormal }

        normal {bumps BlurAmount scale 0.001}

//    }

#end







#if (Use_BlurRef = true)

    #ifndef (Use_BlurAmt) #declare Use_BlurAmt = 0.05; #end                // amount of surface reflection blurring

    #macro ldrawBuildTex(basePigment, baseNormal, baseFinish, pngIdx)

        #if (pngIdx<0)

            BlurredReflectionSingleNormals(basePigment, baseFinish, baseNormal, Use_BlurAmt)

        #else

            texture

            {

                pigment

                {

                    uv_mapping

                    image_map

                    {

                        png getPngName(pngIdx)

                        getPngMapType(pngIdx)

                        interpolate 2

                    }

                    getPngWarp(pngIdx)

                }

            }

            texture

            {

                BlurredReflectionSingleNormals(basePigment, baseFinish, baseNormal, Use_BlurAmt)

            }

        #end

    #end

#else

    #macro ldrawBuildTex(basePigment, baseNormal, baseFinish, pngIdx)

        #if (pngIdx<0)

            pigment { basePigment }

            normal { baseNormal }

            finish { baseFinish }

        #else

            #local texPigment= pigment

            {

                uv_mapping

                image_map

                {

                    png getPngName(pngIdx)

                    getPngMapType(pngIdx)

                    interpolate 2

                }

                getPngWarp(pngIdx)

            }

            #local result = texture

            {

                pigment { basePigment }

                normal { baseNormal }

                finish { baseFinish }

            }

            texture

            {

                pigment { texPigment }

            }

            result

        #end

    #end

#end

Code:

#declare ldColorBlurCount=3;         

#declare ldColorBlur=array[ldColorBlurCount][2] {

 {2, 0.25},

 {7, 0.4},

 {256, 0.7}

}      



#macro getColorBlur(ldCode)

 #local result=-1

 #local i=0;

 #while (result=-1 & i<ldColorBlurCount)

  #if (ldColorBlur[i][0]=ldCode)

    #local result=i

  #else

    #local i=i+1;

  #end

 #end

 

 #if (result>=0)

   ldColorBlur[i][1];

 else //def

   1.0 

 #end

#end