Richtige kovertierung von glm zum shader programm

Hier werden alle anderen GUI-Toolkits sowie Spezial-Toolkits wie Spiele-Engines behandelt.
Buh
User
Beiträge: 2
Registriert: Sonntag 5. November 2017, 02:05

Richtige kovertierung von glm zum shader programm

Beitragvon Buh » Sonntag 5. November 2017, 02:17

Hallo

Ich habe bisher opengl nur in c++ programmiert was mir aber mittlerweile viel zu schwer fällt

nun hab ich python entdeckt und würde dort mein spiel gerne weiter programmieren.

Im Moment möchte ich mit dem Packet PyGlm (also glm) die Matrix-Arbeiten ausführen und im vertex shader (perspektivische Darstellung -> 3D) darstellen lassen.

  1. self._transformationMatrixID = glGetUniformLocation(shaderProgram._programID, "transformationMatrix)
  2. self._transformationMatrix = glm.translate(tmat4x4([]), tvec3([0.0, 0.0, -3.0]))
  3. glUniformMatrix4fv(self._transformationMatrixID, 1, GL_FALSE, self._transformationMatrix)


Der Vertex Shader :

Code: Alles auswählen

#version 440

in ... position;

uniform mat4 transformationMatrix;

void main()
{..}

sollte soweit richtig sein

Der Error heißt dort: TypeError

Muss ich (laut tutorials) auf das Modul pyrr zurückgreifen oder kann ich das irgendwie anders handlen?

Liebe Grüße

Buh
Benutzeravatar
__deets__
User
Beiträge: 1304
Registriert: Mittwoch 14. Oktober 2015, 14:29

Re: Richtige kovertierung von glm zum shader programm

Beitragvon __deets__ » Sonntag 5. November 2017, 10:16

Das sind alles zu kleine Ausschnitte von teilweise offensichtlich mit Syntax-Fehlern behaftetem Code - dazu kann man so nix sagen.
Buh
User
Beiträge: 2
Registriert: Sonntag 5. November 2017, 02:05

Re: Richtige kovertierung von glm zum shader programm

Beitragvon Buh » Montag 6. November 2017, 17:33

Mein Object ist hier als klasse definiert, wo auch die Uniforms behandelt werden

  1. import sys
  2. import fileinput
  3. import string
  4. import os
  5.  
  6. import glfw
  7. from OpenGL.GL import *
  8.  
  9. from glm.gtc.matrix_transform import *
  10. import pyrr
  11. import numpy as np
  12.  
  13. class MyObject:
  14.    BYTE_SIZE = 4
  15.    _vertices = None
  16.    _normals = None
  17.    _textures = None
  18.    _indices = None
  19.  
  20.    _vao = None
  21.    _vertexVBO = None
  22.    _indexVBO = None
  23.    
  24.    transformMatrix = None
  25.    
  26.    def __init__(self, shaderProgram):
  27.       self._shaderProgram = shaderProgram
  28.      
  29.    def makeTriangle(self):
  30.       self._vertices = [-0.5, -0.5, 0.0,
  31.                         0.5, -0.5, 0.0,
  32.                         0.0, 0.5, 0.0]
  33.       self._indices = [0,1,2]
  34.       self._vertices = np.array(self._vertices, dtype=np.float32)
  35.       self._indices = np.array(self._indices, dtype=np.uint32)
  36.      
  37.       self._vao = glGenVertexArrays(1)
  38.       glBindVertexArray(self._vao)
  39.       self._vertexVBO = glGenBuffers(1)
  40.       glBindBuffer(GL_ARRAY_BUFFER, self._vertexVBO)
  41.       glBufferData(GL_ARRAY_BUFFER, self.BYTE_SIZE * self._vertices.size, self._vertices, GL_STATIC_DRAW)
  42.       glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)
  43.       glEnableVertexAttribArray(0)
  44.      
  45.       self._indexVBO = glGenBuffers(1)
  46.       glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self._indexVBO)
  47.       glBufferData(GL_ELEMENT_ARRAY_BUFFER, self.BYTE_SIZE * self._indices.size, self._indices, GL_STATIC_DRAW)
  48.      
  49.      
  50.       # - Matrices test - #
  51.       self._transformMatrix = translate(tmat4x4([]), tvec3([0.0,  0.0, 0.0]))
  52.       tmpMatrix = pyrr.Matrix44.from_x_rotation(np.pi * glfw.get_time())
  53.       try:
  54.          glUniformMatrix4fv(self._transformMatrixID, 1, GL_FALSE, self._transformMatrix)
  55.       except TypeError:
  56.          print("Exception :: " + str(sys.exc_info()[0]))
  57.  
  58.    def readObjectFile(self):
  59.       pass
  60.    
  61.    
  62.    
  63.    def render(self):
  64.       glUseProgram(self._shaderProgram._programID)
  65.       glBindVertexArray(self._vao)
  66.       glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self._indexVBO)
  67.       glDrawElements(GL_TRIANGLES, self._indices.size, GL_UNSIGNED_INT, None)
  68.       glUseProgram(0)


Die shader sehen so aus:

Code: Alles auswählen

#version 440
in layout(location=0) vec3 vertexPosition;
uniform mat4 transformMatrix;
void main(void)
{
gl_Position = transformMatrix * vec4(vertexPosition, 1.0f);
}


fragment shader:

Code: Alles auswählen

#version 440
out vec4 outColor;
void main(void)
{
outColor = vec4(1.0f, 1.0f, 1.0f, 1.0f);
}


Und das alles wird in einem Fenster angezeigt:

  1. import sys
  2. import os
  3. import time
  4. import threading
  5. import math
  6.  
  7. import glfw
  8. from OpenGL.GL import *
  9. import numpy as np
  10. import pyrr
  11.  
  12. from Game.object import MyObject
  13. from Game.shaderprogram import ShaderProgram
  14.  
  15. class MyWindow:
  16.    def __init__(self):
  17.       self._height = 400
  18.       self._width = 400
  19.       self._title = "OpenGL Game (1)"
  20.       self._window = None
  21.    
  22.    def _window_size_callback(self, window, width, height):
  23.       self._height = height
  24.       self._width = width
  25.       glViewport(0, 0, width, height)
  26.      
  27.    def initWindow(self):
  28.       if not glfw.init():
  29.          return
  30.       self._window = glfw.create_window(self._width, self._height, self._title, None, None)
  31.       if not self._window:
  32.          glfw.terminate()
  33.          return
  34.       glfw.make_context_current(self._window)
  35.      
  36.       # ** Callbacks ** #
  37.       glfw.set_window_size_callback(self._window, self._window_size_callback)
  38.      
  39.  
  40.    def start(self):
  41.       sp = ShaderProgram("","")
  42.      
  43.       object = MyObject(sp)
  44.       object.makeTriangle()
  45.  
  46.       glClearColor(0.2, 0.3, 0.2, 1.0)
  47.       while(glfw.window_should_close(self._window) != True):
  48.          glfw.poll_events()
  49.          glClear(GL_COLOR_BUFFER_BIT or GL_COLOR_BUFFER_BIT)
  50.          
  51.          object.render()
  52.          
  53.          glfw.swap_buffers(self._window)
  54.  
  55.  
  56.       glfw.terminate()
Benutzeravatar
__deets__
User
Beiträge: 1304
Registriert: Mittwoch 14. Oktober 2015, 14:29

Re: Richtige kovertierung von glm zum shader programm

Beitragvon __deets__ » Montag 6. November 2017, 17:40

Und jetzt noch die volle Fehlermeldung, und dann kann man mal schauen.

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder