arViewer.cpp

Go to the documentation of this file.

/*
        Original version for VRML97-0.8.7 by Hirokazu Kato.
 
        Updated for OpenVRML-0.14.3 by Raphael Grasset.
        -remove vrmlScene since we use reference now.
        -remove culling pb

        Updated for OpenVRML-0.16.1 by Philip Lamb. 2006-11-15.
        - add arVrmlBrowser class and Boost dependencies.
*/
/*
 * 
 * This file is part of ARToolKit.
 * 
 * ARToolKit is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * ARToolKit is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with ARToolKit; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * 
 */

#include <iostream>
#include <math.h>
#ifdef __APPLE__
#  include <GLUT/glut.h>
#else
#  include <GL/glut.h>
#endif
#include "arViewer.h"

using namespace openvrml;

arVrmlBrowser::arVrmlBrowser(): openvrml::browser(std::cout, std::cerr)
{
}

std::auto_ptr<openvrml::resource_istream>
arVrmlBrowser::do_get_resource(const std::string & uri)
{
        using std::auto_ptr;
        using std::invalid_argument;
        using std::string;
        using openvrml::resource_istream;
        
        class file_resource_istream : public resource_istream {
                std::string url_;
                std::filebuf buf_;
                
        public:
                explicit file_resource_istream(const std::string & path): resource_istream(&this->buf_)
                {
                        if (!this->buf_.open(path.c_str(), ios_base::in | ios_base::binary)) {
                                this->setstate(ios_base::badbit);
                        }
                }
                        
                void url(const std::string & str) throw (std::bad_alloc)
                {
                        this->url_ = str;
                }
                        
        private:
                virtual const std::string do_url() const throw ()
                {
                        return this->url_;
                }
                        
                virtual const std::string do_type() const throw ()
                {
                        //
                        // A real application should use OS facilities for this.  This
            // is a crude hack because sdl-viewer uses std::filebuf in
            // order to remain simple and portable.
                        //
                        using std::find;
                        using std::string;
                        using boost::algorithm::iequals;
                        using boost::next;
                        string media_type = "application/octet-stream";
                        const string::const_reverse_iterator dot_pos =
                                find(this->url_.rbegin(), this->url_.rend(), '.');
                        if (dot_pos == this->url_.rend()
                                || next(dot_pos.base()) == this->url_.end()) {
                                return media_type;
                        }
                        const string::const_iterator hash_pos =
                                find(next(dot_pos.base()), this->url_.end(), '#');
                        const string ext(dot_pos.base(), hash_pos);
                        if (iequals(ext, "wrl")) {
                media_type = openvrml::vrml_media_type;
                        } else if (iequals(ext, "x3dv")) {
                media_type = openvrml::x3d_vrml_media_type;
                        } else if (iequals(ext, "png")) {
                                media_type = "image/png";
                        } else if (iequals(ext, "jpg") || iequals(ext, "jpeg")) {
                                media_type = "image/jpeg";
                        }
                        return media_type;
                }
                        
                virtual bool do_data_available() const throw ()
                {
                        return !!(*this);
                }
        }; // class file_resource_istream
        
        const string scheme = uri.substr(0, uri.find_first_of(':'));
        if (scheme != "file") {
                throw invalid_argument('\"' + scheme + "\" URI scheme not supported");
        }
        //
        // file://
        //        ^
        // 01234567
        static const string::size_type authority_start_index = 7;

        //
        // On Windows we want to start at the drive letter, which is after the
        // first slash in the path.
        //
        // We ignore the content of the authority; a smarter implementation
        // should confirm that it is localhost, the machine name, or zero
        // length.
        //
        string::size_type path_start_index =
# ifdef _WIN32
                uri.find_first_of('/', authority_start_index) + 1;
# else
                uri.find_first_of('/', authority_start_index);
# endif
        string path = uri.substr(path_start_index);
        
        auto_ptr<resource_istream> in(new file_resource_istream(path));
        static_cast<file_resource_istream *>(in.get())->url(uri);
        
        return in;
}


arVrmlViewer::arVrmlViewer()
{
    internal_light = true;

    translation[0] = 0.0;
    translation[1] = 0.0;
    translation[2] = 0.0;

    rotation[0] = 0.0;
    rotation[1] = 0.0;
    rotation[2] = 0.0;
    rotation[3] = 0.0;

    scale[0] = 1.0;
    scale[1] = 1.0;
    scale[2] = 1.0;
}

arVrmlViewer::~arVrmlViewer() throw()
{
  
}

