Orario: 23-05-2013, 0:15 Benvenuto ospite! (Log in — Registrati)

Indie Vault Forum / Game Development / The Source / Codice nativo v / Problema movimento spazio 3d navicella

Rispondi 
Problema movimento spazio 3d navicella
Autore Messaggio
David90villa
Junior Member

Messaggi: 6
Registrato: Aug 2012
Offline Offline
#1 Problema movimento spazio 3d navicella
0
Salve a tutti, è la prima volta che scrivo su questo forum.
ho un problema con un progettino che sto facendo per l'università.
è la prima volta che utilizzo le openGl e voglio creare uno spazio 3dimensionale e all'interno ci voglio far muovere liberamente un astronave.
Inizialmente utilizzavo le coordinate sferiche, poi ho trovato questo codice e ho pensato di utilizzarlo.

Citazione:DSCamera::DSCamera()
{
m_position.x = 0.0f;
m_position.y = 0.0f;
m_position.z = 1000.0f;

m_directionVector.x = 0.0f;
m_directionVector.y = 0.0f;
m_directionVector.z = -1.0f;

m_upVector.x = 0.0f;
m_upVector.y = 1.0f;
m_upVector.z = 0.0f;

m_rightVector = VectorProduct(m_directionVector, m_upVector);

return;
}


void DSCamera::MoveRight(void)
{
m_position.x += DELTA*m_rightVector.x;
m_position.y += DELTA*m_rightVector.y;
m_position.z += DELTA*m_rightVector.z;
}

void DSCamera::MoveLeft(void)
{
m_position.x -= DELTA*m_rightVector.x;
m_position.y -= DELTA*m_rightVector.y;
m_position.z -= DELTA*m_rightVector.z;
}

void DSCamera::MoveUp(void)
{
m_position.x += DELTA*m_upVector.x;
m_position.y += DELTA*m_upVector.y;
m_position.z += DELTA*m_upVector.z;
}

void DSCamera::MoveDown(void)
{
m_position.x -= DELTA*m_upVector.x;
m_position.y -= DELTA*m_upVector.y;
m_position.z -= DELTA*m_upVector.z;
}

void DSCamera::MoveForward()
{
m_position.x += DELTA*m_directionVector.x;
m_position.y += DELTA*m_directionVector.y;
m_position.z += DELTA*m_directionVector.z;
}

void DSCamera::MoveBackward()
{
m_position.x -= DELTA*m_directionVector.x;
m_position.y -= DELTA*m_directionVector.y;
m_position.z -= DELTA*m_directionVector.z;
}

DSVector3f DSCamera::RotateAroundAnyAxis(DSVector3f input, DSVector3f axis, GLfloat degrees)
{
DSVector3f output;
GLfloat radians = degrees*3.14/180;
DSVector3f normalizedAxis = VectorNormalized(axis);
GLfloat C = cosf(radians);
GLfloat S = sinf(radians);
GLfloat DOT = ScalarProduct(input, normalizedAxis);

output.x = normalizedAxis.x*DOT*(1-C) + C*input.x + ((-normalizedAxis.z)*(input.y) + (normalizedAxis.y)*(input.z))*S;

output.y = normalizedAxis.y*DOT*(1-C) + C*input.y + ((normalizedAxis.z)*(input.x) - (normalizedAxis.x)*(input.z))*S;

output.z = normalizedAxis.z*DOT*(1-C) + C*input.z + ((-normalizedAxis.y)*(input.x) + (normalizedAxis.x)*(input.y))*S;

return output;
}

Nel mio main in questo modo faccio si che l'astronave ruoti verso destra,sinistra,basso o alto

