// Shave and a Haircut
// (c) 2019 Epic Games
// US Patent 6720962

//Qt headers must be included before any others !!!
#include <QtCore/QEvent>
#include <QtGui/QMouseEvent>
#include <QtGui/QTabletEvent>

#if QT_VERSION < 0x050000
#  include <QtGui/QApplication>
#  include <QtGui/QWidget>
#else
#  include <QtWidgets/QApplication>
#  include <QtWidgets/QWidget>
#endif

#include <vector>
#include <sstream>
#include <assert.h>
#include <time.h>
#include <string.h>
#include <stdlib.h>

#include <maya/M3dView.h>
#include <maya/MBoundingBox.h>
#include <maya/MDrawInfo.h>
#include <maya/MDrawRequest.h>
#include <maya/MDrawRequestQueue.h>
#include <maya/MFnDoubleIndexedComponent.h>
#include <maya/MFnSingleIndexedComponent.h>
#include <maya/MGlobal.h>
#include <maya/MMatrix.h>
#include <maya/MPlug.h>
#include <maya/MPoint.h>
#include <maya/MPointArray.h>
#include <maya/MSelectInfo.h>
#include <maya/MSelectionList.h>
#include <maya/MSelectionMask.h>
#include <maya/MFnCamera.h>
#include <maya/MAnimControl.h>
#include <maya/MDagPath.h>
#include <maya/MFloatPointArray.h>
#include <maya/MIOStream.h>

#include "shaveCheckObjectVisibility.h"
#include "shaveCursorCtx.h"
#include "shaveGlobals.h"
#include "shaveHairShape.h"
#include "shaveHairUI.h"
#include "shaveMaya.h"
#include "shaveRender.h"
#include "shaveSDKTYPES.h"
#include "shaveStyleCmd.h"
#include "shaveTextureStore.h"
#include "shaveUtil.h"

#ifdef OSMac_
#include <mach-o/dyld.h>
#include <stdlib.h>
#include <string.h>
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#endif

//
// Some magic numbers which the API *should* give you, but doesn't.
//
static const int LEAD_COLOR				= 18;
static const int ACTIVE_SURFACE_COLOR	= 15;
static const int DORMANT_SURFACE_COLOR	= 4;
static const int ACTIVE_TEMPLATE_COLOR	= 19;
static const int ACTIVE_AFFECTED_COLOR	= 8;
static const int HILITE_COLOR			= 17;
static const int ACTIVE_VERTEX_COLOR	= 16;
static const int DORMANT_VERTEX_COLOR	= 8;
static const int ACTIVE_ISOPARM_COLOR	= 16;

static const int DORMANT_GUIDE_COMPONENT_COLOR	= 22;
static const int ACTIVE_GUIDE_COMPONENT_COLOR	= LEAD_COLOR;
static const int LEAD_HAIR_COLOR				= 22;
static const int ACTIVE_HAIR_COLOR				= 2;

static const float	POINT_SIZE	= 3.0f;

#ifdef NEW_INSTNACE_DISPLAY
#ifndef GL_ACTIVE_TEXTURE
PFNGLATCIVETEXTUREPROC glActiveTexture = NULL;
#endif
#endif

///// shaders
#if defined(_WIN32) || defined(LINUX)
typedef GLuint (APIENTRY * PFNGLCREATESHADERPROC) (GLenum shaderType);
PFNGLCREATESHADERPROC glCreateShader = NULL;

typedef void (APIENTRY * PFNGLCOMPILESHADERPROC) (GLuint shader);
PFNGLCOMPILESHADERPROC glCompileShader = NULL;

typedef void (APIENTRY * PFNGATTACHSHADERPROC) (GLuint program, GLuint shader);
PFNGATTACHSHADERPROC glAttachShader = NULL;

typedef void (APIENTRY * PFNGLDETACHSHADERPROC) (GLuint program, GLuint shader);
PFNGLDETACHSHADERPROC glDetachShader = NULL;

typedef void (APIENTRY * PFNGLDELETESHADERPROC) (GLuint shader);
PFNGLDELETESHADERPROC glDeleteShader = NULL;

typedef void (APIENTRY * PFNGLGETSHADDERIVPROC) (GLuint shader, GLenum pname, GLint *params);
PFNGLGETSHADDERIVPROC glGetShaderiv = NULL;

typedef void (APIENTRY * PFNGLGETSHADERINFOLOGPROC) (GLuint shader, GLsizei maxLength, GLsizei *length, char *infoLog);
PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog = NULL;

#if GL_GLEXT_VERSION > 71
typedef void (APIENTRY * PFNGLSHADERSOURCEPROC) (GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length);
PFNGLSHADERSOURCEPROC glShaderSource = NULL;
#else
typedef void (APIENTRY * PFNGLSHADERSOURCEPROC) (GLuint shader, GLsizei count, const char **string, const GLint *length);
PFNGLSHADERSOURCEPROC glShaderSource = NULL;
#endif


/////// programs
typedef GLuint (APIENTRY * PFNGLCREATEPROGRAMPROC) (void);
PFNGLCREATEPROGRAMPROC glCreateProgram = NULL;

typedef void (APIENTRY * PFNGLDELETEPROGRAMPROC) (GLuint program);
PFNGLDELETEPROGRAMPROC glDeleteProgram = NULL;

typedef void (APIENTRY * PFNGLLINKPROGRAMPROC) (GLuint program);
PFNGLLINKPROGRAMPROC glLinkProgram = NULL;

typedef void (APIENTRY * PFNGLUSEPROGRAMPROC) (GLuint program);
PFNGLUSEPROGRAMPROC glUseProgram = NULL;

typedef void (APIENTRY * PFNVALIDATEPROGRAMPROC) (GLuint program);
PFNVALIDATEPROGRAMPROC glValidateProgram = NULL;

typedef void (APIENTRY * PFNGLGETPROGRAMIVPROC) (GLuint program, GLenum pname, GLint *params);
PFNGLGETPROGRAMIVPROC glGetProgramiv = NULL;

typedef void (APIENTRY * PFNGLGETPROGRAMINFOLOGPROC) (GLuint program, GLsizei maxLength, GLsizei *length, char *infoLog);
PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog = NULL;

typedef GLint (APIENTRY * PFNGLGETUNIFORMLOCATIONPROC) (GLuint program, const char *name);
PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation = NULL;

/////// uniforms
typedef void (APIENTRY * PFNGLUNIFORM3FPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
PFNGLUNIFORM3FPROC glUniform3f = NULL;

typedef void (APIENTRY * PFNGLUNIFORM1FPROC) (GLint location, GLfloat f);
PFNGLUNIFORM1FPROC glUniform1f = NULL;

typedef void (APIENTRY * PFNGLUNIFORM1IPROC) (GLint location, GLint v0);
PFNGLUNIFORM1IPROC glUniform1i = NULL;

//////per vertex attributes
typedef GLint (APIENTRY * PFNGLGETATTRIBLOCATION)(GLuint program, char *name);
PFNGLGETATTRIBLOCATION glGetAttribLocation = NULL;

typedef void (APIENTRY * PFNGLVERTEXATTRIB1FV)(GLuint index, GLfloat v);
PFNGLVERTEXATTRIB1FV glVertexAttrib1f = NULL;

typedef void (APIENTRY * PFNGLVERTEXATTRIB3FV)(GLuint index, GLfloat v0, GLfloat v1, GLfloat v2);
PFNGLVERTEXATTRIB3FV glVertexAttrib3f = NULL;

typedef void (APIENTRY * PFNGLVERTEXATTRIBPOINTER)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* pointer);
PFNGLVERTEXATTRIBPOINTER glVertexAttribPointer = NULL;

typedef void (APIENTRY * PFNGLENABLEVERTEXATTRIBARRAY)(GLuint index);
PFNGLENABLEVERTEXATTRIBARRAY glEnableVertexAttribArray = NULL;

/////////FBO
typedef void (APIENTRY * PFNGLGENFRAMEBUFFERSEXTPROC) (GLsizei n, GLuint *framebuffers);
PFNGLGENFRAMEBUFFERSEXTPROC glGenFramebuffersEXT = NULL;

typedef void (APIENTRY * PFNGLDELETEFRAMEBUFFERSEXTPROC) (GLsizei n, const GLuint *framebuffers);
PFNGLDELETEFRAMEBUFFERSEXTPROC  glDeleteFramebuffersEXT = NULL; 

typedef void (APIENTRY * PFNGLBINDFRAMEBUFFEREXTPROC) (GLenum target, GLuint framebuffer);
PFNGLBINDFRAMEBUFFEREXTPROC glBindFramebufferEXT = NULL;

typedef GLenum (APIENTRY * PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC) (GLenum target);
PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC glCheckFramebufferStatusEXT = NULL;

typedef void (APIENTRY * PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC) (GLenum target, GLenum attachment, GLenum pname, GLint *params);
 PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC glGetFramebufferAttachmentParameterivEXT = NULL;

typedef void (APIENTRY * PFNGLFRAMEBUFFERTEXTURE2DEXTPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
PFNGLFRAMEBUFFERTEXTURE2DEXTPROC glFramebufferTexture2DEXT = NULL;

typedef void (APIENTRY * PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC) (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC glFramebufferRenderbufferEXT = NULL;

typedef void (APIENTRY * PFNGLGENRENDERBUFFERSEXTPROC) (GLsizei n, GLuint *renderbuffers);
PFNGLGENRENDERBUFFERSEXTPROC glGenRenderbuffersEXT = NULL;

typedef void (APIENTRY * PFNGLDELETERENDERBUFFERSEXTPROC) (GLsizei n, const GLuint *renderbuffers);
PFNGLDELETERENDERBUFFERSEXTPROC glDeleteRenderbuffersEXT = NULL;

typedef void (APIENTRY * PFNGLBINDRENDERBUFFEREXTPROC) (GLenum target, GLuint renderbuffer);
PFNGLBINDRENDERBUFFEREXTPROC glBindRenderbufferEXT = NULL;

typedef void (APIENTRY * PFNGLRENDERBUFFERSTORAGEEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
PFNGLRENDERBUFFERSTORAGEEXTPROC glRenderbufferStorageEXT = NULL;

typedef void (APIENTRY * PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint *params);
PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC glGetRenderbufferParameterivEXT = NULL;

typedef GLboolean (APIENTRY * PFNGLISRENDERBUFFEREXTPROC) (GLuint renderbuffer);
PFNGLISRENDERBUFFEREXTPROC glIsRenderbufferEXT = NULL;

typedef void (APIENTRY * PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC glRenderbufferStorageMultisampleEXT  = NULL;

typedef void (APIENTRY * PFNGLBLITFRAMEBUFFEREXT)(	GLint,GLint,GLint,GLint,GLint,GLint,GLint,GLint,GLbitfield,GLenum);	
PFNGLBLITFRAMEBUFFEREXT glBlitFramebufferEXT = NULL;

////MISC
typedef void (APIENTRY * PFNGLGENERATEMIPMAPEXTPROC) (GLenum texture);
PFNGLGENERATEMIPMAPEXTPROC glGenerateMipmapEXT = NULL;
#endif


////////////////////////////////////////////////////////////// Profiling ////////////////////////////////////////////////////////
#ifdef DO_PROFILE
namespace Profile {

//// out

class LStrFile {
public:
	const static char* NUM_PATTERNS_TAG;
	const static char* PATTERN_TAG;
	const static char* NO_STR_VAL;

	enum _e_consts 
	{
		eMaxStringLen = 300
	};

	enum _e_errcodes 
	{
		eOK = 1,
		eIOError = 0,	//GetLastError() should be used for details
		eTagError = -1,
		eDataError = -2
	};

    LStrFile(const char *filename,const char *mode)
{ 
	_stream() = NULL; 
	Open(filename, mode); 
}
    ~LStrFile()	
{
	Close();
}

	bool IsNULL() const {return stream() == NULL;}
    
	int	Close()     
{
	int result=0;
    if(stream()) 
		result = fclose(_stream());
    
	_stream() = NULL;
    return result; 
}
    bool Open(const char *filename,const char *mode)
{
	Close(); 
	_stream() = fopen(filename,mode);
	//errno_t err = fopen_s(&_stream(),filename,mode);  //vc8.0 stuff
	return (stream() != NULL);
}

	int Write(const char* buf)
{
	if(stream())
	{
		int res = fprintf(_stream(),"%s",buf);
		//int res = fprintf_s(_stream(),"[%s] %i [/%s] \n",NUM_PATTERNS_TAG, n, NUM_PATTERNS_TAG); //vc8.0 stuff
		if(res > 0)
			fflush(_stream());

		return (res > 0) ? eOK : eIOError;
	}
	return eOK;
}

protected:
	inline const  FILE* stream() const {return m_stream;}
	inline FILE*& _stream() {return m_stream;}

private:
    FILE* m_stream;
	
};

class LDiagFile {
public:
	LStrFile* diagDump;
	LDiagFile()
	{		
		diagDump = NULL;
	}
	~LDiagFile()
	{		
		if(diagDump)
			delete diagDump;
	}
};
static LDiagFile diag;



LStrFile* OpenDiagFile()
{
	MString mdir;
	MGlobal::executeCommand("internalVar -userTmpDir",mdir);
	if(mdir != "")
	{	
		MString log = mdir + "shave_profile.log";
		

		diag.diagDump = new LStrFile(log.asChar(),"wt");

		if(diag.diagDump->IsNULL())
		{
			printf("Shave: can't write log to %s\n",log.asChar());
			fflush(stdout);

			MGlobal::displayError(MString("Shave: can't write log to ") + log);

			return NULL;
		}
		MGlobal::displayInfo(MString("LipService: writing log to ") + log);
		return diag.diagDump;
	}
	else
	{
		printf("cant write log, internalVar -userBitmapsDir returned empty path\n");
		fflush(stdout);
		return NULL;
	}
}

void  CloseDiagFile()
{
	if(diag.diagDump)
	{
		delete diag.diagDump;
		diag.diagDump = NULL;
	}
}

LStrFile* GetDiagFile()
{
	return diag.diagDump;
}

//// frofile functions

int numZeros(long N) //nuber of traling zeros for nano
{
	int d = 0;
	while(N > 0) {
    d++;
    N/=10;
	}
	int z = 9 - d;
	return z;
}

static bool just_started = false;
#ifdef WIN32
//static unsigned int last = 0;
//static unsigned int start = 0;
LARGE_INTEGER last;
LARGE_INTEGER start;
#elif defined(LINUX)
timespec last;
timespec start;

timespec diff(timespec start, timespec end)
{
	timespec temp;
	if ((end.tv_nsec-start.tv_nsec)<0) {
		temp.tv_sec = end.tv_sec-start.tv_sec-1;
		temp.tv_nsec = 1000000000+end.tv_nsec-start.tv_nsec;
	} else {
		temp.tv_sec = end.tv_sec-start.tv_sec;
		temp.tv_nsec = end.tv_nsec-start.tv_nsec;
	}
	return temp;
}
#endif



void ProfileStart(LStrFile* f)
{
	if(f==NULL)
		f = OpenDiagFile();

	just_started = true;

	char tbuf[100];
    time_t t = time(0);   
    struct tm* tnow = localtime(&t);
	sprintf(tbuf,"%i:%i:%i", tnow->tm_hour, tnow->tm_min, tnow->tm_sec);

#ifdef WIN32
#if 0
	QueryPerformanceCounter(&last);
	QueryPerformanceCounter(&start);
#endif
	if(f)
	{
		char buf[100]; sprintf(buf,"[%s] initalized \n",tbuf);
		f->Write(buf);
	}
	else
	{
		fprintf(stdout,"[%s] initalized\n",tbuf);
		fflush(stdout);
	}
#elif defined(LINUX)
#if 0
	int res1 = clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start);
	int res2 = clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &last);

	if(f)
	{
		char buf[100];
		if(res1 != -1 && res2 != -1)
			sprintf(buf,"[%s] initalized \n",tbuf);
		else 
			sprintf(buf,"Profiling: start failed!\n");

		f->Write(buf);
	}
	else
	{
		if(res1 != -1 && res2 != -1)
			fprintf(stdout,"[%s] initalized\n",tbuf);
		else
			fprintf(stdout,"Profiling: failed!\n");

		fflush(stdout);
	}
#else
	if(f)
	{
		char buf[100]; sprintf(buf,"[%s] initalized\n",tbuf);
		f->Write(buf);
	}
	else
	{
		fprintf(stdout,"[%s] initalized\n",tbuf);
		fflush(stdout);
	}
#endif

#else
	
#endif

}

void ProfileDump(char* msg, LStrFile* f)
{
	if(f==NULL)
		f=GetDiagFile();
		
	char tbuf[100];
    time_t t = time(0);   
    struct tm* now = localtime(&t);
	sprintf(tbuf,"%i:%i:%i", now->tm_hour, now->tm_min, now->tm_sec);

	if(just_started)
	{
#ifdef WIN32
		QueryPerformanceCounter(&last);
		QueryPerformanceCounter(&start);

		if(f)
		{
			char buf[100]; sprintf(buf,"[%s] started | %s\n",tbuf,msg);
			f->Write(buf);
		}
		else
		{
			fprintf(stdout,"[%s] started | %s \n",tbuf,msg);
			fflush(stdout);
		}
#elif defined(LINUX)
	int res1 = clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start);
	int res2 = clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &last);

	if(f)
	{
		char buf[100];
		if(res1 != -1 && res2 != -1)
			sprintf(buf,"[%s] started | %s\n",tbuf,msg);
		else 
			sprintf(buf,"Profiling: start failed! | %s\n",msg);

		f->Write(buf);
	}
	else
	{
		if(res1 != -1 && res2 != -1)
			fprintf(stdout,"[%s] started | %s\n",tbuf,msg);
		else
			fprintf(stdout,"Profiling: start failed! | %s\n",msg);

		fflush(stdout);
	}
#else
	
#endif
		just_started = false;
	}
	else
	{
#ifdef WIN32
		LARGE_INTEGER now;
		QueryPerformanceCounter(&now);

		LARGE_INTEGER freq;
		QueryPerformanceFrequency(&freq);

		long long from_start = now.QuadPart - start.QuadPart;
		long long from_last  = now.QuadPart - last.QuadPart;

		last = now;
		float t1 = (float)(from_last*1000.0/freq.QuadPart);
		float t2 = (float)(from_start*1000.0/freq.QuadPart);
		if(f)
		{
			char buf[200];sprintf(buf,"[%s] %f (total %f) | %s\n",tbuf,t1,t2,msg);
			f->Write(buf);
		}
		else
		{
			fprintf(stdout,"[%s] %f  (total %f) | %s\n",tbuf,t1,t2,msg);
			fflush(stdout);
		}
		/////////////
		//int s, n;
		//char buf0[20] = ""; int nz = numZeros(n);for(int k = 0; k < nz; k++) strcat(buf0,"0");
		//char buf[200];sprintf(buf,"[%s] %u.%u (total %u.%u) | %s\n",tbuf,s,buf0,n);
		////////////
#elif defined(LINUX)
		timespec now;
		int res = clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &now);
		if(res != -1)
		{
			timespec tdiff = diff(last,now);
			timespec tdiff2 = diff(start,now);
			last=now;

			char buf1[20] = ""; int nz1 = numZeros(tdiff.tv_nsec);for(int k = 0; k < nz1; k++) strcat(buf1,"0");
			char buf2[20] = ""; int nz2 = numZeros(tdiff2.tv_nsec);for(int k = 0; k < nz2; k++) strcat(buf2,"0");
			char buf[200];sprintf(buf,"[%s] %u.%s%u (total %u.%s%u) | %s\n",tbuf,
				(unsigned int)tdiff.tv_sec, buf1, (unsigned int)tdiff.tv_nsec,
				(unsigned int)tdiff2.tv_sec, buf2, (unsigned int)tdiff2.tv_nsec,
				msg);

			if(f)
			{
				
				f->Write(buf);
			}
			else
			{
				fprintf(stdout,"%s\n",buf);
				fflush(stdout);
			}
		}
#endif
	}
	
}

void ProfileEnd(LStrFile* f)
{
	if(f==NULL)
		f=GetDiagFile();

	char tbuf[100];
    time_t t = time(0);   
    struct tm* fnow = localtime(&t);
	sprintf(tbuf,"%i:%i:%i", fnow->tm_hour, fnow->tm_min, fnow->tm_sec);

#ifdef WIN32
	LARGE_INTEGER now;
	QueryPerformanceCounter(&now);

	LARGE_INTEGER freq;
	QueryPerformanceFrequency(&freq);

	long long from_start = now.QuadPart - start.QuadPart;

	if(f)
	{
		char buf[200];sprintf(buf,"[%s] finished: %f\n",tbuf,(float)(from_start*1000.0/freq.QuadPart));
		f->Write(buf);
	}
	else
	{
		fprintf(stdout,"[%s] finished: %f \n",tbuf,(float)(from_start*1000.0/freq.QuadPart));
		fflush(stdout);
	}
#elif defined(LINUX)
	timespec now;
	int res = clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &now);
	if(res != -1)
	{
		timespec tdiff = diff(start,now);
		now = last;
		char buf1[20] = ""; int nz1 = numZeros(tdiff.tv_nsec);for(int k = 0; k < nz1; k++) strcat(buf1,"0");
		char buf[200];sprintf(buf,"[%s] finished: %u.%s%u \n",tbuf,(unsigned int)tdiff.tv_sec, buf1, (unsigned int)tdiff.tv_nsec);
		if(f)
		{
			
			f->Write(buf);
		}
		else
		{
			fprintf(stdout,"%s\n",tbuf,(unsigned int)tdiff.tv_sec, (unsigned int)tdiff.tv_nsec);
			fflush(stdout);
		}
	}
#else
#endif	
}

} //end of namespace LServiceSDK
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


//////////////////////////// GL EXT INITIALIZATION ////////////////////////////

static bool glFuncionsInited = false;

bool GLFunctionsInited()
{
	return glFuncionsInited;
}

