Ogre Forums

Code: Select all

#include <iostream>
#include <string>
#include <list>
#include <cstdlib>
#include <numeric>
#include <ctime>
#include <vector>
#include <algorithm>
#include <ctime>
#include <cmath>

#include <boost/shared_ptr.hpp>
#include <boost/foreach.hpp>
#include <boost/optional.hpp>
#include <boost/any.hpp>
//#include <boost/thread.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/thread.hpp>

#include <corona.h>

#include <cml/cml.h>

#include "phys/body.hpp"
#include "phys/ray.hpp"
#include "phys/world.hpp"
#include "phys/mesh.hpp"
#include "types.hpp"
#include "rand.hpp"

using namespace engine;

class entity: public phys::body
{
    private:

    public:

        entity(const phys::world &w):
            phys::body(w)
        {
            misc = this;
        }

        struct material_t
        {
            float reflectivity;
            vec3 diffuse, specular;

            material_t(): reflectivity(0), diffuse(1, 1, 1), specular(1, 1, 1) {}
        } material;
};

struct light
{
    vec3 diffuse;
    vec3 specular;
    vec3 position;
    float radius;

    light(const vec3 &d = vec3(1, 1, 1), const vec3 &s = vec3(1, 1, 1), const vec3 &p = vec3(0, 0, 0), float r = 10):
        diffuse(d), specular(s), position(p), radius(r) {}
};

typedef boost::shared_ptr<entity> entityPtr;
typedef std::list<entityPtr> entityList;
typedef std::list<light> lightList;

mat4 lookAt(const vec3 &p, const vec3 &dir, const vec3 &up)
{
    mat4 ret;
    cml::matrix_look_at_RH(ret, p, dir, up);
    return ret;
}

struct ray_t
{
    vec3 origin, dir;

    ray_t(const vec3 &o, const vec3 &d):
        origin(o), dir(d) {}

    ray_t():
        origin(0, 0, 0), dir(0, 0, -1) {}
};

ray_t screenRay(float x, float y, const mat4 &camMat, const float FOCAL_DIST = 1) // normalized screen coords
{
    x = x * 2 - 1;
    y = y * 2 - 1;

    vec3 orig(camMat(0, 3), camMat(1, 3), camMat(2, 3));
    vec4 dest(x, y, -FOCAL_DIST, 1);
    //orig = mat * orig;
    dest = camMat * dest;
    return ray_t(orig, normalize(vec3(dest[0], dest[1], dest[2]) - orig));
}

//vec3 calcDirect(vec3 p, vec3 n, const light &l, const entity::material_t &mat)
//{
//    vec3 distv3 = l.position - p;
//    float dist = length(distv3);
//    distv3 /= dist; // normalize
//
//    float att = 1.0 - saturate(dist / l.radius);
//
//    vec3 illum(0, 0, 0);
//    { // NdotL
//        float NdotL = saturate(dot(n, distv3));
//        illum += mul(mat.diffuse, l.diffuse) * NdotL * att;
//    }
//    { // specular
//    }
//    return illum;
//}

boost::optional<phys::ray::hitInfo> rayTrace(const ray_t &start, const phys::world &w, float dist = 1.e3)
{
    phys::ray ray(w);
    if (ray(start.origin, start.origin + start.dir * dist))
        return ray.result;
    return boost::optional<phys::ray::hitInfo>();
}

size_t maxIterations = 10;