Citazione:GLvoid
specialkeys( GLint key, GLint x, GLint y )
{
switch (key) {
case GLUT_KEY_LEFT:
theta = fmod( (theta + 1), 360.0 );

// il vettore attorno a cui ruotiamo è m_upVector

prova1->m_directionVector = prova1->RotateAroundAnyAxis(prova1->m_directionVector, prova1->m_upVector, 1);

// il vettore rimanente lo calcoliamo come prodotto vettoriale dei due altri assi

prova1->m_rightVector = VectorProduct(prova1->m_directionVector, prova1->m_upVector);

glutPostRedisplay();
break;

Key_Right{....}

case GLUT_KEY_UP:


lambda = fmod( (lambda + 1), 360.0 );
prova1->m_directionVector = prova1->RotateAroundAnyAxis(prova1->m_directionVector, prova1->m_rightVector, 1);

prova1->m_upVector=prova1->RotateAroundAnyAxis(prova1->m_upVector, prova1->m_rightVector, +1);

// il vettore attorno a cui ruotiamo è m_upVector



// il vettore rimanente lo calcoliamo come prodotto vettoriale dei due altri assi



glutPostRedisplay();
break;

Key_Down{...}

qua la faccio avanzare

Citazione:GLvoid
keyboard( GLubyte key, GLint x, GLint y )
{
switch (key) {
case 'w':
prova1->MoveForward();
glutPostRedisplay();
break;

e poi nel drawscene chiamo la look at con questi valori

Citazione: glPushMatrix();

gluLookAt(prova1->m_position.x,
prova1->m_position.y,
prova1->m_position.z,
prova1->m_position.x + prova1->m_directionVector.x,
prova1->m_position.y + prova1->m_directionVector.y,
prova1->m_position.z + prova1->m_directionVector.z,
prova1->m_upVector.x,
prova1->m_upVector.y,
prova1->m_upVector.z);



glPushMatrix();


glTranslatef(prova1->m_position.x + prova1->m_directionVector.x*300,
prova1->m_position.y + prova1->m_directionVector.y*300,
prova1->m_position.z + prova1->m_directionVector.z*300);
glRotatef(theta, prova1->m_upVector.x, prova1->m_upVector.y, prova1->m_upVector.z);
glRotatef(lambda, prova1->m_rightVector.x, prova1->m_rightVector.y, prova1->m_rightVector.z);


glScalef(0.05,0.05,0.05);
glBindTexture(GL_TEXTURE_2D, texture[0].texID);
glmDraw(f16, GLM_MATERIAL | GLM_TEXTURE);
glPopMatrix();

glPopMatrix();

in pratica faccio si che l'astronave sia al centro e io ruoto il punto di vista in base a quanto ruoto l'astronave in modo da seguirla. Fino a che ruoto solo lungo uno degli assi( o solo X o solo Y)
[Immagine: schermata20120819a13474.png]
nessun problema ma quando ruoto l'astronave verso l'alto e poi ad esempio verso destra non mi segue più e ruota in modo diverso Hmm …
[Immagine: schermata20120819a13484.png]

Grazie in anticipo. Spero di nn aver fatto troppo casino Inchino
19-08-2012 13:02
Trova tutti i messaggi di questo utente Cita questo messaggio nella tua risposta
Sotty75
Junior Member

Messaggi: 11
Registrato: Jun 2011
Offline Offline
#2 RE: Problema movimento spazio 3d navicella
0
Ciao David,
premetto che su questo forum ci sono utenti moooolto più esperti del sottoscritto, ti rispondo perchè vedo che fai riferimento a un articolo che postai sul mio blog tempo fa.

Non uso più quell'approccio, che avevo trovato utile per capire alcuni concetti da niubbo. Tuttavia ho ancora il progetto che mi compila e, dopo averlo provato, non riesco a replicare il problema.

In quell'esempio quando ruoto la telecamera attorno agli assi D, U, R li ricalcolo in modo che siano sempre solidali con la posizione corrente della telecamera. Mi pare di capire che nel tuo caso ci sia qualcosa che non va nel momento in cui ruoti la telecamera per "guardare" in alto o in basso. Questo movimento è quello di rotazione della telecamera sul vettore R. In questo caso R rimane fisso e D (direction) e U (up) dovranno essere ricalcolati.

Rispetto alla classe che avevo scritto io è difficile dire cosa ci sia di diverso, quindi te la riporto in toto. E' presente sia la la classe GLCamera (che quando scrissi il post rinominai DSCamera) che la classe DSMath che include le funzioni che uso per effettuare operazioni fra vettori.

Puoi fare delle verifiche per capire se faccio qualcosa di diverso rispetto a quello che fai tu, il codice che ho postato è sufficiente per capire cosa viene processato dal momento in cui si preme su un tasto della tastiera fino alla chiamata alla funzione glLookAt.

DSMath.h
Codice:
#ifndef _DSMATH_H_
#define _DSMATH_H_

#include <math.h>
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#include <OpenGL/glext.h>
#include <GLUT/glut.h>

#define PI 3.1415926535898

typedef struct tag_DSVector2f
{
    GLfloat u;
    GLfloat v;
} DSVector2f;

typedef struct tag_DSVector3f
{
    GLfloat x;
    GLfloat y;
    GLfloat z;
} DSVector3f;

DSVector3f VectorProduct(DSVector3f a, DSVector3f b);
DSVector3f VectorSum(DSVector3f a, DSVector3f b);
DSVector3f VectorDiff(DSVector3f a, DSVector3f b);
GLfloat ScalarProduct(DSVector3f a, DSVector3f b);
GLfloat VectorLenght(DSVector3f a);
DSVector3f VectorNormalized(DSVector3f a);

DSVector3f RotateAroundXAxis(DSVector3f input, GLfloat degrees);
DSVector3f RotateAroundYAxis(DSVector3f input, GLfloat degrees);
DSVector3f RotateAroundZAxis(DSVector3f input, GLfloat degrees);

DSVector3f RotateAroundAnyAxis(DSVector3f input, DSVector3f axis, GLfloat degrees);
#endif

DSMath.cpp
Codice:
#include <iostream>
#include "DSMath.h"
#include <math.h>

DSVector3f VectorProduct(DSVector3f a, DSVector3f b)
{
    DSVector3f c;
    
    c.x = a.y*b.z - b.y*a.z;
    c.y = a.z*b.x - a.x*b.z;
    c.z = a.x*b.y - a.y*b.x;
    
    return c;
}

DSVector3f VectorSum(DSVector3f a, DSVector3f b)
{
    DSVector3f result;
    
    result.x = a.x + b.x;
    result.y = a.y + b.y;
    result.z = a.z + b.z;
    
    return result;
}

DSVector3f VectorDiff(DSVector3f a, DSVector3f b)
{
    DSVector3f result;
    
    result.x = a.x - b.x;
    result.y = a.y - b.y;
    result.z = a.z - b.z;
    
    return result;
}


GLfloat ScalarProduct(DSVector3f a, DSVector3f b)
{
    GLfloat result = a.x*b.x + a.y*b.y + a.z*b.z;
    return result;
}

GLfloat VectorLenght(DSVector3f a)
{  
    GLfloat result = sqrt(a.x*a.x + a.y*a.y + a.z*a.z);
    return result;
}

DSVector3f VectorNormalized(DSVector3f a)
{
    DSVector3f result = {0.0f, 0.0f, 0.0f};
    
    GLfloat lenght = VectorLenght(a);
    
    if (lenght != 0.0)
    {
        result.x = a.x / lenght;
        result.y = a.y / lenght;
        result.z = a.z / lenght;
    }
    
    return result;
}

DSVector3f RotateAroundXAxis(DSVector3f input, GLfloat degrees)
{
    DSVector3f output;    
    GLfloat radians = degrees*PI/180;
    
    output.x = input.x;
    output.y = cosf(radians)*input.y + sinf(radians)*input.z;
    output.z = -sinf(radians)*input.y + cosf(radians)*input.z;
    
    return output;
}

DSVector3f RotateAroundYAxis(DSVector3f input, GLfloat degrees)
{
    DSVector3f output;
    GLfloat radians = degrees*PI/180;
    
    output.x = cosf(radians)*input.x - sinf(radians)*input.z;
    output.y = input.y;
    output.z = sinf(radians)*input.x + cosf(radians)*input.z;
    
    return output;
}

DSVector3f RotateAroundZAxis(DSVector3f input, GLfloat degrees)
{
    DSVector3f output;
    GLfloat radians = degrees*PI/180;
    
    output.x = cosf(radians)*input.x + sinf(radians)*input.y;
    output.y = -sinf(radians)*input.x + cosf(radians)*input.y;
    output.z = input.z;
    
    return output;
}

DSVector3f RotateAroundAnyAxis(DSVector3f input, DSVector3f axis, GLfloat degrees)
{
    DSVector3f output;
    GLfloat radians = degrees*PI/180;
    DSVector3f normalizedAxis = VectorNormalized(axis);
    GLfloat C = cosf(radians);
    GLfloat S = sinf(radians);
    GLfloat DOT = ScalarProduct(input, normalizedAxis);
            
    output.x = normalizedAxis.x*DOT*(1-C) + C*input.x + ((-normalizedAxis.z)*(input.y) + (normalizedAxis.y)*(input.z))*S;
    output.y = normalizedAxis.y*DOT*(1-C) + C*input.y + ((normalizedAxis.z)*(input.x) - (normalizedAxis.x)*(input.z))*S;
    output.z = normalizedAxis.z*DOT*(1-C) + C*input.z + ((-normalizedAxis.y)*(input.x) + (normalizedAxis.x)*(input.y))*S;
    
    return output;
}

GLCamera.h
Codice:
#ifndef _GLCAMERA_H_
#define _GLCAMERA_H_

#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#include <OpenGL/glext.h>
#include <GLUT/glut.h>
#include "GLKeyboardManager.h"
#include "DSMath.h"


class GLCamera
{
public:
    GLCamera();
    void UpdatePosition(void);
    void UpdatedDirectionAxis(void);
    void UpdatedUpAxis(void);
    void UpdatedRightAxis(void);
    
    // Translate Camera
    void MoveRight(void);
    void MoveLeft(void);
    void MoveUp(void);
    void MoveDown(void);    
    void ZoomIn(void);
    void ZoomOut(void);
        
    // Rotate Camera
    void RotateCW_DirectionVector(void);
    void RotateCCW_DirectionVector(void);
    void RotateCW_UpVector(void);
    void RotateCCW_UpVector(void);
    void RotateCW_RightVector(void);
    void RotateCCW_RightVector(void);
    
    // Set Position
    void SetPosition(GLfloat x, GLfloat y, GLfloat z);
    
private:
    // Keynboard manager instance
    GLKeyboardManager *m_keyboardManager;
    
    // Camera per-frame increment
    GLfloat m_translationDelta;
    GLfloat m_rotationDelta;
    
    // Camera Rotation
    GLfloat m_directionAxisRotation;
    GLfloat m_upAxisRotation;
    GLfloat m_rightAxisRotation;
    
    // Local Coordinates System
    DSVector3f m_position;
    DSVector3f m_upVector;
    DSVector3f m_directionVector;
    DSVector3f m_rightVector;
};

GLCamera.cpp
Codice:
#include <iostream>
#include "GLCamera.h"
#include "DSMath.h"

GLCamera::GLCamera()
{
    m_keyboardManager = GLKeyboardManager::Instance();
    m_translationDelta = 0.1f;
    m_rotationDelta = 0.5f;
    
    // Starting Camera Position
    m_position.x = 0.0f;
    m_position.y = 0.0f;
    m_position.z = 0.0f;
    
    // Starting Camera Rotation
    m_directionAxisRotation = 0.0f;
    m_rightAxisRotation = 0.0f;
    m_upAxisRotation = 0.0f;
    
    m_directionVector.x = 0.0f;
    m_directionVector.y = 0.0f;
    m_directionVector.z = -1.0f;
    
    m_upVector.x = 0.0f;
    m_upVector.y = 1.0f;
    m_upVector.z = 0.0f;
    
    m_rightVector = VectorProduct(m_directionVector, m_upVector);
        
    return;
}

void GLCamera::UpdatePosition()
{
    if (m_keyboardManager->m_capsShiftPressed)
    {
        if (m_keyboardManager->m_arrowUpPressed)
            this->ZoomIn();
        
        if (m_keyboardManager->m_arrowDownPressed)
            this->ZoomOut();
    }
    else if (m_keyboardManager->m_ctrlPressed)
    {
        if (m_keyboardManager->m_arrowUpPressed)
            this->ZoomIn();
        
        if (m_keyboardManager->m_arrowDownPressed)
            this->ZoomOut();
    }
    else if (!(m_keyboardManager->m_ctrlPressed || m_keyboardManager->m_capsShiftPressed))
    {
        if (m_keyboardManager->m_arrowLeftPressed)
            this->MoveLeft();

        if (m_keyboardManager->m_arrowRightPressed)
            this->MoveRight();
    
        if (m_keyboardManager->m_arrowUpPressed)
            this->MoveUp();
    
        if (m_keyboardManager->m_arrowDownPressed)
            this->MoveDown();
        
        if (m_keyboardManager->m_Q_Pressed)
            this->RotateCCW_RightVector();
        
        if (m_keyboardManager->m_A_Pressed)
            this->RotateCW_RightVector();

        if (m_keyboardManager->m_Z_Pressed)
            this->RotateCCW_DirectionVector();
        
        if (m_keyboardManager->m_X_Pressed)
            this->RotateCW_DirectionVector();

        if (m_keyboardManager->m_O_Pressed)
            this->RotateCCW_UpVector();
        
        if (m_keyboardManager->m_P_Pressed)
            this->RotateCW_UpVector();
    }

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    
    // Create the LookAt Matrix
    // Create the Translation Matrix
    // Multiply LookAt and Translation Matrices
    // Apply transformation
    
    // We leave the gluLookAt call to ve sure the vectors for the local camera are correct
    gluLookAt(m_position.x, m_position.y, m_position.z,
              m_position.x + m_directionVector.x, m_position.y + m_directionVector.y, m_position.z + m_directionVector.z,
              m_upVector.x, m_upVector.y, m_upVector.z);
}

void GLCamera::MoveRight(void)
{
    m_position.x += m_translationDelta*m_rightVector.x;
    m_position.y += m_translationDelta*m_rightVector.y;
    m_position.z += m_translationDelta*m_rightVector.z;
}

void GLCamera::MoveLeft(void)
{
    m_position.x -= m_translationDelta*m_rightVector.x;
    m_position.y -= m_translationDelta*m_rightVector.y;
    m_position.z -= m_translationDelta*m_rightVector.z;
}

void GLCamera::MoveUp(void)
{
    m_position.x += m_translationDelta*m_upVector.x;
    m_position.y += m_translationDelta*m_upVector.y;
    m_position.z += m_translationDelta*m_upVector.z;
}

void GLCamera::MoveDown(void)
{  
    m_position.x -= m_translationDelta*m_upVector.x;
    m_position.y -= m_translationDelta*m_upVector.y;
    m_position.z -= m_translationDelta*m_upVector.z;
}

void GLCamera::ZoomIn()
{
    m_position.x += m_translationDelta*m_directionVector.x;
    m_position.y += m_translationDelta*m_directionVector.y;
    m_position.z += m_translationDelta*m_directionVector.z;
}

void GLCamera::ZoomOut()
{
    m_position.x -= m_translationDelta*m_directionVector.x;
    m_position.y -= m_translationDelta*m_directionVector.y;
    m_position.z -= m_translationDelta*m_directionVector.z;
}

void GLCamera::RotateCW_DirectionVector()
{
    m_directionAxisRotation = m_rotationDelta;
    this->UpdatedDirectionAxis();
}

void GLCamera::RotateCCW_DirectionVector()
{
    m_directionAxisRotation = -m_rotationDelta;
    this->UpdatedDirectionAxis();  
}

void GLCamera::RotateCW_RightVector()        // A button
{
    m_rightAxisRotation = -m_rotationDelta;
    this->UpdatedRightAxis();
}

void GLCamera::RotateCCW_RightVector()
{
    m_rightAxisRotation = m_rotationDelta;
    this->UpdatedRightAxis();
}

void GLCamera::RotateCW_UpVector()
{
    m_upAxisRotation = -m_rotationDelta;
    this->UpdatedUpAxis();
}

void GLCamera::RotateCCW_UpVector()         // O Button
{
    m_upAxisRotation = m_rotationDelta;
    this->UpdatedUpAxis();
}

void GLCamera::UpdatedDirectionAxis()
{    
    m_upVector = RotateAroundAnyAxis(m_upVector, m_directionVector, m_directionAxisRotation);
    m_rightVector = VectorProduct(m_directionVector, m_upVector);
}

void GLCamera::UpdatedUpAxis()
{  
    m_directionVector = RotateAroundAnyAxis(m_directionVector, m_upVector, m_upAxisRotation);
    m_rightVector = VectorProduct(m_directionVector, m_upVector);
}

void GLCamera::UpdatedRightAxis()
{    
    m_upVector = RotateAroundAnyAxis(m_upVector, m_rightVector, m_rightAxisRotation);
    m_directionVector = RotateAroundAnyAxis(m_directionVector, m_rightVector, m_rightAxisRotation);
}

void GLCamera::SetPosition(GLfloat x, GLfloat y, GLfloat z)
{
    m_position.x = x;
    m_position.y = y;
    m_position.z = z;
}
Paolo "Sotty75" Sotgiu
19-08-2012 14:29
Visita il sito web di questo utente Trova tutti i messaggi di questo utente Cita questo messaggio nella tua risposta
Gabriele
Posting Freak

Messaggi: 4,383
Registrato: Oct 2010
Offline Offline
#3 RE: Problema movimento spazio 3d navicella
0
Ho letto mooooooooolto e sottolineo molto velocemente, ma il problema tuo mi sembra derivi dal fatto che usi gli angoli di eulero per descrivere rotazioni tridimensionali, e mi sa tanto che incorri nel Gimble Lock:





Quindi devi usare i quaternion..... ( http://it.wikipedia.org/wiki/Quaternione )
http://www.cprogramming.com/tutorial/3d/...nions.html
Gabriele Di Bari
Account G+
Account bitbucket
Account GITHUB
E ricordate: ((VMJava*)(NULL))->~VMJava();
(Questo messaggio è stato modificato l'ultima volta il: 19-08-2012 16:20 da Gabriele.)
19-08-2012 16:07
Visita il sito web di questo utente Trova tutti i messaggi di questo utente Cita questo messaggio nella tua risposta
TheCrib
Indie Pellerossa

Messaggi: 5,188
Registrato: Sep 2010
Offline Offline
#4 RE: Problema movimento spazio 3d navicella
0
(19-08-2012 16:07)Gabriele ha scritto:  Ho letto mooooooooolto e sottolineo molto velocemente, ma il problema tuo mi sembra derivi dal fatto che non usi gli angoli di eulero per descrivere rotazioni tridimensionali, e mi sa tanto che incorri nel Gimble Lock:

Spelling alert ! gimbal lock, non gimble (anche se lo spelling e' sbagliato anche nel video 8)
Davide Pasca
http://v5.kazzuya.com - @109mae
http://oyatsukai.com - @oyatsukai
"O frechete !" - M.Magnotta
19-08-2012 16:20
Visita il sito web di questo utente Trova tutti i messaggi di questo utente Cita questo messaggio nella tua risposta
Gabriele
Posting Freak

Messaggi: 4,383
Registrato: Oct 2010
Offline Offline
#5 RE: Problema movimento spazio 3d navicella
0
(19-08-2012 16:20)TheCrib ha scritto:  
(19-08-2012 16:07)Gabriele ha scritto:  Ho letto mooooooooolto e sottolineo molto velocemente, ma il problema tuo mi sembra derivi dal fatto che non usi gli angoli di eulero per descrivere rotazioni tridimensionali, e mi sa tanto che incorri nel Gimble Lock:

Spelling alert ! gimbal lock, non gimble (anche se lo spelling e' sbagliato anche nel video 8)
Asd sono un grammar naziskin cmq ecco cosa succede quando si fa il drag and drop per ogni cosa (compreso il titolo).
Gabriele Di Bari
Account G+
Account bitbucket
Account GITHUB
E ricordate: ((VMJava*)(NULL))->~VMJava();
19-08-2012 16:23
Visita il sito web di questo utente Trova tutti i messaggi di questo utente Cita questo messaggio nella tua risposta
David90villa
Junior Member

Messaggi: 6
Registrato: Aug 2012
Offline Offline
#6 RE: Problema movimento spazio 3d navicella
0
Grazie a tutti delle risposte Asd

cmq Sotty ho provato a utilizzare il tuo codice che mi hai appena dato, ma il problema persiste.
Penso sia un problema della mia rotate che faccio in modo da vedere sempre il sedere dell'astronave perche senza rotate il tuo codice funziona ma ci giro intorno all'astronave

Citazione:lookat()

glRotatef(theta,prova1->m_upVector.x, prova1->m_upVector.y, prova1->m_upVector.z);
glRotatef(lambda, prova1->m_rightVector.x, prova1->m_rightVector.y, prova1->m_rightVector.z);

disegno astronave

..
quando vado destra o sinistra giro attorno all'up vector
quando vado su o giu giro intrno al right vector
sbaglio qualcosa nelle rotazioni o il problema e il gimble lock ?
20-08-2012 0:19
Trova tutti i messaggi di questo utente Cita questo messaggio nella tua risposta
TheCrib
Indie Pellerossa

Messaggi: 5,188
Registrato: Sep 2010
Offline Offline
#7 RE: Problema movimento spazio 3d navicella
0
(20-08-2012 0:19)David90villa ha scritto:  quando vado destra o sinistra giro attorno all'up vector
quando vado su o giu giro intrno al right vector
sbaglio qualcosa nelle rotazioni o il problema e il gimble lock ?

Non credo sia il gimbal lock. Quello si tira fuori troppo spesso come possibile causa, ma e' solo un problema se uno lavora con rotazioni discre su assi x, y, z.

Onestamente non ho cercato di capire quello che fa tutto quello che hai postato. Sotty75 sembra in parte artefice.. ma lui dice che il codice funziona, quindi dipende da come lo hai implementato e modificato tu.

Quello che farei io e'.. prima di tutto fare i calcoli con vettori e matrici proprie in modo da avere piu' flessibilita'.

Poi, in qualunque modo ruoti l'astronave, alla fine avrai una matrice di trasformazione di questa mtxShipWSfromLS *.

Codice:
shipPosWS = mtxShipWSfromLS.GetTranslation();
viewDistance = shipBoundingSphere.CalcRadius() * 2; // ..o quello che vuoi

viewDirWS = normalize( mtxShipWSfromLS.GetSub3x3() * float3(0,0,1) );

viewPosWS = shipPosWS + viewDirWS * viewDistance;

Poi la "view matrix" dovrebbe essere:

Codice:
mtxVSfromWS = LookAt( shipPosWS, viewPosWS, upVec );

Ovviamente poi a OpenGL va passata la model-view matrix.. quindi:

mtxVSfromLS = mtxVSfromWS * mtxShipWSfromLS;


*: WS = World-Space e LS = Local-Space. Uso la post-concatenazione come OpenGL normalmente ragiona.. ma non e' necessario..
**: Si puo' semplificare a mano o comunque lo semplifica il compilatore.
Davide Pasca
http://v5.kazzuya.com - @109mae
http://oyatsukai.com - @oyatsukai
"O frechete !" - M.Magnotta
(Questo messaggio è stato modificato l'ultima volta il: 20-08-2012 11:16 da TheCrib.)
20-08-2012 7:51
Visita il sito web di questo utente Trova tutti i messaggi di questo utente Cita questo messaggio nella tua risposta
Sotty75
Junior Member

Messaggi: 11
Registrato: Jun 2011
Offline Offline
#8 RE: Problema movimento spazio 3d navicella
0
Se ho capito bene sostanzialmente vuoi che la tua astronave si muova in modo solidale con la telecamera.

Ti ricordo che in OpenGL la telecamera è sempre fissa all'origine dello spazio 3D, e che l'illusione del movimento della telecamera è semplicemente dato dallo spostare in toto gli oggetti che hai nel tuo universo...significa ad esempio che quando tu "pensi" di muovere la telecamera in avanti, in realtà stai traslando gli oggetti in modo da allontanarli dalla telecamera stessa.

Da www.opengl.org/archives/resources/faq/technical/viewing.htm
Citazione:8.010 How does the camera work in OpenGL?
As far as OpenGL is concerned, there is no camera. More specifically, the camera is always located at the eye space coordinate (0., 0., 0.). To give the appearance of moving the camera, your OpenGL application must move the scene with the inverse of the camera transformation.

La funziona glLookAt non fa altro che generare la trasformazione che viene applicata agli oggetti del tuo universo (la trasformazione inversa di quella che applicheresti alla telecamera). Nel tuo caso però vuoi che l'astronave non subisca questa trasformazione, ma rimanga solidale con la telecamera stessa (al limite traslata lungo la direzione di un delta a piacere, in modo che finisca dentro il view frustum).

Andando a naso direi che potresti provare banalmente a disegnare la tua astronave PRIMA di chiamare la funzione glLookAt, applicandoci una semplice traslazione per vederla dentro il tuo viewfrustum,

- glTranslate(posizioneAstronave)
- disegnaAstronave
- glLoadIdentity()
- gluLookAt
- disegna tutto il resto
Paolo "Sotty75" Sotgiu
20-08-2012 13:50
Visita il sito web di questo utente Trova tutti i messaggi di questo utente Cita questo messaggio nella tua risposta
David90villa
Junior Member

Messaggi: 6
Registrato: Aug 2012
Offline Offline
#9 RE: Problema movimento spazio 3d navicella
0
Grazie a tutti delle risposte Smile
cmq sotty sembra funzionare Smile faccio qualche altro test.. grazie mille davvero!!! Kiss
20-08-2012 14:42
Trova tutti i messaggi di questo utente Cita questo messaggio nella tua risposta
Jak
Vaporizator

Messaggi: 472
Registrato: Jul 2011
Offline Offline
#10 RE: Problema movimento spazio 3d navicella
0
(20-08-2012 13:50)Sotty75 ha scritto:  bla bla bla
Se è per questo anche directx è così, anche tutto è così, dopotutto lo schermo "fisico" è sempre la di fronte alla scrivania. Tutto ciò che si vede è una rappresentazione, opengl directx o che la telecamera non esiste, sono tutti una serie di calcoli matematici per simulare la telecamera.
20-08-2012 19:11
Trova tutti i messaggi di questo utente Cita questo messaggio nella tua risposta
Sotty75
Junior Member

Messaggi: 11
Registrato: Jun 2011
Offline Offline
#11 RE: Problema movimento spazio 3d navicella
0
(20-08-2012 19:11)Jak ha scritto:  bla bla bla
Non volevo fare il saccente...non ho mai usato DirectX e non so come funziona in quel caso. Mi faceva piacere dare qualche informazione utile a risolvere il problema di chi ha aperto il post.
Sinceramente quando ho studiato io questi aspetti non mi era parso così scontato, probabile limite mio.
Paolo "Sotty75" Sotgiu
20-08-2012 20:23
Visita il sito web di questo utente Trova tutti i messaggi di questo utente Cita questo messaggio nella tua risposta
Jak
Vaporizator

Messaggi: 472
Registrato: Jul 2011
Offline Offline
#12 RE: Problema movimento spazio 3d navicella
0
(20-08-2012 20:23)Sotty75 ha scritto:  Non volevo fare il saccente...
Ed io non ti ho dato del saccente, semplicemente il tuo post era un po troppo lungo.
(20-08-2012 20:23)Sotty75 ha scritto:  Sinceramente quando ho studiato io questi aspetti non mi era parso così scontato, probabile limite mio.
Vabbè, non è una tragedia, non è così scontato infatti, semplicemente io sono uno che gli piace cercare di capire come funzionano le cose prima di conoscere la realtà dei fatti(che fortunatamente concidono quasi sempre yeah Approvazione)
20-08-2012 23:29
Trova tutti i messaggi di questo utente Cita questo messaggio nella tua risposta
TheCrib
Indie Pellerossa

Messaggi: 5,188
Registrato: Sep 2010
Offline Offline
#13 RE: Problema movimento spazio 3d navicella
0
(20-08-2012 23:29)Jak ha scritto:  
(20-08-2012 20:23)Sotty75 ha scritto:  Non volevo fare il saccente...
Ed io non ti ho dato del saccente, semplicemente il tuo post era un po troppo lungo.

Ma la smetti di trollare, please ?

Ha dato una risposta giusta che ha funzionato.. non mi pare il caso di stare a sindacare... e comunque mi pare sia stato piuttosto conciso.
Davide Pasca
http://v5.kazzuya.com - @109mae
http://oyatsukai.com - @oyatsukai
"O frechete !" - M.Magnotta
21-08-2012 6:47
Visita il sito web di questo utente Trova tutti i messaggi di questo utente Cita questo messaggio nella tua risposta
Rispondi 


Vai al forum:


Contattaci | Indie Vault | Torna all'inizio della pagina | Torna al contenuto | Modalità archivio | RSS Syndication | Usermap