Subversion Repositories gelsvn

/*
 *  VisObj.cpp
 *  GEL
 *
 *  Created by J. Andreas Bærentzen on 20/09/08.
 *  Copyright 2008 __MyCompanyName__. All rights reserved.
 *
 */

#include "VisObj.h"

#include <GLGraphics/Console.h>
#include <HMesh/Manifold.h>
#include <HMesh/AttributeVector.h>
#include <HMesh/load.h>
#include <HMesh/curvature.h>

#include <CGLA/Mat3x3d.h>
#include <CGLA/Vec3d.h>
#include <CGLA/Vec4d.h>

using namespace std;
using namespace CGLA;
using namespace HMesh;
using namespace GLGraphics;

int WINX=800, WINY=800;

namespace GLGraphics {
    
    void VisObj::refit()
    {
        bsphere(mani, bsphere_center, bsphere_radius);
        
        view_ctrl.set_centre(Vec3f(bsphere_center));
        view_ctrl.set_eye_dist(2*bsphere_radius);
    }
    
    bool VisObj::reload(string _file)
    {
        if(_file != "") file = _file;
        mani.clear();
        if(!load(file, mani))
            return false;
        refit();
        return true;
    }
    
    bool VisObj::add_mesh(string file)
    {
        if(!load(file, mani))
            return false;
        refit();
        return true;
    }
    
    
    
    void VisObj::display(const std::string& display_method , Console& cs, bool smooth, float gamma)
    {
        if(create_display_list){
            create_display_list = false;
            
            delete renderer;
            
            string short_name = display_method.substr(0,3);
            if(short_name== "wir")
                renderer = new WireframeRenderer(mani, smooth);
            
                else if(short_name == "har")
                                renderer = new HarmonicsRenderer(mani, harm, cs);
            
            else if(short_name == "iso") {
                renderer = new IsophoteLineRenderer();
                renderer->compile_display_list(mani,smooth);
            }
            else if(short_name == "ref") {
                renderer = new ReflectionLineRenderer();
                renderer->compile_display_list(mani,smooth);
            }
            else if(short_name == "gla") {
                renderer = new GlazedRenderer();
                dynamic_cast<GlazedRenderer*>(renderer)->compile_display_list(mani,smooth);
            }
            
            
            else if(short_name == "too") {
                renderer = new ToonRenderer();
                renderer->compile_display_list(mani,smooth);
            }
            
            
            else if(short_name == "cur"){
                static Console::variable<string> line_direction("min");
                static Console::variable<string> method("tensors");
                static Console::variable<int> smoothing_iter(1);
                
                line_direction.reg(cs,"display.curvature_lines.direction", "");
                method.reg(cs, "display.curvature_lines.method", "");
                smoothing_iter.reg(cs, "display.curvature_lines.smoothing_iter", "");
                
                VertexAttributeVector<Mat3x3d> curvature_tensors(mani.allocated_vertices());
                VertexAttributeVector<Vec3d> min_curv_direction(mani.allocated_vertices());
                VertexAttributeVector<Vec3d> max_curv_direction(mani.allocated_vertices());
                string _line_direction = line_direction;
                VertexAttributeVector<Vec3d>& lines = (_line_direction == "min") ? min_curv_direction : max_curv_direction;
                VertexAttributeVector<Vec2d> curvature(mani.allocated_vertices());
                
                if(string(method) == "tensors")
                {
                    curvature_tensors_from_edges(mani, curvature_tensors);
                    for(int i=0;i<smoothing_iter; ++i)
                        smooth_curvature_tensors(mani,curvature_tensors);
                    
                    curvature_from_tensors(mani, curvature_tensors,
                                           min_curv_direction,
                                           max_curv_direction,
                                           curvature);
                }
                else
                    curvature_paraboloids(mani,
                                          min_curv_direction,
                                          max_curv_direction,
                                          curvature);
                
                renderer = new LineFieldRenderer();
                dynamic_cast<LineFieldRenderer*>(renderer)->compile_display_list(mani, lines);
            }
            else if(short_name == "gau"){
                static Console::variable<float> smoothing(2.0f);
                smoothing.reg(cs, "display.gaussian_curvature_renderer.smoothing", "");
                VertexAttributeVector<double> scalars(mani.allocated_vertices());
                gaussian_curvature_angle_defects(mani, scalars, smoothing);
                double max_G = 0;
                
                for(VertexIDIterator v = mani.vertices_begin(); v != mani.vertices_end(); ++v)
                    max_G = max(abs(scalars[*v]), max_G);
                
                renderer = new ScalarFieldRenderer();
                dynamic_cast<ScalarFieldRenderer*>(renderer)->compile_display_list(mani, smooth, scalars, max_G, gamma);
                
            }
            else if(short_name == "mea"){
                static Console::variable<int> smoothing(2);
                smoothing.reg(cs, "display.mean_curvature_renderer.smoothing", "");
                
                VertexAttributeVector<double> scalars(mani.allocated_vertices());
                mean_curvatures(mani, scalars, smoothing);
                double max_G = 0;
                double mean = 0;
                
                for(VertexIDIterator v = mani.vertices_begin(); v != mani.vertices_end(); ++v){
                    max_G = max(abs(scalars[*v]), max_G);
                    mean += scalars[*v];
                }
                
                renderer = new ScalarFieldRenderer();
                dynamic_cast<ScalarFieldRenderer*>(renderer)->compile_display_list(mani, smooth, scalars, max_G, gamma);
            }
            else if(short_name == "amb"){
                static Console::variable<int> smoothing(2);
                smoothing.reg(cs, "display.ambient_occlusion_renderer.smoothing", "");
                
                VertexAttributeVector<double> scalars(mani.allocated_vertices());
                mean_curvatures(mani, scalars, smoothing);
                double max_G = 0;
                
                for(VertexIDIterator v = mani.vertices_begin(); v != mani.vertices_end(); ++v)
                    max_G = max(abs(scalars[*v]), max_G);
                
                renderer = new AmbientOcclusionRenderer();
                dynamic_cast<AmbientOcclusionRenderer*>(renderer)->compile_display_list(mani, scalars, max_G);
                
            }
            else if(short_name == "deb")
            {
                renderer = new DebugRenderer;
                renderer->compile_display_list(mani, smooth);
            }
            else {
                renderer = new NormalRenderer();
                renderer->compile_display_list(mani, smooth);
            }
            
            
        }
        view_ctrl.set_gl_modelview();
        renderer->draw();
    }
}