Question

我正在制作一个简单的opengl游戏，以了解更多相关信息。但由于某些原因，当我尝试旋转我的立方体时，它会变得拉长。你可以在照片中看到它：

我认为这与我的模型矩阵有关，但我不确定。这是我的代码的一部分：

    model := mgl32.Ident4()                                                               
    model = model.Mul4(mgl32.HomogRotate3D(float32(glfw.GetTime()) * 
    mgl32.DegToRad(50.0), mgl32.Vec3{0.5, 1.0, 0.0}))

    view := mgl32.Ident4()
    view = view.Mul4(mgl32.Translate3D(0.0, 0.0, -3.0))

    projection := mgl32.Ident4()
    projection = mgl32.Perspective(mgl32.DegToRad(45.0), 800/ float32(600), 0.1, 100)

    shader.setMat4("model", model)
    shader.setMat4("view", view)
    shader.setMat4("projection", projection)

这是我的Minimal，Complete和Verifiable示例。我删除了纹理，因为没有必要看到问题。我也在使用线框，以便您可以更清楚地看到拉伸。

package main

import(
     "github.com/go-gl/glfw/v3.2/glfw"
     "github.com/go-gl/gl/v4.5-core/gl"
     "log"
     "strings"
     "fmt"
     "github.com/go-gl/mathgl/mgl32"
 )

 const(
     vertexShaderSource = `
         #version 450 core
         layout (location = 0) in vec3 aPos;

        uniform mat4 model;
        uniform mat4 view;
        uniform mat4 projection;

        void main()
        {
            gl_Position = projection * view * model * vec4(aPos, 1.0);
        }` + "\x00"

    fragmentShaderSource =  `
        #version 450 core
        out vec4 FragColor;

        void main()
        {
            FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);
        }` + "\x00"
)

var(
    vertices = []float32 {
        -0.5,0.5,-0.5,
        -0.5,-0.5,-0.5,
        0.5,-0.5,-0.5,
        0.5,0.5,-0.5,

        -0.5,0.5,0.5,
        -0.5,-0.5,0.5,
        0.5,-0.5,0.5,
        0.5,0.5,0.5,

        0.5,0.5,-0.5,
        0.5,-0.5,-0.5,
        -0.5,-0.5,0.5,
        -0.5,0.5,0.5,

        -0.5,0.5,-0.5,
        -0.5,-0.5,0.5,
        0.5,-0.5,0.5,
    }
    indices = []int {
        0,1,3, // -z
        3,1,2,
        5,4,7, // +z
        7,6,5,
        9,8,7, // +x
        7,6,9,
        0,1,11, // -x
        11,1,10,
        12,4,7, // +y
        7,3,12,
        13,1,14,  // -y
        14,1,2,
    }
)