bool InitGLFunctionPointers()
{
#ifdef _WIN32
	assert(_CrtCheckMemory());
#endif

	bool ret=true;
	MGlobal::displayInfo("InitGLFunctionPointers");

	//// these are delcalred in OSX's gl.h so no need to get ptrs
#ifdef WIN32
	//glNewBufferRegionEXT = (PFNGLNEWBUFFERREGIONEXTPROC) getGlFncPtr("glNewBufferRegionEXT");
//	if(!glNewBufferRegionEXT)
//	{
//		MGlobal::displayInfo(MString("glNewBufferRegionEXTT not found (error")+ GetLastError() + ")");
//		return false;
//	}

//glDeleteBufferRegionEXT = (PFNGLDELETEBUFFERREGIONEXTPROC) getGlFncPtr("glDeleteBufferRegionEXT");
//	if(!glDeleteBufferRegionEXT)
//	{
//		MGlobal::displayInfo(MString("glDeleteBufferRegionEXT not found (error")+ GetLastError() + ")");
//		ret= false;
//	}

//glReadBufferRegionEXT = (PFNGLREADBUFFERREGIONEXTPROC) getGlFncPtr("glReadBufferRegionEXT");
//	if(!glReadBufferRegionEXT)
//	{
//		MGlobal::displayInfo(MString("glReadBufferRegionEXT not found (error")+ GetLastError() + ")");
//		ret= false;
//	}

//glDrawBufferRegionEXT = (PFNGLDRAWBUFFERREGIONEXTPROC) getGlFncPtr("glDrawBufferRegionEXT");
//	if(!glDrawBufferRegionEXT)
//	{
//		MGlobal::displayInfo(MString("glDrawBufferRegionEXT not found (error")+ GetLastError() + ")");
//		ret= false;
//	}

//glBufferRegionEnabledEXT = (PFNGLBUFFERREGIONENABLEDEXTPROC) getGlFncPtr("glBufferRegionEnabledEXT");
//	if(!glBufferRegionEnabledEXT)
//	{
//		MGlobal::displayInfo(MString("glBufferRegionEnabledEXT not found (error")+ GetLastError() + ")");
//		ret= false;
//	}
	glActiveTexture = (PFNGLATCIVETEXTUREPROC) getGlFncPtr("glActiveTexture");
	if(!glActiveTexture)
	{
		MGlobal::displayInfo(MString("glActiveTexture not found (error")+ GetLastError() + ")");
		ret= false;
	}
	assert(_CrtCheckMemory());
#if 0
	glMultiTexCoord2f = (PFNGLMULTITEXCOORD2FPROC) getGlFncPtr("glMultiTexCoord2f");
	if(!glMultiTexCoord2f)
	{
		MGlobal::displayInfo(MString("glMultiTexCoord2f not found (error")+ GetLastError() + ")");
		ret= false;
	}
#endif
	glAttachShader = (PFNGATTACHSHADERPROC) getGlFncPtr("glAttachShader");
	if(!glAttachShader)
	{
		MGlobal::displayInfo(MString("glAttachShader not found (error")+ GetLastError() + ")");
		ret= false;
	}
	//	ret= false;

	glCompileShader = (PFNGLCOMPILESHADERPROC) getGlFncPtr("glCompileShader");
	if(!glCompileShader)
	{
		MGlobal::displayInfo(MString("glCompileShader not found (error")+ GetLastError() + ")");
		ret= false;
	}

	glDetachShader = (PFNGLDETACHSHADERPROC) getGlFncPtr("glDetachShader");
	if(!glDetachShader)
	{
		MGlobal::displayInfo(MString("glDetachShader not found (error")+ GetLastError() + ")");
		ret= false;
	}

	glDeleteShader = (PFNGLDELETESHADERPROC) getGlFncPtr("glDeleteShader");
	if(!glDeleteShader)
	{
		MGlobal::displayInfo(MString("glDeleteShader not found (error")+ GetLastError() + ")");
		ret= false;
	}

	glCreateShader = (PFNGLCREATESHADERPROC) getGlFncPtr("glCreateShader");
	if(!glCreateShader)
	{
		MGlobal::displayInfo(MString("glCreateShader not found (error")+ GetLastError() + ")");
		ret= false;
	}

	glShaderSource = (PFNGLSHADERSOURCEPROC) getGlFncPtr("glShaderSource");
	if(!glShaderSource)
	{
		MGlobal::displayInfo(MString("glShaderSource not found (error")+ GetLastError() + ")");
		ret= false;
	}

	glGetShaderiv = (PFNGLGETSHADDERIVPROC) getGlFncPtr("glGetShaderiv");
	if(!glGetShaderiv)
	{
		MGlobal::displayInfo(MString("glGetShaderiv not found (error")+ GetLastError() + ")");
		ret= false;
	}

	glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC) getGlFncPtr("glGetShaderInfoLog");
	if(!glGetShaderInfoLog)
	{
		MGlobal::displayInfo(MString("glGetShaderInfoLog not found (error")+ GetLastError() + ")");
		ret= false;
	}

	glDeleteProgram = (PFNGLDELETEPROGRAMPROC) getGlFncPtr("glDeleteProgram");
	if(!glDeleteProgram)
	{
		MGlobal::displayInfo(MString("glDeleteProgram not found (error")+ GetLastError() + ")");
		ret= false;
	}

	glCreateProgram = (PFNGLCREATEPROGRAMPROC) getGlFncPtr("glCreateProgram");
	if(!glCreateProgram)
	{
		MGlobal::displayInfo(MString("glCreateProgram not found (error")+ GetLastError() + ")");
		ret= false;
	}

	glLinkProgram = (PFNGLLINKPROGRAMPROC) getGlFncPtr("glLinkProgram");
	if(!glLinkProgram)
	{
		MGlobal::displayInfo(MString("glLinkProgram not found (error")+ GetLastError() + ")");
		ret= false;
	}

	glUseProgram = (PFNGLUSEPROGRAMPROC) getGlFncPtr("glUseProgram");
	if(!glUseProgram)
	{
		MGlobal::displayInfo(MString("glUseProgram not found (error")+ GetLastError() + ")");
		ret= false;
	}

	glGetProgramiv = (PFNGLGETPROGRAMIVPROC) getGlFncPtr("glGetProgramiv");
	if(!glGetProgramiv)
	{
		MGlobal::displayInfo(MString("glGetProgramiv not found (error")+ GetLastError() + ")");
		ret= false;
	}

	glValidateProgram = (PFNVALIDATEPROGRAMPROC) getGlFncPtr("glValidateProgram");
	if(!glValidateProgram)
	{
		MGlobal::displayInfo(MString("glValidateProgram not found (error")+ GetLastError() + ")");
		ret= false;
	}

	glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC) getGlFncPtr("glGetProgramInfoLog");
	if(!glGetProgramInfoLog)
	{
		MGlobal::displayInfo(MString("glGetProgramInfoLog not found (error")+ GetLastError() + ")");
		ret= false;
	}

	glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC) getGlFncPtr("glGetUniformLocation");
	if(!glGetUniformLocation)
	{
		MGlobal::displayInfo(MString("glGetUniformLocation not found (error")+ GetLastError() + ")");
		ret= false;
	}

	glUniform3f = (PFNGLUNIFORM3FPROC) getGlFncPtr("glUniform3f");
	if(!glUniform3f)
	{
		MGlobal::displayInfo(MString("glUniform3f not found (error")+ GetLastError() + ")");
		ret= false;
	}

	glUniform1f = (PFNGLUNIFORM1FPROC) getGlFncPtr("glUniform1f");
	if(!glUniform1f)
	{
		MGlobal::displayInfo(MString("glUniform1f not found (error")+ GetLastError() + ")");
		ret= false;
	}

	glUniform1i = (PFNGLUNIFORM1IPROC) getGlFncPtr("glUniform1i");
	if(!glUniform1i)
	{
		MGlobal::displayInfo(MString("glUniform1i not found (error")+ GetLastError() + ")");
		ret= false;
	}

	glVertexAttrib1f = (PFNGLVERTEXATTRIB1FV) getGlFncPtr("glVertexAttrib1f");
	if(!glVertexAttrib1f)
	{
		MGlobal::displayInfo(MString("glVertexAttrib1f not found (error")+ GetLastError() + ")");
		ret= false;
	}

	glVertexAttrib3f = (PFNGLVERTEXATTRIB3FV) getGlFncPtr("glVertexAttrib3f");
	if(!glVertexAttrib3f)
	{
		MGlobal::displayInfo(MString("glVertexAttrib3f not found (error")+ GetLastError() + ")");
		ret= false;
	}

	glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTER) getGlFncPtr("glVertexAttribPointer");
	if(!glVertexAttribPointer)
	{
		MGlobal::displayInfo(MString("glVertexAttribPointer not found (error")+ GetLastError() + ")");
		ret= false;
	}

	glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAY) getGlFncPtr("glEnableVertexAttribArray");
	if(!glEnableVertexAttribArray)
	{
		MGlobal::displayInfo(MString("glEnableVertexAttribArray not found (error")+ GetLastError() + ")");
		ret= false;
	}

//	glWindowPos2i = (PFNGLWINDOWPOS2I) getGlFncPtr("glWindowPos2i");
//	if(!glWindowPos2i)
//	{
//		MGlobal::displayInfo(MString("glWindowPos2i not found (error")+ GetLastError() + ")");
//		ret= false;
//	}

//	glWindowPos3f = (PFNGLWINDOWPOS3F) getGlFncPtr("glWindowPos3f");
//	if(!glWindowPos3f)
//	{
//		MGlobal::displayInfo(MString("glWindowPos3f not found (error")+ GetLastError() + ")");
//		ret= false;
//	}

	glGetAttribLocation = (PFNGLGETATTRIBLOCATION) getGlFncPtr("glGetAttribLocation");
	if(!glGetAttribLocation)
	{
		MGlobal::displayInfo(MString("glGetAttribLocation not found (error")+ GetLastError() + ")");
		ret= false;
	}


	//PBO
//	glBindBufferARB = (PFNGLBINDBUFFERARBPROC) getGlFncPtr("glBindBufferARB");
//	glDeleteBuffersARB = (PFNGLDELETEBUFFERSARBPROC) getGlFncPtr("glDeleteBuffersARB");
//	glGenBuffersARB = (PFNGLGENBUFFERSARBPROC) getGlFncPtr("glGenBuffersARB");
//	glBufferDataARB = (PFNGLBUFFERDATAARBPROC) getGlFncPtr("glBufferDataARB");

//	if(!glBindBufferARB)
//	{
//		MGlobal::displayInfo(MString("glBindBufferARB not found (error")+ GetLastError() + ")");
//		ret= false;
//	}

	//FBOs
	glGenFramebuffersEXT  = (PFNGLGENFRAMEBUFFERSEXTPROC)wglGetProcAddress("glGenFramebuffersEXT");
	if(!glGenFramebuffersEXT)
	{
		MGlobal::displayInfo(MString("glGenFramebuffersEXT not found (error")+ GetLastError() + ")");
		ret= false;
	}
	glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC)wglGetProcAddress("glDeleteFramebuffersEXT");
	if(!glDeleteFramebuffersEXT)
	{
		MGlobal::displayInfo(MString("glDeleteFramebuffersEXT not found (error")+ GetLastError() + ")");
		ret= false;
	}
	glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC)wglGetProcAddress("glBindFramebufferEXT");
	if(!glBindFramebufferEXT)
	{
		MGlobal::displayInfo(MString("glBindFramebufferEXT not found (error")+ GetLastError() + ")");
		ret= false;
	}
	glCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)wglGetProcAddress("glCheckFramebufferStatusEXT");
	if(!glCheckFramebufferStatusEXT)
	{
		MGlobal::displayInfo(MString("glCheckFramebufferStatusEXT not found (error")+ GetLastError() + ")");
		ret= false;
	}
	glGetFramebufferAttachmentParameterivEXT = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)wglGetProcAddress("glGetFramebufferAttachmentParameterivEXT");
	if(!glGetFramebufferAttachmentParameterivEXT)
	{
		MGlobal::displayInfo(MString("glGetFramebufferAttachmentParameterivEXT not found (error")+ GetLastError() + ")");
		ret= false;
	}
	glFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)wglGetProcAddress("glFramebufferTexture2DEXT");
	if(!glFramebufferTexture2DEXT)
	{
		MGlobal::displayInfo(MString("glFramebufferTexture2DEXT not found (error")+ GetLastError() + ")");
		ret= false;
	}
	glFramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)wglGetProcAddress("glFramebufferRenderbufferEXT");
	if(!glFramebufferRenderbufferEXT)
	{
		MGlobal::displayInfo(MString("glFramebufferRenderbufferEXT not found (error")+ GetLastError() + ")");
		ret= false;
	}
	glGenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC)wglGetProcAddress("glGenRenderbuffersEXT");
	if(!glGenRenderbuffersEXT)
	{
		MGlobal::displayInfo(MString("glGenRenderbuffersEXT not found (error")+ GetLastError() + ")");
		ret= false;
	}
	glDeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC)wglGetProcAddress("glDeleteRenderbuffersEXT");
	if(!glDeleteRenderbuffersEXT)
	{
		MGlobal::displayInfo(MString("glDeleteRenderbuffersEXT not found (error")+ GetLastError() + ")");
		ret= false;
	}
	glBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC)wglGetProcAddress("glBindRenderbufferEXT");
	if(!glBindRenderbufferEXT)
	{
		MGlobal::displayInfo(MString("glBindRenderbufferEXT not found (error")+ GetLastError() + ")");
		ret= false;
	}
	glRenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXTPROC)wglGetProcAddress("glRenderbufferStorageEXT");
	if(!glRenderbufferStorageEXT)
	{
		MGlobal::displayInfo(MString("glRenderbufferStorageEXT not found (error")+ GetLastError() + ")");
		ret= false;
	}
	glGetRenderbufferParameterivEXT  = (PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC)wglGetProcAddress("glGetRenderbufferParameterivEXT");
	if(!glGetRenderbufferParameterivEXT)
	{
		MGlobal::displayInfo(MString("glGetRenderbufferParameterivEXT not found (error")+ GetLastError() + ")");
		ret= false;
	}
	glIsRenderbufferEXT = (PFNGLISRENDERBUFFEREXTPROC)wglGetProcAddress("glIsRenderbufferEXT");
	if(!glIsRenderbufferEXT)
	{
		MGlobal::displayInfo(MString("glIsRenderbufferEXT not found (error")+ GetLastError() + ")");
		ret= false;
	}
	glRenderbufferStorageMultisampleEXT = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC)getGlFncPtr("glRenderbufferStorageMultisampleEXT");
	if(!glRenderbufferStorageMultisampleEXT)
	{
		MGlobal::displayInfo(MString("glRenderbufferStorageMultisampleEXT not found (error")+ GetLastError() + ")");
		ret= false;
	}
	glBlitFramebufferEXT = (PFNGLBLITFRAMEBUFFEREXT)getGlFncPtr("glBlitFramebufferEXT");
	if(!glBlitFramebufferEXT)
	{
		MGlobal::displayInfo(MString("glBlitFramebufferEXT not found (error")+ GetLastError() + ")");
		ret= false;
	}
	glGenerateMipmapEXT = (PFNGLGENERATEMIPMAPEXTPROC) getGlFncPtr("glGenerateMipmapEXT");
	if(!glGenerateMipmapEXT)
	{
		MGlobal::displayInfo(MString("glGenerateMipmapEXT not found (error")+ GetLastError() + ")");
		ret= false;
	}

#elif defined LINUX

	//glBindBufferARB = (PFNGLBINDBUFFERARBPROC) getGlFncPtr("glBindBufferARB");
	//if(!glBindBufferARB)
	//{
	//	fprintf (stdout,"glAttachShader and glBindBufferARB not found\n");fflush(stdout);
	//	ret= false;
	//}
	//glDeleteBuffersARB = (PFNGLDELETEBUFFERSARBPROC) getGlFncPtr("glDeleteBuffersARB");
	//if(!glDeleteBuffersARB)
	//{
	//	fprintf (stdout,"glAttachShader and glDeleteBuffersARB not found\n");fflush(stdout);
	//	ret= false;
	//}
	//glGenBuffersARB = (PFNGLGENBUFFERSARBPROC) getGlFncPtr("glGenBuffersARB");
	//if(!glGenBuffersARB)
	//{
	//	fprintf (stdout,"glAttachShader and glGenBuffersARB not found\n");fflush(stdout);
	//	ret= false;
	//}
	//glBufferDataARB = (PFNGLBUFFERDATAARBPROC) getGlFncPtr("glBufferDataARB");
	//if(!glBufferDataARB)
	//{
	//	fprintf (stdout,"glAttachShader and glBufferDataARB not found\n");fflush(stdout);
	//	ret= false;
	//}

	glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTER) getGlFncPtr("glVertexAttribPointer");
	if(!glVertexAttribPointer)
	{
		fprintf (stdout,"glAttachShader and glVertexAttribPointer not found\n");fflush(stdout);
		ret= false;
	}

	glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAY) getGlFncPtr("glEnableVertexAttribArray");
	if(!glEnableVertexAttribArray)
	{
		fprintf (stdout,"glAttachShader and glEnableVertexAttribArray not found\n");fflush(stdout);
		ret= false;
	}


#ifndef GL_ACTIVE_TEXTURE
	glActiveTexture = (PFNGLATCIVETEXTUREPROC) getGlFncPtr("glActiveTexture");
	if(!glActiveTexture)
	{
		fprintf (stdout,"glActiveTexture not found \n");fflush(stdout);
		ret= false;
	}
#endif
	//glMultiTexCoord2f = (PFNGLMULTITEXCOORD2FPROC) getGlFncPtr("glMultiTexCoord2f");
	//if(!glMultiTexCoord2f)
	//{
	//	fprintf (stdout,"glMultiTexCoord2f not found \n");fflush(stdout);
	//	ret= false;
	//}
	glAttachShader = (PFNGATTACHSHADERPROC) getGlFncPtr("glAttachShader");
	if(!glAttachShader)
	{
		glAttachShader = (PFNGATTACHSHADERPROC) getGlFncPtr("glAttachObjectARB");
		if(!glAttachShader)
		{
			fprintf (stdout,"glAttachShader and glAttachObjectARB not found\n");fflush(stdout);
			ret= false;
		}
		else
			fprintf (stdout,"glAttachObjectARB - OK\n");
	}
	else
		fprintf (stdout,"glAttachShader - OK\n");

	glCompileShader = (PFNGLCOMPILESHADERPROC) getGlFncPtr("glCompileShader");
	if(!glCompileShader)
	{
		fprintf (stdout,"glCompileShader not found \n");fflush(stdout);
		ret= false;
	}

	glDetachShader = (PFNGLDETACHSHADERPROC) getGlFncPtr("glDetachShader");
	if(!glDetachShader)
	{
		fprintf (stdout,"glDetachShader not found \n");fflush(stdout);
		ret= false;
	}

	glDeleteShader = (PFNGLDELETESHADERPROC) getGlFncPtr("glDeleteShader");
	if(!glDeleteShader)
	{
		fprintf (stdout,"glDeleteShader not found \n");fflush(stdout);
		ret= false;
	}

	glCreateShader = (PFNGLCREATESHADERPROC) getGlFncPtr("glCreateShader");
	if(!glCreateShader)
	{
		fprintf (stdout,"glCreateShader not found \n");fflush(stdout);
		ret= false;
	}

	glShaderSource = (PFNGLSHADERSOURCEPROC) getGlFncPtr("glShaderSource");
	if(!glShaderSource)
	{
		fprintf (stdout,"glShaderSource not found\n");fflush(stdout);
		ret= false;
	}

	glGetShaderiv = (PFNGLGETSHADDERIVPROC) getGlFncPtr("glGetShaderiv");
	if(!glGetShaderiv)
	{
		fprintf (stdout,"glGetShaderiv not found\n");fflush(stdout);
		ret= false;
	}

	glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC) getGlFncPtr("glGetShaderInfoLog");
	if(!glGetShaderInfoLog)
	{
		fprintf (stdout,"glGetShaderInfoLog not found \n");fflush(stdout);
		ret= false;
	}

	glDeleteProgram = (PFNGLDELETEPROGRAMPROC) getGlFncPtr("glDeleteProgram");
	if(!glDeleteProgram)
	{
		fprintf (stdout,"glDeleteProgram not found\n");fflush(stdout);
		ret= false;
	}

	glCreateProgram = (PFNGLCREATEPROGRAMPROC) getGlFncPtr("glCreateProgram");
	if(!glCreateProgram)
	{
		fprintf (stdout,"glCreateProgram not found \n");fflush(stdout);
		ret= false;
	}

	glLinkProgram = (PFNGLLINKPROGRAMPROC) getGlFncPtr("glLinkProgram");
	if(!glLinkProgram)
	{
		fprintf (stdout,"glLinkProgram not found \n");fflush(stdout);
		ret= false;
	}

	glUseProgram = (PFNGLUSEPROGRAMPROC) getGlFncPtr("glUseProgram");
	if(!glUseProgram)
	{
		fprintf (stdout,"glUseProgram not found\n");fflush(stdout);
		ret= false;
	}

	glGetProgramiv = (PFNGLGETPROGRAMIVPROC) getGlFncPtr("glGetProgramiv");
	if(!glGetProgramiv)
	{
		fprintf (stdout,"glGetProgramiv not found\n");fflush(stdout);
		ret= false;
	}

	glValidateProgram = (PFNVALIDATEPROGRAMPROC) getGlFncPtr("glValidateProgram");
	if(!glValidateProgram)
	{
		fprintf (stdout,"glValidateProgram not found \n");fflush(stdout);
		ret= false;
	}

	glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC) getGlFncPtr("glGetProgramInfoLog");
	if(!glGetProgramInfoLog)
	{
		fprintf (stdout,"glGetProgramInfoLog not found\n");fflush(stdout);
		ret= false;
	}

	glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC) getGlFncPtr("glGetUniformLocation");
	if(!glGetUniformLocation)
	{
		fprintf (stdout,"glGetUniformLocation not found\n");fflush(stdout);
		ret= false;
	}

	glUniform3f = (PFNGLUNIFORM3FPROC) getGlFncPtr("glUniform3f");
	if(!glUniform3f)
	{
		fprintf (stdout,"glUniform3f not found\n");fflush(stdout);
		ret= false;
	}

	glUniform1f = (PFNGLUNIFORM1FPROC) getGlFncPtr("glUniform1f");
	if(!glUniform1f)
	{
		fprintf (stdout,"glUniform1f not found \n");fflush(stdout);
		ret= false;
	}

	glUniform1i = (PFNGLUNIFORM1IPROC) getGlFncPtr("glUniform1i");
	if(!glUniform1i)
	{
		fprintf (stdout,"glUniform1i not found \n");fflush(stdout);
		ret= false;
	}

	glGetAttribLocation = (PFNGLGETATTRIBLOCATION) getGlFncPtr("glGetAttribLocation");
	if(!glGetAttribLocation)
	{
		fprintf (stdout,"glGetAttribLocation not found\n");fflush(stdout);
		ret= false;
	}

	glVertexAttrib1f = (PFNGLVERTEXATTRIB1FV) getGlFncPtr("glVertexAttrib1f");
	if(!glVertexAttrib1f)
	{
		fprintf (stdout,"glVertexAttrib1f not found\n");fflush(stdout);
		ret= false;
	}

	glVertexAttrib3f = (PFNGLVERTEXATTRIB3FV) getGlFncPtr("glVertexAttrib3f");
	if(!glVertexAttrib3f)
	{
		fprintf (stdout,"glVertexAttrib3f not found\n");fflush(stdout);
		ret= false;
	}
	//glWindowPos2i = (PFNGLWINDOWPOS2I) getGlFncPtr("glWindowPos2i");
	//if(!glWindowPos2i)
	//{
	//	fprintf (stdout,"glWindowPos2i not found\n");fflush(stdout);
	//	ret= false;
	//}
	//FBOs
	glGenFramebuffersEXT  = (PFNGLGENFRAMEBUFFERSEXTPROC)getGlFncPtr("glGenFramebuffersEXT");
	if(!glGenFramebuffersEXT)
	{
		fprintf (stdout,"glGenFramebuffersEXT not found.\n");fflush(stdout);
		ret= false;
	}
	glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC)getGlFncPtr("glDeleteFramebuffersEXT");
	if(!glDeleteFramebuffersEXT)
	{
		fprintf (stdout,"glDeleteFramebuffersEXT not found.\n");fflush(stdout);
		ret= false;
	}
	glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC)getGlFncPtr("glBindFramebufferEXT");
	if(!glBindFramebufferEXT)
	{
		fprintf (stdout,"glBindFramebufferEXT not found.\n");fflush(stdout);
		ret= false;
	}
	glCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)getGlFncPtr("glCheckFramebufferStatusEXT");
	if(!glCheckFramebufferStatusEXT)
	{
		fprintf (stdout,"glCheckFramebufferStatusEXT not found.\n");fflush(stdout);
		ret= false;
	}
	glGetFramebufferAttachmentParameterivEXT = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)getGlFncPtr("glGetFramebufferAttachmentParameterivEXT");
	if(!glGetFramebufferAttachmentParameterivEXT)
	{
		fprintf (stdout,"glGetFramebufferAttachmentParameterivEXT not found.\n");fflush(stdout);
		ret= false;
	}
	glFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)getGlFncPtr("glFramebufferTexture2DEXT");
	if(!glFramebufferTexture2DEXT)
	{
		fprintf (stdout,"glFramebufferTexture2DEXT not found.\n");fflush(stdout);
		ret= false;
	}
	glFramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)getGlFncPtr("glFramebufferRenderbufferEXT");
	if(!glFramebufferRenderbufferEXT)
	{
		fprintf (stdout,"glFramebufferRenderbufferEXT not found.\n");fflush(stdout);
		ret= false;
	}
	glGenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC)getGlFncPtr("glGenRenderbuffersEXT");
	if(!glGenRenderbuffersEXT)
	{
		fprintf (stdout,"glGenRenderbuffersEXT not found.\n");fflush(stdout);
		ret= false;
	}
	glDeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC)getGlFncPtr("glDeleteRenderbuffersEXT");
	if(!glDeleteRenderbuffersEXT)
	{
		fprintf (stdout,"glDeleteRenderbuffersEXT not found.\n");fflush(stdout);
		ret= false;
	}
	glBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC)getGlFncPtr("glBindRenderbufferEXT");
	if(!glBindRenderbufferEXT)
	{
		fprintf (stdout,"glBindRenderbufferEXT not found.\n");fflush(stdout);
		ret= false;
	}
	glRenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXTPROC)getGlFncPtr("glRenderbufferStorageEXT");
	if(!glRenderbufferStorageEXT)
	{
		fprintf (stdout,"glRenderbufferStorageEXT not found.\n");fflush(stdout);
		ret= false;
	}
	glGetRenderbufferParameterivEXT  = (PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC)getGlFncPtr("glGetRenderbufferParameterivEXT");
	if(!glGetRenderbufferParameterivEXT)
	{
		fprintf (stdout,"glGetRenderbufferParameterivEXT not found.\n");fflush(stdout);
		ret= false;
	}
	glIsRenderbufferEXT = (PFNGLISRENDERBUFFEREXTPROC)getGlFncPtr("glIsRenderbufferEXT");
	if(!glIsRenderbufferEXT)
	{
		fprintf (stdout,"glIsRenderbufferEXT not found.\n");fflush(stdout);
		ret= false;
	}

#endif

	//////////// paltform dependent stufff //////////////
#ifdef WIN32
	//wglShareLists = (PFWGLSHARELISTS) wglGetProcAddress("wglShareLists");
	//if(!wglShareLists)
	//{
	//	fprintf (stdout,"wglShareLists not found (error %i)\n",GetLastError());fflush(stdout);
	//	// ret= false;
	//}
#ifdef USE_PBUFFER
	wglCreatePbufferARB = (PFNWGLCREATEPBUFFERARBPROC) getGlFncPtr("wglCreatePbufferARB");
	if(!wglCreatePbufferARB)
	{
		fprintf (stdout,"wglCreatePbufferARB not found (error %i)\n",GetLastError());fflush(stdout);
		ret= false;
	}

	wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC) getGlFncPtr("wglChoosePixelFormatARB");
	if(!wglChoosePixelFormatARB)
	{
		fprintf (stdout,"wglChoosePixelFormatARB not found (error %i)\n",GetLastError());fflush(stdout);
		ret= false;
	}

	wglGetPbufferDCARB = (PFNWGLGETPBUFFERDCARBPROC) getGlFncPtr("wglGetPbufferDCARB");
	if(!wglGetPbufferDCARB)
	{
		fprintf (stdout,"wglGetPbufferDCARB not found (error %i)\n",GetLastError());fflush(stdout);
		ret= false;
	}

	wglReleasePbufferDCARB = (PFNWGLRELEASEPBUFFERDCARBPROC) getGlFncPtr("wglReleasePbufferDCARB");
	if(!wglReleasePbufferDCARB)
	{
		fprintf (stdout,"wglReleasePbufferDCARB not found (error %i)\n",GetLastError());fflush(stdout);
		ret= false;
	}

	wglDestroyPbufferARB = (PFNWGLDESTROYPBUFFERPROC) getGlFncPtr("wglDestroyPbufferARB");
	if(!wglDestroyPbufferARB)
	{
		fprintf (stdout,"wglDestroyPbufferARB not found (error %i)\n",GetLastError());fflush(stdout);
		ret= false;
	}

	wglQueryPbufferARB = (PFNWGLQUERYPBUFFERPROC) getGlFncPtr("wglQueryPbufferARB");
	if(!wglQueryPbufferARB)
	{
		fprintf (stdout,"wglQueryPbufferARB not found (error %i)\n",GetLastError());fflush(stdout);
		ret= false;
	}

	wglGetPixelFormatAttribivARB = (PFNWGLGETPIXELFORMATATTRBVARBPROC) getGlFncPtr("wglGetPixelFormatAttribivARB");
	if(!wglGetPixelFormatAttribivARB)
	{
		fprintf (stdout,"wglGetPixelFormatAttribivARB not found (error %i)\n",GetLastError());fflush(stdout);
		ret= false;
	}

	wglBindTexImageARB = (PFNWGLBINDTEXIMAGEARBPROC) getGlFncPtr("wglBindTexImageARB");
	if(!wglBindTexImageARB)
	{
		fprintf (stdout,"wglBindTexImageARB not found (error %i)\n",GetLastError());fflush(stdout);
		ret= false;
	}

	wglReleaseTexImageARB = (PFNWGLRELEASETEXIMAGEARB) getGlFncPtr("wglReleaseTexImageARB");
	if(!wglReleaseTexImageARB)
	{
		fprintf (stdout,"wglReleaseTexImageARB not found (error %i)\n",GetLastError());fflush(stdout);
		ret= false;
	}
#endif
#endif	//end of WIN32
	if(ret)
		glFuncionsInited = true;

#ifdef _WIN32
	assert(_CrtCheckMemory());
#endif
	return ret;
}

void FreeGLFunctionPointers()
{
	glFuncionsInited = false;
}


////////////////////////////// GLSL ///////////////////////////////////////////


/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~/
|					glslGenericProgram - generic glsl shader program				|
/~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/


const float cDefLightXDir = 0.0f;
const float cDefLightYDir = -0.5f;
const float cDefLightZDir = -1.0f;

glslGenericProgram::glslGenericProgram()
{
	//wglGetProcAddress("bla bla");

	_vShader() = 0;
	_fShader() = 0;
	_program() = 0;
	_numLights() = 0;

	//some default light dir
	AddLight();
	MVector dir(cDefLightXDir, cDefLightYDir, cDefLightZDir);
	//MVector pos(cDefLightXPos, cDefLightYPos, cDefLightZPos);
	dir.normalize();
	SetLightDir(0,dir);
	
	MVector pos = -20.0f*dir;
	SetLightPos(0,pos);

	s_vertexErrDumped = false;
	s_fragErrDumped = false;
	s_varErrDumped = false;
	s_linkErrDumped= false;

}


glslGenericProgram::~glslGenericProgram()
{
	if(vShader() && program())
	{
		glDetachShader(program(),vShader());
		glDeleteShader(vShader());
	}
	if(fShader() && program())
	{
		glDetachShader(program(),fShader());
		glDeleteShader(fShader());
	}
	if(program())
	{
		glUseProgram(0);
		glDeleteProgram(program());
	}
	glFlush();
}

bool glslGenericProgram::LoadShaders(char* vShaderFile, char* fShaderFile)
{

	_vShader() = glCreateShader(GL_VERTEX_SHADER);
	if(!loadShader( vShader(), vShaderFile)) 
	{
		 MGlobal::displayError(MString("Shave GLSL: unable to load vertex shader file ") + MString(vShaderFile));
		 return false;
	}
	
	_fShader() = glCreateShader(GL_FRAGMENT_SHADER);	
	if(!loadShader( fShader(), fShaderFile)) 
	{
	     MGlobal::displayError(MString("Shave GLSL: unable to load fragment shader file ") + MString(fShaderFile));
		 return false;
	}
	if(!compileShader(vShader(),eVertShader))
	{
		MGlobal::displayError("Shave GLSL: can not compile vertex shader\n");
		return false;
	}
	if(!compileShader(fShader(),eFragShader))
	{
		MGlobal::displayError("Shave GLSL: can not compile fragment shader\n");
		return false;
	}
	_program() = glCreateProgram();
	
	glAttachShader(program(),vShader());
	glAttachShader(program(),fShader());

	if(!linkProgram(program()))
	{
		MGlobal::displayError("Shave GLSL: can not link program\n");
		return false;
	}
	
	return true;
}

bool glslGenericProgram::LoadShaders()
{
	_vShader() = glCreateShader(GL_VERTEX_SHADER);
	loadVertShader( vShader()); 
	
	_fShader() = glCreateShader(GL_FRAGMENT_SHADER);	
	loadFragShader( fShader()); 
	
	if(!compileShader(vShader(),eVertShader))
	{
		MGlobal::displayError("Shave GLSL: can not compile vertex shader\n");
		return false;
	}
	if(!compileShader(fShader(),eFragShader))
	{
		MGlobal::displayError("Shave GLSL: can not compile fragment shader\n");
		return false;
	}
	
	_program() = glCreateProgram();

	
	glAttachShader(program(),vShader());
	glAttachShader(program(),fShader());

	
	if(!linkProgram(program()))
	{
		MGlobal::displayError("Shave GLSL: can not link program\n");
		return false;
	}
	
	return true;
}

void glslGenericProgram::UnLoadShaders()
{
	if(vShader() && program())
	{
		glDetachShader(program(),vShader());
		glDeleteShader(vShader());
	}
	if(fShader() && program())
	{
		glDetachShader(program(),fShader());
		glDeleteShader(fShader());
	}
	if(program())
	{
		glUseProgram(0);
		glDeleteProgram(program());
	}
}

bool glslGenericProgram::IsVadlid() const
{
	GLint   validStatus;
	glValidateProgram(program());

	glGetProgramiv(program(), GL_VALIDATE_STATUS, &validStatus);
	return (validStatus == GL_TRUE);
}
		
bool glslGenericProgram::UseProgram()
{
	if(!program() || !vShader() || !fShader())
		return false;

	GLint   validStatus;
	glValidateProgram(program());

	glGetProgramiv(program(), GL_VALIDATE_STATUS, &validStatus);
	if(validStatus != GL_TRUE)
	{
		MGlobal::displayError("Shave GLSL: program is not valid");

		UnLoadShaders();
		LoadShaders();

		//weird but we can not retrieve log
		//char* infoLog;
		//GLint infoLogLength;
		//glGetProgramiv(program(), GL_INFO_LOG_LENGTH, &infoLogLength);
		//if(infoLogLength)
		//{
		//	infoLog = (char*) malloc(infoLogLength);

		//	glGetProgramInfoLog(program(), infoLogLength, NULL, infoLog);

		//	MGlobal::displayInfo(MString("Info Log:\n\n") + MString(infoLog));

		//	free(infoLog);
		//}
	}
	glUseProgram(program());

	//if we do not share resouces between contexts it can happen that shader was
	//compiled when different context was ative so it becomes unusable for current one.
	//we need to recompile shaders in this case for active context -- dub|16-02-2009
	if(!setupUniformVariables())
	{
		UnLoadShaders();
		LoadShaders();
		glUseProgram(program());
		setupUniformVariables();
	}

	return true;
}

bool glslGenericProgram::UnUseProgram()
{
	glUseProgram(0);

	return true;
}

bool glslGenericProgram::AddLight()
{
	if(numLights() < eMaxNumLights)
	{
		_numLights()++;
		return true;
	}
	return false;
}

bool glslGenericProgram::SetLightDir(int idx, float x, float y, float z)
{
	if(idx < numLights())
	{
		_lightDir(idx).x = x;
		_lightDir(idx).y = y;
		_lightDir(idx).z = z;

		_lightDir(idx).normalize();

		return true;
	}
	return false;
}

bool glslGenericProgram::SetLightDir(int idx, const MVector &p)
{
	if(idx < numLights())
	{
		
		_lightDir(idx) = p;
		_lightDir(idx).normalize();
		return true;
	}
	return false;
}

bool glslGenericProgram::SetLightPos(int idx, float x, float y, float z)
{
	if(idx < numLights())
	{
		_lightPos(idx).x = x;
		_lightPos(idx).y = y;
		_lightPos(idx).z = z;

		return true;
	}
	return false;
}

bool glslGenericProgram::SetLightPos(int idx, const MVector &p)
{
	if(idx < numLights())
	{
		_lightPos(idx) = p;
		return true;
	}
	return false;
}


int glslGenericProgram::GetNumLigths() const
{
	return numLights();
}

const MVector& glslGenericProgram::GetLightDir(int idx) const
{
	return lightDir(idx);
}


const MVector& glslGenericProgram::GetLightPos(int idx) const
{
	return lightPos(idx);
}
/*
|	protected methods
*/

bool glslGenericProgram::loadShader( GLuint shader, char* fn)
{
   FILE *fp;
   GLubyte *buf;
   GLint length;
   bool ret = true;

   if (!(fp = fopen(fn,"rb")))
   {
	   return false;
   }

   fseek(fp, 0, SEEK_END);
   length = ftell(fp);
   fseek(fp, 0, SEEK_SET);

   buf = new GLubyte[length+1];

   fread( buf, 1, length, fp);
   buf[length] = '\0'; // make it a regular C string so str* functions work

   glShaderSource( shader, 1, (const char**)&buf, &length);

   if (glGetError() != 0)
   {
      ret = false;
   }

   fclose(fp);

   delete []buf;

   return ret;
}


bool glslGenericProgram::compileShader(GLuint shader, int vert_or_frag)
{
	char *infoLog;
	GLint  infoLogLength = 0;
	GLint  compileStatus;   

	glCompileShader(shader);

	glGetShaderiv(shader, GL_COMPILE_STATUS, &compileStatus);
	glGetShaderiv(shader, GL_INFO_LOG_LENGTH,&infoLogLength);

	if(compileStatus == GL_TRUE)
		return true;


	if((vert_or_frag == eVertShader && !s_vertexErrDumped) || 
	  (vert_or_frag == eFragShader && !s_fragErrDumped))
	{
		MGlobal::displayInfo(MString("Shave GLSL: Compile status: ") + compileStatus + "\n\n");

		if (infoLogLength)
		{
			infoLog = (char*)malloc(infoLogLength);

			glGetShaderInfoLog(shader, infoLogLength, NULL, infoLog);

			MGlobal::displayInfo(MString("Info Log:\n\n") + MString(infoLog));

			free(infoLog);
		}
		if(vert_or_frag == eVertShader)
			s_vertexErrDumped = true;

		if(vert_or_frag == eFragShader)
			s_fragErrDumped = true;
	}

	return compileStatus != 0;
}



bool glslGenericProgram::linkProgram(GLuint glprog)
{
	char* infoLog;
	GLint   infoLogLength = 0;
	GLint   linkStatus;

	glLinkProgram(glprog);

	glGetProgramiv(glprog, GL_LINK_STATUS, &linkStatus);
	glGetProgramiv(glprog, GL_INFO_LOG_LENGTH, &infoLogLength);

	if(linkStatus == GL_TRUE)
		return true;

	if(!s_linkErrDumped)
	{
		MGlobal::displayInfo(MString("Shave GLSL: Link status: ") + linkStatus + "\n\n");

		if (infoLogLength)
		{
			infoLog = (char*) malloc(infoLogLength);

			glGetProgramInfoLog(glprog, infoLogLength, NULL, infoLog);

			MGlobal::displayInfo(MString("Info Log:\n\n") + MString(infoLog));

			free(infoLog);
		}
		s_linkErrDumped = true;
	}
	return linkStatus != 0;
}



/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~/
|					glslHairProgram - default glsl shader program				|
/~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/


glslHairProgram::glslHairProgram()
{
	_tangentLoc() = -1;
	_specTint() = MColor(1.0f, 1.0f, 1.0f);
	_specTint2() = MColor(0.0f, 0.0f, 0.0f);
	_ambdiff() = 0.4f;
	_specular() = 0.76f;
	_specAmt() = 1.0f;
	_useSSAO() = false;
}

glslHairProgram::~glslHairProgram()
{
}

bool glslHairProgram::setupUniformVariables()
{
	//if(numLights() > 0)
	{
		GLint location = glGetUniformLocation(program(), "lightDir");
		
		if(location != -1)
		{
			_lightDir(0).normalize();
			glUniform3f(location, (GLfloat)lightDir(0).x, (GLfloat)lightDir(0).y, (GLfloat)lightDir(0).z);
		}
		else 
		{
			MGlobal::displayError("default - uniform variable 'lightDir' not found.");

			char* infoLog;
			GLint infoLogLength = 0;
			glGetProgramiv(program(), GL_INFO_LOG_LENGTH, &infoLogLength);
			if(infoLogLength)
			{
				infoLog = (char*) malloc(infoLogLength);

				glGetProgramInfoLog(program(), infoLogLength, NULL, infoLog);

				MGlobal::displayInfo(MString("Info Log:\n\n") + MString(infoLog));

				free(infoLog);
			}
			return false;
		}
	}
	{
		GLint  location = glGetUniformLocation(program(),"ambdiff");
		if(location != -1)
			glUniform1f(location, ambdiff());
		else
		{
			MGlobal::displayError("uniform variable 'ambdiff' not found.");
			return false;
		}
	}
	{
		GLint  location = glGetUniformLocation(program(),"specular");
		if(location != -1)
			glUniform1f(location, specular()/**0.1f*/);
		else
		{
			MGlobal::displayError("uniform variable 'specular' not found.");
			return false;
		}
	}
	{
		GLint  location = glGetUniformLocation(program(),"specAmt");
		if(location != -1)
			glUniform1f(location, specAmt());
		else
		{
			MGlobal::displayError("uniform variable 'specAmt' not found.");
			return false;
		}
	}
	{
		GLint  location = glGetUniformLocation(program(),"specTint");
		if(location != -1)
			glUniform3f(location, specTint().r,specTint().g,specTint().b);
		else
		{
			MGlobal::displayError("uniform variable 'specTint' not found.");
			return false;
		}
	}
	{
		GLint  location = glGetUniformLocation(program(),"specTint2");
		if(location != -1)
			glUniform3f(location, specTint2().r,specTint2().g,specTint2().b);
		else
		{
			MGlobal::displayError("uniform variable 'specTint2' not found.");
			return false;
		}
	}
	{
		GLint  location = glGetUniformLocation(program(),"useSsao");
		if(location != -1)
			glUniform1i(location, useSSAO());
		else
		{
			MGlobal::displayError("uniform variable 'useSsao' not found.");
			return false;
		}
	}
	{
		GLint  location = glGetUniformLocation(program(),"viewWidth");
		if(location != -1)
			glUniform1f(location, viewWidth());
		else
		{
			MGlobal::displayError("uniform variable 'viewWidth' not found.");
			return false;
		}
	}
	{
		GLint  location = glGetUniformLocation(program(),"viewHeight");
		if(location != -1)
			glUniform1f(location, viewHeight());
		else
		{
			MGlobal::displayError("uniform variable 'viewHeight' not found.");
			return false;
		}
	}
	{
		GLint  location = glGetUniformLocation(program(),"useLights");
		if(location != -1)
			glUniform1i(location, useLights() ? 1:0);
		else
		{
			MGlobal::displayError("uniform variable 'useLights' not found.");
			return false;
		}
	}
	{
		GLint  location = glGetUniformLocation(program(),"numLights");
		if(location != -1)
			glUniform1i(location, numLights());
		else
		{
			MGlobal::displayError("uniform variable 'numLights' not found.");
			return false;
		}
	}
	_tangentLoc() = glGetAttribLocation(program(), "tangent"); 
	if(tangentLoc() == -1)
	{
		MGlobal::displayError("attribute variable 'tangent' not found\n");
		return false;
	}

	return true;
}

