codebase / stimlib

  #ifndef STIM_GL_SPIDER_H
  #define STIM_GL_SPIDER_H
  
  #include <GL/glut.h>

  //#include <GL/glew.h>
  #include "gl_texture.h"

  #include "../visualization/camera.h"
  #include "./error.h"
  #include "../math/vector.h"

  #include "../math/rect.h"

  
  namespace stim
  {
  
  template<typename T>
  class gl_spider : public virtual gl_texture<T>
  {
  	//doen't use gl_texture really, just needs the GLuint id.

  	//doesn't even need the texture iD really.

  	private:
  		stim::camera rotator;
  		stim::vec<float> position;  	//vector designating the position of the spider.
  		stim::vec<float> direction;	//vector designating the orientation of the spider
  						//always a unit vector.
  		stim::vec<float> magnitude;	//magnitude of the direction vector.

  						//mag[0] = length.
  						//mag[1] = width.

  		//				Also maybe we some texture representation of
  		//				of the spider i.e [WH_pxl, BL_pxl, WH_pxl].

  		using gl_texture<T>::texID;

  
  
  		void
  		findOptimalDirection()
  		{
  			/* Method for finding the best direction for the spider.
  			   Uses the camera to rotate. Then Calls Evaluate to find new cost.
  			*/
  		}
  
  		void
  		findOptimalPosition()
  		{
  			/* Method for finding the best direction for the spider.
  			   Not sure if necessary since the next position for the spider
  			   will be at direction * magnitude. */
  		}
  	
  		void
  		findOptimalScale()
  		{
  			/* Method for finding the best scale for the spider.
  			   changes the x, y, z size of the spider to minimize the cost
  			   function. */
  		}
  
  		void
  		Evaluate()
  		{	
  			/* Uses uniform sampler2D in order to take a difference between
  			   the colors of two textures. 1st texture is the spider template,
  			   the 2nd is the location of the spider's overlap with the
  			   gl_template 
  	
  			   does the spider need to track it's location? Prob not since
  			   position can be set with gl_texture coordinates */
  		
  		}
  
  		void
  		Optimize()
  		{
  			/*find the optimum direction and scale */ 
  		}

  		/*

  		void
  		Step()
  		{

  			// move to the new position 

  		}

  		*/

  	public:

  		stim::rect<float> hor;
  		stim::rect<float> ver;	
  
  
  
  		gl_spider
  		()

  		{
  			setPosition(0.0,0.0,0.0);
  			setDirection(1.0,1.0,1.0);

  			setMagnitude(0.1,0.1);

  			stim::vec<float> Y(1.0,0.0,0.0);

  			if(cos(Y.dot(direction))< 0.087){
  				Y[0] = 0.0; Y[1] = 1.0;}
  			/*

  			hor = stim::rect<float>(position, direction, Y);

  			hor.scale(magnitude[0], magnitude[1]);
  			ver = stim::rect<float>(position, direction, (Y.cross(direction)).norm());
  			ver.scale(magnitude[0], magnitude[1]);
  			*/
  			hor = stim::rect<float>(magnitude, position, direction, Y);
  			ver = stim::rect<float>(magnitude, position, direction,
  				 (Y.cross(direction)).norm());

  		}
  

  		gl_spider
  		(vec<float> pos, vec<float> dir, vec<float> mag)

  		{
  			position = pos;
  			direction = dir;
  			magnitude = mag;
  			vec<float> Y(1.0,0.0,0.0);

  			if(cos(Y.dot(direction))< 0.087){
  				Y[0] = 0.0; Y[1] = 1.0;}
  			/*
  			hor = stim::rect<float>(position, direction, Y);
  			hor.scale(magnitude[0], magnitude[1]);
  			ver = stim::rect<float>(position, direction, (Y.cross(direction)).norm());
  			ver.scale(magnitude[0], magnitude[1]);
  			*/
  			hor = stim::rect<float>(magnitude, position, direction, Y);
  			ver = stim::rect<float>(magnitude, position, direction,
  				 (Y.cross(direction)).norm());
  		}
  		//temporary cost for convenience.	
  		gl_spider
  		(float pos_x, float pos_y, float pos_z, float dir_x, float dir_y, float dir_z,
  			float mag_x, float mag_y)
  		{
  			setPosition(pos_x, pos_y, pos_z);
  			setDirection(dir_x, dir_y, dir_z);
  			setMagnitude(mag_x, mag_y);
  			vec<float> Y(1.0,0.0,0.0);
  			if(cos(Y.dot(direction))< 0.087){
  				Y[0] = 0.0; Y[1] = 1.0;}
  			/*

  			hor = stim::rect<float>(position, direction, Y);

  			hor.scale(magnitude[0], magnitude[1]);
  			ver = stim::rect<float>(position, direction, (Y.cross(direction)).norm());
  			ver.scale(magnitude[0], magnitude[1]);
  			*/
  			hor = stim::rect<float>(magnitude, position, direction.norm(), Y);
  			ver = stim::rect<float>(magnitude, position, direction.norm(),
  				 (Y.cross(direction)).norm());

  		}

  		vec<float>
  		getCurrentPosition()
  		{
  			return position;
  		}
  	
  		vec<float>
  		getCurrentDirection()
  		{
  			return direction;
  		}
  
  		vec<float>
  		getCurrentMagnitude()
  		{
  			return magnitude;
  		}
  	
  		void
  		setPosition(vec<float> pos)
  		{
  			position = pos;
  		}
  		
  		void
  		setPosition(float x, float y, float z)
  		{
  			position[0] = x;
  			position[1] = y;
  			position[2] = z;
  		}
  
  		void
  		setDirection(vec<float> dir)
  		{
  			direction = dir;
  		}
  		
  		void
  		setDirection(float x, float y, float z)
  		{
  			direction[0] = x;
  			direction[1] = y;
  			direction[2] = z;
  		}
  		
  		void
  		setMagnitude(vec<float> mag)
  		{
  			magnitude = mag;
  		}
  		
  		void

  		setMagnitude(float x, float y)

  		{
  			magnitude[0] = x;
  			magnitude[1] = y;

  		}

  		void
  		Step()
  		{
  			std::cout << position[0] << "," << position[1] << "," << position[1]
  				<< std::endl;
  			setPosition(direction*magnitude[1]+position);
  			std::cout << position[0] << "," << position[1] << "," << position[1]
  				<< std::endl;
  			
  		}

  };

  }
  #endif