~vcs-imports/artoolkit/sf-trunk

/*
	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;
	//}
}