Rendering学習日記

main6.cpp
#includeの両側に半角スペースが入っています。

#include < Lightflow/LfLocalSceneProxy.h >

int main()

{

    LfLocalSceneProxy* s = new LfLocalSceneProxy();

    LfArgList list;

    LfTransform trs;



    // Specify some rendering settings. These values are used by

    // all the built-in types, so they are grouped under a unique

    // interface, named "default".

    list.Reset();

    list << "trace-depth" << LfInt( 5 );

    list << "lighting-depth" << LfInt( 3 );

    s->NewInterface( "default", list );



    // Make a bright, bright light to model the sun.

    list.Reset();

    list << "position" << LfPoint( 0, 900, 100 );

    list << "color" << LfColor( 60000.0, 60000.0, 60000.0 );

    s->LightOn( s->NewLight( "point", list ) );





    // Model the water waves with a fractal pattern.

    s->TransformBegin( trs.Scaling( LfVector3( 10, 5, 5 ) ) );



    list.Reset();

    list << "basis" << "sin";

    list << "scale" << 2.0;

    list << "depth" << 0.1;

    list << "turbulence.distortion" << 1.0;

    list << "turbulence.omega" << 0.1 << 0.3;

    list << "turbulence.lambda" << 2.0;

    list << "turbulence.octaves" << LfInt( 5 );

    LfInt waterbumps = s->NewPattern( "multifractal", list );



    // the "basis" value describes the fractal basis, that here is set to

    // "sin", as waves have a sinusoidal origin. 

    // "scale" represents the width of the waves. This factor is then

    // multiplied by the scaling transform we put before. 

    // "depth" represents the depth of the waves, when used to displace a

    // surface. 

    // the "turbulence." keywords are turbulence parameters, that are

    // explained in the "multifractal" documentation. 



    s->TransformEnd();



    // Model water with a material.

    list.Reset();

    list << "fresnel" << LfInt( 1 ) << LfFloat(0.3) << LfFloat(0.0);

    list << "IOR" << 1.33;

    list << "kr" << LfColor( 1, 1, 1 );

    list << "kt" << LfColor( 1, 1, 1 );

    list << "kd" << 0.0;

    list << "km" << 0.03;

    list << "shinyness" << 0.5;

    list << "displacement" << waterbumps;

    LfInt water = s->NewMaterial( "physical", list );



    // the choosed type is "physical", because this provides physical

    // parameters, very good to model liquids, glasses and metals. 

    // note the use of the waterbumps pattern as a displacement.





    // Model the ocean fundals in a similar way.

    list.Reset();

    list << "basis" << "sin";

    list << "scale" << 10.0;

    list << "depth" << 0.5;

    list << "turbulence.distortion" << 1.0;

    list << "turbulence.omega" << 0.1 << 0.3;

    list << "turbulence.lambda" << 2.0;

    list << "turbulence.octaves" << LfInt( 5 );

    LfInt earthbumps = s->NewPattern( "multifractal", list );



    list.Reset();

    list << "kr" << LfColor( 0.8, 0.75, 0.7 );

    list << "displacement" << earthbumps;

    LfInt earth = s->NewMaterial( "diffuse", list );





    // Here starts the sky.

    // It contains a lot of volumetric clouds, especially at the horizon,

    // so it is a bit complex. 



    // Volumetric clouds are modeled with an interior and a pattern that modulates its density.

    s->TransformBegin( trs.Scaling( LfVector3( 100, 100, 100 ) ) );

    s->TransformBegin( trs.Translation( LfVector3( 0, 0, -0.5 ) ) );



    list.Reset();

    list << "value"

         << 0.0 << 1.0 << 1.0

         << 0.3 << 0.0 << 0.0;

    list << "scale" << 1.0;

    list << "turbulence.distortion" << 1.0;

    list << "turbulence.omega" << 0.5 << 0.8;

    list << "turbulence.lambda" << 2.0;

    list << "turbulence.octaves" << LfInt( 3 );

    LfInt cloudpattern = s->NewPattern( "multifractal", list );



    // Make the output distribution go from 1 to 0.1 to model clouds.



    s->TransformEnd();

    s->TransformEnd();



    list.Reset();

    list << "kr" << LfColor( 2.0, 0.8, 0.4 );

    list << "kaf" << LfColor( 0.6, 0.8, 0.4 ) * 0.035;

    list << "density" << 1.0;

    list << "density" << cloudpattern;

    list << "sampling" << 0.07;

    list << "shadow-caching" << LfPoint( -1000, -1000, -1 ) << LfPoint(1000, 1000, 100 );

    list << "density-caching" << LfInt( 2048 ) << LfPoint( -1000, -1000, -1 ) << LfPoint( 1000, 1000, 100 );

    list << "density-caching" << LfInt( 2048 ) << LfPoint( -1.2, -1.2, -1.2 ) << LfPoint( 1.2, 1.2, 1.2 );

    LfInt cloudinterior = s->NewInterior( "cloud", list );



    // Note that our scene will have a radius of 1000 unities, and our

    // camera would be at its center, so with a sampling factor of 0.07 we

    // allow 70 samples per ray: an enormous quantity! This will make our

    // scene render slowly, but the caches will give a help. Obviously if

    // you remove these volumetric clouds the rendering will be much faster.

    // Here we don't care about speed however, since we want only to

    // produce a single, astonishing image...





    // Now model the fundal, a blue sky made of flat clouds that will be

    // wrapped on a sphere.



    list.Reset();

    list << "color"

         << 0.2 << LfColor( 0.8, 0.9, 1.0 ) << LfColor( 0.8, 0.9, 1.0 )

         << 1.0 << LfColor( 0.2, 0.4, 0.9 ) << LfColor( 0.2, 0.4, 0.9 );

    LfInt skypattern1 = s->NewPattern( "linear-v", list );



    s->TransformBegin( trs.Scaling( LfVector3(80, 80, 10) ) );



    list.Reset();

    list << "color"

         << 0.2 << LfColor( 0.2, 0.4, 0.9 ) << LfColor( 0.2, 0.4, 0.9 )

         << 1.0 << LfColor( 0.2, 0.3, 0.7 ) << LfColor( 0.2, 0.3, 0.7 );

    list << "scale" << 1.1;

    list << "turbulence.distortion" << 1.0;

    list << "turbulence.omega" << 0.5 << 0.8;

    LfInt skypattern2 = s->NewPattern( "multifractal", list );



    s->TransformEnd();



    list.Reset();

    list << "pattern" << skypattern1;

    list << "gradient"

         << 0.3 << skypattern1 << skypattern1

         << 1.0 << skypattern2 << skypattern2;

    LfInt skypattern = s->NewPattern( "blend", list );



    // Note that we actually created two patterns, and we merged them

    // together with a "blend".

    // The first pattern is a linear gradient that will span the V

    // direction of the parametric surface we will attach it to.

    // In this case we will use it on a sphere, where the V direction is

    // the one which connects the north and south poles (that is to say a

    // line of constant U and varying V is a meridian).

    // This gradient associates a color to each parallel of the sphere,

    // going from bright blue near the horizon to dark blue near the

    // azimuth.

    // The second pattern is again a "multifractal", which we use to model

    // very distant clouds. Note that we stretch it with a scaling, so that 

    // the clouds will look wide and thin.

    // The "blend" pattern finally blends the two. It uses the pattern

    // specified with "pattern" to mix more patterns. In particular it

    // defines a pattern-gradient that smoothly interpolates between

    // different patterns. In this case we use the linear pattern both to

    // model the distribution of the gradient and to model the gradient

    // itself.

    // The numeric value of the linear pattern has not been specified

    // (with a value-gradient), and so it goes from 0 to 1, as default.

    // Thus the "blend" will make a transition that goes from a clear

    // and bright sky near the horizon (at the V value of 0.3) to a cloudy

    // sky near the azimuth (at the V value of 1.0).



    // Create the sky material.

    s->InteriorBegin( cloudinterior );



    list.Reset();

    list << "kc" << LfColor(1.0,  1.0,  1.0);

    list << "kc" << skypattern;

    list << "shadowing" << LfFloat(0.0);

    LfInt sky = s->NewMaterial( "matte", list );



    s->InteriorEnd();



    // "matte" is a material made to create matte objects, that are not

    // shaded by light, but that emit a uniform color. In this case this

    // color is first set to white (1, 1, 1) and then scaled by the skypattern.

    // The result will be the skypattern itself.





    // Create a water disc.

    s->MaterialBegin( water );



    list.Reset();

    list << "radius" << 1000.0;

    s->AddObject( s->NewObject( "disc", list ));



    s->MaterialEnd();





    // Create an under-water disc made of earth.

    s->TransformBegin( trs.Translation( LfVector3( 0, 0, -10 ) ) );



    s->MaterialBegin( earth );



    list.Reset();

    list << "radius" << 1000.0;

    s->AddObject( s->NewObject( "disc", list ));



    s->MaterialEnd();



    s->TransformEnd();





    // Create the sky sphere.

    s->TransformBegin( trs.Scaling( LfVector3( 1, 1, 0.1 ) ) );



    s->MaterialBegin( sky );



    list.Reset();

    list << "radius" << 1000.0;

    s->AddObject( s->NewObject( "sphere", list ));



    s->MaterialEnd();



    s->TransformEnd();





    list.Reset();

    list << "file" << "ocean.tga";

    LfInt saver = s->NewImager( "tga-saver", list );



    s->ImagerBegin( saver );



    list.Reset();

    list << "eye" << LfPoint( 0, -8, 4 );

    list << "aim" << LfPoint( 0, 0, 4 );

    list << "aa-samples" << LfInt( 2 ) << LfInt( 5 );

    LfInt camera = s->NewCamera( "pinhole", list );



    s->ImagerEnd();



    s->Render( camera, 400, 300 );



    delete s;

}

