EventList and Spline do not seem to be defined (api)

Aberta
  • Algo errado?
#1 0 comentários 0 reações 0 responsáveis Ver no GitHub

Ninguém assumiu esta issue ainda.

Avaliação

Dificuldade
3/5
Tempo estimado
1-2 dias
Facilidade para iniciantes
45/100
Tipo de issue
Bug
Clareza
Razoavelmente clara
Status de atividade
Estagnada
Stack de tecnologia
c, javascript
Domínio
api, build-system

Direção de pesquisa

Comece com tools/gen_api.js e as entradas da blocklist para EventList e Spline; em seguida, inspecione build/_deps/raylib-src/parser/output/raylib_api.json e o tools/api.json gerado. Compare as declarações geradas com a versão do raylib usada pelo DLL FFI wrapper. Considera-se concluído quando as entradas de API afetadas corresponderem aos símbolos disponíveis do raylib e não produzirem mais erros de função indefinida.

Escrita pelo modelo de indexação a partir do texto da issue.

Descrição

api bug todo

Essentially, all the functions with EventList or Spline are not defined (but are output by raylib api-gen) and throw an error if DLL is ffi-wrapped.

I think this is related to versioning mismatch with raylib (which may be a sign I need to adjust build to use raylib better.)

https://github.com/konsumer/raylib-pointers/blob/f365325/tools/gen_api.js#L27


// this will generate API info about all the new wrapped stuff & utils
// it's basically the same as the stuff parser generates in raylib
// but I add my wrappers and and struct-utils

import { writeFile, readFile } from 'fs/promises'

// check if the function will be wrapped
const isWrapped = (f) => {
  const returnPointer = /^[A-Z]/.test(f.returnType)

  // do any params need to be converted to pointers?
  let paramPointer = false

  for (const p of f.params || []) {
    if (/[A-Z]/.test(p.type)) {
      paramPointer = true
      break
    }
  }
  return returnPointer || paramPointer
}

export const blocklist = [
  // this is blocked because I add wrapped_WindowShouldClose manually
  'WindowShouldClose',

  // TODO: I think these are not available in the current version, but for some reason are referenced
  'LoadAutomationEventList',
  'UnloadAutomationEventList',
  'ExportAutomationEventList',
  'SetAutomationEventList',
  'PlayAutomationEventList',
  'PlayAutomationEvent',
  'DrawLineBezier',
  'DrawCircleLinesV',
  'DrawSplineLinear',
  'DrawSplineBasis',
  'DrawSplineCatmullRom',
  'DrawSplineBezierQuadratic',
  'DrawSplineBezierCubic',
  'DrawSplineSegmentLinear',
  'DrawSplineSegmentBasis',
  'DrawSplineSegmentCatmullRom',
  'DrawSplineSegmentBezierQuadratic',
  'DrawSplineSegmentBezierCubic',
  'GetSplinePointLinear',
  'GetSplinePointBasis',
  'GetSplinePointCatmullRom',
  'GetSplinePointBezierQuad',
  'GetSplinePointBezierCubic'
]

const blocklistStructs = []

const { defines, structs, aliases, enums, callbacks, functions } = JSON.parse(await readFile('build/_deps/raylib-src/parser/output/raylib_api.json'))

const wrapped = []
const unwrapped = []
const struct_utils = []

for (const { name, description, fields } of structs) {
  if (blocklistStructs.includes(name)) {
    continue
  }

  struct_utils.push({
    name: `${name}_size`,
    description: `Get byte-size of ${name} struct`,
    returnType: 'unsigned int',
    params: []
  })
  for (const field of fields) {
    struct_utils.push({
      name: `${name}_get_${field.name}`,
      description: `Getter for ${name}->${field.name}`,
      returnType: field.type,
      params: [{ name: 'obj', type: `${field.name}*` }]
    })
    struct_utils.push({
      name: `${name}_set_${field.name}`,
      description: `Setter for ${name}->${field.name}`,
      returnType: 'void',
      params: [
        { name: 'obj', type: `${field.name}*` },
        { name: 'v', type: field.type }
      ]
    })
  }
}

for (const f of functions) {
  if (blocklist.includes(f.name)) {
    continue
  }
  if (isWrapped(f)) {
    wrapped.push({
      name: `wrapped_${f.name}`,
      description: f.description,
      original: f.name,
      returnType: /[A-Z]/.test(f.returnType) ? `${f.returnType}*` : f.returnType,
      params: (f.params || []).map((p) => {
        return {
          ...p,
          type: /[A-Z]/.test(p.type) ? `${p.type}*` : p.type
        }
      })
    })
  } else {
    f.params ||= []
    unwrapped.push(f)
  }
}

// these are my additions (per-frame alloc/free)

wrapped.push({
  name: 'wrapped_alloc',
  original: 'alloc',
  description: 'Allocate memory, cleared on every WindowShouldClose call (your frame update-loop)',
  returnType: 'void*',
  params: [
    {
      name: 'size',
      type: 'unsigned int',
      description: 'The size (in bytes) to allocate'
    }
  ]
})

wrapped.push({
  name: 'wrapped_free',
  original: 'free',
  description: 'Clear allocated memory. If it was not allocated (or has already been freed) this will error.',
  returnType: 'void',
  params: [
    {
      name: 'pointer',
      type: 'void*',
      description: 'The pointer to free'
    }
  ]
})

wrapped.push({
  name: 'wrapped_WindowShouldClose',
  original: 'WindowShouldClose',
  description: 'Check if application should close (KEY_ESCAPE pressed or windows close icon clicked.) This also clears memory that was allocated since last call.',
  returnType: 'bool',
  params: []
})

await writeFile('tools/api.json', JSON.stringify({ unwrapped, wrapped, struct_utils, defines, structs, aliases, enums, callbacks, functions }, null, 2))
Linguagem predominante
C
Estrelas
0
Forks
1
Nenhum PR com merge em 30d

Preparar o ambiente

Este projeto não oferece contêiner de desenvolvimento, Dockerfile nem guia de contribuição, então a configuração fica por sua conta: comece pelo README e veja nosso guia da primeira contribuição para os passos gerais.

Primeiros passos

  1. Leia a issue inteira e depois o guia de contribuição do projeto.
  2. Comente na issue dizendo que vai assumir — evita que duas pessoas façam o mesmo trabalho.
  3. Faça um fork do repositório e trabalhe em uma branch.
  4. Abra um pull request que referencie o número da issue.

Mais de konsumer/raylib-pointers

Todas as issues de konsumer/raylib-pointers

Issues semelhantes

Mais issues de C

Receba novas issues na sua caixa de entrada

Um resumo curto de issues do GitHub para quem está começando.