LandscapeScene.cpp

#include "LandscapeScene.h"
#include "TerminalObject.h"
#include "DLODObject.h"
#include "Cube.h"
#include "Textures.h"
#include "LandPatch.h"

void LandscapeScene::Init ()
{
        Light * light;
        TerminalObject * sky;
        RawObject * textured_cube;
        GraphicalObject * one_patch;
        GraphicalObject * patch_group;

        // generating sky
        textured_cube = new TexturedCube (5000.0f, Textures::GetId (T_SKY), false);
        sky = new TerminalObject (textured_cube);
        sky->position->SetConstantPosition (2500.0f, 2500.0f, 0.0f, 0.0f, 0.0f, 0.0f);
        AddObject (sky);

        // landscape generation
        PerlinNoise * perlin_height;
        int size_x, size_y;
        float stride;

        printf ("generating height field...\n");

        size_x = 513;
        size_y = 513;
        stride = 3.0f;

        height_field = new float[size_x * size_y];

        perlin_height = new PerlinNoise (size_x, size_y);
        perlin_height->SetParameters (16.0f, 0.5f, 8, true);
        perlin_height->GenerateNoise ();
        perlin_height->TransformAB (1.5f, 0.3f, PerlinNoise::LinearTransform);
        perlin_height->TransformAB (0.0f, 5.0f, PerlinNoise::RangeTransform);
        perlin_height->SmoothBorder (32);
        perlin_height->TransformAB (100.0f, 0.0f, PerlinNoise::LinearTransform);
        perlin_height->Export (height_field);
        delete perlin_height;

        printf ("generating landscape...\n");


        one_patch = GeneratePart (height_field, 0, 7, 0, 7, size_x, size_y, stride);
        one_patch->CalculateRelativePositions ();

        patch_group = ReplicatePatches (one_patch, (size_x - 1) * stride, 0 , 7, 0, 7);
        AddObject (patch_group);

        // Set the camera
        camera = new Camera ();
        camera->SetAttributes (45, 1.333, 1.0, 7000.0);
        camera->position->StartPath (0, 20.0f, 20.0f, 10.0f, 0.0f, 90.0f, 45.0f);
        camera->position->SetDuration (10000);
        camera->position->SetGlobalTransition (PP_SINE, 0.0f);
        camera->position->AddCheckpoint (120.0f, 20.0f, 100.0f, 0.0f, 20.0f, 45.0f);
        camera->position->SetDuration (40000);
        camera->position->SetGlobalTransition (PP_COSINE, 0.0f);
        camera->position->AddCheckpoint (1400.0f, 1200.0f, 100.0f, 0.0f, 20.0f, 45.0f); 
        camera->position->SetDuration (40000);
        camera->position->SetTransitionModes (PP_LINEAR, PP_LINEAR, PP_LINEAR, PP_COSINE, PP_COSINE, PP_COSINE);
        camera->position->SetParameters (0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
        camera->position->AddCheckpoint (3600.0f, 3600.0f, 100.0f, 0.0f, 20.0f, 190.0f);
        camera->position->SetDuration (10000);
        camera->position->SetGlobalTransition (PP_SINE, 0.0f);
        camera->position->AddCheckpoint (4000.0f, 4000.0f, 100.0f, 0.0f, 20.0f, 220.0f);


        // add one light at (0,0,100)
        light = new Light ();
        light->position->SetConstantPosition (20.0f, 20.0f, 400.0f, 0.0f, 0.0f, 0.0f);
        light->SetAmbient (0.2f, 0.2f, 0.2f, 1.0f);
        light->SetSpecular (1.0f, 1.0f, 1.0f, 1.0f);
        AddLight (light);
}


GraphicalObject * LandscapeScene::GeneratePart (float * height_field, int min_x, int max_x, int min_y, int max_y, int total_x, int total_y, float stride)
{
        GroupObject * group;
        DLODObject * landscape;
        RawObject * patch;

        if (min_x == max_x && min_y == max_y)
        {
                // end of recursion
                patch = new LandPatch (height_field, 65, 65, 64 * min_x, 64 * min_y, total_x, total_y, stride, 1);
                patch->SetColor (0.2f, 0.7f, 0.1f, 1.0f);

                landscape = new DLODObject (patch);
                landscape->position->SetConstantPosition (min_x * 64 * stride, min_y * 64 * stride, 0.0f, 0.0f, 0.0f, 0.0f);

                patch = new LandPatch (height_field, 33, 33, 64 * min_x, 64 * min_y, total_x, total_y, stride, 2);
                patch->SetColor (0.2f, 0.7f, 0.1f, 1.0f);
                landscape->AddLevel (patch, 1000.0f);

                patch = new LandPatch (height_field, 17, 17, 64 * min_x, 64 * min_y, total_x, total_y, stride, 4);
                patch->SetColor (0.2f, 0.7f, 0.1f, 1.0f);
                landscape->AddLevel (patch, 1800.0f);

                patch = new LandPatch (height_field, 9, 9, 64 * min_x, 64 * min_y, total_x, total_y, stride, 8);
                patch->SetColor (0.2f, 0.7f, 0.1f, 1.0f);
                landscape->AddLevel (patch, 2800.0f);

                patch = new LandPatch (height_field, 5, 5, 64 * min_x, 64 * min_y, total_x, total_y, stride, 16);
                patch->SetColor (0.2f, 0.7f, 0.1f, 1.0f);
                landscape->AddLevel (patch, 3800.0f);

                patch = new LandPatch (height_field, 3, 3, 64 * min_x, 64 * min_y, total_x, total_y, stride, 32);
                patch->SetColor (0.2f, 0.7f, 0.1f, 1.0f);
                landscape->AddLevel (patch, 4800.0f);

                return landscape;
        }
        else
        {
                group = new GroupObject ();

                int x_boundary = (max_x - min_x) / 2;
                int y_boundary = (max_y - min_y) / 2;

                group->AddChild (GeneratePart (height_field, min_x, min_x + x_boundary, min_y, min_y + y_boundary, total_x, total_y, stride));
                group->AddChild (GeneratePart (height_field, min_x + x_boundary + 1, max_x, min_y, min_y + y_boundary, total_x, total_y, stride));
                group->AddChild (GeneratePart (height_field, min_x, min_x + x_boundary, min_y + y_boundary + 1, max_y, total_x, total_y, stride));
                group->AddChild (GeneratePart (height_field, min_x + x_boundary + 1, max_x, min_y + y_boundary + 1, max_y, total_x, total_y, stride));

                return group;
        }
}

GroupObject * LandscapeScene::ReplicatePatches (GraphicalObject * one_patch, float size, int min_x, int max_x, int min_y, int max_y)
{
        GroupObject * group;
        GroupObject * intermediate;

        if (min_x == max_x && min_y == max_y)
        {
                intermediate = new GroupObject ();
                intermediate->AddChild (one_patch);

                return intermediate;
        }
        else
        {
                group = new GroupObject ();

                int x_boundary = (max_x - min_x) / 2;
                int y_boundary = (max_y - min_y) / 2;

                intermediate = ReplicatePatches (one_patch, size, min_x, min_x + x_boundary, min_y, min_y + y_boundary);
                RandomRotate (intermediate, 0.0f, 0.0f, size * (x_boundary + 1));
                group->AddChild (intermediate);

                intermediate = ReplicatePatches (one_patch, size, min_x + x_boundary + 1, max_x, min_y, min_y + y_boundary);
                RandomRotate (intermediate, size * (x_boundary + 1), 0.0f, size * (x_boundary + 1));
                group->AddChild (intermediate);

                intermediate = ReplicatePatches (one_patch, size, min_x, min_x + x_boundary, min_y + y_boundary + 1, max_y);
                RandomRotate (intermediate, 0.0f, size * (y_boundary + 1), size * (x_boundary + 1));
                group->AddChild (intermediate);

                intermediate = ReplicatePatches (one_patch, size, min_x + x_boundary + 1, max_x, min_y + y_boundary + 1, max_y);
                RandomRotate (intermediate, size * (x_boundary + 1), size * (y_boundary + 1), size * (x_boundary + 1));
                group->AddChild (intermediate);

                return group;
        }
}

void LandscapeScene::RandomRotate (GraphicalObject * patch, float x_offset, float y_offset, float size)
{
        int rotation;
        float x_new, y_new;

        rotation = rand ()%4;
        switch (rotation)
        {
                case 0:         x_new = x_offset;
                                        y_new = y_offset;
                                        break;
                case 1:         x_new = size + x_offset;
                                        y_new = y_offset;
                                        break;
                case 2:         x_new = size + x_offset;
                                        y_new = size + y_offset;
                                        break;
                case 3:         x_new = x_offset;
                                        y_new = size + y_offset;
                                        break;
        }

        patch->position->SetConstantPosition (x_new, y_new, 0.0f, 0.0f, 0.0f, 90.0f * rotation);
}

---