últimos mensajes de: class_OpenGL

Mostrar Mensajes
Páginas: 1 ... 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 [36] 37 38 39 40 41 42 43 44 45

351	Programación / Programación C/C++ / Re: ayuda con getline	en: 26 Febrero 2016, 02:39 am
El método std::istream::getline está definido así: Código istream& getline (char* s, streamsize n ); istream& getline (char* s, streamsize n, char delim ); Es decir, el primer parámetro es de tipo cadena estilo C (es decir, tipo char) y lo que tu le estás pasando es una cadena estilo C++*, es decir, de tipo string. Para solucionar esto, tienes dos opciones: o bien declarar la cadena 'f' como char f[100], o bien usas la función std::getline, la cual está definida así: Código istream& getline (istream& is, string& str); istream& getline (istream& is, string& str, char delim);

352

Programación / Programación General / Re: Movimiento local 3D

en: 10 Febrero 2016, 05:51 am

1º aclaración: un valor arbitrario es aquel valor que tu decides, no es un valor aleatorio.
2º Aclaración: Vas a necesitar saber sobre matrices para entender todo lo que voy a explicar abajo.

//////////////////////////////////////////////////////////////

Bueno, sabiendo que trabajas con el OpenGL antiguo, te puedo indicar mejor.

Cuando rotas con glTranslatef, los tres últimos parámetros son vectores que representan ejes de rotación. Entonces, en resumidas cuentas, hay que seguir estos pasos:

1º Paso (Opcional): Declarar una estructura llamada vec3, que represente un vector en 3D:

Código

struct vec3 {
    float x;
    float y;
    float z;
};

Además de una estructura que represente una matriz de 3x3:

Código

struct mat3 {
    float elementos[3][3];
};

2º Paso: Declarar un vector 3D que represente la dirección relativa en la que quieres mover el cubo (en tu caso, como lo quieres mover por el eje X, pues el vector sería (1, 0, 0)):

Código

vec3 eje_desplazamiento = {1, 0, 0};

3º Paso: Crear matriz de rotación. Para realizar este paso, debes saber que la matriz de rotación sobre un eje es la siguiente:

Una vez sabido esto, declaramos una función que asigne una matriz de rotación a nuestra matriz:

Código

void rotar_matriz(float angulo, mat3& matriz, vec3& eje) {
    matriz.elementos[0][0] = cos(angulo) + pow(eje.x, 2.0)*(1 - cos(angulo));
    matriz.elementos[0][1] = eje.x*eje.y*(1 - cos(angulo)) - eje.z*sin(angulo);
    matriz.elementos[0][2] = eje.x*eje.z*(1 - cos(angulo)) + eje.y*sin(angulo);
 
    matriz.elementos[1][0] = eje.x*eje.y*(1 - cos(angulo)) + eje.z*sin(angulo);
    matriz.elementos[1][1] = cos(angulo) + pow(eje.y, 2.0)*(1 - cos(angulo));
    matriz.elementos[1][2] = eje.y*eje.z*(1 - cos(angulo)) - eje.x*sin(angulo);
 
    matriz.elementos[2][0] = eje.x*eje.z*(1 - cos(angulo)) - eje.y*sin(angulo);
    matriz.elementos[2][1] = eje.y*eje.z*(1 - cos(angulo)) + eje.x*sin(angulo);
    matriz.elementos[2][2] = cos(angulo) + pow(eje.z, 2.0)*(1 - cos(angulo));
}

4º Paso: Crear una función (o si quieres sobrecargas el operador *) que multiplique una matriz por un vector:

Código

void multiplicar(mat3& matriz, vec3& vector) {
    vec3 resultado = {0, 0, 0};
 
    resultado.x = matriz.elementos[0][0] * vector.x + matriz.elementos[0][1] * vector.y + matriz.elementos[0][2] * vector.z;
    resultado.y = matriz.elementos[1][0] * vector.x + matriz.elementos[1][1] * vector.y + matriz.elementos[1][2] * vector.z;
    resultado.y = matriz.elementos[2][0] * vector.x + matriz.elementos[2][1] * vector.y + matriz.elementos[2][2] * vector.z;
 
    vector.x = resultado.x;
    vector.y = resultado.y;
    vector.z = resultado.z;
}

5º Paso: rotar el vector que declaramos en el paso dos tal y como has rotado el cubo:

Código

vec3 eje_desplazamiento = {1, 0, 0};
mat3 matriz_rotacion;
 
