void Mesh::writemesh(char *out_path){
	fstream outfile;
	double p=3.14;double r=3.0;
	outfile.open(out_path,ios::out);
	outfile<<96<<" "<<20<<" "<<134<<"\n\n";
	double N=4.0;
	GLfloat theta = ( 2.0f * 3.1415926536 ) / N;
	for(double i=0;i<=10;i+=(p/6))
	{
		r+=(p/6);
		for(double c=0;c<N;c++){
		outfile<<r*cos(theta * c)<<" "<<r*sin(theta * c)<<" "<<i<<"\n";
		}
 
 
		/*outfile<<(4+cos(r*p/6))*cos(i)<<" "<<(4+cos(r*p/6))*cos(i)+1.0<<" "<<(r*p/6)*sin(i)+2.0<<"\n";
		outfile<<(4+cos(r*p/6))*cos(i)<<" "<<(4+cos(r*p/6))*cos(i)+2.0<<" "<<(r*p/6)*sin(i)+2.0<<"\n";
		outfile<<(4+cos(r*p/6))*cos(i)<<" "<<(4+cos(r*p/6))*cos(i)+2.0<<" "<<(r*p/6)*sin(i)+1.0<<"\n";
		outfile<<(4+cos(r*p/6))*cos(i)<<" "<<(4+cos(r*p/6))*cos(i)+1.0<<" "<<(r*p/6)*sin(i)+1.0<<"\n";*/
	}
	outfile<<"\n";
	outfile<<"0 0 0"<<"\n";
	outfile<<"\n";
	for(double i=0;i<48;i=i+4.0)
	{
		outfile<<N;
		for(double j=0;j<N;j++)
		{
			outfile<<" "<<i+j<<" 0";
		}
		outfile<<"\n";
 
		outfile<<"4 "<<i+1<<" 0 "<<i+5.0<<" 0 "<<i+6.0<<" 0 "<<i+2.0<<" 0"<<"\n";
		outfile<<"4 "<<i<<" 0 "<<i+4.0<<" 0 "<<i+5.0<<" 0 "<<i+1.0<<" 0"<<"\n";
		outfile<<"4 "<<i+2.0<<" 0 "<<i+6.0<<" 0 "<<i+7.0<<" 0 "<<i+3.0<<" 0"<<"\n";
		outfile<<"4 "<<i<<" 0 "<<i+3.0<<" 0 "<<i+7<<" 0 "<<i+4.0<<" 0"<<"\n";	
	}
	outfile.close();
}

#include <stdio.h>
#include <GL/glew.h>
#include <GL/freeglut.h>
#include "math_3d.h"
 
GLuint VBO;
 
static void RenderSceneCB()
{
    glClear(GL_COLOR_BUFFER_BIT);
 
    glEnableVertexAttribArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
 
    glDrawArrays(GL_POINTS, 0, 1);
 
    glDisableVertexAttribArray(0);
 
    glutSwapBuffers();
}
 
 
static void InitializeGlutCallbacks()
{
    glutDisplayFunc(RenderSceneCB);
}
 
static void CreateVertexBuffer()
{
    Vector3f Vertices[1];
    Vertices[0] = Vector3f(0.0f, 0.0f, 0.0f);
 
 	glGenBuffers(1, &VBO);
	glBindBuffer(GL_ARRAY_BUFFER, VBO);
	glBufferData(GL_ARRAY_BUFFER, sizeof(Vertices), Vertices, GL_STATIC_DRAW);
}
 
 
int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA);
    glutInitWindowSize(1024, 768);
    glutInitWindowPosition(100, 100);
    glutCreateWindow("Tutorial 02");
 
    InitializeGlutCallbacks();
 
    // Must be done after glut is initialized!
    GLenum res = glewInit();
    if (res != GLEW_OK) {
      fprintf(stderr, "Error: '%s'\n", glewGetErrorString(res));
      return 1;
    }
 
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
 
    CreateVertexBuffer();
 
    glutMainLoop();
 
    return 0;
}

obj\Debug\main.o||In function `RenderSceneCB':|
C:\C Programs\OpenGL Test\main.cpp|33|undefined reference to `_imp____glewEnableVertexAttribArray'|
C:\C Programs\OpenGL Test\main.cpp|34|undefined reference to `_imp____glewBindBuffer'|
C:\C Programs\OpenGL Test\main.cpp|35|undefined reference to `_imp____glewVertexAttribPointer'|
C:\C Programs\OpenGL Test\main.cpp|39|undefined reference to `_imp____glewDisableVertexAttribArray'|
obj\Debug\main.o||In function `CreateVertexBuffer':|
C:\C Programs\OpenGL Test\main.cpp|55|undefined reference to `_imp____glewGenBuffers'|
C:\C Programs\OpenGL Test\main.cpp|56|undefined reference to `_imp____glewBindBuffer'|
C:\C Programs\OpenGL Test\main.cpp|57|undefined reference to `_imp____glewBufferData'|
obj\Debug\main.o||In function `main':|
C:\C Programs\OpenGL Test\main.cpp|72|undefined reference to `_imp__glewInit'|
C:\C Programs\OpenGL Test\main.cpp|74|undefined reference to `_imp__glewGetErrorString'|
||=== Build finished: 9 errors, 0 warnings (0 minutes, 0 seconds) ===|

#include <GL/glut.h>
#include <math.h>
# include <stdio.h>
# include <string.h>
#include <GL/bitmap.h>
BITMAPINFO *imginfo;
GLubyte *img;
void init(void)
{
    glClearColor(0.0,0.0,0.0,0.0); //establece el color de la ventana de visualización en blanco
    glMatrixMode(GL_PROJECTION); //establece los parámetros de proyección
    gluOrtho2D(0.0,210.0,0.0,210.0); //define una matriz deproyección ortográfica 2D, esl amitad de lo que se especificó en
                                //en windowsSize.
}
void tex(char *textura)
{
 
	//img = LoadDIBitmap("1.bmp", &imginfo);
	img = LoadDIBitmap(textura, &imginfo);
 
    glTexImage2D(GL_TEXTURE_2D, 0, 3,imginfo->bmiHeader.biWidth,imginfo->bmiHeader.biHeight, 0, GL_RGB,GL_UNSIGNED_BYTE, img);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 
    glEnable(GL_TEXTURE_2D);
    glEnable(GL_TEXTURE_GEN_S);
    glEnable(GL_TEXTURE_GEN_T);
    glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
    glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
 
 
 
}
 
void textura()
{
    glDisable(GL_TEXTURE_2D);
    glDisable(GL_TEXTURE_GEN_S);
    glDisable(GL_TEXTURE_GEN_T);
}
 
void cuadrado(void)
{
 
	GLfloat angulo;
	int i; 
	glBegin(GL_LINES);
	for (i=0; i<360; i+=3)
	{
      angulo = (GLfloat)i*3.14159f/180.0f; // grados a radianes
      glVertex3f(0.0f, 0.0f, 0.0f);
      glVertex3f(cos(angulo), sin(angulo), 0.0f);
	}
	glEnd();//Finaliza el dibujo
	//glFlush();
	glPushMatrix();
    glColor3f(3,4,0.5);
   tex("1.bmp");
    glutSolidSphere(30,60,60);
    textura();
    glPopMatrix();
 
}
void lee()
{
cuadrado();
glFlush();
}
 
int main(int argc, char ** argv)
{
 
        glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); //Funcion Main
	glutInitWindowPosition(20,20); //Posicion de Ventana
	glutInitWindowSize(600,450); //Cambiar Tamaño de Ventana
	glutCreateWindow("Figuras OpenGL"); //Crea y cambia el nombre de la ventana
    init();
 
	glutDisplayFunc(lee);//se pintan todas las figuras
 
	glutMainLoop(); //Loop
 
	return 0;
 
 
 
 
	return 0;
}

#version 150
 
layout(shared) uniform scene
{
     float A;
     float B;
     float C;
};
 
out float result;
 