func main() {
    if err := glfw.Init(); err != nil {
        log.Fatalln("failed to initialize glfw:", err)
    }
    defer glfw.Terminate()

    glfw.WindowHint(glfw.ContextVersionMajor, 4)
    glfw.WindowHint(glfw.ContextVersionMinor, 5)
    glfw.WindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile)
    glfw.WindowHint(glfw.OpenGLForwardCompatible, glfw.True)

    window, err := glfw.CreateWindow(800, 600, "LearnOpenGL", nil, nil)
    if err != nil {
        panic(err)
    }
    defer window.Destroy()

    window.MakeContextCurrent()

    // Initialize Glow
    if err := gl.Init(); err != nil {
        panic(err)
    }

    gl.Viewport(0, 0, 800, 600)

    //SHADERS
    vertexID, err := loadShader(vertexShaderSource, gl.VERTEX_SHADER)
    if err != nil {
        panic(err)
    }
    fragmentID, err := loadShader(fragmentShaderSource, gl.FRAGMENT_SHADER)
    if err != nil {
        panic(err)
    }

    programID := gl.CreateProgram()
    gl.AttachShader(programID, vertexID)
    gl.AttachShader(programID, fragmentID)

    gl.DeleteShader(vertexID)
    gl.DeleteShader(fragmentID)

    gl.LinkProgram(programID)

    // VBO / VAO / EBO data
    var vbo, vao, ebo uint32
    gl.GenVertexArrays(1, &vao)
    gl.GenBuffers(1, &vbo)
    gl.GenBuffers(1, &ebo)
    gl.BindVertexArray(vao)

    gl.BindBuffer(gl.ARRAY_BUFFER, vbo)
    gl.BufferData(gl.ARRAY_BUFFER, len(vertices)*4, gl.Ptr(vertices), gl.STATIC_DRAW)

    gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, ebo)
    gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, len(indices) * 4, gl.Ptr(indices), gl.STATIC_DRAW)

    gl.VertexAttribPointer(0, 3, gl.FLOAT, false, 0, gl.PtrOffset(0))
    gl.EnableVertexAttribArray(0)

    gl.BindBuffer(gl.ARRAY_BUFFER, 0)
    gl.BindVertexArray(0)

    gl.Enable(gl.DEPTH_TEST)
    gl.PolygonMode(gl.FRONT_AND_BACK, gl.LINE)

    for !window.ShouldClose() {
        gl.ClearColor(0.2, 0.3, 0.3, 1.0)
        gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)

        gl.UseProgram(programID)

        model := mgl32.Ident4()
        view := mgl32.Ident4()
        projection := mgl32.Ident4()
        model = model.Mul4(mgl32.HomogRotate3D(float32(glfw.GetTime()) * mgl32.DegToRad(50), mgl32.Vec3{0.5, 1, 0}))
        view = view.Mul4(mgl32.Translate3D(0, 0, -3))
        projection = projection.Mul4(mgl32.Perspective(mgl32.DegToRad(45), 800/float32(600), 0.1, 100))

        gl.UniformMatrix4fv(gl.GetUniformLocation(programID, gl.Str("model\x00")), 1, false, &model[0])
        gl.UniformMatrix4fv(gl.GetUniformLocation(programID, gl.Str("view\x00")), 1, false, &view[0])
        gl.UniformMatrix4fv(gl.GetUniformLocation(programID, gl.Str("projection\x00")), 1, false, &projection[0])

        gl.BindVertexArray(vao)
        gl.DrawElements(gl.TRIANGLES, 36, gl.UNSIGNED_INT, gl.PtrOffset(0))

        window.SwapBuffers()
        glfw.PollEvents()
        }
    }

func loadShader(file string, shaderType uint32) (uint32, error) {
    shader := gl.CreateShader(shaderType)

    csources, free := gl.Strs(string(file))
    gl.ShaderSource(shader, 1, csources, nil)
    free()
    gl.CompileShader(shader)

    var status int32
    gl.GetShaderiv(shader, gl.COMPILE_STATUS, &status)
    if status == gl.FALSE {
        var logLength int32
        gl.GetShaderiv(shader, gl.INFO_LOG_LENGTH, &logLength)

        log := strings.Repeat("\x00", int(logLength+1))
        gl.GetShaderInfoLog(shader, logLength, nil, gl.Str(log))

        return 0,fmt.Errorf("failed to compile %v: %v", file, log)
    }
    return shader, nil
}

Answer 1

HomogRotate3D创建一个3D旋转矩阵，该矩阵围绕 规范化 向量给出的某个任意轴旋转（弧度）。

mgl32.Vec3{1, 1, 0}.Normalize()

显然你所需要的只是标准化旋转轴矢量并停止失真。所以你的模型旋转线：

model = model.Mul4(mgl32.HomogRotate3D(float32(glfw.GetTime()) * 
    mgl32.DegToRad(50.0), mgl32.Vec3{1.0, 1.0, 0.0}.Normalize()))

玩得开心！

Opengl模型矩阵展开顶点

1 个答案: