Baillehache Pascal's personal website

LibCapy - lsystem

LSystem class.

Macros:

#define CAPY_LSYSTEM_H

#define CapyDecLSystem(N, T)        \
typedef struct N {                  \
  T* state;                         \
  size_t len;                       \
  void* params;                     \
  void (*destruct)(void);           \
  void (*step)(void);               \
  T* (*rule)(                       \
    size_t const idx,               \
    size_t* const lenOut);          \
} N;                                \
void N ## Destruct(void);           \
void N ## Step(void);               \
N N ## Create(                      \
      T* const initState,           \
  size_t const len);                \
N* N ## Alloc(                      \
      T* const initState,           \
  size_t const len);                \
void N ## Free(N** const that);

Declaration macro for a LSystem object with name N and data type T (must have a destruct method, but maybe null).

#define CapyDefLSystem(N, T, R)                       \
void N ## Destruct(void) {                            \
  N* that = (N*)capyThat;                             \
  loop(i, that->len) if(that->state[i].destruct) {    \
    $(that->state + i, destruct)();                   \
  }                                                   \
  free(that->state);                                  \
  that->state = NULL;                                 \
  that->len = 0;                                      \
}                                                     \
void N ## Step(void) {                                \
  N* that = (N*)capyThat;                             \
  T* res = NULL;                                      \
  size_t lenRes = 0;                                  \
  loop(idx, that->len) {                              \
    size_t lenOut = 0;                                \
    T* out = $(that, rule)(idx, &lenOut);             \
    if(out != NULL) {                                 \
      safeRealloc(res, lenRes + lenOut);              \
      assert(res != NULL);                            \
      loop(i, lenOut) res[lenRes + i] = out[i];       \
      free(out);                                      \
      lenRes += lenOut;                               \
    }                                                 \
  }                                                   \
  loop(i, that->len) if(that->state[i].destruct) {    \
    $(that->state + i, destruct)();                   \
  }                                                   \
  free(that->state);                                  \
  that->state = res;                                  \
  that->len = lenRes;                                 \
}                                                     \
N N ## Create(                                        \
      T* const initState,                             \
  size_t const len) {                                 \
  N that = {                                          \
    .state = NULL,                                    \
    .len = 0,                                         \
    .params = NULL,                                   \
    .destruct = N ## Destruct,                        \
    .step = N ## Step,                                \
    .rule = R,                                        \
  };                                                  \
  if(len > 0) {                                       \
    safeMalloc(that.state, len);                      \
    assert(that.state);                               \
    loop(i, len) that.state[i] = initState[i];        \
    that.len = len;                                   \
  }                                                   \
  return that;                                        \
}                                                     \
N* N ## Alloc(                                        \
      T* const initState,                             \
  size_t const len) {                                 \
  N* that = NULL;                                     \
  safeMalloc(that, 1);                                \
  if(!that) return NULL;                              \
  *that = N ## Create(initState, len);                \
  return that;                                        \
}                                                     \
void N ## Free(N** const that) {                      \
  if(that == NULL || *that == NULL) return;           \
  $(*that, destruct)();                               \
  free(*that);                                        \
  *that = NULL;                                       \
}

Definition macro for a LSystem object with name N, data type T (must have a destruct method), and rule R. The rule take the index of the current cymbol in the current state of the L-System and return a null terminated array of symbols (eventually empty). When calling 'step', the rule is applied to each symbol of the current state, and the current state is replaced by the result state.

Enumerations:

None.

Typedefs:

None.

Struct CapyLSysLindenMayerAlgaeState :

Struct CapyLSysLindenMayerAlgaeState's properties:

  char val;

  CapyPad(char, val);

Struct CapyLSysLindenMayerAlgaeState's methods:

  void (*destruct)();

Struct CapyLSysKochSnowflakeState :

Struct CapyLSysKochSnowflakeState's properties:

  char val;

  CapyPad(char, val);

Struct CapyLSysKochSnowflakeState's methods:

  void (*destruct)();

Struct CapyLSysFractalBinaryTreeState :

Struct CapyLSysFractalBinaryTreeState's properties:

  char val;

  CapyPad(char, val);

Struct CapyLSysFractalBinaryTreeState's methods:

  void (*destruct)();

Functions:

None.

2024-03-20
in LibCapy,
0 views