void main()
{
     result = A + B;
}

        float offset[5] = { 0.0, 1.0, 2.0, 3.0, 4.0 };
        float weight[5] = { 0.2270270270, 0.1945945946, 0.1216216216, 0.0540540541, 0.0162162162 };
 
        anchors.fill: parent
 
        vertexShader: "
            uniform mat4 matrix;
            uniform float scale;
            attribute vec4 gl_Vertex;
            attribute vec2 gl_MultiTexCoord0;
            varying vec2 coord;
            void main() {
                coord = gl_MultiTexCoord0;
                coord.x /= scale;
                lowp vec4 vertex = gl_Vertex;
                vertex.x *= scale;
                gl_Position = matrix * vertex;
            }"
        fragmentShader: "
            varying vec2 coord;
            uniform sampler2D src;
            uniform float qt_Opacity;
            uniform float textureWidth;
            uniform float offset[5];
            uniform float weight[5];
            void main() {
                vec4 acc = texture2D(src, coord / textureWidth) * weight[0];
                for (int i = 1; i < 5; i++)
                {
                   acc += texture2D(src, coord + vec2(offset[i] / textureWidth, 0.0)) * weight[i];
                   acc += texture2D(src, coord - vec2(offset[i] / textureWidth, 0.0)) * weight[i];
                }
                gl_FragColor = acc;
            }"
    }

//Create the textures and obtain the handles
foreach instance
	glGenTextures(1, &this->gpuTextureId);
	glBindTexture(GL_TEXTURE_2D, this->gpuTextureId);
 
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, ResX, ResY, 0, GL_RGBA, GL_UNSIGNED_BYTE, info); 
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);	// Linear Filtering
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);	// Linear Filtering
 
	// Get a handle for the texture.
	this->gpuTextureHandlerId = glGetTextureHandleNV(this->gpuTextureId);
 
	// Make the handle resident before using it.
	glMakeTextureHandleResidentNV(this->gpuTextureHandlerId);
endfor
//Pass the handle to the buffer
	#define INSTANCE_TEXTURE_LOCATION 6
 
	glGenBuffers(1, &this->instanceTextureHandlerVboId);
	glBindBuffer(this->instanceTextureHandlerVboId);
 
	glEnableVertexAttribArray(INSTANCE_TEXTURE_LOCATION);
	glVertexAttribPointer(INSTANCE_TEXTURE_LOCATION, 1, GL_UNSIGNED_INT64_NV, GL_FALSE, sizeof(GLuint64), 0); 
	glVertexAttribDivisor(INSTANCE_TEXTURE_LOCATION, 1);
 
	glBufferData(GL_ARRAY_BUFFER, sizeof(GLuint64) * this->numElements, instanceTextureHandle, GL_DYNAMIC_DRAW); //instanceTextureHandle contains the texture handles for all the instances.

#version 430
#extension GL_NV_bindless_texture : require
#extension GL_NV_gpu_shader5 : require 
 
in vec2 ex_textCoord;
layout(location = 6) in  uint64_t in_textHandler;
 
out vec4 out_Color;
 
void main(void)
{
	sampler2D s = sampler2D(in_textHandler);
	out_Color = texture(s, ex_textCoord);
}

    // open file    FILE *fp = fopen(filename.c_str(),"rb");
    if (fp == NULL) {
        return false;
    }
    // read in file marker, make sure its a DDS file
 
    char filecode[4];
    fread(filecode, 1, 4, fp);
    if (strncmp(filecode, "DDS ", 4) != 0) {
        fclose(fp);
        return false;
    }
 
    // read in DDS header
    DDS_HEADER ddsh;
 
 
 
 
    fread(&ddsh, 1,sizeof( DDS_HEADER ), fp);//sizeof( DDS_HEADER )

template <typename T>
 inline QuaternionT<T>  QuaternionT<T>::CreateFromAxisAngle(const Vector3<T>& axis, float radians)
 {
QuaternionT<T> q;
q.w = std::cos(radians / 2);
q.x = q.y = q.z = std::sin(radians / 2);
q.x *= axis.x;
q.y *= axis.y;
q.z *= axis.z;
return q;
}