hvis ikke INIT da
    glfw.ÅpneVindu(512, 512, 0, 0, 0, 0, 0, 0, GLFW_VINDU)
    glfw.SettVinduTittel("meg # 2")
    INIT = sant
slutt

lokal ramme = 0

kam_pos = kam_pos eller Vek3(0, 0, 0)
kam_vin = kam_vin eller Vin3(0, 0, 0)

funksjon dekode_obj(str)
    lokal data = {}
    lokal toppunktetene = {}
    lokal normalene = {}
    lokal polygoner = {}

    lokalt i = 1

    for t, x, y, z i str:gsamsvarer("(% S +)% s-(% S +)% s-(% S +)% s-(% S +)% s-\ n")
        x, y, z = tilnummer(x), tilnummer(y), tilnummer(z)

        hvis t == "v" da
            bord.setteinn(toppunktetene, {x = x, y = y, z = z})
            i = i + 1
        hvisikke t == "vn" da
            bord.setteinn(normaler, {x = x, y = y, z = z})
        hvisikke t == "f" da
            bord.setteinn(
                polygoner,
                {
                    [1] = toppunktetene [x],
                    [2] = toppunktetene [y],
                    [3] = toppunktetene [z],
                }
            )
        slutt
    slutt

    for k, v parvis(normaler) gjør
        polygoner [k]. n = v
    slutt

    data.polygons = polygoner

    returnere data
slutt

lokal FFT = 1

krok.Legg("FFT", 1, funksjon(l, r)
    FFT = l + r
    FFT = 0,2 ^ FFT * 0,5
slutt)


lokal active_models = {}

gjør - model
    lokal META = {}
    META.__indeks = META

    klasse.GetSet(META, "Pos", Vek3(0,0,0))
    klasse.GetSet(META, "Vinkle", Vek3(0,0,0))
    klasse.GetSet(META, "Scale", Vek3(1,1,1))
    klasse.GetSet(META, "Størrelse", 1)
    klasse.GetSet(META, "model", 1)

    funksjon META:SettModel(bane)
        selv.obj = dekode_obj(file.Read(Bane("modeller /" .. bane)))
        selv.Model = sti
        slutt

        funksjon META:Draw()
        hvis ikke selv.obj så tilbake slutten

        gl.MatrixMode(GL_MODELVIEW)
        gl.LoadIdentity()

        gl.Oversatt(selv.pos.x, selv.pos.y, selv.pos.z)
        gl.Rotere(selv.vin.p, 1, 0, 0)
        gl.Rotere(selv.vin.y, 0, 1, 0)
        gl.Rotere(selv.vin.r, 0, 0, 1)

        lokal s = selv.stør
        gl.Scala(selv.scale.x * s, selv.scale.y * s, selv.scale.z * s)

        for nøkkel, data i ipairs(selv.obj.polygons) gjør
            gl.Begin(GL_TRIANGLES)
            lokal c = HSVToFarge(((nøkkel / # selv.obj.polygons) + frame/100) * 360, 1, 1)
            gl.Farge3d(
                c.r * math.sin(FFT),
                c.g * math.cos(FFT),
                c.b * math.sin(FFT)
            )
            gl.Vertex3d(data [1]. x, data [1]. y, data [1]. z)
            gl.Vertex3d(data [2]. x, data [2]. y, data [2]. z)
            gl.Vertex3d(data [3]. x, data [3]. y, data [3]. z)
            gl.End()
        slutt
    slutt

    funksjon Model(bane)
        lokal selvstyre = setmetabord(
        {
            pos = Vek3(),
            vin = Vin3(),
            skala = Vek3(1,1,1),
            stør = 1,
            }, META
        )
        bord.setteinn(active_models, selv)

        tilbake selv
    slutt
slutt

lokal funksjon kalk_kamera()
    hvis inngang.ErNøkkelNede(GLFW_KEY_SPACE) da
        kam_pos = kam_pos -(kam_vin:getup() * 1)
    hvisikke inngang.ErNøkkelNede(GLFW_KEY_LCTRL) da
        kam_pos = kam_pos +(kam_vin:getup() * 1)
    slutt

    hvis inngang.ErNøkkelNede(("W"):byte()) så
        kam_pos = kam_pos +(kam_vin:FåForward() * 1)
    hvisikke inngang.ErNøkkelNede(("S"):byte()) så
        kam_pos = kam_pos -(kam_vin:FåForward() * 1)
    slutt

    hvis inngang.ErNøkkelNede(("A"):byte()) så
        kam_pos = kam_pos +(kam_vin:FåRight() * 1)
    hvisikke inngang.ErNøkkelNede(("D"):byte()) så
        kam_pos = kam_pos -(kam_vin:FåRight() * 1)
    slutt

    hvis inngang.ErNøkkelNede(GLFW_KEY_UP) da
        kam_vin.p = math.clamp(kam_vin.p - 4, -90, 90)
    hvisikke inngang.ErNøkkelNede(GLFW_KEY_DOWN) da
        kam_vin.p = math.clamp(kam_vin.p + 4, -90, 90)
    slutt

    hvis inngang.ErNøkkelNede(GLFW_KEY_LEFT) da
        kam_vin.y =(kam_vin.y - 4)% 360
    hvisikke inngang.ErNøkkelNede(GLFW_KEY_RIGHT) da
        kam_vin.y =(kam_vin.y + 4)% 360
    slutt
slutt

krok.Legg("PåOppdatering", "GL", funksjon()
    lokal bredde, høyde = glfw.FåVinduStørelse()
    ramme = glfw.FåTid() * 10
    kalk_kamera()

    gl.VisPort(0, 0, bredde, høyde)

    gl.FjerneFarge(0, 0, 0, 1)
    gl.Fjerne(GL_COLOR_BUFFER_BIT)

    gl.MatriseModus(GL_PROJECTION)
    gl.LoadIdentity()
    glu.Perspective(90, bredde / høyde, 0.5, 100)
    gl.Rotere(kam_vin.p, 1, 0, 0)
    gl.Rotere(kam_vin.y, 0, 1, 0)
    gl.Oversatt(kam_pos.x, kam_pos.y, kam_pos.z)

    for nøkkel, obj parvis(active_models) gjør
        obj:Tegn()
    slutt

    glfw.ByttBufferene()
slutt)

lokal obj = Model()
obj:SettModel("pumpkin.obj")
obj:SettStø(0,1)
obj:SettVinkler(Vin3(10,0,0))