$ /usr/local/gcc-2.95/bin/g++ -I ./include -lLightflow main6.cpp -o simplescene6
$ ./simplescene6
$ convert ocean.tga ocean.jpg
$ eog ocean.jpg

main5.cpp
#includeの両側に半角スペースが入っています。

#include < Lightflow/LfLocalSceneProxy.h >



void main()

{

    LfLocalSceneProxy* s = new LfLocalSceneProxy();

    LfArgList list;



    list.Reset();

    list << "direction" << LfVector3( 8.0, 5.0, -6.0 );

    list << "color" << LfColor( 1.0, 1.0, 1.0 );

    s->LightOn( s->NewLight( "directional", list ) );





    list.Reset();

    list << "value"

         << 0.3 << 1.0 << 1.0

         << 0.5 << 0.0 << 0.0;

    list << "scale" << 1.0;

    list << "turbulence.omega" << 0.55;

    list << "turbulence.lambda" << 1.8;

    list << "turbulence.octaves" << LfInt( 6 );

    LfInt cloudpattern1 = s->NewPattern( "granite", list );



    // Make a granite-like volumetric pattern.

    // Note the keyword "value", followed by two rows of three parameters

    // each. 

    // This is an example of value-gradient. A gradient is a function which 

    // interpolates many values, which may be numbers, colors, or entire

    // patterns and materials.

    // By convention numeric gradients are called value-gradients, color ones

    // are named color-gradients and so on.

    // As a function a gradient associates a value to a real variable.

    // You can imagine it in cartesian coordinates, putting the variable on 

    // the abscissas and the associated value on the ordinates.

    // Here the first expected argument is the abscissa at which the value

    // of the function is specified, then the value follows. The value is

    // specified both at the right and at the left of the abscissa in order

    // to model discontinuities, so it is composed by two numbers.

    // You can specify how many abscissas (and values) you want.

    // This gradient is used to model the output of our fractal pattern,

    // that we will use to describe the spatial density of the cloud.

    // Here the gradient smoothly blends from the value of 1 at the point 0.3, 

    // to the value of 0 at the point 0.5.

    // Normally the output would be a value between 0 and 1, but we

    // make it droppoff rapidly from 1 to 0 to model masses of clouds that

    // are denser at their center and that disappear at their boundaries.



    list.Reset();

    list << "value"

         << 0.8 << 1.0 << 1.0

         << 1.0 << 0.0 << 0.0;

    list << "scale" << 1.2;

    LfInt cloudpattern2 = s->NewPattern( "radial", list );



    // Make a radial pattern, that is to say a spherical figure that is

    // dense at its center and that has zero density at its border.

    // This sphere has a radius of 1.2.



    list.Reset();

    list << "patterns" << cloudpattern1 << cloudpattern2;

    LfInt cloudpattern = s->NewPattern( "compose", list );



    // Compose the two patterns. Here the output of cloudpattern1 is used

    // as the input of cloudpattern2. Since the radial pattern uses its

    // input to scale its output, the result will be a sphere containing a

    // granitic texture which diminishes its intensity near the border.



    list.Reset();

    list << "kr" << LfColor( 0.7, 0.85, 1.0 );

    list << "kaf" << LfColor( 0.2, 0.35, 0.5 );

    list << "density" << 1.0;

    list << "density" << cloudpattern;

    list << "sampling" << 20.0;

    list << "shadow-caching" << LfPoint( -1.2, -1.2, -1.2 ) << LfPoint( 1.2, 1.2, 1.2 );

    list << "density-caching" << LfInt( 2048 ) << LfPoint( -1.2, -1.2, -1.2 ) << LfPoint( 1.2, 1.2, 1.2 );

    LfInt cloudinterior = s->NewInterior( "cloud", list );



    // Here you should note how we described density.

    // It has been specified with a single value of 1 and then with the

    // pattern we modeled before. The value of 1 will be used as a input to 

    // cloudpattern1, which will scale its output by this factor. In

    // this case there will be no scaling, and the output will go from 1 to 

    // 0, as we stated above.

    // The "shadow-caching" and "density-caching" attributes specify the use of 

    // two different caching mechanisms that will be used to speed-up

    // computations. They both require a bounding box where to work, and

    // the density cache also requires the maximum allowed memory

    // occupancy, which is expressed in Kb (here 2048, i.e. 2 Mb).

    // The "sampling" value specifies how many samples will be taken into a

    // segment long one.



    s->InteriorBegin( cloudinterior );



    list.Reset();

    LfInt cloud = s->NewMaterial( "transparent", list );



    s->InteriorEnd();





    s->MaterialBegin( cloud );



    list.Reset();

    list << "radius" << 1.2;

    s->AddObject( s->NewObject( "sphere", list ) );



    s->MaterialEnd();





    list.Reset();

    list << "file" << "cloud.tga";

    LfInt saver = s->NewImager( "tga-saver", list );



    s->ImagerBegin( saver );



    list.Reset();

    list << "eye" << LfPoint( 0, -4, 0 );

    list << "aim" << LfPoint( 0, 0, 0 );

    LfInt camera = s->NewCamera( "pinhole", list );



    s->ImagerEnd();



    s->Render( camera, 300, 300 );



    delete s;

}