boost::optional<vec3> colourFromRay(const ray_t &start, const phys::world &w, const mat4 &invViewMat,
    const lightList &lights, size_t iter = 0)
{
    if (iter > maxIterations)
        return boost::optional<vec3>();

    vec3 cameraPos(invViewMat(0, 3), invViewMat(1, 3), invViewMat(2, 3));

    boost::optional<phys::ray::hitInfo> ret = rayTrace(start, w);
    if (ret)
    {
        phys::ray::hitInfo info = ret.get();
        entity *ent = boost::any_cast<entity*>(info.b->misc);

        vec3 eyePos(invViewMat(0, 3), invViewMat(1, 3), invViewMat(2, 3));
        vec3 eyeDir = normalize(eyePos - info.p);

        vec3 illum(0, 0, 0);

        BOOST_FOREACH(const light &l, lights)
        {
            vec3 distv3 = l.position - info.p;

            // raw NdotL, just to figure out whether we should compute lighting
            float NdotLRaw = dot(info.n, distv3);
            if (NdotLRaw > 0)
            {
                float dist = length(distv3);
                distv3 /= dist; // normalize
                // take 'real' NdotL
                float NdotL = dot(info.n, distv3);

                float att = 1.0 - saturate(dist / l.radius);

                vec3 diffuse = mul(ent->material.diffuse, l.diffuse) * NdotL * att;
                vec3 specular(0, 0, 0);

                vec3 hv = normalize(distv3 + eyeDir);
                float NdotH = dot(info.n, hv);
                if (NdotH > 0)
                {
                    specular = /*mul(ent->material.specular, l.specular)*/vec3(1, 1, 1) * std::pow(NdotH, 64);
                }

                ray_t shadowRay(info.p, normalize(l.position - info.p));
                illum += (diffuse + specular) * !rayTrace(shadowRay, w, l.radius);
            }
        }

        if (ent->material.reflectivity > 0.01)
        {
            boost::optional<vec3> c = colourFromRay(ray_t(info.p, reflect(start.dir, info.n)), w, invViewMat, lights, ++iter);
            if (c)
                illum += mul(ent->material.specular, c.get()) * ent->material.reflectivity;
        }

        return illum;
    }
    float sky = /*std::abs(*/dot(start.dir, vec3(0, 1, 0))/*)*/;
    if (sky <= 0)
        return boost::optional<vec3>();
    return boost::optional<vec3>(vec3(223.0 / 255.0, 151.0 / 255.0, 0) * sky);
}

void createScene(entityList &scene, phys::world &world, size_t numObjects = 250)
{
    for (size_t i = 0; i < numObjects; ++i)
    {
        entityPtr ent(new entity(world));

        vec3 p(randUnit() * 25, rand01() * 50, randUnit() * 25);
        vec3 d(10, 10, 10);
        ent->collision(phys::mesh::ball(world, d));
        ent->pos(p);
        ent->mass(10);

        entity::material_t &m = ent->material;
        m.reflectivity = 1;
        m.diffuse = m.specular = randUnitVec() * 0.5 + vec3(0.5, 0.5, 0.5);
        //m.specular = randUnitVec() * 0.5 + vec3(0.5, 0.5, 0.5);

        scene.push_back(ent);
    }
    // ent
    {
        entityPtr ent(new entity(world));

        vec3 d(150, 1, 150);
        ent->collision(phys::mesh::box(world, d));
        ent->pos(vec3(0, d[1] * -0.5, 0));
        ent->mass(0);
        ent->material.reflectivity = 1;
        ent->material.diffuse = ent->material.specular = vec3(1, 1, 1);

        scene.push_back(ent);
    }
}

void createLights(lightList &lights)
{
    lights.push_back(light(vec3(1, 1, 1), vec3(1, 1, 1), vec3(0, 50, 0), 100));
    //lights.push_back(light(vec3(1, 1, 1), vec3(1, 1, 1), vec3(0, 15, 0), 25));
    //lights.push_back(light(vec3(1, 1, 1), vec3(1, 1, 1), vec3(-50, 75, 50), 150));
    //lights.push_back(light(vec3(1, 1, 1), vec3(1, 1, 1), vec3(-50, 75, -50), 150));
    //lights.push_back(light(vec3(1, 1, 1), vec3(1, 1, 1), vec3(50, 75, 50), 150));
    //lights.push_back(light(vec3(1, 1, 1), vec3(1, 1, 1), vec3(50, 75, -50), 150));
}

mat4 createViewMat()
{
    return lookAt(vec3(25, 25, 25), vec3(0, 0, 0), vec3(0, 1, 0));
}

struct pixel
{
    float x, y;
    engine::byte *p;
    pixel(float x, float y, engine::byte *p):
        x(x), y(y), p(p) {}
};

void tracePixel(const pixel &p, const mat4 &viewMat, const mat4 &invViewMat, const phys::world &w, const lightList &lights)
{
    // y goes from bottom to top
    ray_t r = screenRay(p.x, p.y, invViewMat);
    vec3 c = saturate(colourFromRay(r, w, invViewMat, lights).get_value_or(vec3(0, 0, 0)));

    for (size_t j = 0; j < 3; ++j)
        p.p[j] = engine::byte(c[j] * 255.0);
    p.p[3] = 255;
}