void glslHairProgram::loadVertShader(GLuint shader)          //loads internal vert shader
{
	char* buf = 
   "varying vec3 normal;\n\
	varying vec4  vert;\n\
	varying vec4  color;\n\
	varying vec3  tang;\n\
	varying vec3  view;\n\
	attribute vec3 tangent;\n\
	void main(){\n\
		color = gl_Color;\n\
		gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n\
		normal   = normalize(gl_NormalMatrix * gl_Normal);\n\
		vert = gl_ModelViewMatrix * vec4(gl_Vertex.xyz,1.0);\n\
		tang = gl_NormalMatrix * normalize(tangent);\n\
		view = -normalize(vert.xyz);\n\
	}\n\
	\0";

	GLint length = (int)strlen(buf);
	glShaderSource( shader, 1, (const char**)&buf, &length);

	
}

void glslHairProgram::loadFragShader(GLuint shader)			 //loads internal frag shader
{
	char* buf = 
   "uniform vec3  lightDir;\n\
    uniform vec3 specTint;\n\
	uniform vec3 specTint2;\n\
	uniform float ambdiff;\n\
	uniform float specular;\n\
	uniform float specAmt;\n\
	uniform int   useSsao;\n\
	uniform float viewWidth;\n\
	uniform float viewHeight;\n\
	uniform int   useLights;\n\
	uniform int   numLights;\n\
	uniform sampler2D ssaoTex;\n\
	varying vec3  normal;\n\
	varying vec4  vert;\n\
	varying vec4  color;\n\
	varying vec3  tang;\n\
	varying vec3  view;\n\
	float blur8x8flat(vec2 st, float d, sampler2D sampler){\n\
		float x = 0.0;\n\
		float y = 0.0;\n\
		float du = 0.0;\n\
		float dv = 0.0;\n\
		float s = 0.0;\n\
		for(y = -4.0; y < 4.0; y++)\n\
		{\n\
			du = y*d;\n\
			for(x = -4.0; x < 4.0; x++)\n\
			{\n\
				dv = x*d;\n\
				float r = texture2D(sampler, vec2(st.x + du, st.y + dv) ).r;\n\
				s += r;\n\
			}\n\
		}\n\
		s = s/64.0;\n\
		return s;\n\
	}\n\
	void main(){\n\
		vec3 D = vec3(0.0,0.0,0.0);\n\
		vec3 S = vec3(0.0,0.0,0.0);\n\
		vec3 S2 = vec3(0.0,0.0,0.0);\n\
		//vec3 N = normalize(normal);\n\
		//float D = max(0.0, dot(N,-lightDir));\n\
		if(useLights==1){\n\
			for(int i=0;i<numLights;i++){\n\
				vec3 ldir0 = gl_LightSource[i].position.xyz - vert.xyz;\n\
				float dist = length(ldir0);\n\
				vec3 ldir = ldir0/dist;\n\
				//direction light\n\
				if(gl_LightSource[i].position.w == 0.0){\n\
					 ldir = gl_LightSource[i].position.xyz;//halfVector.xyz;\n\
				}\n\
				//diffuse \n\
				float diff  = 0.3;\n\
				float ltdot = dot(ldir, tang);\n\
				float tsq = ltdot*ltdot;\n\
				float shd2 = sqrt(1.0 - tsq);\n\
				float shd = max(shd2, 0.0);\n\
				shd *= ambdiff;\n\
				shd += (1.0 - ambdiff);\n\
				D += shd*gl_LightSource[i].diffuse.rgb;\n\
				//specular \n\
				float K =  1.0/(3.0*(0.101 - specular));\n\
				//float kspec = 0.076;\n\
				float vtdot = dot(view, tang);\n\
				float sqr_vdot2 = sqrt(1.0 - vtdot*vtdot);\n\
				float sp = max(shd2*sqr_vdot2 - ltdot*vtdot, 0.0);\n\
				float spec = max(pow(sp, K), 0.0);\n\
				S += spec*gl_LightSource[i].specular.rgb;\n\
				//secondary specular\n\
				vec3 ldir2 = normalize(ldir*0.7+view*0.3);\n\
				float ltdot2 = dot(ldir2, tang);\n\
				float sp2 = max(shd2*sqr_vdot2 - ltdot2*vtdot, 0.0);\n\
				float spec2 = max(pow(sp2, K), 0.0);\n\
				S2 += spec2*gl_LightSource[i].specular.rgb;\n\
				//spotlight\n\
				if(gl_LightSource[i].spotCutoff != 180.0){\n\
					float spotEffect = dot(normalize(gl_LightSource[i].spotDirection), -ldir);\n\
					if (spotEffect > gl_LightSource[i].spotCosCutoff){\n\
						float spot =  pow(spotEffect, gl_LightSource[i].spotExponent);\n\
						D *= spot;\n\
						S *= spot;\n\
						S2 *= spot;\n\
					}else{\n\
						D = vec3(0.0,0.0,0.0); S = vec3(0.0,0.0,0.0); S2 = vec3(0.0,0.0,0.0);\n\
					}\n\
				}\n\
				//attenuation\n\
				if(gl_LightSource[i].position.w != 0.0 ){\n\
					float decay = 1.0 / (gl_LightSource[i].constantAttenuation +  \n\
										 gl_LightSource[i].linearAttenuation * dist + \n\
										 gl_LightSource[i].quadraticAttenuation * dist * dist);\n\
					D *= decay;\n\
				    S *= decay;\n\
				    S2 *= decay;\n\
				}\n\
			}\n\
		}else{\n\
			vec3 ldir = -lightDir;\n\
			//diffuse \n\
			float diff  = 0.3;\n\
			float ltdot = dot(ldir, tang);\n\
			float tsq = ltdot*ltdot;\n\
			float shd2 = sqrt(1.0 - tsq);\n\
			float shd = max(shd2, 0.0);\n\
			shd *= ambdiff;\n\
			shd += (1.0 - ambdiff);\n\
			//D += shd*gl_LightSource[i].diffuse.rgb;\n\
			D += shd;\n\
			//specular \n\
			float K =  1.0/(3.0*(0.101 - specular));\n\
			//float kspec = 0.076;\n\
			float vtdot = dot(view, tang);\n\
			float sqr_vdot2 = sqrt(1.0 - vtdot*vtdot);\n\
			float sp = max(shd2*sqr_vdot2 - ltdot*vtdot, 0.0);\n\
			float spec = max(pow(sp, K), 0.0);\n\
			//S += spec*gl_LightSource[i].specular.rgb;\n\
			S += spec*vec3(1.0,1.0,1.0);\n\
			//secondary specular\n\
			vec3 ldir2 = normalize(ldir*0.7+view*0.3);\n\
			float ltdot2 = dot(ldir2, tang);\n\
			float sp2 = max(shd2*sqr_vdot2 - ltdot2*vtdot, 0.0);\n\
			float spec2 = max(pow(sp2, K), 0.0);\n\
			//S2 += spec2*gl_LightSource[i].specular.rgb;\n\
			S2 += spec2*vec3(1.0,1.0,1.0);\n\
		}\n\
		if(D.r > 1.0) D.r = 1.0;\n\
		if(D.g > 1.0) D.g = 1.0;\n\
		if(D.b > 1.0) D.b = 1.0;\n\
		if(S.r > 1.0) S.r = 1.0;\n\
		if(S.g > 1.0) S.g = 1.0;\n\
		if(S.b > 1.0) S.b = 1.0;\n\
		if(S2.r > 1.0) S2.r = 1.0;\n\
		if(S2.g > 1.0) S2.g = 1.0;\n\
		if(S2.b > 1.0) S2.b = 1.0;\n\
		//SSAO\n\
		float ssao = 1.0;\n\
		if(useSsao != 0){\n\
			vec2  uv = gl_FragCoord.xy;\n\
			uv.x /= viewWidth; \n\
			uv.y /= viewHeight; \n\
			ssao = 0.25 + 0.75*blur8x8flat(uv,0.001, ssaoTex);\n\
			ssao *= 1.15;\n\
			if (ssao>1.0) ssao=1.0;\n\
		}\n\
		gl_FragColor.xyz = (D*ssao)*color.xyz  + specAmt*(S*specTint + S2*specTint2);\n\
		gl_FragColor.a = color.a;\n\
	}";

	GLint length = (int)strlen(buf);
	glShaderSource( shader, 1, (const char**)&buf, &length);

}

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~/
|						glslSSAOdepthShader -  for ssao pass 1)									|
/~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/


bool glslSSAOdepthShader::setupUniformVariables()
{
	bool ok = true;
	GLint location;

	
	location = glGetUniformLocation(program(), "far");
	if(location != -1)
		glUniform1f(location, zfar());
	else 
	{
		ok &= false;
		if(!s_varErrDumped)
			MGlobal::displayError("uniform variable 'far' not found.");
	}
	location = glGetUniformLocation(program(), "near");
	if(location != -1)
		glUniform1f(location, znear());
	else 
	{
		ok &= false;
		if(!s_varErrDumped)
			MGlobal::displayError("uniform variable 'near' not found.");
	}

	return ok;
}

void glslSSAOdepthShader::loadVertShader(GLuint shader)          //loads internal vert shader
{
	char* buf = "\n\
	uniform float far; \n\
	uniform float near; \n\
	varying float depth; // in eye space\n\
	void main( void ){\n\
		vec4 viewPos = gl_ModelViewMatrix * gl_Vertex;\n\
		depth = (-viewPos.z - near)/(far - near); \n\
		gl_Position = ftransform();\n\
	}\n\0";
	
	GLint length = (int)strlen(buf);
	glShaderSource( shader, 1, (const char**)&buf, &length);
}

void glslSSAOdepthShader::loadFragShader(GLuint shader)			 //loads internal frag shader
{
	char* buf = "\n\
	varying float depth;\n\
	void main( void )\n\
	{\n\
		float R = depth*255.0;\n\
		int   Ri = int(R); \n\
		R = float(Ri);\n\
		float G = depth*255.0 - R;\n\
		R /= 255.0;\n\
		gl_FragColor = vec4(R,G,0.0,depth);\n\
	}\n\0";

	GLint length = (int)strlen(buf);
	glShaderSource( shader, 1, (const char**)&buf, &length);
}

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~/
|	glslSSAOshader - (pass 2) shader used to render map used for SSAO				|
/~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

glslSSAOshader::glslSSAOshader()
{
	_radius() = 0.03f;
	_samples() = 20;
}

bool glslSSAOshader::setupUniformVariables()
{
	bool ok = true;
	GLint location;

	location = glGetUniformLocation(program(), "rad");
	if(location != -1)
		glUniform1f(location, radius());
	else 
	{
		ok &= false;
		if(!s_varErrDumped)
			MGlobal::displayError("uniform variable 'rad' not found.");
	}

	location = glGetUniformLocation(program(), "samples");
	if(location != -1)
		glUniform1i(location, samples());
	else 
	{
		ok &= false;
		if(!s_varErrDumped)
			MGlobal::displayError("uniform variable 'samples' not found.");
	}

	//location = glGetUniformLocation(program(), "rnm");
	//if(location != -1)
	//	glUniform1i(location, 0);
	//else 
	//{
	//	ok &= false;
	//	if(!s_varErrDumped)
	//		MGlobal::displayError("uniform variable 'rnm' not found.");
	//}

	location = glGetUniformLocation(program(), "normalMap");
	if(location != -1)
		glUniform1i(location, 1);
	else 
	{
		ok &= false;
		if(!s_varErrDumped)
			MGlobal::displayError("uniform variable 'normalMap' not found.");
	}
	return ok;
}

void glslSSAOshader::loadVertShader(GLuint shader)          //loads internal vert shader
{
	char* buf = "\n\
	varying vec2  uv; \n\
	void main(void) \n\
	{ \n\
		gl_Position = ftransform(); \n\
		gl_Position = sign( gl_Position ); \n\
		// Texture coordinate for screen aligned (in correct range): \n\
 		//uv = (vec2( gl_Position.x, - gl_Position.y ) + vec2( 1.0 ) ) * 0.5; \n\
		uv = (vec2( gl_Position.x, gl_Position.y ) + vec2( 1.0 ) ) * 0.5; \n\
	}\n\0";
	
	GLint length = (int)strlen(buf);
	glShaderSource( shader, 1, (const char**)&buf, &length);
}

void glslSSAOshader::loadFragShader(GLuint shader)			 //loads internal frag shader
{
	char* buf = "\n\
	uniform float rad; ///0.006; \n\
	uniform sampler2D rnm; \n\
	uniform sampler2D normalMap; \n\
	uniform int samples;\n\
	\n\
	varying vec2 uv; \n\
	void main(void) \n\
	{ \n\
		int x = 0;\n\
		int y = 0;\n\
		int half_size = samples/2;\n\
		float du = 0.0;\n\
		float dv = 0.0;\n\
		int   nsamp = 0;\n\
		int   close = 0;\n\
		vec4 vd = texture2D(normalMap, uv ); //line 17\n\
		if(vd.a == 0.0)\n\
		{\n\
			gl_FragColor.r = 0.1;\n\
			return; \n\
		}\n\
		float D = vd.r + vd.g/255.0; \n\
		D -= 0.01; // out of loop \n\
		for(y = -half_size; y < half_size; y++)\n\
		{\n\
			du = float(y)*rad;\n\
			for(x = -half_size; x < half_size; x++)\n\
			{\n\
				dv = float(x)*rad;\n\
				vec4 zv = texture2D(normalMap, vec2(uv.x + du, uv.y + dv) ); \n\
				if(zv.a != 0.0)\n\
				{\n\
					float z = zv.r + zv.g/255.0;\n\
					nsamp++;\n\
					if(D < z) \n\
						close++;\n\
				}\n\
			}\n\
		}\n\
		float ssao = 1.0;\n\
		if(nsamp != 0) ssao = float(close)/float(nsamp);\n\
		//dither \n\
		gl_FragColor.r = ssao; \n\
		\n\
	}\n\0";

	GLint length = (int)strlen(buf);
	glShaderSource( shader, 1, (const char**)&buf, &length);
}



/////////////////////////// SSAO /////////////////////////////////////////////

//utilities

std::string convertInternalFormatToString(GLenum format)
{
    std::string formatName;

    switch(format)
    {
    case GL_STENCIL_INDEX:
        formatName = "GL_STENCIL_INDEX";
        break;
    case GL_DEPTH_COMPONENT:
        formatName = "GL_DEPTH_COMPONENT";
        break;
    case GL_ALPHA:
        formatName = "GL_ALPHA";
        break;
    case GL_RGB:
        formatName = "GL_RGB";
        break;
    case GL_RGBA:
        formatName = "GL_RGBA";
        break;
    case GL_LUMINANCE:
        formatName = "GL_LUMINANCE";
        break;
    case GL_LUMINANCE_ALPHA:
        formatName = "GL_LUMINANCE_ALPHA";
        break;
    case GL_ALPHA4:
        formatName = "GL_ALPHA4";
        break;
    case GL_ALPHA8:
        formatName = "GL_ALPHA8";
        break;
    case GL_ALPHA12:
        formatName = "GL_ALPHA12";
        break;
    case GL_ALPHA16:
        formatName = "GL_ALPHA16";
        break;
    case GL_LUMINANCE4:
        formatName = "GL_LUMINANCE4";
        break;
    case GL_LUMINANCE8:
        formatName = "GL_LUMINANCE8";
        break;
    case GL_LUMINANCE12:
        formatName = "GL_LUMINANCE12";
        break;
    case GL_LUMINANCE16:
        formatName = "GL_LUMINANCE16";
        break;
    case GL_LUMINANCE4_ALPHA4:
        formatName = "GL_LUMINANCE4_ALPHA4";
        break;
    case GL_LUMINANCE6_ALPHA2:
        formatName = "GL_LUMINANCE6_ALPHA2";
        break;
    case GL_LUMINANCE8_ALPHA8:
        formatName = "GL_LUMINANCE8_ALPHA8";
        break;
    case GL_LUMINANCE12_ALPHA4:
        formatName = "GL_LUMINANCE12_ALPHA4";
        break;
    case GL_LUMINANCE12_ALPHA12:
        formatName = "GL_LUMINANCE12_ALPHA12";
        break;
    case GL_LUMINANCE16_ALPHA16:
        formatName = "GL_LUMINANCE16_ALPHA16";
        break;
    case GL_INTENSITY:
        formatName = "GL_INTENSITY";
        break;
    case GL_INTENSITY4:
        formatName = "GL_INTENSITY4";
        break;
    case GL_INTENSITY8:
        formatName = "GL_INTENSITY8";
        break;
    case GL_INTENSITY12:
        formatName = "GL_INTENSITY12";
        break;
    case GL_INTENSITY16:
        formatName = "GL_INTENSITY16";
        break;
    case GL_R3_G3_B2:
        formatName = "GL_R3_G3_B2";
        break;
    case GL_RGB4:
        formatName = "GL_RGB4";
        break;
    case GL_RGB5:
        formatName = "GL_RGB4";
        break;
    case GL_RGB8:
        formatName = "GL_RGB8";
        break;
    case GL_RGB10:
        formatName = "GL_RGB10";
        break;
    case GL_RGB12:
        formatName = "GL_RGB12";
        break;
    case GL_RGB16:
        formatName = "GL_RGB16";
        break;
    case GL_RGBA2:
        formatName = "GL_RGBA2";
        break;
    case GL_RGBA4:
        formatName = "GL_RGBA4";
        break;
    case GL_RGB5_A1:
        formatName = "GL_RGB5_A1";
        break;
    case GL_RGBA8:
        formatName = "GL_RGBA8";
        break;
    case GL_RGB10_A2:
        formatName = "GL_RGB10_A2";
        break;
    case GL_RGBA12:
        formatName = "GL_RGBA12";
        break;
    case GL_RGBA16:
        formatName = "GL_RGBA16";
        break;
    default:
        formatName = "Unknown Format";
    }

    return formatName;
}


std::string getTextureParameters(GLuint id)
{
    if(glIsTexture(id) == GL_FALSE)
        return "Not texture object";

    GLint width, height, format;
    std::string formatName;
    glBindTexture(GL_TEXTURE_2D, id);
    glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width);            // get texture width
    glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &height);          // get texture height
    glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, &format); // get texture internal format
    glBindTexture(GL_TEXTURE_2D, 0);

    formatName = convertInternalFormatToString(format);

    std::stringstream ss;
    ss << width << "x" << height << ", " << formatName;
    return ss.str();
}

std::string getRenderbufferParameters(GLuint id)
{
    if(glIsRenderbufferEXT(id) == GL_FALSE)
        return "Not Renderbuffer object";

    GLint width, height, format;
    std::string formatName;
    glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, id);
    glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_WIDTH_EXT, &width);    // get renderbuffer width
    glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_HEIGHT_EXT, &height);  // get renderbuffer height
    glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_INTERNAL_FORMAT_EXT, &format); // get renderbuffer internal format
    glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);

    formatName = convertInternalFormatToString(format);

    std::stringstream ss;
    ss << width << "x" << height << ", " << formatName;
    return ss.str();
}

void glhDumpFBOinfo()
{
	std::cout << "\n***** FBO STATUS *****\n";

    // print max # of colorbuffers supported by FBO
    GLint colorBufferCount = 0;
    glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS_EXT, &colorBufferCount);
    std::cout << "Max Number of Color Buffer Attachment Points: " << colorBufferCount << std::endl;

    GLint objectType;
    GLint objectId;

    // print info of the colorbuffer attachable image
    for(int i = 0; i < colorBufferCount; ++i)
    {
        glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT,
                                                 GL_COLOR_ATTACHMENT0_EXT+i,
                                                 GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT,
                                                 &objectType);
        if(objectType != GL_NONE)
        {
            glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT,
                                                     GL_COLOR_ATTACHMENT0_EXT+i,
                                                     GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT,
                                                     &objectId);

            std::string formatName;

            std::cout << "Color Attachment " << i << ": ";
		    if(objectType == GL_TEXTURE)
                std::cout << "GL_TEXTURE, " << getTextureParameters(objectId) << std::endl;
            else if(objectType == GL_RENDERBUFFER_EXT)
                std::cout << "GL_RENDERBUFFER_EXT, " << getRenderbufferParameters(objectId) << std::endl;
        }
    }

    // print info of the depthbuffer attachable image
    glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT,
                                             GL_DEPTH_ATTACHMENT_EXT,
                                             GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT,
                                             &objectType);
    if(objectType != GL_NONE)
    {
        glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT,
                                                 GL_DEPTH_ATTACHMENT_EXT,
                                                 GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT,
                                                 &objectId);

        std::cout << "Depth Attachment: ";
		switch(objectType)
        {
        case GL_TEXTURE:
            std::cout << "GL_TEXTURE, " << getTextureParameters(objectId) << std::endl;
            break;
        case GL_RENDERBUFFER_EXT:
            std::cout << "GL_RENDERBUFFER_EXT, " << getRenderbufferParameters(objectId) << std::endl;
			break;
        }
    }

    // print info of the stencilbuffer attachable image
    glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT,
                                             GL_STENCIL_ATTACHMENT_EXT,
                                             GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT,
                                             &objectType);
    if(objectType != GL_NONE)
    {
        glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT,
                                                 GL_STENCIL_ATTACHMENT_EXT,
                                                 GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT,
                                                 &objectId);

        std::cout << "Stencil Attachment: ";
		switch(objectType)
        {
        case GL_TEXTURE:
            std::cout << "GL_TEXTURE, " << getTextureParameters(objectId) << std::endl;
			break;
        case GL_RENDERBUFFER_EXT:
            std::cout << "GL_RENDERBUFFER_EXT, " << getRenderbufferParameters(objectId) << std::endl;
			break;
        }
    }

    std::cout << std::endl;
}