rotar_matriz(objPruebas1.rotX, matriz_rotacion, {1, 0, 0});
multiplicar(matriz_rotacion, eje_desplazamiento);
rotar_matriz(objPruebas1.rotY, matriz_rotacion, {0, 1, 0});
multiplicar(matriz_rotacion, eje_desplazamiento);
rotar_matriz(objPruebas1.rotZ, matriz_rotacion, {0, 0, 1}); // Date cuenta que el tercer parametro es el mismo que usabas en glRotatef
multiplicar(matriz_rotacion, eje_desplazamiento);

5º Paso: desplazar el cubo. Ahora ya tenemos el eje donde se desplazará el cubo rotado tal y como hemos rotado el cubo. Ahora tenemos que desplazar el cubo:

Código

float unidades_a_desplazar = 5.0f; // Aquí pones las unidades que te quieres desplazar. Por ejemplo, yo he puesto 5.0f, pero tu puedes poner el valor que quieras.
 
eje_desplazamiento.x *= unidades_a_desplazar;
eje_desplazamiento.y *= unidades_a_desplazar;
eje_desplazamiento.z *= unidades_a_desplazar;
 
glTranslatef(eje_desplazamiento.x, eje_desplazamiento.y, eje_desplazamiento.z);

Como ves, es un proceso relativamente largo, pero si quieres hacerlo manualmente, me temo que no tenemos otra salida.

353

Programación / Programación C/C++ / Re: Archivos bINARIOS c++

en: 9 Febrero 2016, 06:28 am

Supongo que es el código suyo que expuso al principio pero cambiándolo con mis consejos. Vamos, que sería así:

Código

#include <iostream>
#include <fstream>
#include <cstdlib>
 
using namespace std;
using std::exit;
 
struct alumno {
    char nombre[256];
    char apellido[256];
    int edad;
};
 
