Mise à l'échelle d'un seul objet dans une scène - OpenGL 3.0

Question

J'ai une scène avec deux cubes, et j'aimerais pouvoir mettre à l'échelle un seul cube. Fondamentalement, ce que je veux faire est quand j'appuie sur la touche S majuscule, le cube continuera à devenir plus grand plus longtemps que je continue à appuyer sur majuscule S, et quand j'appuie sur les minuscules je veux être en mesure de rendre le cube plus petit tant que la lettre minuscule est enfoncée.

J'ai couru en deux problèmes:

1. Je ne sais pas comment détecter si la touche est enfoncée minuscules ou majuscules.
2. Mes scènes entières (comme dans les deux cubes) s'agrandissent et se rétrécissent lorsque j'appuie sur les touches.

Voici mon code pour les clés:

void keyPressed(GLFWwindow *_window, int key, int scancode, int action, int mods) { 

// Control the state of keys pressed 
if (action == GLFW_PRESS) 
    keys[key] = true; 
else if (action == GLFW_RELEASE) 
    keys[key] = false; 

switch (key) { 
    case GLFW_KEY_ESCAPE: glfwSetWindowShouldClose(_window, GL_TRUE); break; 

    // Change between points, lines and fill 
    case GLFW_KEY_P: glPolygonMode(GL_FRONT_AND_BACK, getMode('P')); break; 
    case GLFW_KEY_W: glPolygonMode(GL_FRONT_AND_BACK, getMode('W')); break; 
    case GLFW_KEY_T: glPolygonMode(GL_FRONT_AND_BACK, getMode('T')); break; 

    case GLFW_KEY_S: scale_matrix = scale(scale_matrix, vec3(2.0f, 2.0f, 2.0f)); 

        //model_matrix = scale(model_matrix, vec3(2.0f, 2.0f, 2.0f)); 
        break; 

    case GLFW_KEY_R: scale_matrix = scale(scale_matrix, vec3(0.5f, 0.5f, 0.5f)); 
        //model_matrix = scale(model_matrix, vec3(0.0f, 0.0f, -1.0f)); 
        break; 


    //Reset camera 
    case GLFW_KEY_D: cameraPosition = vec3(0.0, 0.0, 1.0); 
        view_matrix = lookAt(
         cameraPosition, 
         vec3(0.0f, 0.0f, -100.0f), 
         vec3(0.0, 1.0, 0.0)); 
        break; 
    default: break; 
} 
return;} 

Depuis que je ne savais pas sur la façon de détecter les cas majuscules et minuscules, j'affecté R comme la clé pour réduire la scène. Voici le code pour mes positions de cube:

glm::vec3 cubePositions[] = { 
glm::vec3(0.0f, 0.0f, -1.0f), 
glm::vec3(2.0f, 10.0f, -10.0f), 
}; 

Ce que j'ai essayé jusqu'à présent était d'utiliser une instruction if pour le cas: GLFW_KEY_S pour vérifier la position du cube, mais cela ne fonctionne pas.

Answer 1

La plupart des bibliothèques ne reconnaissent pas les majuscules et les minuscules. Vous devriez le faire vous-même en détectant que vous appuyez sur la touche Shift en même temps ...

Pour la mise à l'échelle. Vous devez multiplier votre matrice par matrice d'échelle seulement avant le rendu d'un cube et ensuite revenir à l'état précédent. Si vous utilisez le système matriciel OGL, vous devriez le faire comme ceci.

Si vous utilisez le pipeline de fonction fixe:

glLoadIdentity(); 
glMultMatrix(view_matrix); 
// 1st cube 
glPushMatrix(); 
glMultMatrix(scale_matrix); 
drawCube(); 
glPopMatrix; 

// 2nd cube 
glPushMatrix(); 
drawCube(); 
glPopMatrix; 

Si vous utilisez shaders:

mat4 modelview; 

modelview = view_matrix; 
glUniformMatrix4fv(location_modelview, 1, GL_FLASE, modelview); 
drawCube(); 

modelview = view_matrix * scale_matrix 
glUniformMatrix4fv(location_modelview, 1, GL_FLASE, modelview); 
drawCube(); 

Si vous multipliez vos matrices yourslef, vous devez garder différentes object-> matrice mondiale pour tous les objets scène séparément.

Je ne voudrais pas déranger avec la fonction dépréciée maintenant. Obtenez ce que vous voulez d'abord et essayez de trouver comment le faire mieux plus tard.

Answer 2

La première est que je ne sais pas comment détecter si la touche pressée est minuscule ou majuscules

Pour que vous tester si une touche de modification a été pressé, dans votre cas la "Maj" touche de modification.

et la seconde est que ma scène entière (comme dans les deux cubes)

OpenGL est une API de dessin, pas un graphe de scène. L'astuce consiste donc à appliquer cette matrice de mise à l'échelle uniquement lors du dessin des modèles qui doivent être mis à l'échelle et à l'omettre pour le reste.