bool glhCheckFBOstatus()
{
    // check FBO status
    GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
    switch(status)
    {
    case GL_FRAMEBUFFER_COMPLETE_EXT:
        std::cout << "Framebuffer complete." << std::endl;
		return true;

    case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT:
        std::cout << "[ERROR] Framebuffer incomplete: Attachment is NOT complete." << std::endl;
		return false;

    case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT:
        std::cout << "[ERROR] Framebuffer incomplete: No image is attached to FBO." << std::endl;
		return false;

    case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT:
        std::cout << "[ERROR] Framebuffer incomplete: Attached images have different dimensions." << std::endl;
		return false;

    case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT:
        std::cout << "[ERROR] Framebuffer incomplete: Color attached images have different internal formats." << std::endl;
		return false;

    case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT:
        std::cout << "[ERROR] Framebuffer incomplete: Draw buffer." << std::endl;
		return false;

    case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT:
        std::cout << "[ERROR] Framebuffer incomplete: Read buffer." << std::endl;
		return false;

    case GL_FRAMEBUFFER_UNSUPPORTED_EXT:
        std::cout << "[ERROR] Unsupported by FBO implementation." << std::endl;
		return false;

    default:
        std::cout << "[ERROR] Unknow FBO error." << std::endl;
		return false;
    }
}



//FBO
ssaoFBO::ssaoFBO(unsigned int w, unsigned int h)
{
	_texid()  = 0;
	_fboid()  = 0;
	_rboid()  = 0;
	_width()  = w;
	_height() = h;
	
	_origView() = new GLint[4];

	_initOK() = false;

	//Init();
}

ssaoFBO::~ssaoFBO()
{
	delete [] origView();
}

void ssaoFBO::Init()
{
	// create a texture object
	glGenTextures(1, &_texid());
	glBindTexture(GL_TEXTURE_2D, texid());
#ifdef OSMac_
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NONE);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NONE);
#else
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
#endif
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width(), height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
	glBindTexture(GL_TEXTURE_2D, 0);

	// create a framebuffer object, you need to delete them when program exits.
	glGenFramebuffersEXT(1, &_fboid());
	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboid());

	// create a renderbuffer object to store depth info
	// NOTE: A depth renderable image should be attached the FBO for depth test.
	// If we don't attach a depth renderable image to the FBO, then
	// the rendering output will be corrupted because of missing depth test.
	// If you also need stencil test for your rendering, then you must
	// attach additional image to the stencil attachement point, too.
	glGenRenderbuffersEXT(1, &_rboid());
	glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rboid());
	glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, width(), height());
	glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);

	// attach a texture to FBO color attachement point
	glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, texid(), 0);
	// attach a renderbuffer to depth attachment point
	glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, rboid());
	    

	// check FBO status
	//glhDumpFBOinfo();
	bool status = glhCheckFBOstatus();
		
	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);

	_initOK() = true;
}


void ssaoFBO::Destroy()
{
	if(texid())
	{
		glDeleteTextures(1, &_texid());
		_texid() = 0;
	}
    // clean up FBO, RBO
    if(fboid())
    {
        glDeleteFramebuffersEXT(1, &_fboid());
        _fboid() = 0;
	}
	if(fboid())
    {
        glDeleteRenderbuffersEXT(1, &_rboid());
		_rboid() = 0;
	}
}

bool ssaoFBO::MakeCurrent()
{
	// grab original matrices
	glGetFloatv(GL_PROJECTION_MATRIX, _cameraProjectionMatrix());
	glGetFloatv(GL_MODELVIEW_MATRIX, _cameraViewMatrix());
	glGetIntegerv(GL_VIEWPORT, _origView());

	glViewport(0, 0, width(), height()); //is it correct size for normal/depth map

	//Setup view
    glMatrixMode(GL_PROJECTION);
    glLoadMatrixf(cameraProjectionMatrix());

	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboid());

	glMatrixMode(GL_MODELVIEW);
    glLoadMatrixf(cameraViewMatrix());

	//Set parmeters
	glEnable(GL_DEPTH_TEST);
	glDisable(GL_CULL_FACE);

	glPixelTransferf(GL_DEPTH_SCALE,1.0f);
	glPixelTransferf(GL_DEPTH_BIAS, 0.0f);

	glShadeModel(GL_SMOOTH);
	glColorMask(1, 1, 1, 1);
	glDepthMask( GL_TRUE );

	
	glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);

	return true;
}

bool ssaoFBO::ResetCurrent()
{
	/////////////////
	//glFlush();
	////////////////
	
	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); // unbind
	
	//////////////////
	//glBindRenderbufferEXT(GL_FRAMEBUFFER_EXT, 0); // unbind
	////////////////

	glViewport(origView()[0],origView()[1],origView()[2],origView()[3]);
    glShadeModel(GL_SMOOTH);
    glColorMask(1, 1, 1, 1);
    
	//restore original matrices
	glMatrixMode(GL_PROJECTION);
    glLoadMatrixf(cameraProjectionMatrix());

    glMatrixMode(GL_MODELVIEW);
    glLoadMatrixf(cameraViewMatrix());

	return true;
}

bool ssaoFBO::ActivateTexture(int samplerIdx)
{
	if(texid())
	{
		glActiveTexture(GL_TEXTURE0 + samplerIdx);
		glBindTexture(GL_TEXTURE_2D, texid());
#ifdef OSMac_
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NONE);
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NONE);
#else
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
#endif
		glMatrixMode(GL_TEXTURE);
		glLoadIdentity ();

#if 0
		///////////////////// debug ssao depth /////////////////
		MImage mimage;
		MStatus stat = mimage.create(width(),height(),4,MImage::kByte);
		unsigned char* pb = mimage.pixels(); 
		unsigned char* p = (unsigned char*)malloc(width()*height()*4);
		glGetTexImage(GL_TEXTURE_2D,0,GL_RGBA,GL_UNSIGNED_BYTE,p);
		if(stat == MStatus::kSuccess)
		{
			int idx = 0;
			for(unsigned int i = 0; i < width(); i++)
				for(unsigned int j=0; j < height(); j++)
				{
					pb[idx]  = (unsigned char)(p[idx]);
					pb[idx+1]  = (unsigned char)(p[idx+1]);
					pb[idx+2]  = (unsigned char)(p[idx+2]);
					pb[idx+3]  = (unsigned char)(p[idx+3]);
					
					idx+=4;
					
				}
				
		}
		free(p);
		MString mdir;
		MGlobal::executeCommand("internalVar -userBitmapsDir",mdir);
		MString path = mdir + samplerIdx + MString(".jpg");
		MGlobal::displayInfo(path);
		mimage.writeToFile(path,"jpg");
		///////////////// end debug ////////////////////////
#endif
		
		return true;
	}
	return false;
}



////////////////////// LEGACY DISPLAY STUFF //////////////////////////////////

bool shaveHairUI::mBrushIsActive = false;

static bool glslInited = false;
static glslHairProgram hairGlsl;
static glslSSAOdepthShader ssaodepthGlsl;
static glslSSAOshader ssaoGlsl;

ssaoFBO ssaodepth;
ssaoFBO ssao;


bool shaveHairUI::InitGlsl()
{
	bool glIsOK = true;
	if(!GLFunctionsInited())
		glIsOK = InitGLFunctionPointers();
		
	if(glIsOK && !glslInited)
	{
		if(hairGlsl.LoadShaders()
		&& ssaodepthGlsl.LoadShaders()
		&& ssaoGlsl.LoadShaders())
		{
			ssaodepth.Init();
			ssao.Init();
			glslInited = true;
		}
	}
	return glslInited;
}

void shaveHairUI::getDrawRequests(
	const MDrawInfo& drawInfo, bool noActiveComponents, MDrawRequestQueue& queue
)
{
#ifdef DO_PROFILE
	if(!Profile::GetDiagFile())
		Profile::ProfileStart(NULL);
	Profile::ProfileDump("shaveHairUI::getDrawRequests", NULL);
#endif

	// If the object is invisible or intermediate, don't draw anything.
	//
	M3dView::DisplayStatus	dStatus = drawInfo.displayStatus();
	M3dView::DisplayStyle	dStyle = drawInfo.displayStyle();

	if ((dStatus == M3dView::kInvisible)
	||	(dStatus == M3dView::kIntermediateObject))
	{
		return;
	}

	// Maya does not necessarily call us with a displayStatus of kInvisible
	// when we're invisible. We need to do a more exhaustive check
	// ourselves.
	//
	shaveHairShape*	nodePtr = dynamic_cast<shaveHairShape*>(surfaceShape());
    MObject         shaveHairNode = nodePtr->thisMObject();
    MDagPath        path;
    MDagPath::getAPathTo(shaveHairNode, path);

	if (!areObjectAndParentsVisible(path, false, true, true)) return;

	// Similarly, Maya does not necessarily call us with a displayStatus of
	// kTemplate when our template attribute is true, so we have to check
	// that ourselves.
	//
	bool	isTemplated;

	MPlug plug(shaveHairNode, shaveHairShape::isTemplated);
	plug.getValue(isTemplated);

	if (isTemplated) dStatus = M3dView::kTemplate;

	//
	// If we're displaying a bounding box, then that's all we will be
	// displaying.
	//
	MDrawRequest	request;
	M3dView			view = drawInfo.view();

	if (dStyle == M3dView::kBoundingBox)
	{
		request = drawInfo.getPrototype(*this);
		request.setToken(kDrawBBox);
		setWireframeColor(request, view, dStatus);
		queue.add(request);
	}
	else
	{
		// Are we displaying hairs?
		//
		shaveHairShape* shave = dynamic_cast<shaveHairShape*>(surfaceShape());
		if (shave->isHairDisplayEnabled())
		{
			short	hairDisplayMode;

			plug.setAttribute(shaveHairShape::dspyMode);
			plug.getValue(hairDisplayMode);

			if (hairDisplayMode == shaveHairShape::kHairDisplayHair)
			{
				request = drawInfo.getPrototype(*this);

				///////////// incremental update trick ///////////////
				//numDisplayHairs = shave->
				//////////////////////////////////////////////////////

				switch (dStyle)
				{
					case M3dView::kWireFrame:
						request.setToken(kDrawHairs);

						// If the display status is kHilite then we are in
						// component selection mode, in which case we want to
						// display the hair as dormant and let the guides
						// handle all of the burden of selection.
						//
						if (dStatus == M3dView::kHilite)
						{
							request.setColor(
								DORMANT_SURFACE_COLOR, M3dView::kDormantColors
							);
						}
						else if (dStatus == M3dView::kLead)
						{
							request.setColor(
								LEAD_HAIR_COLOR, M3dView::kActiveColors
							);
						}
						else if (dStatus == M3dView::kActive)
						{
							request.setColor(
								ACTIVE_HAIR_COLOR, M3dView::kActiveColors
							);
						}
						else
							setWireframeColor(request, view, dStatus);

						queue.add(request);
					break;

					case M3dView::kFlatShaded:
					case M3dView::kGouraudShaded:
					{
						if(!doFallbackGlob)
							request.setToken(kDrawActiveShadedHairs);
						else
						switch (dStatus)
						{
							case M3dView::kHilite:
							case M3dView::kLead:
							case M3dView::kActive:
								request.setToken(kDrawActiveShadedHairs);
							break;

							default:
								request.setToken(kDrawInactiveShadedHairs);
							break;
						}

						queue.add(request);
					}
					break;

					default:
						// No hair display.
					break;
				}
			}
//#ifdef NEW_INSTNACE_DISPLAY
			else if (hairDisplayMode == shaveHairShape::kHairDisplayGeom)
			{
				shaveGlobals::Globals	globals;
				shaveGlobals::getGlobals(globals);

				if(glisntGlob)
				{
					request = drawInfo.getPrototype(*this);

					switch (dStyle)
					{
						case M3dView::kWireFrame:
							request.setToken(kDrawInstancedWire);

							//
							// If the display status is kHilite then we are in
							// component selection mode, in which case we want to
							// display the hair as dormant and let the guides
							// handle all of the burden of selection.
							//
							if (dStatus == M3dView::kHilite)
							{
								request.setColor(
									DORMANT_SURFACE_COLOR, M3dView::kDormantColors
								);
							}
							else if (dStatus == M3dView::kLead)
							{
								request.setColor(
									LEAD_HAIR_COLOR, M3dView::kActiveColors
								);
							}
							else if (dStatus == M3dView::kActive)
							{
								request.setColor(
									ACTIVE_HAIR_COLOR, M3dView::kActiveColors
								);
							}
							else
								setWireframeColor(request, view, dStatus);

							queue.add(request);
						break;

						case M3dView::kFlatShaded:
						case M3dView::kGouraudShaded:
						{
							switch (dStatus)
							{
								case M3dView::kHilite:
								case M3dView::kLead:
								case M3dView::kActive:
									{
									
										if (dStatus == M3dView::kLead)
										{
											request.setToken(kDrawInstancedShadedOffset);

											MDrawRequest request2 = drawInfo.getPrototype(*this);
											request2.setColor(LEAD_HAIR_COLOR, M3dView::kActiveColors);
											request2.setToken(kDrawInstancedWire);
											queue.add(request2);
										}
										else
											request.setToken(kDrawInstancedShaded);
									
									}
								break;

								default:
									request.setToken(kDrawInstancedShaded);
								break;
							}

							queue.add(request);
						}
						break;

						default:
							// No hair display.
						break;
					}
				}
				else //we want to update texures
				{
					shaveHairShape*	nodePtr = dynamic_cast<shaveHairShape*>(surfaceShape());
					nodePtr->updateTexLookups();

				}
			}
//#endif
		}

		bool	componentSelectionMode = (!noActiveComponents
										&& (dStatus == M3dView::kHilite));

		if (componentSelectionMode)
		{
			// We always display guides in component selection mode.
			// Inactive guides are displayed in the standard hilite color
			// while active ones are display in our own active guide color.
			//
			request = drawInfo.getPrototype(*this);
			request.setToken(kDrawInactiveGuides);
			request.setColor(
				DORMANT_GUIDE_COMPONENT_COLOR, M3dView::kDormantColors
			);
			queue.add(request);

			request = drawInfo.getPrototype(*this);
			request.setToken(kDrawActiveGuides);
			request.setColor(
				ACTIVE_GUIDE_COMPONENT_COLOR, M3dView::kActiveColors
			);

			queue.add(request);

			// Get the guide selection type.
			//
			MString	selectType;

			MGlobal::executeCommand(
				"optionVar -q shaveBrushSelectMode", selectType
			);

			// Use the selection type to determine which guide vertices to
			// display.
			//
			int	activeDrawToken = kDrawNone;
			int	inactiveDrawToken = kDrawNone;

			if (selectType == "root")
			{
				activeDrawToken = kDrawActiveRoots;
				inactiveDrawToken = kDrawInactiveRoots;
			}
			else if (selectType == "tip")
			{
				activeDrawToken = kDrawActiveTips;
				inactiveDrawToken = kDrawInactiveTips;
			}
			else if (selectType == "vert")
			{
				activeDrawToken = kDrawActiveVerts;
				inactiveDrawToken = kDrawInactiveVerts;
			}

			if (activeDrawToken != kDrawNone)
			{
				request = drawInfo.getPrototype(*this);
				request.setToken(inactiveDrawToken);

				request.setColor(
					DORMANT_VERTEX_COLOR, M3dView::kDormantColors
				);

				queue.add(request);

				request = drawInfo.getPrototype(*this);
				request.setToken(activeDrawToken);

				request.setColor(
					ACTIVE_VERTEX_COLOR, M3dView::kActiveColors
				);

				queue.add(request);
			}
		}
		// In object mode we display guides if the user has explicitly
		// requested that we do so, or if the object is selected and a
		// brush is active.
		//
		else
		{
			//bool	displayGuides;
			//plug.setAttribute(shaveHairShape::aDisplayGuides);
			//plug.getValue(displayGuides);

			bool	displayGuides = nodePtr->getDisplayGuides();

			bool	selected = (dStatus == M3dView::kActive)
							|| (dStatus == M3dView::kLead);

			if (displayGuides || (mBrushIsActive && selected))
			{
				request = drawInfo.getPrototype(*this);
				setWireframeColor(request, view, dStatus);
				request.setToken(kDrawGuides);
				queue.add(request);
			}
		}
	}
#ifdef DO_PROFILE
	Profile::ProfileDump("shaveHairUI::getDrawRequests - done", NULL);
#endif
}

/// dummy implementation now
void SHAVEpre_draw() {}
void SHAVEpost_draw() {}

void shaveHairUI::draw(const MDrawRequest& request, M3dView& view) const
{
#ifdef DO_PROFILE
	if(!Profile::GetDiagFile())
		Profile::ProfileStart(NULL);
	Profile::ProfileDump("shaveHairUI::draw", NULL);
#endif

	int	drawToken = request.token();

	//vlad|03Jun2010 -- update shave camera 
	SHAVEpre_draw();

	static int MBAAQ[] = {1,3,8,15,23};
	
	MDagPath camPath = shaveRender::getRenderCamPath();
	shaveRender::SceneInfo si;
	si.shaveRenderPixels	= NULL;
	si.shaveZBuffer			= NULL;
	si.aa					= MBAAQ[renderQualityGlob];
	si.currentFrame			= (float)MAnimControl::currentTime().value();
	si.haveTracedLights		= false;
	si.height				= shaveMaya::imageHeight;
	si.shaveTraceInitialized= false;
	si.width				= shaveMaya::imageWidth;

	shaveRender::doCamera(camPath,shaveConstant::kShutterOpen,si);
	shaveRender::doCamera(camPath,shaveConstant::kShutterClose,si);

	view.beginGL();

	//
	// We do all of our drawing in worldSpace, so set the current
	// transformation to worldSpace.
	//
	MMatrix	worldInverse = request.multiPath().inclusiveMatrixInverse();

	glPushMatrix();
	glMultMatrixd((double *)worldInverse.matrix);

	switch (drawToken)
	{
		case kDrawBBox:
			drawBoundingBox();
		break;

		case kDrawGuides:
		case kDrawActiveGuides:
		case kDrawInactiveGuides:
			drawGuides(drawToken, view);
		break;

		case kDrawHairs:
		case kDrawActiveShadedHairs:
		case kDrawInactiveShadedHairs:
			drawHairs(drawToken, view);
		break;
#ifdef NEW_INSTNACE_DISPLAY
		case kDrawInstancedWire:
		case kDrawInstancedShaded:
		case kDrawInstancedShadedOffset:
			drawInstances(drawToken, view);
		break;
#endif
		case kDrawActiveRoots:
		case kDrawActiveTips:
		case kDrawActiveVerts:
		case kDrawInactiveRoots:
		case kDrawInactiveTips:
		case kDrawInactiveVerts:
			drawVerts(drawToken);
		break;

		default:
		break;
	}

	glPopMatrix();
	view.endGL();

	//vlad|03Jun2010 -- update shave camera 
	SHAVEpost_draw();
#ifdef DO_PROFILE
	Profile::ProfileDump("shaveHairUI::draw - done", NULL);
#endif
}


bool shaveHairUI::select(
		MSelectInfo		&selectInfo,
		MSelectionList	&selectionList,
		MPointArray		&worldSpaceSelectPts
) const
{
	//	If the node is not visible, return immediately.
	shaveHairShape*	nodePtr = dynamic_cast<shaveHairShape*>(surfaceShape());
    MDagPath        path;
    MDagPath::getAPathTo(nodePtr->thisMObject(), path);

    if (!areObjectAndParentsVisible(path, false, true, true)) return false;

	bool	alreadyTriedGuides = false;
	bool	somethingSelected = false;
	bool	componentMode = (selectInfo.displayStatus() == M3dView::kHilite);

	//
	// Load the proper hair shape into the Shave engine.
	//
	nodePtr->makeCurrent();

	//
	// We do all of our drawing in worldSpace, so set the current
	// transformation to worldSpace.
	//
	M3dView	view = selectInfo.view();
	MMatrix	worldInverse = selectInfo.multiPath().inclusiveMatrixInverse();

	view.beginGL();
	glPushMatrix();
	glMultMatrixd((double *)worldInverse.matrix);
	view.endGL();

	// If we're in component mode then try to get a hit on individual
	// vertices or guides.
	//
	if (componentMode)
	{
		MString	selectMode;

		MGlobal::executeCommand(
			"optionVar -q shaveBrushSelectMode", selectMode
		);

		if (selectMode == "guide")
		{
			somethingSelected = selectGuides(
									selectInfo,
									selectionList,
									worldSpaceSelectPts
								);
			alreadyTriedGuides = true;
		}
		else
		{
			somethingSelected = selectVerts(
									selectMode,
									selectInfo,
									selectionList,
									worldSpaceSelectPts
								);
		}
	}

	// If we didn't get any component hits then try for an overall hit on the
	// object.
	//
	if (!somethingSelected)
	{
		// Get the hair and guide display settings.
		//
		//bool	displayGuides;

		short	hairDisplayMode;
		MPlug	plug(surfaceShape()->thisMObject(), shaveHairShape::dspyMode);
		plug.getValue(hairDisplayMode);
		
		//plug.setAttribute(shaveHairShape::aDisplayGuides);
		//plug.getValue(displayGuides);
		bool displayGuides = nodePtr->getDisplayGuides();

		// If guides are being displayed, and we didn't already check them
		// during component testing, try for a hit on them first.
		//
		if (!alreadyTriedGuides && (componentMode || displayGuides))
		{
			somethingSelected = selectObjByGuides(
									selectInfo,
									selectionList,
									worldSpaceSelectPts
								);
		}

		// If we didn't get a hit on guides and hairs are being displayed,
		// then try them.
		//
		if (!somethingSelected)
		{
			if(hairDisplayMode == shaveHairShape::kHairDisplayHair)
			{
				somethingSelected = selectObjByHairs(
										selectInfo,
										selectionList,
										worldSpaceSelectPts
									);
			}
			else if(hairDisplayMode == shaveHairShape::kHairDisplayGeom)
			{
				somethingSelected = selectObjByGeom(
										selectInfo,
										selectionList,
										worldSpaceSelectPts
									);
			}
		}
	}

	view.beginGL();
	glPopMatrix();
	view.endGL();

	return somethingSelected;
}


void shaveHairUI::setBrushActive(bool isActive)
{
	mBrushIsActive = isActive;
}


//-------------------------------------------------------------
//
//		Utility Methods
//
//-------------------------------------------------------------