void arVrmlViewer::timerUpdate()
{ 
        this->update(0.0);
}



void arVrmlViewer::setInternalLight(bool flag)
{
    internal_light = flag;
}

void arVrmlViewer::redraw()
{
        //double start = browser::current_time();
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glTranslated( translation[0], translation[1], translation[2] );
    if (rotation[0] != 0.0) {
        glRotated(rotation[0], rotation[1], rotation[2], rotation[3]);
    }
    glScaled(scale[0], scale[1], scale[2]);
        
#if USE_STENCIL_SHAPE
    glEnable(GL_STENCIL_TEST);
    glStencilFunc(GL_ALWAYS, 1, 1);
    glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
#endif
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LEQUAL);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glDisable(GL_FOG);          // this is a global attribute
    //glDisable(GL_TEXTURE_2D);
    glEnable(GL_CULL_FACE);
    glFrontFace(GL_CCW);
    glCullFace(GL_BACK);
        
        if (internal_light) {
                if (lit) glEnable(GL_LIGHTING);
                glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
                glEnable(GL_NORMALIZE);
                glDisable(GL_COLOR_MATERIAL);
                glDisable(GL_BLEND);
                glShadeModel(GL_SMOOTH);
                
                for (int i = 0; i < max_lights; ++i) {
                        light_info_[i].type = light_unused;
                        GLenum light = (GLenum) (GL_LIGHT0 + i);
                        glDisable(light);
                }
        }
        
    objects = 0;
    nested_objects = 0;
    sensitive = 0;
        
    browser()->render();
        
        if (internal_light) {
                if (lit) glDisable(GL_LIGHTING);
        }
    glDisable(GL_BLEND);
    glDisable(GL_CULL_FACE);
    //glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
        
    glMatrixMode(GL_MODELVIEW);
    glPopMatrix();
}

void  arVrmlViewer::post_redraw()
{

}
void  arVrmlViewer::set_cursor(cursor_style c)
{

}

void  arVrmlViewer::swap_buffers()
{

}

void  arVrmlViewer::set_timer(double t)
{

}


void arVrmlViewer::set_viewpoint(const openvrml::vec3f & position,
                                 const openvrml::rotation & orientation,
                                 float fieldOfView,
                                 float avatarSize,
                                 float visibilityLimit)
{

}

viewer::object_t arVrmlViewer::insert_background(const std::vector<float> & groundAngle,
                                                                                                 const std::vector<color> & groundColor,
                                                                                                 const std::vector<float> & skyAngle,
                                                                                                 const std::vector<color> & skyColor,
                                                                                                 const image & front,
                                                                                                 const image & back,
                                                                                                 const image & left,
                                                                                                 const image & right,
                                                                                                 const image & top,
                                                                                                 const image & bottom)
{
        return 0;
}

viewer::object_t arVrmlViewer::insert_dir_light(float ambientIntensity,
                                  float intensity,
                                  const openvrml::color & color,
                                  const openvrml::vec3f & direction)
{
    if (internal_light) return gl::viewer::insert_dir_light(ambientIntensity, intensity, color, direction);
    return 0;
}

viewer::object_t arVrmlViewer::insert_point_light(float ambientIntensity,
                                    const openvrml::vec3f & attenuation,
                                    const openvrml::color & color,
                                    float intensity,
                                    const openvrml::vec3f & location,
                                    float radius)
{
        if (internal_light) return gl::viewer::insert_point_light(ambientIntensity, attenuation, color, intensity, location, radius);

    return 0;
}

 
viewer::object_t arVrmlViewer::insert_spot_light(float ambientIntensity,
                                   const openvrml::vec3f & attenuation,
                                   float beamWidth,
                                   const openvrml::color & color,
                                   float cutOffAngle,
                                   const openvrml::vec3f & direction,
                                   float intensity,
                                   const openvrml::vec3f & location,
                                   float radius)
{
    if (internal_light) return gl::viewer::insert_spot_light(ambientIntensity, attenuation, beamWidth, color,cutOffAngle, direction, intensity, location, radius);
    return 0;
}

 bounding_volume::intersection
arVrmlViewer::intersect_view_volume(const bounding_volume & bvolume) const
{
  // if( d_cull ) {
  //return  openvrml::viewer::intersect_view_volume(bvolume);
        // }
        // else {
         return bounding_volume::inside;
        //}
}

---

artoolkit
Author(s): Gautier Dumonteil
autogenerated on Fri Jan 11 10:05:45 2013