$ /usr/local/gcc-2.95/bin/g++ -I ./include -lLightflow main5.cpp -o simplescene5
$ ./simplescene5
$ convert cloud.tga cloud.jpg
$ eog cloud.jpg

main4.cpp
#includeの両側に半角スペースが入っています。

#include < Lightflow/LfLocalSceneProxy.h >



int main()

{

    LfLocalSceneProxy* s = new LfLocalSceneProxy();

    LfArgList list;

    LfTransform trs;



    list.Reset();

    list << "position" << LfPoint( 4.0, -6.0, -5.0 );

    list << "color" << LfColor( 200.0, 200.0, 200.0 );

    s->LightOn( s->NewLight( "point", list ) );



    list.Reset();

    list << "position" << LfPoint( -7.5, -6.0, 2.0 );

    list << "color" << LfColor( 300.0, 150.0, 150.0 );

    LfInt light1 = s->NewLight( "point", list );



    list.Reset();

    list << "position" << LfPoint( -2.0, 0.0, 8.0 );

    list << "color" << LfColor( 150.0, 300.0, 150.0 );

    LfInt light2 = s->NewLight( "point", list );



    list.Reset();

    list << "position" << LfPoint( 8.0, -6.0, 5.0 );

    list << "color" << LfColor( 150.0, 150.0, 300.0 );

    LfInt light3 = s->NewLight( "point", list );





    s->LightBegin();

    s->LightOn( light1 );



    list.Reset();

    list << "ka" << LfColor( 0.1, 0.1, 0.1 );

    list << "kc" << LfColor( 1, 1, 1 );

    list << "kd" << 0.5;

    list << "km" << 0.1;

    LfInt plastic1 = s->NewMaterial( "standard", list );



    s->LightEnd();



    s->LightBegin();

    s->LightOn( light2 );



    list.Reset();

    list << "ka" << LfColor( 0.1, 0.1, 0.1 );

    list << "kc" << LfColor( 1, 1, 1 );

    list << "kd" << 0.5;

    list << "km" << 0.1;

    LfInt plastic2 = s->NewMaterial( "standard", list );



    s->LightEnd();



    s->LightBegin();

    s->LightOn( light3 );



    list.Reset();

    list << "ka" << LfColor( 0.1, 0.1, 0.1 );

    list << "kc" << LfColor( 1, 1, 1 );

    list << "kd" << 0.5;

    list << "km" << 0.1;

    LfInt plastic3 = s->NewMaterial( "standard", list );



    s->LightEnd();





    s->TransformBegin( trs.Translation( LfVector3( -2.0, 0, 0 ) ) );



    s->MaterialBegin( plastic1 );



    list.Reset();

    list << "radius" << 1.0;

    s->AddObject( s->NewObject( "sphere", list ) );



    s->MaterialEnd();



    s->TransformEnd();





    s->MaterialBegin( plastic2 );



    list.Reset();

    list << "radius" << 1.0;

    s->AddObject( s->NewObject( "sphere", list ) );



    s->MaterialEnd();





    s->TransformBegin( trs.Translation( LfVector3( 2.0, 0, 0 ) ) );



    s->MaterialBegin( plastic3 );



    list.Reset();

    list << "radius" << 1.0;

    s->AddObject( s->NewObject( "sphere", list ) );



    s->MaterialEnd();



    s->TransformEnd();





    list.Reset();

    list << "file" << "lights.tga";

    LfInt saver = s->NewImager( "tga-saver", list );



    s->ImagerBegin( saver );



    list.Reset();

    list << "eye" << LfPoint( 0, -4, 0 );

    list << "aim" << LfPoint( 0, 0, 0 );

    list << "fov" << atan( 0.5 / 0.75 )*2.0;

    LfInt camera = s->NewCamera( "pinhole", list );



    s->ImagerEnd();



    s->Render( camera, 300, 300 );



    delete s;

}

$ /usr/local/gcc-2.95/bin/g++ -I ./include -lLightflow main4.cpp -o simplescene4
$ ./simplescene4
$ convert lights.tga lights.jpg
$ eog lights.jpg