void shaveHairUI::drawBoundingBox()
	const
{
	shaveHairShape*	nodePtr = dynamic_cast<shaveHairShape*>(surfaceShape());
	MBoundingBox	bbox = nodePtr->boundingBoxTemp();
	MPoint	bbmin = bbox.min();
	MPoint	bbmax = bbox.max();

	glBegin(GL_LINES);
		glVertex3d(bbmin.x, bbmin.y, bbmin.z);
		glVertex3d(bbmax.x, bbmin.y, bbmin.z);

		glVertex3d(bbmin.x, bbmin.y, bbmin.z);
		glVertex3d(bbmin.x, bbmax.y, bbmin.z);

		glVertex3d(bbmin.x, bbmin.y, bbmin.z);
		glVertex3d(bbmin.x, bbmin.y, bbmax.z);

		glVertex3d(bbmax.x, bbmax.y, bbmax.z);
		glVertex3d(bbmin.x, bbmax.y, bbmax.z);

		glVertex3d(bbmax.x, bbmax.y, bbmax.z);
		glVertex3d(bbmax.x, bbmin.y, bbmax.z);

		glVertex3d(bbmax.x, bbmax.y, bbmax.z);
		glVertex3d(bbmax.x, bbmax.y, bbmin.z);

		glVertex3d(bbmax.x, bbmin.y, bbmin.z);
		glVertex3d(bbmax.x, bbmax.y, bbmin.z);

		glVertex3d(bbmax.x, bbmin.y, bbmin.z);
		glVertex3d(bbmax.x, bbmin.y, bbmax.z);

		glVertex3d(bbmin.x, bbmax.y, bbmin.z);
		glVertex3d(bbmax.x, bbmax.y, bbmin.z);

		glVertex3d(bbmin.x, bbmax.y, bbmin.z);
		glVertex3d(bbmin.x, bbmax.y, bbmax.z);

		glVertex3d(bbmin.x, bbmin.y, bbmax.z);
		glVertex3d(bbmax.x, bbmin.y, bbmax.z);

		glVertex3d(bbmin.x, bbmin.y, bbmax.z);
		glVertex3d(bbmin.x, bbmax.y, bbmax.z);
	glEnd();
}


void shaveHairUI::drawGuides(int drawToken, M3dView& view) const
{
#ifdef DO_PROFILE
	if(!Profile::GetDiagFile())
		Profile::ProfileStart(NULL);
	Profile::ProfileDump(" shaveHairUI::drawGuides", NULL);
#endif

	// Make sure that this shaveNode is loaded into the engine.
	// 
	shaveHairShape*	nodePtr = dynamic_cast<shaveHairShape*>(surfaceShape());


	const shaveHairShape::Guides& guides = nodePtr->getGuides().guides;


	float w = nodePtr->getGuideThinkness();
	

	// Draw the guides.
	//
	int i;
	shaveHairShape::Guides::const_iterator	iter;

	if(w == 0)
	{
		for (iter = guides.begin(); iter != guides.end(); iter++)
		{
			const shaveHairShape::Guide&	guide = *iter;

			if (!guide.hidden)
			{
				// Does this guide have any selected verts?
				//
				bool	isActive = (guide.select != 0);

				// Skip this guide if it does not meet our drawing
				// requirements.
				//
				if (((drawToken == kDrawActiveGuides) && !isActive)
				||	((drawToken == kDrawInactiveGuides) && isActive))
				{
					continue;
				}
				
				glBegin(GL_LINE_STRIP);

				for (i = 0; i < SHAVE_VERTS_PER_GUIDE; i++)
					glVertex3f(guide.verts[i].x, guide.verts[i].y, guide.verts[i].z);

				glEnd();
			}
		}
	}
	else
	{
		float ext = nodePtr->getGuideExt(); 
		if(ext == 0.0f)//compute once
		{
			//printf("compute bbox\n");
			//MBoundingBox	bbox = nodePtr->boundingBoxTemp();
			MBoundingBox	bbox;
			bbox.clear();

			for (iter = guides.begin(); iter != guides.end(); iter++)
			{	
				const shaveHairShape::Guide&	guide = *iter;
				if (!guide.hidden)
				{
					MPoint v = guide.verts[SHAVE_VERTS_PER_GUIDE-1];//tip only
					bbox.expand(v);
				}
			}
			ext = (bbox.max() - bbox.min()).length();
			nodePtr->setGuideExt(ext);
		}
		w *= (4.0f*ext)/1500.0f;

		MVector viewDir( 0.0, 0.0, 1.0);
		MDagPath camPath;
		MStatus stat = MStatus::kSuccess;
		stat = view.getCamera(camPath);

		if(stat == MStatus::kSuccess)
		{
			MFnCamera camFn(camPath);
			viewDir = camFn.viewDirection( MSpace::kWorld );
			viewDir.normalize();
		}

		//
		// Draw the guides.
		//
		int	v;
		for (iter = guides.begin(); iter != guides.end(); iter++)
		{
			const shaveHairShape::Guide&	guide = *iter;

			if (!guide.hidden)
			{
				//
				// Does this guide have any selected verts?
				//
				bool	isActive = (guide.select != 0);

				//
				// Skip this guide if it does not meet our drawing
				// requirements.
				//
				if (((drawToken == kDrawActiveGuides) && !isActive)
				||	((drawToken == kDrawInactiveGuides) && isActive))
				{
					continue;
				}

				glBegin(GL_QUADS);

				MVector tangent0;
				MVector tangent1;
				MVector p0;
				MVector p1;
				MVector p2;
				int numS = SHAVE_VERTS_PER_GUIDE-1;
				
				for (v = 0; v < numS; v++)
				{
					int vv = v+1;
					int vvv = v+2;
					if(v == 0)	//root polygon
					{
						p0.x = guide.verts[0].x; 
						p0.y = guide.verts[0].y;
						p0.z = guide.verts[0].z;
						p1.x = guide.verts[1].x; 
						p1.y = guide.verts[1].y;
						p1.z = guide.verts[1].z;

						tangent0 = p1 - p0;
						tangent0.normalize();
						tangent1 = tangent0;
					}
					else if(vv == numS) //tip poly
					{
						p0 = p1;
						p1.x = guide.verts[vv].x; 
						p1.y = guide.verts[vv].y;
						p1.z = guide.verts[vv].z;

						tangent0 = tangent1;
						tangent1 = p1 - p0;
						tangent1.normalize();
					}
					else
					{
						p0 = p1;
						p1.x = guide.verts[vv].x; 
						p1.y = guide.verts[vv].y;
						p1.z = guide.verts[vv].z;

						tangent0 = tangent1;
						if(vvv < SHAVE_VERTS_PER_GUIDE)
						{
							p2.x = guide.verts[vvv].x; 
							p2.y = guide.verts[vvv].y;
							p2.z = guide.verts[vvv].z;
							tangent1 = p2 - p0;
						}
						else
						{
							tangent1 = p1 - p0;
						}
						tangent1.normalize();
					}
					if(p0 == p1)
						continue;

					
					MVector d0 = tangent0^viewDir;
					MVector d1 = tangent1^viewDir;
					d0.normalize();
					d1.normalize();

					MVector v0 = p0 + d0*(float)w;
					MVector v1 = p0 - d0*(float)w;
					MVector v2 = p1 - d1*(float)w;
					MVector v3 = p1 + d1*(float)w;
					
	

					glVertex3d(v0.x, v0.y, v0.z);
					glVertex3d(v1.x, v1.y, v1.z);

					glVertex3d(v2.x, v2.y, v2.z);
					glVertex3d(v3.x, v3.y, v3.z);

				}
				glEnd();
			}
		}
	}
#ifdef DO_PROFILE
	Profile::ProfileDump(" shaveHairUI::drawGuides -- done", NULL);
#endif
}

class Group {
public:
	MIntArray pids;
	MIntArray hids;
};

struct Poly {

	MVector t[4];
	MVector v[4];
	MColor  c[4];
};

class PolyGroup {
public:
	std::vector<Poly> p;
};


bool incrementaldraw = false;

void shaveHairUI::drawHairs(int drawToken, M3dView& view) const
{
	//printf("draw hairs\n"); fflush(stdout);
#ifdef DO_PROFILE
	if(!Profile::GetDiagFile())
		Profile::ProfileStart(NULL);
	Profile::ProfileDump(" shaveHairUI::drawHairs", NULL);
#endif
	
	shaveHairShape*			nodePtr = dynamic_cast<shaveHairShape*>(surfaceShape());

	//	We won't be able to draw hair until the node has been properly
	//	initialized. We might arrive here before initialization if Maya
	//	triggers a refresh during file I/O.
	//
	if ((nodePtr == 0) || !nodePtr->nodeIsInitialized()) {
		return;
	}

	shaveDirties& dirties = nodePtr->dirties;
	if(dirties.DIRTY_HAIRCOUNT)
	{
		//do something there
	}
	shaveGlobals::getGlobals();


#ifndef NEW_DISPLAY // old lines code
	

	const std::vector<shaveHairShape::DisplayHair>&
							displayHairs = nodePtr->getDisplayHairs();

	//
	// Determine the number of hairs to be drawn.
	//
	unsigned	numHairsToDraw = nodePtr->getNumDisplayHairs(false);

	if (numHairsToDraw > displayHairs.size())
		numHairsToDraw = displayHairs.size();

	//
	// Draw the hairs.
	//
	unsigned	h;
	unsigned	s;
	unsigned	v;

	for (h = 0; h < numHairsToDraw; h++)
	{
		const shaveHairShape::DisplayHair&	hair = displayHairs[h];

		for (s = 0; s < hair.size(); s++)
		{
			const shaveHairShape::DisplayStrand&	strand = hair[s];

			glBegin(GL_LINE_STRIP);

			for (v = 0; v < strand.verts.length(); v++)
			{
				if (drawToken == kDrawActiveShadedHairs)
				{
					view.setDrawColor(
						MColor(
							strand.colors[v].r,
							strand.colors[v].g,
							strand.colors[v].b
						)
					);
				}
				else if (drawToken == kDrawInactiveShadedHairs)
				{
					view.setDrawColor(
						MColor(
							strand.colors[v].r * 0.5f,
							strand.colors[v].g * 0.5f,
							strand.colors[v].b * 0.5f
						)
					);
				}

				glVertex3d(
					strand.verts[v].x, strand.verts[v].y, strand.verts[v].z
				);
			}

			glEnd();
		}
	}
#else	//new poly hair code

	bool        doxpar = nodePtr->getDoHairXparency();
	float       xpar  = nodePtr->getHairXparency();
	bool        tipfade = nodePtr->getDoTipfade();
	bool		fallback = nodePtr->getDoFallback();
	int         passes = nodePtr->getNumPasses();
	float       invPasses = 1.0f/(float)passes;
#ifdef DO_PROFILE
	{
		unsigned	numToDisplay =  nodePtr->getNumDisplayHairs(false);
		char  buf[300]={'\0'}; sprintf(buf,"Going to get cache %i %s", numToDisplay, IsMouseDown()?"mouse down":"mose up");
		Profile::ProfileDump(/*"Going to get cache"*/ buf, NULL);
	}
#endif

#if 1
	//this does not work, event are not coming
	//ClearEvents();
	//qApp->flush(); //gah, event are present in queue
	unsigned	numToDisplay =  nodePtr->getNumDisplayHairs(false);
	if(numToDisplay==0)
		return;

	unsigned    bunchSize = nodePtr->getNumDisplayHairs(true);
	if(bunchSize == 0) bunchSize = numToDisplay;

	const shaveHairShape::DisplayHairCache& cache = nodePtr->getDisplayHairs(view,true); 
	int done=0;
	//lets try to return there
	//return; //15fps even for 2 hairs. so its related to not empty display cache
#if 1
//	printf("mousedown: %s, mousemove: %s\n", IsMouseDown()?"yes":"no", GetEventsHappen()?"yes":"no");fflush(stdout);
	//qApp->flush();
#ifdef GLOBAL_FALLBACK
	ClearEvents();
#endif
	incrementaldraw = false;
	while(/*cache.displayHair.capacity()*/ /*numToDisplay != cache.displayHair.size()*/ numToDisplay > cache.displayHair.size()
#ifdef GLOBAL_FALLBACK
	&& (done==0) //
#endif
	)
	{
#ifdef GLOBAL_FALLBACK
		if (QCoreApplication::hasPendingEvents())
		{
			SetEventsHappen();
			incrementaldraw = true;
			//if(!shaveStyleCmd::redrawOnIdlDone)
			//{
			//	printf("redrawOnIdle fired+\n");fflush(stdout);
			//	MGlobal::executeCommandOnIdle("shaveStyle -redrawOnIdle");
			//}
		}

		//	if (qApp->hasPendingEvents()) SetEventsHappen() ;
		//	qApp->processEvents();
		//	qApp->flush();
		///////////////////////////////////////////
		//	incrementaldraw = true;
		//	qApp->processEvents(/*0x02*/ QEventLoop::ExcludeSocketNotifiers);
		//	incrementaldraw = false;
		//////////////////////////////////////////

		if((IsMouseDown() || GetEventsHappen()) && !liveModeGlob && fallback)
		//if(GetEventsHappen())
		//qApp->checkQueueSize(); there is no such member
		//if(qApp->hasPendingEvents());
		{
			//printf("event\n"); fflush(stdout);
			//no, lets draw
			//if(doxpar && tipfade && (drawToken == kDrawActiveShadedHairs || drawToken == kDrawInactiveShadedHairs))
			//{
			//	//nodePtr->clearDisplayHairs();
			//	//return;
			//}
			//else
			{
				nodePtr->invalidateDisplayHairs();
//				printf("interrupt 01\n");fflush(stdout);
				break;
			}
		}
		if (GetEventsHappen()) done=1;
		if (!GetEventsHappen())
#endif
		nodePtr->getDisplayHairs(view,false);
		//Sleep(1);
	}
#ifdef GLOBAL_FALLBACK
	ClearEvents();
#endif
#endif
#else
	const shaveHairShape::DisplayHairCache& cache = nodePtr->getDisplayHairs(view);
#endif
	//no computing
	//const shaveHairShape::DisplayHairCache& cache = nodePtr->getDisplayHairs();

	
	//return; //just a test

	//
	// Determine the number of hairs to be drawn.
	//
	unsigned	numHairsToDraw = nodePtr->getNumDisplayHairs(false);
	
	

	if (numHairsToDraw > cache.displayHair.size())
		numHairsToDraw = (unsigned int)cache.displayHair.size();

	// Grab view direction 

	MMatrix worldToCam;
	MVector viewDir( 0.0, 0.0, 1.0);
	MDagPath camPath;
	MStatus stat = MStatus::kSuccess;
	stat = view.getCamera(camPath);
	if(stat == MStatus::kSuccess)
	{
		MFnCamera camFn(camPath);
		viewDir = camFn.viewDirection( MSpace::kWorld );
		viewDir.normalize();

		worldToCam = camPath.inclusiveMatrixInverse(); 

	}

	///////////////////////////////////////////////
	//
	// Draw the hairs.
	//
#ifdef DO_PROFILE
	Profile::ProfileDump("Going to draw hairs", NULL);
#endif
	if(doxpar && (tipfade || passes > 1) && (drawToken == kDrawActiveShadedHairs || drawToken == kDrawInactiveShadedHairs))
	{
		unsigned int	h;
		unsigned int	s;
		int	v;

		MPoint centerPt(cache.center);
		MPoint nearPt = centerPt - viewDir*cache.radius;
		MPoint farPt = centerPt + viewDir*cache.radius;

		MPoint nearSc = nearPt*worldToCam;
		MPoint farSc = farPt*worldToCam;

		glPushAttrib(GL_ALL_ATTRIB_BITS);
		glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);

		//glEnable(GL_COLOR_MATERIAL);

		glEnable (GL_BLEND); 
		glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

		//////////// GLSL ///////////////
		bool doGlsl = false;
		if(glslInited)
		{
			doGlsl = true;
			
			glEnable ( GL_LIGHTING );

			//count OpengGL lights
			bool  uselights = false;
			int   nlights = 0;
			//MString lightmode = "";
			//MGlobal::executeCommand("string $editor = `modelEditor`; modelEditor -q -displayLights $editor;",lightmode);
			//MGlobal::executeCommand("modelEditor -q -displayLights modelEditor1;",lightmode);
			//MGlobal::displayInfo(MString("mode ") + lightmode);

			M3dView::LightingMode lightmode = M3dView::kLightDefault;
			view.getLightingMode(lightmode);
			if(lightmode == M3dView::kLightActive ||
				lightmode == M3dView::kLightAll)
			{
				uselights = true;
				
				GLint maxlights;
				glGetIntegerv(GL_MAX_LIGHTS,&maxlights);
				for(int k=0; k < maxlights; k++)
				{
					GLboolean on;
					glGetBooleanv(GL_LIGHT0+k,&on);
					if(on)
						nlights++;
				}
				//MGlobal::displayInfo(MString("max lights ")+maxlights+" numlight " + nlights);
			}
			hairGlsl.SetUseLights(uselights,nlights);

			hairGlsl.SetAmbDiff(nodePtr->getAmbDiff());
			hairGlsl.SetSpecular( nodePtr->getGloss());
			hairGlsl.SetSpecularAmt(nodePtr->getSpecular());
			hairGlsl.SetSpecularTint(nodePtr->getSpecularTint());
			hairGlsl.SetSpecularTint2(nodePtr->getSpecularTint2());
			hairGlsl.SetUseSSAO(false);
			hairGlsl.UseProgram();

			if(hairGlsl.GetUseSSAO())	
				ssao.ActivateTexture(0);
		}
		else
			glEnable(GL_COLOR_MATERIAL);
		/////////////////////////////////

		bool dobreak = false;
		unsigned int ingroups = 0;
		int numS = 1;
		std::vector<PolyGroup> groups;
		groups.resize(400);
		for(int g = (int)groups.size()-1; g >= 0; g--)
			groups[g].p.reserve(300);
		
		for (h = 0; h < numHairsToDraw; h++)
		{
			const shaveHairShape::DisplayHair&	hair = cache.displayHair[h];
			for (s = 0; s < hair.size(); s++)
			{
				const shaveHairShape::DisplayStrand&	strand = hair[s];

				MVector tangent0;
				MVector tangent1;
				MVector p0;
				MVector p1;
				MVector p2;
				float   r0;
				float   r1;
				numS = strand.verts.length()-1;
				float inumS = 1.0f/(float)numS;
				
				for (v = 0; v < numS; v++)
				{
					int vv = v+1;
					int vvv = v+2;
					float t1 = vv*inumS;
					if(v == 0)	//root polygon
					{
						p0.x = strand.verts[0].x; 
						p0.y = strand.verts[0].y;
						p0.z = strand.verts[0].z;
						p1.x = strand.verts[1].x; 
						p1.y = strand.verts[1].y;
						p1.z = strand.verts[1].z;

						tangent0 = p1 - p0;
						tangent0.normalize();

						tangent1 = tangent0;
						
						r0 = strand.rootrad;
						r1 = strand.rootrad*(1.0f - t1) + strand.tiprad*t1;
						
					}
					else if(vv == numS) //tip poly
					{
						p0 = p1;
						p1.x = strand.verts[vv].x; 
						p1.y = strand.verts[vv].y;
						p1.z = strand.verts[vv].z;

						tangent0 = tangent1;
						tangent1 = p1 - p0;
						tangent1.normalize();
						

						r0 = r1;
						r1 = strand.tiprad;
					}
					else
					{
						p0 = p1;
						p1.x = strand.verts[vv].x; 
						p1.y = strand.verts[vv].y;
						p1.z = strand.verts[vv].z;

						tangent0 = tangent1;
						if(vvv < (int)strand.verts.length())
						{
							p2.x = strand.verts[vvv].x; 
							p2.y = strand.verts[vvv].y;
							p2.z = strand.verts[vvv].z;
							tangent1 = p2 - p0;
						}
						else
						{
							tangent1 = p1 - p0;
						}
						tangent1.normalize();

						r0 = r1;
						r1 = strand.rootrad*(1.0f - t1) + strand.tiprad*t1;

					}
					if(p0 == p1)
						continue;

					
					MVector d0 = tangent0^viewDir;
					MVector d1 = tangent1^viewDir;
					d0.normalize();
					d1.normalize();

					MVector v0 = p0 + d0*r0;
					MVector v1 = p0 - d0*r0;
					MVector v2 = p1 - d1*r1;
					MVector v3 = p1 + d1*r1;
					
					MColor col = strand.colors[v];
					if (drawToken == kDrawInactiveShadedHairs)
					{
						col.r *= 0.75f;
						col.g *= 0.75f;
						col.b *= 0.75f;
					}
					//we do get 1.0 in WFTYPE.alpha[] at the moment, lets fake it with tipfade
					//col.a = 1.0f - vv*inumS;
					col.a = 1.0f;
					if(tipfade)
						col.a -= v*inumS;
					if(passes)
						col.a *= invPasses;


					Poly P;

					P.v[0] = v0;
					P.c[0] = col;
										
					P.v[1] = v1;
					P.c[1] = col;
					P.t[0] = P.t[1] = tangent0;
					
					col = strand.colors[vv];
					if (drawToken == kDrawInactiveShadedHairs)
					{
						col.r *= 0.75f;
						col.g *= 0.75f;
						col.b *= 0.75f;
					}
					//we do get 1.0 in WFTYPE.alpha[] at the moment, lets fake it with tipfade
					col.a = 1.0f - vv*inumS;

					col.a = 1.0f;
					if(tipfade)
						col.a -= vv*inumS;
					if(passes)
						col.a *= invPasses;

					P.v[2] = v2;
					P.c[2] = col;
					
					P.v[3] = v3;
					P.c[3] = col;
					P.t[2] = P.t[3] = tangent1;

					//for Joe: what I am doing wrong with z-sort?
					MPoint V(0.5f*(p0.x+p1.x), 0.5f*(p0.y+p1.y), 0.5f*(p0.z+p1.z));//a middle of poly
					MPoint S = V*worldToCam;	//to camera space
					float d = (S.z-nearSc.z)/(farSc.z-nearSc.z); 
					//if(d > 1.0f) d = 1.0f;
					//if(d < 0.0f) d = 0.0f;
					int pos = (int)(d*(float)groups.size());
					if(pos >= groups.size()) pos = (int)groups.size()-1;
					if(pos < 0) pos = 0;
				
					groups[pos].p.push_back(P);
				}
				ingroups++;

				//if(ingroups%bunchSize==0) //no, bazilion of issues
				//{
				//	qApp->processEvents();
				//}
#ifdef GLOBAL_FALLBACK
				if((IsMouseDown() || GetEventsHappen()) && !liveModeGlob && fallback)
				{
					//Sleep(1);
					if(ingroups >= bunchSize)
					{ 
						dobreak = true;
//						printf("interrupt 02\n");fflush(stdout);
						break;
					}
				}
#endif
			}
			if(dobreak)
				break;
		}
#ifdef DO_PROFILE		
		Profile::ProfileDump("xparency groups", NULL);
#endif
		dobreak = false;
		unsigned drawn = 0;
		glBegin(GL_QUADS);
		for(int g = (int)groups.size()-1; g >= 0; g--)
		{
			const PolyGroup& gr = groups[g];
			unsigned int gs = (unsigned int)gr.p.size();
			for(unsigned int i = 0; i < gs; i++)
			{
				const Poly& p = gr.p[i];
				if(doGlsl) glVertexAttrib3f(hairGlsl.GetTangentLoc(),p.t[0].x, p.t[0].y, p.t[0].z);
				glColor4f(p.c[0].r,p.c[0].g, p.c[0].b, p.c[0].a*xpar);
				glVertex3d(p.v[0].x, p.v[0].y, p.v[0].z);

				if(doGlsl) glVertexAttrib3f(hairGlsl.GetTangentLoc(),p.t[1].x, p.t[1].y, p.t[1].z);
				glColor4f(p.c[1].r,p.c[1].g, p.c[1].b, p.c[1].a*xpar);
				glVertex3d(p.v[1].x, p.v[1].y, p.v[1].z);

				if(doGlsl) glVertexAttrib3f(hairGlsl.GetTangentLoc(),p.t[2].x, p.t[2].y, p.t[2].z);
				glColor4f(p.c[2].r,p.c[2].g, p.c[2].b, p.c[2].a*xpar);
				glVertex3d(p.v[2].x, p.v[2].y, p.v[2].z);

				if(doGlsl) glVertexAttrib3f(hairGlsl.GetTangentLoc(),p.t[3].x, p.t[3].y, p.t[3].z);
				glColor4f(p.c[3].r,p.c[3].g, p.c[3].b, p.c[3].a*xpar);
				glVertex3d(p.v[3].x, p.v[3].y, p.v[3].z);

				drawn++;

//				if( (drawn>bunchSize)&&((drawn/numS)%bunchSize==0) ) //no, bazilion of issues
	//			{
			//		if (qApp->hasPendingEvents()) SetEventsHappen() ;
//				}

	//			if((IsMouseDown() || GetEventsHappen()) && !liveModeGlob && fallback)
		//		{
			//		if(drawn/numS >= bunchSize)
				//	{
					//	dobreak = true;
					//	printf("interrupt 03\n");fflush(stdout);
				//		break;
			//		}
			//	}
			}
			//if(dobreak)
				//break;
		}
		glEnd();
#ifdef DO_PROFILE
		Profile::ProfileDump(" shaveHairUI::drawHairs xparent -- done", NULL);
#endif
		//////////// END GLSL ///////////////
		if(doGlsl)
		{
			hairGlsl.UnUseProgram();
		}
		glBindTexture(GL_TEXTURE_2D, 0);	
		/////////////////////////////////

		glPopClientAttrib();
		glPopAttrib();

	}
	else
	{
		unsigned int	h;
		unsigned int	s;
		int	v;

		//////////// GLSL ///////////////
		bool doGlsl = false;
		if(glslInited && (drawToken == kDrawActiveShadedHairs || drawToken == kDrawInactiveShadedHairs))
		{
			doGlsl = true;
			glPushAttrib(GL_ALL_ATTRIB_BITS);
			glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);

			glEnable ( GL_LIGHTING );

			hairGlsl.SetAmbDiff(nodePtr->getAmbDiff());
		//	hairGlsl.SetSpecular(nodePtr->getSpecular());
		//	hairGlsl.SetSpecularAmt(nodePtr->getGloss());
			hairGlsl.SetSpecular( nodePtr->getGloss());
			hairGlsl.SetSpecularAmt(nodePtr->getSpecular());
			hairGlsl.SetSpecularTint(nodePtr->getSpecularTint());
			hairGlsl.SetSpecularTint2(nodePtr->getSpecularTint2());
			hairGlsl.SetUseSSAO(false);
			hairGlsl.SetViewSize(view.portWidth(),view.portHeight());
			hairGlsl.UseProgram();

			if(hairGlsl.GetUseSSAO())	
				ssao.ActivateTexture(0);
		}
		/////////////////////////////////

		for (h = 0; h < numHairsToDraw; h++)
		{
			const shaveHairShape::DisplayHair&	hair = cache.displayHair[h];

			for (s = 0; s < hair.size(); s++)
			{
				const shaveHairShape::DisplayStrand&	strand = hair[s];

				glBegin(GL_QUADS);

				MVector tangent0;
				MVector tangent1;
				MVector p0;
				MVector p1;
				MVector p2;
				float   r0;
				float   r1;
				int numS = strand.verts.length()-1;
				float inumS = 1.0f/(float)numS;
				
				for (v = 0; v < numS; v++)
				{
					int vv = v+1;
					int vvv = v+2;
					float t1 = vv*inumS;;
					if(v == 0)	//root polygon
					{
						p0.x = strand.verts[0].x; 
						p0.y = strand.verts[0].y;
						p0.z = strand.verts[0].z;
						p1.x = strand.verts[1].x; 
						p1.y = strand.verts[1].y;
						p1.z = strand.verts[1].z;

						tangent0 = p1 - p0;
						tangent0.normalize();

						tangent1 = tangent0;
						
						r0 = strand.rootrad;
						r1 = strand.rootrad*(1.0f - t1) + strand.tiprad*t1;
						
					}
					else if(vv == numS) //tip poly
					{
						p0 = p1;
						//p0.x = strand.verts[v].x; 
						//p0.y = strand.verts[v].y;
						//p0.z = strand.verts[v].z;
						p1.x = strand.verts[vv].x; 
						p1.y = strand.verts[vv].y;
						p1.z = strand.verts[vv].z;

						tangent0 = tangent1;
						tangent1 = p1 - p0;
						tangent1.normalize();
						

						r0 = r1;
						r1 = strand.tiprad;
					}
					else
					{
						p0 = p1;
						p1.x = strand.verts[vv].x; 
						p1.y = strand.verts[vv].y;
						p1.z = strand.verts[vv].z;

						tangent0 = tangent1;
						if(vvv < (int)strand.verts.length())
						{
							p2.x = strand.verts[vvv].x; 
							p2.y = strand.verts[vvv].y;
							p2.z = strand.verts[vvv].z;
							tangent1 = p2 - p0;
						}
						else
						{
							tangent1 = p1 - p0;
						}
						tangent1.normalize();

						r0 = r1;
						r1 = strand.rootrad*(1.0f - t1) + strand.tiprad*t1;

					}
					if(p0 == p1)
						continue;

					
					MVector d0 = tangent0^viewDir;
					MVector d1 = tangent1^viewDir;
					d0.normalize();
					d1.normalize();

					MVector v0 = p0 + d0*r0;
					MVector v1 = p0 - d0*r0;
					MVector v2 = p1 - d1*r1;
					MVector v3 = p1 + d1*r1;
					
					if(doGlsl)
					{
						MColor c1(strand.colors[v].r,strand.colors[v].g,strand.colors[v].b);
						MColor c2(strand.colors[vv].r,strand.colors[vv].g,strand.colors[vv].b);
						
						if (drawToken == kDrawInactiveShadedHairs)
						{
							c1 *= 0.5;
							c2 *= 0.5;
						}
						glVertexAttrib3f(hairGlsl.GetTangentLoc(),tangent0.x,tangent0.y,tangent0.z);
						glColor4f(c1.r, c1.g, c1.b, 1.0f);
						glVertex3d(v0.x, v0.y, v0.z);

						glVertexAttrib3f(hairGlsl.GetTangentLoc(),tangent0.x,tangent0.y,tangent0.z);
						glColor4f(c1.r, c1.g, c1.b, 1.0f);
						glVertex3d(v1.x, v1.y, v1.z);

						glVertexAttrib3f(hairGlsl.GetTangentLoc(),tangent1.x,tangent1.y,tangent1.z);
						glColor4f(c2.r, c2.g, c2.b, 1.0f);
						glVertex3d(v2.x, v2.y, v2.z);

						glVertexAttrib3f(hairGlsl.GetTangentLoc(),tangent1.x,tangent1.y,tangent1.z);
						glColor4f(c2.r, c2.g, c2.b, 1.0f);
						glVertex3d(v3.x, v3.y, v3.z);
					}
					else
					{
						if (drawToken == kDrawActiveShadedHairs)
						{
							view.setDrawColor(
								MColor(
									strand.colors[v].r,
									strand.colors[v].g,
									strand.colors[v].b
								)
							);
						}
						else if (drawToken == kDrawInactiveShadedHairs)
						{
							view.setDrawColor(
								MColor(
									strand.colors[v].r * 0.5f,
									strand.colors[v].g * 0.5f,
									strand.colors[v].b * 0.5f
								)
							);
						}

						glVertex3d(v0.x, v0.y, v0.z);
						glVertex3d(v1.x, v1.y, v1.z);

						if (drawToken == kDrawActiveShadedHairs)
						{
							view.setDrawColor(
								MColor(
									strand.colors[vv].r,
									strand.colors[vv].g,
									strand.colors[vv].b
								)
							);
						}
						else if (drawToken == kDrawInactiveShadedHairs)
						{
							view.setDrawColor(
								MColor(
									strand.colors[vv].r * 0.5f,
									strand.colors[vv].g * 0.5f,
									strand.colors[vv].b * 0.5f
								)
							);
						}

						glVertex3d(v2.x, v2.y, v2.z);
						glVertex3d(v3.x, v3.y, v3.z);
					}
					

					//glVertex3d(
					//	strand.verts[v].x, strand.verts[v].y, strand.verts[v].z
					//);
				}

				glEnd();
				
			}
		}
		//////////// END GLSL ///////////////
		if(doGlsl)
		{
			hairGlsl.UnUseProgram();

			glPopClientAttrib();
			glPopAttrib();
		}
		glBindTexture(GL_TEXTURE_2D, 0);	
		/////////////////////////////////

		//ClearEvents();