int main () {
	int i;
	alumno alum[50];
 
	ofstream f;
 
	f.open("alumnos.bin", ios::out | ios::binary);
	if(f.open) {
		for (i=0; i<=50; i++) {
		cout<<"Teclee el nombre del alumno"<<endl;
			cin>>alum[i].nombre
			cout<<"Teclee  el apellido"<<endl;
			cin>>alum[i].apellido;
			cout<<"Teclee  la edad"<<endl;
			cin>>alum[i].edad;
			f.write(reinterpret_cast<const char*>(&alum[i]), sizeof(alumno);
		}
	} else {
		cout<<"Error al abrir el archivo"<<endl;
		exit(1);
	}
	is.close();
 
 
	//leemos el archivo
 
	ifstream fe("alumnos.bin", ios::in | ios::binary);
	if (fe){
		cerr<<"Se abrio correctamente"<<endl;
	} else {
		cout<<"No se abrio correctamente"<<endl;
		exit(1);
	}
 
	while (fe && !fe.eof()){
		for (i=0; i<=50; i++){
			cout<<"Teclee el nombre del alumno"<<endl;
			cin>>alum[i].nombre
			cout<<"Teclee  el apellido"<<endl;
			cin>>alum[i].apellido;
			cout<<"Teclee  la edad"<<endl;
			cin>>alum[i].edad;
 
			fe.read( reinterpret_cast<const char*>(&alum[i]), sizeof(alumno));
		}
	}//fin del while 
 
	return 0;
}

354	Programación / Programación C/C++ / Re: Archivos bINARIOS c++	en: 8 Febrero 2016, 15:28 pm
Lo que hace el código es pasarle todos los datos de la estructura al método ofstream::write. Le pasas los datos en forma de array de caracteres (para eso sirve reinterpret_cast). Y si, para cuando leas los datos puedes hacerlo relativamente igual Es lo bueno de ese código!

355	Programación / Programación C/C++ / Re: Archivos bINARIOS c++	en: 8 Febrero 2016, 00:21 am
Las clases tipo string no guardan la cadena de caracteres en la memoria ocupada por la estructura en sí. Para mayor comodidad, declararía la estructura así: Código struct alumno { char nombre[256]; char apellido[256]; int edad; }; Una vez rellenada dicha estructura, es tan simple como copiar byte a byte la memoria de la estructura: Código f.write(reinterpret_cast<const char*>(&alum[i]), sizeof(alumno);

356	Programación / Programación General / Re: Movimiento local 3D	en: 7 Febrero 2016, 10:35 am
Por si la imagen se cae: https://mega.nz/#!BNUDxQyJ!jZ7K4moQhvfmh7Lbvsh_0lV-wo9Cgun2ysTA3C9u5R4

357	Programación / Programación General / Re: Movimiento local 3D	en: 7 Febrero 2016, 09:55 am
No sé si estás usando el OpenGL antiguo o el moderno. No sabiendo eso, lo único que puedo hacer es orientarte. Tampoco sé si para rotar el cubo has usado ángulos, o has rotado el cubo alrededor de un eje. Si lo has hecho con ángulos, espero que lo hayas hecho con los de Euler. Si has usado un eje para rotarlo, es bastante simple. Lo único que tienes que hacer es rotar el vector unitario î alrededor de ese eje de rotación usado con el cubo, después multiplicas el resultado por las unidades que te quieres mover, y luego le sumas ese vector resultante a todos los vértices del cubo. Esta es una representación gráfica: En pseudocódigo, sería así: Código: vec3 eje_rotacion = {0.6, 0.4, 0.0} --Este evidentemente es arbitrario vec3 posicion_cubo = {0, 0, 0} -- También es arbitrario vec3 vector_unitario = {1, 0, 0} --Este no es arbitrario. Tiene que ser así float angulo = 0.3 -- Arbritario float unidades_a_mover = 6.5; rotar_cubo(eje_rotacion, angulo, posicion_cubo) rotar_eje(eje_rotacion, angulo, vector_unitario) trasladar_cubo(posicion_cubo + unidades_a_mover*vector_unitario) Es difícil de explicar, pues es 3D y solo disponemos (al menos yo) de monitores 2D XDD Espero que se haya comprendido

358

Programación / Programación C/C++ / Re: C++ , un entero en 2 bytes

en: 29 Enero 2016, 03:17 am

Es relativamente posible. Todo depende del compilador que uses. Por ejemplo: si usas short int ES POSIBLE, PERO NO SIEMPRE que su tamaño sea de 16 bits o 2 bytes...

Mira esta tabla:

Integer types (signed)
signed char	signed short int	signed int	signed long int	signed long long int
Mismo tamaño que char. Al menos 8 bits.	No es más pequeño que char. Al menos 16 bits.	No es más pequeño que. Al menos 16 bits.	No es más pequeño que int. Al menos 32 bits.	No es más pequeño que long. Al menos 64 bits.

Tabla sacada de http://www.cplusplus.com/doc/tutorial/variables/

359	Programación / Programación C/C++ / Re: Como extraer datos de un txt y guardar en funcion de un valor en un binario??	en: 28 Enero 2016, 23:09 pm
Interesante... ¡Cada día se aprende algo nuevo! Por si no ha quedado claro, lo que ha dicho ivancea96 es que cuando declaramos un array dentro de una estructura (o clase), todos los datos de ese array estarán dentro de la misma (pero el array seguirá siendo un puntero, esto se explica mejor con ensamblador...), mientras que si declaramos un puntero como tal, entonces (evidentemente), los datos apuntados por ese puntero no estarán dentro de la estructura.

360	Programación / Programación C/C++ / Re: Como extraer datos de un txt y guardar en funcion de un valor en un binario??	en: 28 Enero 2016, 21:15 pm
Cita de: Carlos D. Alvarez Chicos, recuerden que si bien las cadenas de caracteres son en realidad punteros al primer caracter, cuando la cadena es estática, es almacenada en la propia estructura. En tal caso se guardaría en memoria TAL CUAL. Si guardas la estructura, tambien se guarda la cadena, no el puntero. Pues eso no lo sabía. Para probarlo, he elaborado el siguiente código: Código #include <iostream> struct FOO { char lpszName[33]; }; int main() { FOO foo = {"Esto es una cadena de caracteres"}; std::cout << "Size: " << sizeof(foo) << std::endl; for(unsigned int i = 0; i < sizeof(foo); i++) { std::cout << reinterpret_cast<char*>(&foo)[i]; } std::cin.get(); return 0; } el cual imprime byte a byte toda la estructura... Lo que me ha sorprendido es obtener la siguiente salida: Código: Size: 33 Esto es una cadena de caracteres Me ha sorprendido, porque no he declarado la cadena como estática, como mencionas en tu respuesta... Espero que alguien pueda aclararlo. PD.: He usado el compilador de MinGW64 (el g++ de 64 bits para Windows). Por si aclara algo, no he usado ninguna etiqueta al compilar (vamos, que no lo he compilado como c++11, ni nada parecido...)

Páginas: 1 ... 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 [36] 37 38 39 40 41 42 43 44 45