void tracePixels(const std::vector<pixel> &pixels, const mat4 &viewMat, const mat4 &invViewMat,
    const phys::world &w, const lightList &lights)
{
    for (size_t i = 0; i < pixels.size(); ++i)
        tracePixel(pixels[i], viewMat, invViewMat, w, lights);
}

struct tracer
{
    std::vector<pixel> pixels;
    mat4 viewMat, invViewMat;
    const phys::world &world;
    const lightList &lights;

    tracer(const std::vector<pixel> &pixels, const mat4 &viewMat, const mat4 &invViewMat,
        const phys::world &w, const lightList &lights):
        pixels(pixels), viewMat(viewMat), invViewMat(invViewMat), world(w), lights(lights) {}

    inline void operator()() { tracePixels(pixels, viewMat, invViewMat, world, lights); }
};

typedef boost::shared_ptr<corona::Image> imagePtr;

inline imagePtr create(size_t w, size_t h) { return imagePtr(corona::CreateImage(w, h, corona::PF_R8G8B8A8)); }
inline void save(const imagePtr &img, size_t i = 0)
{
    corona::SaveImage(("out" + boost::lexical_cast<engine::string>(i) + ".png").c_str(), corona::FF_AUTODETECT, img.get());
}

void go(const mat4 &viewMat, const mat4 &invViewMat,
    const phys::world &world, const lightList &lights, std::vector<pixel> &pixels, size_t numThreads)
{
    size_t numPixels = pixels.size();
    size_t pixelsPerThread = numPixels / numThreads;

    std::vector<std::vector<pixel> > threadPixels(numThreads);

    for (size_t i = 0; i < threadPixels.size(); ++i)
    {
        std::vector<pixel> &v = threadPixels[i];
        v = std::vector<pixel>(pixels.begin() + i * pixelsPerThread, pixels.begin() + (i + 1) * pixelsPerThread);
    }

    typedef boost::shared_ptr<boost::thread> threadPtr;
    std::vector<threadPtr > threads;

    for (size_t i = 1; i < threadPixels.size(); ++i)
        threads.push_back(threadPtr(new boost::thread(tracer(threadPixels[i], viewMat, invViewMat, world, lights))));

    // use the current thread, too
    tracePixels(threadPixels[0], viewMat, invViewMat, world, lights);

    // wait for other threads
    for (size_t i = 0; i < threads.size(); ++i)
        threads[i]->join();
}

int main(int argc, char **argv)
{
    seedRand();

    size_t width = 512, height = 512, numThreads = 1;

    std::cout << "size: ";
    std::cin >> width;
    if (width < 4)
        width = 4;
    height = width;

    std::cout << "number of threads: ";
    std::cin >> numThreads;

    std::cout << "number of frames: ";
    size_t numFrames = 1;
    std::cin >> numFrames;

    std::cout << "delta time (seconds) (big if you're not rendering loads of frames): ";
    double deltaTime = 0.25;
    std::cin >> deltaTime;

    std::cout << "number of objects (phys time is pretty low usually): ";
    size_t numObjects = 250;
    std::cin >> numObjects;

    std::cout << "max number of reflections: ";
    std::cin >> maxIterations;

    imagePtr screen = create(width, height);
    engine::byte *data = (engine::byte*)screen->getPixels();

    std::vector<pixel> pixels;
    pixels.reserve(width * height);
    for (size_t i = 0; i < pixels.capacity(); ++i)
    {
        size_t x = i % width;
        size_t y = i / width;
        pixels.push_back(pixel(float(x) / width, 1.0 - float(y) / height, data + i * 4));
    }

    mat4 viewMat = createViewMat();
    mat4 invViewMat = inverse(viewMat);

    phys::world world;
    world.threads(numThreads);

    entityList scene;
    createScene(scene, world, numObjects);

    lightList lights;
    createLights(lights);

    for (size_t i = 0; i < numFrames; ++i)
    {
        go(viewMat, invViewMat, world, lights, pixels, numThreads);
        world.tick(deltaTime);

        save(screen, i);

        std::cout << "done with frame " << i << "\n";
    }

    return 0;
}