#ifdef DO_PROFILE
		Profile::ProfileDump(" shaveHairUI::drawHairs -- done", NULL);
#endif
	}
#endif
	// nodePtr->dirties.BRUSH_JUST_MOVED = 0; //// crraaaaap!
}

void shaveHairUI::drawSsaoDepth( int drawToken, M3dView& view, const shaveHairShape::DisplayHairCache& cache, const MVector& viewDir ) const
{

	shaveHairShape*			nodePtr = dynamic_cast<shaveHairShape*>(surfaceShape());
	unsigned int numHairsToDraw = nodePtr->getNumDisplayHairs(false);
	
	if (numHairsToDraw > cache.displayHair.size())
		numHairsToDraw = (unsigned int)cache.displayHair.size();

	Matrix4 m;
	glGetFloatv(GL_MODELVIEW_MATRIX, m); //already set up by maya

	float maxz = -1000000.f;
	float minz = 1000000.f;
	float m4x4[4][4];
	memcpy(m4x4,m.entries,16*sizeof(float));
	MMatrix mm(m4x4);

	MBoundingBox b = nodePtr->boundingBoxTemp();
	b.transformUsing(mm);

	MPoint bmin = b.min();
	MPoint bmax = b.max();
	float z1 = (float)(-bmin.z);
	float z2 = (float)(-bmax.z);
	float znear = ( z1 < z2 ) ? z1 : z2;
	float zfar = ( z1 > z2 ) ? z1 : z2;
	ssaodepthGlsl.SetFarNear(zfar,znear);

	ssaodepth.MakeCurrent();

	glPushAttrib(GL_ALL_ATTRIB_BITS);
	glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);

	glEnable( GL_LIGHTING );
	glEnable( GL_DEPTH_TEST );
	glDisable( GL_CULL_FACE );

	ssaodepthGlsl.UseProgram();

	for (unsigned int h = 0; h < numHairsToDraw; h++)
	{
		const shaveHairShape::DisplayHair&	hair = cache.displayHair[h];

		for (unsigned int s = 0; s < hair.size(); s++)
		{
			const shaveHairShape::DisplayStrand&	strand = hair[s];

			glBegin(GL_QUADS);

			MVector tangent0;
			MVector tangent1;
			MVector p0;
			MVector p1;
			MVector p2;
			float   r0;
			float   r1;
			int numS = strand.verts.length()-1;
				
			for (int v = 0; v < numS; v++)
			{
				int vv = v+1;
				int vvv = v+2;
				float t1 = vv/(float)numS;
				if(v == 0)	//root polygon
				{
					p0.x = strand.verts[0].x; 
					p0.y = strand.verts[0].y;
					p0.z = strand.verts[0].z;
					p1.x = strand.verts[1].x; 
					p1.y = strand.verts[1].y;
					p1.z = strand.verts[1].z;

					tangent0 = p1 - p0;
					tangent0.normalize();

					tangent1 = tangent0;
						
					r0 = strand.rootrad;
					r1 = strand.rootrad*(1.0f - t1) + strand.tiprad*t1;
						
				}
				else if(vv == numS) //tip poly
				{
					p0 = p1;
					p1.x = strand.verts[vv].x; 
					p1.y = strand.verts[vv].y;
					p1.z = strand.verts[vv].z;

					tangent0 = tangent1;
					tangent1 = p1 - p0;
					tangent1.normalize();
						

					r0 = r1;
					r1 = strand.tiprad;
				}
				else
				{
					p0 = p1;
					p1.x = strand.verts[vv].x; 
					p1.y = strand.verts[vv].y;
					p1.z = strand.verts[vv].z;

					tangent0 = tangent1;
					if(vvv < (int)strand.verts.length())
					{
						p2.x = strand.verts[vvv].x; 
						p2.y = strand.verts[vvv].y;
						p2.z = strand.verts[vvv].z;
						tangent1 = p2 - p0;
					}
					else
					{
						tangent1 = p1 - p0;
					}
					tangent1.normalize();

					r0 = r1;
					r1 = strand.rootrad*(1.0f - t1) + strand.tiprad*t1;

				}
				if(p0 == p1)
					continue;

					
				MVector d0 = tangent0^viewDir;
				MVector d1 = tangent1^viewDir;
				d0.normalize();
				d1.normalize();

				MVector v0 = p0 + d0*r0;
				MVector v1 = p0 - d0*r0;
				MVector v2 = p1 - d1*r1;
				MVector v3 = p1 + d1*r1;
				
				glVertex3d(v0.x, v0.y, v0.z);
				glVertex3d(v1.x, v1.y, v1.z);
				glVertex3d(v2.x, v2.y, v2.z);
				glVertex3d(v3.x, v3.y, v3.z);
				
			}
			glEnd();
		}
	}

	ssaodepthGlsl.UnUseProgram();


	glPopClientAttrib();
	glPopAttrib();

	ssaodepth.ResetCurrent();	//FBO

}

void  shaveHairUI::drawSsao( int drawToken, M3dView& view, const shaveHairShape::DisplayHairCache& cache, const MVector& viewDir ) const
{

	shaveHairShape*			nodePtr = dynamic_cast<shaveHairShape*>(surfaceShape());

	///// BFO /////
	glPushAttrib(GL_ALL_ATTRIB_BITS);
	glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);

	glEnable( GL_LIGHTING );
	glEnable(GL_TEXTURE_2D);

	drawSsaoDepth( drawToken, view, cache, viewDir); 

	
	ssao.MakeCurrent();

	
//	if(ssaoGlsl.GetProgram() == 0 || !ssaoGlsl.IsVadlid())
//	{
//		if(ssaoGlsl.GetProgram() != 0)
//			ssaoGlsl.UnLoadShaders();
//		ssaoGlsl.LoadShaders();
//	}

	//float ssaorad = 0.007;
	//int   samples = 20;


	ssaoGlsl.SetRadius(1.0f/(float)view.portWidth());
	ssaoGlsl.SetSamples(25);
	
	

	ssaoGlsl.UseProgram();
	ssaodepth.ActivateTexture(1);

	
	//draw full screen quad
	glMatrixMode (GL_MODELVIEW);
	glPushMatrix ();
	glLoadIdentity ();
	glMatrixMode (GL_PROJECTION);
	glPushMatrix ();
	glLoadIdentity ();

	glBegin (GL_QUADS);
	glVertex3i (-1, -1, -1);
	glVertex3i (1, -1, -1);
	glVertex3i (1, 1, -1);
	glVertex3i (-1, 1, -1);
	glEnd ();

	glPopMatrix ();
	glMatrixMode (GL_MODELVIEW);
	glPopMatrix ();

	ssaoGlsl.UnUseProgram();

	glBindTexture(GL_TEXTURE_2D, 0);	

	glPopClientAttrib(); 
	glPopAttrib();

	ssao.ResetCurrent();	//BFO
}


#ifdef NEW_INSTNACE_DISPLAY
static GLfloat material_ambient[] = {0.1f, 0.1f, 0.1f, 1.0f};
static GLfloat material_specular[]= {0.1f, 0.1f, 0.1f, 1.0f};
static GLfloat material_shininess[]={.1f};
static GLfloat material_diffuse[] = {0.82f, 0.82f, 0.82f, 1.0f};



void shaveHairUI::drawInstances(int drawToken, M3dView& view) const
{
#if defined(WIN32) || defined(LINUX)
#ifndef GL_ACTIVE_TEXTURE
	if(!glActiveTexture)
	{
		glActiveTexture = (PFNGLATCIVETEXTUREPROC) getGlFncPtr("glActiveTexture");
		if(!glActiveTexture)
#ifdef WIN32
			MGlobal::displayInfo(MString("glActiveTexture not found (error")+ GetLastError() + ")");
#else
			MGlobal::displayInfo(MString("glActiveTexture not found"));
#endif
	}
#endif
#endif
	MStatus stat = MStatus::kSuccess;
	shaveHairShape*			nodePtr = dynamic_cast<shaveHairShape*>(surfaceShape());

	shaveDirties& dirties = nodePtr->dirties;
	if(dirties.DIRTY_HAIRCOUNT)
	{
		//do something there
	}

	/*const*/ shaveInstanceDisplay& cache = nodePtr->getInstanceDisplay();

	//printf("draw instance for node 0x%X nf %i\n",nodePtr,cache.faceCounts.length());fflush(stdout);
	

	glPushAttrib(GL_ALL_ATTRIB_BITS);
	glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);

	if(drawToken == kDrawInstancedShaded || 
	   drawToken == kDrawInstancedShadedOffset )
	{
		if(drawToken == kDrawInstancedShadedOffset)
			glEnable( GL_POLYGON_OFFSET_FILL );

		glEnable ( GL_LIGHTING );
		glEnable(GL_SMOOTH); 
		glEnable( GL_DEPTH_TEST );
		glEnable (GL_BLEND);
		glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

		if(cache.diffuse != 0 /*|| cache.xparenc != 0*/)
			glEnable(GL_TEXTURE_2D);

		glPolygonMode (GL_FRONT, GL_FILL);
		glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);

		glMaterialfv(GL_FRONT,GL_AMBIENT,material_ambient);
		glMaterialfv(GL_FRONT,GL_SPECULAR,material_specular);
		glMaterialfv(GL_FRONT,GL_SHININESS,material_shininess);
		

		if(cache.diffuse != 0)
		{
			if(glActiveTexture)
				glActiveTexture(GL_TEXTURE0); 

			glBindTexture(GL_TEXTURE_2D, cache.diffuse);
			
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

			glMatrixMode(GL_TEXTURE);
			glLoadIdentity();

			
		}
		else
			glMaterialfv(GL_FRONT,GL_DIFFUSE,material_diffuse);

		int oo=0;
		glBegin(GL_TRIANGLES);
		if(cache.hasXparency)
		{
			MDagPath camPath;
			MStatus stat = view.getCamera(camPath);
			MMatrix worldToCam = camPath.inclusiveMatrixInverse(); 

			MFnCamera camFn(camPath);
			MVector viewDir = camFn.viewDirection( MSpace::kWorld );
			MPoint centerPt(cache.center);
			MPoint nearPt = centerPt - viewDir*cache.radius;
			MPoint farPt = centerPt + viewDir*cache.radius;

			MPoint p = nearPt*worldToCam;
			MFloatPoint nearSc((float)p.x, (float)p.y, (float)p.z);
			
			p = farPt*worldToCam;
			MFloatPoint farSc((float)p.x, (float)p.y, (float)p.z);

			std::vector<Group> groups;
			groups.resize(100);

			for(unsigned int i = 0; i < cache.faceCounts.length(); i++)
			{
				
				int fc = cache.faceCounts[i];
				if(fc != 3)
					continue; //trianglular faces expected

				int fs = cache.faceStart[i];
				int fv = cache.faceVerts[fs];
				const MPoint& p = cache.points[fv];
				MPoint s = p*worldToCam;
				//float d = s.z-nearSc.z* (farSc.z-nearSc.z/(float)groups.size()); 
				float d = (s.z-nearSc.z)/(farSc.z-nearSc.z); 
				groups[(int)(d*(float)groups.size())].pids.append(i);
			}
			for(int xx = (int)groups.size()-1; xx >= 0; xx--)
			//for(int xx = 0; xx < groups.size(); xx++)
			{
				for(unsigned int zz = 0; zz < groups[xx].pids.length(); zz++)
				{
					int i = groups[xx].pids[zz];
					int fc = cache.faceCounts[i];
					if(fc != 3)
						continue; //trianglular faces expected

					int fs = cache.faceStart[i];
					int fe = cache.faceEnd[i];
					int jj = 0;
					for(int j = fs; j <  fe; j++)
					{
						int    k = cache.faceVerts[j];
						const MFloatPoint& p = cache.points[k];
						const MFloatPoint& t = cache.uvs[/*oo*/i*3 + jj];
						const MFloatPoint& n = cache.normals[k];
						//something is weird with this, normals are inverted...
						glNormal3f(-n.x, -n.y, -n.z );
						glTexCoord2f(t.x, t.y);
						glVertex3f(p.x,p.y, p.z);
						//oo++;
						jj++;
					}
				}
			}
		}
		else
		{
			for(unsigned int i = 0; i < cache.faceCounts.length(); i++)
			{
				
				int fc = cache.faceCounts[i];
				if(fc != 3)
					continue; //trianglular faces expected

				int fs = cache.faceStart[i];
				int fe = cache.faceEnd[i];
				for(int j = fs; j <  fe; j++)
				{
					int    k = cache.faceVerts[j];
					const MFloatPoint& p = cache.points[k];
					const MFloatPoint& t = cache.uvs[oo];
					const MFloatPoint& n = cache.normals[k];
					//something is weird with this, normals are inverted...
					glNormal3f(-n.x, -n.y, -n.z );
					glTexCoord2f(t.x, t.y);
					glVertex3f(p.x,p.y, p.z);
					oo++;
				}
			}
		}
		glEnd();

		if(cache.diffuse != 0)
		{
			glBindTexture(GL_TEXTURE_2D, 0);
		}
	}
	else if(drawToken == kDrawInstancedWire)
	{
		//glEnable( GL_POLYGON_OFFSET_LINE );
		
		glBegin( GL_LINES );
		for(unsigned int i = 0; i < cache.faceCounts.length(); i++)
		{
			
			int fc = cache.faceCounts[i];
			if(fc != 3)
				continue; //trianglular faces expected

			int fs = cache.faceStart[i];
			int fe = cache.faceEnd[i];
			for(int j = fs; j <  fe; j++)
			{
				int    jj = (j < fe-1) ? j + 1 : fs;
				int    k = cache.faceVerts[j];
				int    kk = cache.faceVerts[jj];
				const MPoint& p = cache.points[k];
				const MPoint& pp = cache.points[kk];
				glVertex3f(p.x,p.y, p.z);
				glVertex3f(pp.x,pp.y, pp.z);
			}
		}
		glEnd();
	}
	

	glPopClientAttrib();
	glPopAttrib();

}
#endif


void shaveHairUI::drawVerts(int drawToken) const
{
	//
	// Which verts will we be drawing?
	//
	bool	drawActive = false;
	int		startVert = 0;
	int		endVert = SHAVE_VERTS_PER_GUIDE - 1;

	switch (drawToken)
	{
		case kDrawActiveRoots:
			drawActive = true;
		case kDrawInactiveRoots:
			startVert = endVert = 0;
		break;

		case kDrawActiveTips:
			drawActive = true;
		case kDrawInactiveTips:
			startVert = endVert = SHAVE_VERTS_PER_GUIDE - 1;
		break;

		case kDrawActiveVerts:
			drawActive = true;
		case kDrawInactiveVerts:
			startVert = 0;
			endVert = SHAVE_VERTS_PER_GUIDE - 1;
		break;

		default:
			//
			// We should never get here, but if somehow we do then there's
			// nothing for us to draw.
			//
			return;
	}

	//
	// Get the guides.
	//
	shaveHairShape*			nodePtr = dynamic_cast<shaveHairShape*>(surfaceShape());

	const shaveHairShape::Guides& guides = nodePtr->getGuides().guides;

	//
	// Save the old point size for later restoration, and set the point
	// size that we'll be using.
	//
	float	oldPointSize;
	glGetFloatv(GL_POINT_SIZE, &oldPointSize);
	glPointSize(POINT_SIZE);

	//
	// Draw the guide vertices.
	//
	glBegin(GL_POINTS);

	int 		i;
	shaveHairShape::Guides::const_iterator	iter;

	for (iter = guides.begin(); iter != guides.end(); iter++)
	{
		const shaveHairShape::Guide&	guide = *iter;

		if (!guide.hidden)
		{
			for (i = startVert; i <= endVert ; i++)
			{
				//
				// Is this vert active?
				//
				bool	isActive = ((guide.select & (1 << i)) != 0);

				//
				// If the vert meets our drawing requirements, draw it.
				//
				if (drawActive == isActive)
				{
					glVertex3f(
						guide.verts[i].x, guide.verts[i].y, guide.verts[i].z
					);
				}
			}
		}
	}

	glEnd();

	glPointSize(oldPointSize);
}


bool shaveHairUI::selectGuides(
		MSelectInfo&	selectInfo,
		MSelectionList&	selectionList,
		MPointArray&	worldSpaceSelectPts
) const
{
	//
	// Create a component to store the selected guides.
	//
	MFnSingleIndexedComponent	compFn;
	MObject						compObj;

	compObj = compFn.create(shaveHairShape::kShaveGuideComponent);

	//
	// In single-selection mode we'll use the alignmentMatrix to determine
	// which of multiple hits is closest to the viewer.
	//
	MMatrix		alignmentMatrix;
	MPoint		singlePoint; 
	bool		singleSelection = selectInfo.singleSelection();
	MDagPath	path = selectInfo.multiPath();

	if (singleSelection)
	{
		alignmentMatrix = selectInfo.getAlignmentMatrix();

		//
		// I don't know for sure, but I'm willing to bet that the
		// alignmentMatrix is expecting local-space points.  Our points are
		// all in worldSpace to we have to multiply in a localSpace
		// transformation for it to work properly.
		//
		alignmentMatrix = path.inclusiveMatrixInverse() * alignmentMatrix;
	}

	//
	// Make sure that this shaveNode is loaded into the engine.
	//
	shaveHairShape*	nodePtr = dynamic_cast<shaveHairShape*>(surfaceShape());
	nodePtr->makeCurrent();

	//
	// Check the guide segments for selection hits.
	//
	SOFTGUIDE	guide;
	int			guideIndex;
	int 		i;
	int			closestGuideIndex = -1;
	MPoint		closestPt;
	float		closestXformedZ = 0.0f;
	M3dView		view = selectInfo.view();

	for (guideIndex = 0;
		SHAVEfetch_guide(guideIndex, &guide) != -1;
		guideIndex++)
	{
		if (guide.hidden) continue;

		view.beginSelect();
		glBegin(GL_LINES);

		//	To speed things up, we skip over the even verts.
		for (i = 0; i < SHAVE_VERTS_PER_GUIDE-2; i += 2)
		{
			glVertex3f(
				guide.guide[i].x, guide.guide[i].y, guide.guide[i].z
			);
			glVertex3f(
				guide.guide[i+2].x, guide.guide[i+2].y, guide.guide[i+2].z
			);
		}

		glEnd();

		if (view.endSelect() > 0)
		{
			//
			// We got a hit so store it.
			//
			if (singleSelection)
			{
				//
				// On singleSelection we only store the hit closest to
				// the viewer.  We'll use the midpoint of the guide
				// as our hit point. (We used to test each segment
				// individually, which gave us a more accurate result, but
				// was much slower.)
				//
				MPoint	currentPt(
							(guide.guide[0].x
								+ guide.guide[SHAVE_VERTS_PER_GUIDE-1].x) / 2.0,
							(guide.guide[0].y
								+ guide.guide[SHAVE_VERTS_PER_GUIDE-1].y) / 2.0,
							(guide.guide[0].z
								+ guide.guide[SHAVE_VERTS_PER_GUIDE-1].z) / 2.0
						);
				MPoint	xformedPt = currentPt;

				xformedPt.homogenize();
				xformedPt *= alignmentMatrix;

				float	xformedZ = (float)xformedPt.z;

				if ((closestGuideIndex < 0)
				||	(xformedZ < closestXformedZ))
				{
					closestGuideIndex = guideIndex;
					closestPt = currentPt;
					closestXformedZ = xformedZ;
				}
			}
			else
			{
				//
				// On multiple selection we store all guides which are
				// hit.
				//
				compFn.addElement(guideIndex);
			}
		}
	}

	//
	// If we were doing singleSelection then store the closest hit that we
	// got.
	//
	if (closestGuideIndex >= 0)
	{
		compFn.addElement(closestGuideIndex);

		//
		// Convert the hit point to worldspace.
		//
		closestPt *= path.inclusiveMatrix();
	}


	if (!compFn.isEmpty())
	{
		MSelectionList	newSelections;

		newSelections.add(path, compObj);

		MSelectionMask	mask(MSelectionMask::kSelectComponentsMask);

		selectInfo.addSelection(
			newSelections,
			closestPt,
			selectionList,
			worldSpaceSelectPts,
			mask,
			true
		);
	}

	return !compFn.isEmpty();
}


bool shaveHairUI::selectObjByGuides(
		MSelectInfo&	selectInfo,
		MSelectionList&	selectionList,
		MPointArray&	worldSpaceSelectPts
) const
{
	SOFTGUIDE	guide;
	int			guideIndex;
	int 		i;
	M3dView		view = selectInfo.view();
	MPoint		samplePt;

	view.beginSelect();

	for (guideIndex = 0;
		SHAVEfetch_guide(guideIndex, &guide) != -1;
		guideIndex++)
	{
		if (guide.hidden) continue;

		//	In single-selection mode we need to return the point on our
		//	object which is "closest to the viewer".  However, to really do
		//	that for hair is extremely expensive and slows down the picking
		//	of everything.  So instead we just return the first first of
		//	the first guide. That means that if there are other objects
		//	within the pickbox then they will likely win, but the user can
		//	avoid that by using the Outliner or zooming in for a more
		//	accurate pick.
		if (guideIndex == 0)
		{
			samplePt.x = (double)guide.guide[0].x;
			samplePt.y = (double)guide.guide[0].y;
			samplePt.z = (double)guide.guide[0].z;
		}

		glBegin(GL_LINE_STRIP);

		for (i = 0; i < SHAVE_VERTS_PER_GUIDE; i++)
			glVertex3f(guide.guide[i].x, guide.guide[i].y, guide.guide[i].z);

		glEnd();
	}

	if (view.endSelect() > 0)
	{
		MSelectionMask	priorityMask(MSelectionMask::kSelectNurbsSurfaces);
		MSelectionList	newItem;
		MDagPath		path = selectInfo.selectPath();

		newItem.add(path);

		selectInfo.addSelection(
			newItem,
			samplePt,
			selectionList,
			worldSpaceSelectPts,
			priorityMask,
			false
		);

		return true;
	}

	return false;
}


bool shaveHairUI::selectObjByHairs(
		MSelectInfo&	selectInfo,
		MSelectionList&	selectionList,
		MPointArray&	worldSpaceSelectPts
) const
{
	shaveHairShape*	nodePtr = dynamic_cast<shaveHairShape*>(surfaceShape());
	M3dView			view = selectInfo.view();

	//const std::vector<shaveHairShape::DisplayHair>& displayHairs = nodePtr->getDisplayHairs();
	//M3dView view = M3dView::active3dView();
	const shaveHairShape::DisplayHairCache& cache = nodePtr->getDisplayHairs(view); 

	//
	// Determine the number of hairs to be drawn.
	//
	unsigned	numHairsToDraw = nodePtr->getNumDisplayHairs(false);

	if (numHairsToDraw > cache.displayHair.size())
		numHairsToDraw = (unsigned int)cache.displayHair.size();

	//
	// Draw the hairs.
	//
	unsigned	h;
	unsigned	s;
	unsigned	v;
	MPoint		samplePt;

	view.beginSelect();

	for (h = 0; h < numHairsToDraw; h++)
	{
		const shaveHairShape::DisplayHair&	hair = cache.displayHair[h];

		for (s = 0; s < hair.size(); s++)
		{
			const shaveHairShape::DisplayStrand&	strand = hair[s];

			//	In single-selection mode we need to return the point on our
			//	object which is "closest to the viewer".  However, to
			//	really do that for hair is extremely expensive and slows
			//	down the picking of everything.  So instead we just return
			//	the first first of the first guide. That means that if
			//	there are other objects within the pickbox then they will
			//	likely win, but the user can avoid that by using the
			//	Outliner or zooming in for a more accurate pick.
			if ((h == 0) && (s == 0))
			{
				samplePt.x = strand.verts[0].x;
				samplePt.y = strand.verts[0].y;
				samplePt.z = strand.verts[0].z;
			}

			glBegin(GL_LINE_STRIP);

			for (v = 0; v < strand.verts.length(); v++)
			{
				glVertex3d(
					strand.verts[v].x, strand.verts[v].y, strand.verts[v].z
				);
			}

			glEnd();
		}
	}

	if (view.endSelect() > 0)
	{
		MSelectionMask	priorityMask(MSelectionMask::kSelectNurbsSurfaces);
		MSelectionList	newItem;
		MDagPath		path = selectInfo.selectPath();

		newItem.add(path);

		selectInfo.addSelection(
			newItem,
			samplePt,
			selectionList,
			worldSpaceSelectPts,
			priorityMask,
			false
		);

		return true;
	}

	return false;
}

bool shaveHairUI::selectObjByGeom(
		MSelectInfo&	selectInfo,
		MSelectionList&	selectionList,
		MPointArray&	worldSpaceSelectPts
) const
{
	shaveHairShape*	nodePtr = dynamic_cast<shaveHairShape*>(surfaceShape());
	M3dView			view = selectInfo.view();

	shaveInstanceDisplay& cache = nodePtr->getInstanceDisplay();

	//
	// Draw the hairs.
	//
	MPoint		samplePt;

	view.beginSelect();

	glBegin( GL_LINES );
	for(unsigned int i = 0; i < cache.faceCounts.length(); i++)
	{
		
		int fc = cache.faceCounts[i];
		if(fc != 3)
			continue; //trianglular faces expected

		int fs = cache.faceStart[i];
		int fe = cache.faceEnd[i];
		for(int j = fs; j <  fe; j++)
		{
			int    jj = (j < fe-1) ? j + 1 : fs;
			int    k = cache.faceVerts[j];
			int    kk = cache.faceVerts[jj];
			const MPoint& p = cache.points[k];
			const MPoint& pp = cache.points[kk];
			glVertex3f(p.x,p.y, p.z);
			glVertex3f(pp.x,pp.y, pp.z);
		}
	}
	glEnd();

	if (view.endSelect() > 0)
	{
		MSelectionMask	priorityMask(MSelectionMask::kSelectNurbsSurfaces);
		MSelectionList	newItem;
		MDagPath		path = selectInfo.selectPath();

		newItem.add(path);

		selectInfo.addSelection(
			newItem,
			samplePt,
			selectionList,
			worldSpaceSelectPts,
			priorityMask,
			false
		);

		return true;
	}

	return false;
}




bool shaveHairUI::selectVerts(
		MString			selectMode,
		MSelectInfo&	selectInfo,
		MSelectionList&	selectionList,
		MPointArray&	worldSpaceSelectPts
) const
{
	// Use the guide selection mode to determine which vertices to
	// check.
	//
	int		startVert = 0;
	int		endVert = SHAVE_VERTS_PER_GUIDE - 1;
	bool	entireGuide = false;

	if (selectMode == "root")
	{
		startVert = endVert = 0;

		// In 'root' mode we are selecting entire guides by their root
		// verts.
		//
		entireGuide = true;
	}
	else if (selectMode == "tip")
	{
		startVert = endVert = SHAVE_VERTS_PER_GUIDE - 1;
	}
	else if (selectMode == "vert")
	{
		startVert = 0;
		endVert = SHAVE_VERTS_PER_GUIDE - 1;
	}
	else
		return false;

	// Create a component to store the selected verts/guides.
	//
	MFnSingleIndexedComponent	guideCompFn;
	MFnDoubleIndexedComponent	vertCompFn;
	MObject						compObj;

	if (entireGuide)
		compObj = guideCompFn.create(shaveHairShape::kShaveGuideComponent);
	else
		compObj = vertCompFn.create(shaveHairShape::kShaveGuideVertComponent);

	// In single-selection mode we'll use the alignmentMatrix to determine
	// which of multiple hits is closest to the viewer.
	//
	MMatrix		alignmentMatrix;
	MPoint		singlePoint; 
	bool		singleSelection = selectInfo.singleSelection();
	MDagPath	path = selectInfo.multiPath();

	if (singleSelection)
	{
		alignmentMatrix = selectInfo.getAlignmentMatrix();

		// I don't know for sure, but I'm willing to bet that the
		// alignmentMatrix is expecting local-space points.  Our points are
		// all in worldSpace to we have to multiply in a localSpace
		// transformation for it to work properly.
		//
		alignmentMatrix = path.inclusiveMatrixInverse() * alignmentMatrix;
	}

	// Save the old point size for later restoration, and set the point
	// size that we'll be using.
	//
	M3dView	view = selectInfo.view();
	float	oldPointSize;

	view.beginGL();
	glGetFloatv(GL_POINT_SIZE, &oldPointSize);
	glPointSize(POINT_SIZE);
	view.endGL();

	// Make sure that this shaveNode is loaded into the engine.
	//
	shaveHairShape*	nodePtr = dynamic_cast<shaveHairShape*>(surfaceShape());
	nodePtr->makeCurrent();

	// Check the guide vertices for selection hits.
	//
	SOFTGUIDE	guide;
	int			guideIndex;
	int 		i;
	int			closestGuideIndex = -1;
	int			closestVertIndex = -1;
	MPoint		closestPt;
	float		closestXformedZ = 0.0f;

	for (guideIndex = 0;
		SHAVEfetch_guide(guideIndex, &guide) != -1;
		guideIndex++)
	{
		if (guide.hidden) continue;

		for (i = startVert; i <= endVert ; i++)
		{
			view.beginSelect();
			glBegin(GL_POINTS);
			glVertex3f(guide.guide[i].x, guide.guide[i].y, guide.guide[i].z);
			glEnd();

			if (view.endSelect() > 0)
			{
				// We got a hit so store it.
				//
				if (singleSelection)
				{
					// On singleSelection we only store the hit closest to
					// the viewer.
					//
					MPoint	currentPt(
								guide.guide[i].x,
								guide.guide[i].y,
								guide.guide[i].z
							);
					MPoint	xformedPt = currentPt;

					xformedPt.homogenize();
					xformedPt *= alignmentMatrix;

					float	xformedZ = (float)xformedPt.z;

					if ((closestGuideIndex < 0)
					||	(xformedZ < closestXformedZ))
					{
						closestGuideIndex = guideIndex;
						closestVertIndex = i;
						closestPt = currentPt;
						closestXformedZ = xformedZ;
					}
				}
				else
				{
					// On multiple selection we store all hits.
					//
					if (entireGuide)
					{
						guideCompFn.addElement(guideIndex);
						break;
					}
					else
						vertCompFn.addElement(guideIndex, i);
				}
			}
		}
	}

	// If we were doing singleSelection then store the closest hit that we
	// got.
	//
	if (closestGuideIndex >= 0)
	{
		if (entireGuide)
			guideCompFn.addElement(closestGuideIndex);
		else
			vertCompFn.addElement(closestGuideIndex, closestVertIndex);

		// Convert the hit point to worldspace.
		//
		closestPt *= path.inclusiveMatrix();
	}

	bool	haveSelection = !guideCompFn.isEmpty() || !vertCompFn.isEmpty();

	if (haveSelection)
	{
		MSelectionList	newSelections;

		newSelections.add(path, compObj);

		MSelectionMask	mask(MSelectionMask::kSelectComponentsMask);

		selectInfo.addSelection(
			newSelections,
			closestPt,
			selectionList,
			worldSpaceSelectPts,
			mask,
			true
		);
	}

	// Restore the point size.
	//
	view.beginGL();
	glPointSize(oldPointSize);
	view.endGL();

	return haveSelection;
}


//
// Maya Bug:	In Maya 6.5 MDrawRequest::setDisplayStatus() doesn't work,
// 				so we have to pass the display status as a separate arg
// 				rather than the caller setting it in 'request'.
//
void shaveHairUI::setWireframeColor(
		MDrawRequest& request, M3dView& view, M3dView::DisplayStatus dStatus
) const
{
	M3dView::ColorTable		colorTable = M3dView::kDormantColors;
	int						colorIndex = 0;

	switch (dStatus)
	{
		case M3dView::kActive:
			colorIndex = ACTIVE_SURFACE_COLOR;
			colorTable = M3dView::kActiveColors;
		break;

		case M3dView::kActiveComponent:
			colorIndex = DORMANT_SURFACE_COLOR;
			colorTable = M3dView::kDormantColors;
		break;

		case M3dView::kHilite:
			colorIndex = HILITE_COLOR;
			colorTable = M3dView::kActiveColors;
		break;

		case M3dView::kTemplate:
			colorIndex = 0;
			colorTable = M3dView::kTemplateColor;
		break;

		case M3dView::kActiveTemplate:
			colorIndex = ACTIVE_TEMPLATE_COLOR;
			colorTable = M3dView::kActiveColors;
		break;

		case M3dView::kLead:
			colorIndex = LEAD_COLOR;
			colorTable = M3dView::kActiveColors;
		break;

		case M3dView::kActiveAffected:
			colorIndex = ACTIVE_AFFECTED_COLOR;
			colorTable = M3dView::kActiveColors;
		break;

		case M3dView::kLive:
			//
			// %%%	This is not correct.  If we think we might allow
			//		hair to become a live construction surface, then we
			//		should determine the correct settings.
			//
			colorIndex = ACTIVE_SURFACE_COLOR;
			colorTable = M3dView::kActiveColors;
		break;

		case M3dView::kDormant:
		{
			//
			// If our drawing overrides are on, then use the specified
			// override colour.
			//
			MFnDependencyNode	nodeFn(surfaceShape()->thisMObject());
			bool				colourOverridden;

			colorIndex = -1;

			MPlug	plug = nodeFn.findPlug("overrideEnabled");
			plug.getValue(colourOverridden);

			if (colourOverridden)
			{
				plug = nodeFn.findPlug("overrideColor");
				plug.getValue(colorIndex);

				//
				// The colour index contained in the 'overrideColor'
				// attribute is one greater than the actual colour index
				// (so that 0 can represent the override colour being
				// disabled).  To get the correct colour index, we must
				// decrement the value just retrieved by 1.
				//
				--colorIndex;
			}

			//
			// If no override colour was specified, then check to
			// see if we've been assigned a user-defined colour.
			//
			if (colorIndex == -1)
			{
				plug.setAttribute(shaveHairShape::useObjectColor);
				plug.getValue(colourOverridden);

				if (colourOverridden)
				{
					int	userIndex;

					plug.setAttribute(shaveHairShape::objectColor);
					plug.getValue(userIndex);

					colorIndex = view.userDefinedColorIndex(
									userIndex
								);
				}
				else
				{
					//
					// None of the various overrides are in use, so
					// just draw the wireframe in the default
					// dormant surface colour.
					//
					colorIndex = DORMANT_SURFACE_COLOR;
				}
			}

			colorTable = M3dView::kDormantColors;
		}
		break;

		case M3dView::kInvisible:
		case M3dView::kIntermediateObject:
		case M3dView::kNoStatus:
		default:
			//	Nothing to draw.
			return;
	}

	request.setColor(colorIndex, colorTable);
}