From 0ff9c5a62cb59afdaee556ba2e256a3a6e2fd4f2 Mon Sep 17 00:00:00 2001 From: kichikuou Date: Sat, 3 Sep 2022 10:20:19 +0900 Subject: [PATCH] ReignEngine: Add loader for particle effects This implements a parser for particle effect definition files (.pae) and a set of field accessor functions for the RE_ITYPE_PARTICLE_EFFECT instance type. Rendering of effects is not yet implemented. --- include/reign.h | 63 ++++++ src/3d/3d_internal.h | 122 ++++++++++ src/3d/debug.c | 2 + src/3d/model.c | 13 +- src/3d/particle.c | 489 ++++++++++++++++++++++++++++++++++++++++ src/3d/reign.c | 409 ++++++++++++++++++++++++++++++++- src/hll/ReignEngine.c | 511 ++++++++++++++++++++++++++++++++---------- src/meson.build | 1 + 8 files changed, 1479 insertions(+), 131 deletions(-) create mode 100644 src/3d/particle.c diff --git a/include/reign.h b/include/reign.h index 1ec6e91..8c14490 100644 --- a/include/reign.h +++ b/include/reign.h @@ -118,6 +118,7 @@ struct RE_plugin { struct RE_instance { struct RE_plugin *plugin; struct model *model; + struct particle_effect *effect; struct motion *motion; struct motion *next_motion; struct height_detector *height_detector; @@ -175,6 +176,68 @@ bool RE_motion_set_frame(struct motion *motion, float frame); bool RE_motion_set_frame_range(struct motion *motion, float begin, float end); bool RE_motion_set_loop_frame_range(struct motion *motion, float begin, float end); +int RE_effect_get_num_object(struct particle_effect *effect); +struct particle_object *RE_get_effect_object(struct particle_effect *effect, unsigned object); +int RE_particle_get_type(struct particle_object *po); +int RE_particle_get_move_type(struct particle_object *po); +int RE_particle_get_up_vec_type(struct particle_object *po); +float RE_particle_get_move_curve(struct particle_object *po); +void RE_particle_get_frame(struct particle_object *po, int *begin_frame, int *end_frame); +int RE_particle_get_stop_frame(struct particle_object *po); +const char *RE_particle_get_name(struct particle_object *po); +int RE_particle_get_num_pos(struct particle_object *po); +int RE_particle_get_num_pos_unit(struct particle_object *po, int pos); +int RE_particle_get_pos_unit_type(struct particle_object *po, int pos, int unit); +int RE_particle_get_pos_unit_index(struct particle_object *po, int pos, int unit); +int RE_particle_get_num_texture(struct particle_object *po); +const char *RE_particle_get_texture(struct particle_object *po, int texture); +bool RE_particle_get_size(struct particle_object *po, float *begin_size, float *end_size); +bool RE_particle_get_size2(struct particle_object *po, int frame, float *size); +bool RE_particle_get_size_x(struct particle_object *po, int frame, float *size); +bool RE_particle_get_size_y(struct particle_object *po, int frame, float *size); +bool RE_particle_get_size_type(struct particle_object *po, int frame, int *type); +bool RE_particle_get_size_x_type(struct particle_object *po, int frame, int *type); +bool RE_particle_get_size_y_type(struct particle_object *po, int frame, int *type); +int RE_particle_get_num_size2(struct particle_object *po); +int RE_particle_get_num_size_x(struct particle_object *po); +int RE_particle_get_num_size_y(struct particle_object *po); +int RE_particle_get_num_size_type(struct particle_object *po); +int RE_particle_get_num_size_x_type(struct particle_object *po); +int RE_particle_get_num_size_y_type(struct particle_object *po); +int RE_particle_get_blend_type(struct particle_object *po); +const char *RE_particle_get_polygon_name(struct particle_object *po); +int RE_particle_get_num_particles(struct particle_object *po); +int RE_particle_get_alpha_fadein_time(struct particle_object *po); +int RE_particle_get_alpha_fadeout_time(struct particle_object *po); +int RE_particle_get_texture_anime_time(struct particle_object *po); +float RE_particle_get_alpha_fadein_frame(struct particle_object *po); +float RE_particle_get_alpha_fadeout_frame(struct particle_object *po); +float RE_particle_get_texture_anime_frame(struct particle_object *po); +int RE_particle_get_frame_ref_type(struct particle_object *po); +int RE_particle_get_frame_ref_param(struct particle_object *po); +void RE_particle_get_x_rotation_angle(struct particle_object *po, float *begin_angle, float *end_angle); +void RE_particle_get_y_rotation_angle(struct particle_object *po, float *begin_angle, float *end_angle); +void RE_particle_get_z_rotation_angle(struct particle_object *po, float *begin_angle, float *end_angle); +void RE_particle_get_x_revolution_angle(struct particle_object *po, float *begin_angle, float *end_angle); +void RE_particle_get_x_revolution_distance(struct particle_object *po, float *begin_distance, float *end_distance); +void RE_particle_get_y_revolution_angle(struct particle_object *po, float *begin_angle, float *end_angle); +void RE_particle_get_y_revolution_distance(struct particle_object *po, float *begin_distance, float *end_distance); +void RE_particle_get_z_revolution_angle(struct particle_object *po, float *begin_angle, float *end_angle); +void RE_particle_get_z_revolution_distance(struct particle_object *po, float *begin_distance, float *end_distance); +bool RE_particle_get_curve_length(struct particle_object *po, vec3 out); +int RE_particle_get_child_frame(struct particle_object *po); +float RE_particle_get_child_length(struct particle_object *po); +float RE_particle_get_child_begin_slope(struct particle_object *po); +float RE_particle_get_child_end_slope(struct particle_object *po); +float RE_particle_get_child_create_begin_frame(struct particle_object *po); +float RE_particle_get_child_create_end_frame(struct particle_object *po); +int RE_particle_get_child_move_dir_type(struct particle_object *po); +int RE_particle_get_dir_type(struct particle_object *po); +int RE_particle_get_num_damage(struct particle_object *po); +int RE_particle_get_damage(struct particle_object *po, int frame); +float RE_particle_get_offset_x(struct particle_object *po); +float RE_particle_get_offset_y(struct particle_object *po); + bool RE_back_cg_set(struct RE_back_cg *bcg, int no); bool RE_back_cg_set_name(struct RE_back_cg *bcg, struct string *name, struct archive *aar); diff --git a/src/3d/3d_internal.h b/src/3d/3d_internal.h index 79963c7..20e8ab0 100644 --- a/src/3d/3d_internal.h +++ b/src/3d/3d_internal.h @@ -166,6 +166,8 @@ void model_free(struct model *model); struct motion *motion_load(const char *name, struct RE_instance *instance, struct archive *aar); void motion_free(struct motion *motion); +struct archive_data *RE_get_aar_entry(struct archive *aar, const char *dir, const char *name, const char *ext); + // renderer.c struct RE_renderer *RE_renderer_new(struct texture *texture); @@ -175,6 +177,126 @@ struct height_detector *RE_renderer_create_height_detector(struct RE_renderer *r void RE_renderer_free_height_detector(struct height_detector *hd); float RE_renderer_detect_height(struct height_detector *hd, float x, float z); +// particle.c + +enum particle_type { + PARTICLE_TYPE_BILLBOARD = 0, + PARTICLE_TYPE_POLYGON_OBJECT = 1, + PARTICLE_TYPE_SWORD_BLUR = 2, + PARTICLE_TYPE_CAMERA_VIBRATION = 3, +}; + +enum particle_move_type { + PARTICLE_MOVE_FIXED = 0, + PARTICLE_MOVE_LINEAR = 1, + PARTICLE_MOVE_EMITTER = 2, +}; + +enum particle_blend_type { + PARTICLE_BLEND_NORMAL = 0, + PARTICLE_BLEND_ADDITIVE = 1, +}; + +enum particle_frame_ref_type { + PARTICLE_FRAME_REF_EFFECT = 0, + PARTICLE_FRAME_REF_TARGET = 1, +}; + +struct particle_position_unit { + enum { + PARTICLE_POS_UNIT_NONE = 0, + PARTICLE_POS_UNIT_TARGET = 1, + PARTICLE_POS_UNIT_BONE = 2, + PARTICLE_POS_UNIT_RAND = 4, + PARTICLE_POS_UNIT_RAND_POSITIVE_Y = 5, + PARTICLE_POS_UNIT_ABSOLUTE = 6, + } type; + union { + struct { + int n; + vec3 pos; + } target; + struct { + int n; + // char *name; + vec3 pos; + } bone; + struct { + float f; + } rand; + vec3 absolute; + }; +}; + +#define NR_PARTICLE_POSITIONS 2 +#define NR_PARTICLE_POSITION_UNITS 3 +struct particle_position { + struct particle_position_unit units[NR_PARTICLE_POSITION_UNITS]; +}; + +struct particle_object { + char *name; + enum particle_type type; + enum particle_move_type move_type; + int up_vector_type; + float move_curve; + struct particle_position *position[NR_PARTICLE_POSITIONS]; + float size[2]; + int nr_sizes2; + float *sizes2; + int nr_sizes_x; + float *sizes_x; + int nr_sizes_y; + float *sizes_y; + int nr_size_types; + int *size_types; + int nr_size_x_types; + int *size_x_types; + int nr_size_y_types; + int *size_y_types; + int nr_textures; + char **textures; + enum particle_blend_type blend_type; + float texture_anime_frame; + int texture_anime_time; + char *polygon_name; + int begin_frame; + int end_frame; + int stop_frame; + enum particle_frame_ref_type frame_ref_type; + int frame_ref_param; + int nr_particles; + float alpha_fadein_frame; + int alpha_fadein_time; + float alpha_fadeout_frame; + int alpha_fadeout_time; + vec3 rotation[2]; + vec3 revolution_angle[2]; + vec3 revolution_distance[2]; + vec3 curve_length; + int child_frame; + float child_length; + float child_begin_slope; + float child_end_slope; + float child_create_begin_frame; + float child_create_end_frame; + int child_move_dir_type; + int dir_type; + int nr_damages; + int *damages; + float offset_x; + float offset_y; +}; + +struct particle_effect { + char *path; + int nr_objects; + struct particle_object *objects; +}; + +struct particle_effect *particle_effect_load(struct archive *aar, const char *path); +void particle_effect_free(struct particle_effect *effect); + // parser.c struct pol { diff --git a/src/3d/debug.c b/src/3d/debug.c index cd436cb..9473391 100644 --- a/src/3d/debug.c +++ b/src/3d/debug.c @@ -96,6 +96,8 @@ static void print_instance(struct RE_instance *inst, int index, int indent) print_motion("next_motion", inst->next_motion, indent); if (inst->motion_blend) indent_printf(indent, "motion_blend_rate = %f,\n", inst->motion_blend_rate); + if (inst->effect) + indent_printf(indent, "path = \"%s\",\n", inst->effect->path); indent--; indent_printf(indent, "},\n"); diff --git a/src/3d/model.c b/src/3d/model.c index 68e88a1..8bfd78d 100644 --- a/src/3d/model.c +++ b/src/3d/model.c @@ -48,7 +48,7 @@ struct vertex_bones { GLfloat bone_weight[NR_WEIGHTS]; }; -static struct archive_data *get_aar_entry(struct archive *aar, const char *dir, const char *name, const char *ext) +struct archive_data *RE_get_aar_entry(struct archive *aar, const char *dir, const char *name, const char *ext) { char *path = xmalloc(strlen(dir) + strlen(name) + strlen(ext) + 2); sprintf(path, "%s\\%s%s", dir, name, ext); @@ -59,7 +59,7 @@ static struct archive_data *get_aar_entry(struct archive *aar, const char *dir, static GLuint load_texture(struct archive *aar, const char *path, const char *name) { - struct archive_data *dfile = get_aar_entry(aar, path, name, ""); + struct archive_data *dfile = RE_get_aar_entry(aar, path, name, ""); if (!dfile) { WARNING("cannot load texture %s\\%s", path, name); return 0; @@ -357,14 +357,11 @@ static void destroy_bone(struct bone *bone) struct model *model_load(struct archive *aar, const char *path, struct RE_renderer *r) { - if (path[0] == '\0') - return NULL; - const char *basename = strrchr(path, '\\'); basename = basename ? basename + 1 : path; // Load .POL file - struct archive_data *pol_file = get_aar_entry(aar, path, basename, ".POL"); + struct archive_data *pol_file = RE_get_aar_entry(aar, path, basename, ".POL"); if (!pol_file) { WARNING("%s\\%s.POL: not found", path, basename); return NULL; @@ -379,7 +376,7 @@ struct model *model_load(struct archive *aar, const char *path, struct RE_render // Load .amt file, if any struct amt *amt = NULL; - struct archive_data *amt_file = get_aar_entry(aar, path, basename, ".amt"); + struct archive_data *amt_file = RE_get_aar_entry(aar, path, basename, ".amt"); if (amt_file) { amt = amt_parse(amt_file->data, amt_file->size); if (!amt) @@ -480,7 +477,7 @@ struct motion *motion_load(const char *name, struct RE_instance *instance, struc if (!model) return NULL; - struct archive_data *dfile = get_aar_entry(aar, model->path, name, ".MOT"); + struct archive_data *dfile = RE_get_aar_entry(aar, model->path, name, ".MOT"); if (!dfile) { WARNING("%s\\%s.MOT: not found", model->path, name); return NULL; diff --git a/src/3d/particle.c b/src/3d/particle.c new file mode 100644 index 0000000..69ff53a --- /dev/null +++ b/src/3d/particle.c @@ -0,0 +1,489 @@ +/* Copyright (C) 2022 kichikuou + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +#include "system4.h" +#include "system4/aar.h" +#include "system4/utfsjis.h" + +#include "3d_internal.h" + +static void parse_error(const char *msg, char *input) +{ + char *eol = strchr(input, '\n'); + *eol = '\0'; + WARNING("Parse error: %s Near: \"%s\"", msg, input); +} + +static enum particle_type parse_particle_type(const char *s) +{ + if (!strcmp(s, "ビルボード")) + return PARTICLE_TYPE_BILLBOARD; + else if (!strcmp(s, "ポリゴンオブジェクト")) + return PARTICLE_TYPE_POLYGON_OBJECT; + else if (!strcmp(s, "剣ブラー")) + return PARTICLE_TYPE_SWORD_BLUR; + else if (!strcmp(s, "カメラ振動")) + return PARTICLE_TYPE_CAMERA_VIBRATION; + WARNING("unknown object type \"%s\"", s); + return (enum particle_type)-1; +} + +static enum particle_move_type parse_particle_move_type(const char *s) +{ + if (!strcmp(s, "固定")) + return PARTICLE_MOVE_FIXED; + else if (!strcmp(s, "直線")) + return PARTICLE_MOVE_LINEAR; + else if (!strcmp(s, "放射")) + return PARTICLE_MOVE_EMITTER; + WARNING("unknown move type \"%s\"", s); + return (enum particle_move_type)-1; +} + +static enum particle_blend_type parse_particle_blend_type(const char *s) +{ + if (!strcmp(s, "標準")) + return PARTICLE_BLEND_NORMAL; + else if (!strcmp(s, "加算")) + return PARTICLE_BLEND_ADDITIVE; + WARNING("unknown blend type \"%s\"", s); + return (enum particle_blend_type)-1; +} + +static enum particle_frame_ref_type parse_particle_frame_ref_type(const char *s, int *param) +{ + if (!strcmp(s, "エフェクト")) + return PARTICLE_FRAME_REF_EFFECT; + else if (sscanf(s, "ターゲット[%d]", param) == 1) + return PARTICLE_FRAME_REF_TARGET; + WARNING("unknown blend type \"%s\"", s); + return (enum particle_frame_ref_type)-1; +} + +static char *parse_quoted_string(char **ptext) +{ + char *text = *ptext; + + if (*text++ != '"') { + parse_error("quoted string expected.", text); + return NULL; + } + char *p = strchr(text, '"'); + if (!p) { + parse_error("unfinished string.", text); + return NULL; + } + *p = '\0'; + *ptext = p + 1; + return utf2sjis(text, 0); +} + +#define MATCH(fmt, ...) (len = 0, sscanf(text, fmt " %n", ##__VA_ARGS__, &len), text += len, len) +#define STRING_BUF_SIZE 64 +#define KEYWORD "%63s" +#define QUOTED_STRING "\"%63[^\"]\"" + +static float *parse_float_list(char **ptext, int *nr) +{ + char *text = *ptext; + int len; + float f; + + if (!MATCH("%f", &f)) { + parse_error("float expected.", text); + return NULL; + } + + int cap = 16; + float *floats = xmalloc(cap * sizeof(float)); + floats[0] = f; + *nr = 1; + while (MATCH(" , %f", &f)) { + if (*nr == cap) { + cap *= 2; + floats = xrealloc(floats, cap * sizeof(float)); + } + floats[(*nr)++] = f; + } + *ptext = text; + return floats; +} + +static int *parse_int_list(char **ptext, int *nr) +{ + char *text = *ptext; + int len; + int n; + + if (!MATCH("%d", &n)) { + parse_error("int expected.", text); + return NULL; + } + + int cap = 16; + int *ints = xmalloc(cap * sizeof(int)); + ints[0] = n; + *nr = 1; + while (MATCH(" , %d", &n)) { + if (*nr == cap) { + cap *= 2; + ints = xrealloc(ints, cap * sizeof(int)); + } + ints[(*nr)++] = n; + } + *ptext = text; + return ints; +} + +static char **parse_qstr_list(char **ptext, int *nr) +{ + char *text = *ptext; + int len; + + int cap = 16; + char **strs = xmalloc(cap * sizeof(char *)); + *nr = 0; + do { + if (*nr == cap) { + cap *= 2; + strs = xrealloc(strs, cap * sizeof(char *)); + } + strs[*nr] = parse_quoted_string(&text); + if (!strs[*nr]) { + for (int i = 0; i < *nr; i++) + free(strs[i]); + free(strs); + return NULL; + } + (*nr)++; + } while (MATCH(" , ")); + *ptext = text; + return strs; +} + +static struct particle_position *parse_position(char **ptext) +{ + char *text = *ptext; + int len; + + struct particle_position *epos = xcalloc(1, sizeof(struct particle_position)); + + int n; + float x, y, z; + char string_buf[STRING_BUF_SIZE]; + for (int i = 0; i < NR_PARTICLE_POSITION_UNITS; i++) { + struct particle_position_unit *unit = &epos->units[i]; + if (MATCH("なし")) { + unit->type = PARTICLE_POS_UNIT_NONE; + } else if (MATCH("絶対位置( %f , %f , %f )", &x, &y, &z)) { + unit->type = PARTICLE_POS_UNIT_ABSOLUTE; + unit->absolute[0] = x; + unit->absolute[1] = y; + unit->absolute[2] = -z; + } else if (MATCH("ボーン[ %d , "QUOTED_STRING" , %f , %f , %f ]", &n, string_buf, &x, &y, &z) || + MATCH("ボーン[ %d , \"\" , %f , %f , %f ]", &n, &x, &y, &z)) { + unit->type = PARTICLE_POS_UNIT_BONE; + unit->bone.n = n; + // unit->bone.name = utf2sjis(string_buf, 0); + unit->bone.pos[0] = x; + unit->bone.pos[1] = y; + unit->bone.pos[2] = -z; + } else if (MATCH("ターゲット[ %d , %f , %f , %f ]", &n, &x, &y, &z)) { + unit->type = PARTICLE_POS_UNIT_TARGET; + unit->target.n = n; + unit->target.pos[0] = x; + unit->target.pos[1] = y; + unit->target.pos[2] = -z; + } else if (MATCH("ランダム方向( %f )", &x)) { + unit->type = PARTICLE_POS_UNIT_RAND; + unit->rand.f = x; + } else if (MATCH("ランダム方向Ｙ＋( %f )", &x)) { + unit->type = PARTICLE_POS_UNIT_RAND_POSITIVE_Y; + unit->rand.f = x; + } else { + parse_error("unknown position unit.", text); + free(epos); + return NULL; + } + if (!MATCH(" + ")) + break; + } + + *ptext = text; + return epos; +} + +static struct particle_effect *parse_pae(char *text) +{ + struct particle_effect *pae = xcalloc(1, sizeof(struct particle_effect)); + struct particle_object *current_object = NULL; + + for (;;) { + // Skip whitespaces and comments + for (;;) { + while (isspace(*text)) + text++; + if (text[0] == '/' && text[1] == '/') { + char *newline = strchr(text, '\n'); + if (newline) + text = newline + 1; + else + text += strlen(text); + } else { + break; + } + } + + int len; + int n, n2; + float f, f2; + char string_buf[STRING_BUF_SIZE]; + if (!current_object) { + // Toplevel + if (!*text) { // EOF + return pae; + } else if (MATCH("オブジェクト " QUOTED_STRING " = {", string_buf)) { + pae->objects = xrealloc_array(pae->objects, pae->nr_objects, pae->nr_objects + 1, sizeof(struct particle_object)); + current_object = &pae->objects[pae->nr_objects++]; + current_object->name = utf2sjis(string_buf, 0); + // Default values. + current_object->move_type = PARTICLE_MOVE_LINEAR; + } else { + parse_error("unknown toplevel.", text); + goto err; + } + } else { + // Object context + if (!*text) { + WARNING("unexpected EOF"); + return false; + } else if (MATCH("}")) { + current_object = NULL; + } else if (MATCH("種類 = " KEYWORD, string_buf)) { + current_object->type = parse_particle_type(string_buf); + if (current_object->type < 0) + goto err; + } else if (MATCH("移動タイプ = " KEYWORD, string_buf)) { + current_object->move_type = parse_particle_move_type(string_buf); + if (current_object->move_type < 0) + goto err; + } else if (MATCH("アップベクトルタイプ = %d", &n)) { + current_object->up_vector_type = n; + } else if (MATCH("移動カーブ = %f", &f)) { + current_object->move_curve = f; + } else if (MATCH("位置 = ")) { + current_object->position[0] = parse_position(&text); + if (!current_object->position[0]) + goto err; + if (MATCH(" , ")) { + current_object->position[1] = parse_position(&text); + if (!current_object->position[1]) + goto err; + } + } else if (MATCH("サイズ = %f", &f)) { + current_object->size[0] = f; + if (MATCH(" , %f", &f2)) + current_object->size[1] = f2; + else + current_object->size[1] = f; + } else if (MATCH("サイズ2 = ")) { + current_object->sizes2 = parse_float_list(&text, ¤t_object->nr_sizes2); + if (!current_object->sizes2) + goto err; + } else if (MATCH("サイズＸ = ")) { + current_object->sizes_x = parse_float_list(&text, ¤t_object->nr_sizes_x); + if (!current_object->sizes_x) + goto err; + } else if (MATCH("サイズＹ = ")) { + current_object->sizes_y = parse_float_list(&text, ¤t_object->nr_sizes_y); + if (!current_object->sizes_y) + goto err; + } else if (MATCH("サイズタイプ = ")) { + current_object->size_types = parse_int_list(&text, ¤t_object->nr_size_types); + if (!current_object->size_types) + goto err; + } else if (MATCH("サイズＸタイプ = ")) { + current_object->size_x_types = parse_int_list(&text, ¤t_object->nr_size_x_types); + if (!current_object->size_x_types) + goto err; + } else if (MATCH("サイズＹタイプ = ")) { + current_object->size_y_types = parse_int_list(&text, ¤t_object->nr_size_y_types); + if (!current_object->size_y_types) + goto err; + } else if (MATCH("テクスチャ = ")) { + current_object->textures = parse_qstr_list(&text, ¤t_object->nr_textures); + if (!current_object->textures) + goto err; + } else if (MATCH("ブレンドタイプ = " KEYWORD, string_buf)) { + current_object->blend_type = parse_particle_blend_type(string_buf); + if (current_object->blend_type < 0) + goto err; + } else if (MATCH("テクスチャアニメフレーム = %f", &f)) { + current_object->texture_anime_frame = f; + } else if (MATCH("テクスチャアニメ時間 = %d", &n)) { + current_object->texture_anime_time = n; + } else if (MATCH("ポリゴン = ")) { + current_object->polygon_name = parse_quoted_string(&text); + if (!current_object->polygon_name) + goto err; + } else if (MATCH("フレーム = %d , %d", &n, &n2)) { + current_object->begin_frame = n; + current_object->end_frame = n2; + } else if (MATCH("停止フレーム = %d", &n)) { + current_object->stop_frame = n; + } else if (MATCH("フレーム参照 = " KEYWORD, string_buf)) { + current_object->frame_ref_type = parse_particle_frame_ref_type(string_buf, ¤t_object->frame_ref_param); + if (current_object->frame_ref_type < 0) + goto err; + } else if (MATCH("個数 = %d", &n)) { + current_object->nr_particles = n; + } else if (MATCH("アルファフェードインフレーム = %f", &f)) { + current_object->alpha_fadein_frame = f; + } else if (MATCH("アルファフェードイン時間 = %d", &n)) { + current_object->alpha_fadein_time = n; + } else if (MATCH("アルファフェードアウトフレーム = %f", &f)) { + current_object->alpha_fadeout_frame = f; + } else if (MATCH("アルファフェードアウト時間 = %d", &n)) { + current_object->alpha_fadeout_time = n; + } else if (MATCH("Ｘ軸自転角度 = %f , %f", &f, &f2)) { + current_object->rotation[0][0] = f; + current_object->rotation[1][0] = f2; + } else if (MATCH("Ｙ軸自転角度 = %f , %f", &f, &f2)) { + current_object->rotation[0][1] = f; + current_object->rotation[1][1] = f2; + } else if (MATCH("Ｚ軸自転角度 = %f , %f", &f, &f2)) { + current_object->rotation[0][2] = f; + current_object->rotation[1][2] = f2; + } else if (MATCH("Ｘ軸公転角度 = %f , %f", &f, &f2)) { + current_object->revolution_angle[0][0] = f; + current_object->revolution_angle[1][0] = f2; + } else if (MATCH("Ｙ軸公転角度 = %f , %f", &f, &f2)) { + current_object->revolution_angle[0][1] = f; + current_object->revolution_angle[1][1] = f2; + } else if (MATCH("Ｚ軸公転角度 = %f , %f", &f, &f2)) { + current_object->revolution_angle[0][2] = f; + current_object->revolution_angle[1][2] = f2; + } else if (MATCH("Ｘ軸公転距離 = %f , %f", &f, &f2)) { + current_object->revolution_distance[0][0] = f; + current_object->revolution_distance[1][0] = f2; + } else if (MATCH("Ｙ軸公転距離 = %f , %f", &f, &f2)) { + current_object->revolution_distance[0][1] = f; + current_object->revolution_distance[1][1] = f2; + } else if (MATCH("Ｚ軸公転距離 = %f , %f", &f, &f2)) { + current_object->revolution_distance[0][2] = f; + current_object->revolution_distance[1][2] = f2; + } else if (MATCH("カーブＸ距離 = %f", &f)) { + current_object->curve_length[0] = f; + } else if (MATCH("カーブＹ距離 = %f", &f)) { + current_object->curve_length[1] = f; + } else if (MATCH("カーブＺ距離 = %f", &f)) { + current_object->curve_length[2] = f; + } else if (MATCH("子フレーム = %d", &n)) { + current_object->child_frame = n; + } else if (MATCH("子距離 = %f", &f)) { + current_object->child_length = f; + } else if (MATCH("子傾き = %f", &f)) { + current_object->child_begin_slope = f; + } else if (MATCH("子傾き２ = %f", &f)) { + current_object->child_end_slope = f; + } else if (MATCH("子生成開始フレーム = %f", &f)) { + current_object->child_create_begin_frame = f; + } else if (MATCH("子生成終了フレーム = %f", &f)) { + current_object->child_create_end_frame = f; + } else if (MATCH("子移動方向タイプ = %d", &n)) { + current_object->child_move_dir_type = n; + } else if (MATCH("方向タイプ = %d", &n)) { + current_object->dir_type = n; + } else if (MATCH("ダメージ = ")) { + current_object->damages = parse_int_list(&text, ¤t_object->nr_damages); + if (!current_object->damages) + goto err; + } else if (MATCH("オフセットＸ = %f", &f)) { + current_object->offset_x = f; + } else if (MATCH("オフセットＹ = %f", &f)) { + current_object->offset_y = f; + } else { + parse_error("unknown object field.", text); + goto err; + } + } + } + err: + particle_effect_free(pae); + return NULL; +} + +struct particle_effect *particle_effect_load(struct archive *aar, const char *path) +{ + const char *basename = strrchr(path, '\\'); + basename = basename ? basename + 1 : path; + + struct archive_data *dfile = RE_get_aar_entry(aar, path, basename, ".pae"); + if (!dfile) { + WARNING("%s\\%s.pae: not found", path, basename); + return NULL; + } + + char *sjis_text = xmalloc(dfile->size + 1); + memcpy(sjis_text, dfile->data, dfile->size); + // Replace null characters (written by buggy .pae formatter) with spaces. + for (size_t i = 0; i < dfile->size; i++) { + if (sjis_text[i] == '\0') + sjis_text[i] = ' '; + } + sjis_text[dfile->size] = '\0'; + + // We could parse the SJIS text directly, but convert it to UTF-8 for code + // clarity. + char *text = sjis2utf(sjis_text, dfile->size); + free(sjis_text); + struct particle_effect *effect = parse_pae(text); + free(text); + if (!effect) { + WARNING("could not parse %s", dfile->name); + archive_free_data(dfile); + return NULL; + } + archive_free_data(dfile); + + effect->path = strdup(path); + + return effect; +} + +void particle_effect_free(struct particle_effect *effect) +{ + for (int i = 0; i < effect->nr_objects; i++) { + struct particle_object *obj = &effect->objects[i]; + free(obj->name); + free(obj->position[0]); + free(obj->position[1]); + free(obj->sizes2); + free(obj->sizes_x); + free(obj->sizes_y); + free(obj->size_types); + free(obj->size_x_types); + free(obj->size_y_types); + for (int j = 0; j < obj->nr_textures; j++) + free(obj->textures[j]); + free(obj->textures); + free(obj->polygon_name); + free(obj->damages); + } + free(effect->objects); + free(effect->path); + free(effect); +} diff --git a/src/3d/reign.c b/src/3d/reign.c index 8b8c173..948bd46 100644 --- a/src/3d/reign.c +++ b/src/3d/reign.c @@ -62,6 +62,10 @@ static void unload_instance(struct RE_instance *instance) model_free(instance->model); instance->model = NULL; } + if (instance->effect) { + particle_effect_free(instance->effect); + instance->effect = NULL; + } if (instance->bone_transforms) { free(instance->bone_transforms); instance->bone_transforms = NULL; @@ -305,10 +309,23 @@ bool RE_instance_load(struct RE_instance *instance, const char *name) if (!instance) return false; unload_instance(instance); - instance->model = model_load(instance->plugin->aar, name, instance->plugin->renderer); - if (instance->model && instance->model->nr_bones > 0) - instance->bone_transforms = xcalloc(instance->model->nr_bones, sizeof(mat4)); - return !!instance->model; + if (name[0] == '\0') + return false; + + switch (instance->type) { + case RE_ITYPE_STATIC: + case RE_ITYPE_SKINNED: + instance->model = model_load(instance->plugin->aar, name, instance->plugin->renderer); + if (instance->model && instance->model->nr_bones > 0) + instance->bone_transforms = xcalloc(instance->model->nr_bones, sizeof(mat4)); + return !!instance->model; + case RE_ITYPE_PARTICLE_EFFECT: + instance->effect = particle_effect_load(instance->plugin->aar, name); + return !!instance->effect; + default: + WARNING("Invalid instance type %d", instance->type); + return false; + } } bool RE_instance_load_motion(struct RE_instance *instance, const char *name) @@ -468,6 +485,390 @@ bool RE_motion_set_loop_frame_range(struct motion *motion, float begin, float en return true; } +int RE_effect_get_num_object(struct particle_effect *effect) +{ + return effect ? effect->nr_objects : 0; +} + +struct particle_object *RE_get_effect_object(struct particle_effect *effect, unsigned object) +{ + if (!effect || object >= (unsigned)effect->nr_objects) + return NULL; + return &effect->objects[object]; +} + +int RE_particle_get_type(struct particle_object *po) +{ + return po ? po->type : 0; +} + +int RE_particle_get_move_type(struct particle_object *po) +{ + return po ? po->move_type : 0; +} + +int RE_particle_get_up_vec_type(struct particle_object *po) +{ + return po ? po->up_vector_type : 0; +} + +float RE_particle_get_move_curve(struct particle_object *po) +{ + return po ? po->move_curve : 0.0; +} + +void RE_particle_get_frame(struct particle_object *po, int *begin_frame, int *end_frame) +{ + if (!po) + return; + *begin_frame = po->begin_frame; + *end_frame = po->end_frame; +} + +int RE_particle_get_stop_frame(struct particle_object *po) +{ + return po ? po->stop_frame : 0; +} + +const char *RE_particle_get_name(struct particle_object *po) +{ + return po ? po->name : NULL; +} + +int RE_particle_get_num_pos(struct particle_object *po) +{ + return po ? NR_PARTICLE_POSITIONS : 0; +} + +int RE_particle_get_num_pos_unit(struct particle_object *po, int pos) +{ + return po ? NR_PARTICLE_POSITION_UNITS : 0; +} + +static struct particle_position_unit *get_position_unit(struct particle_object *po, int pos, int unit) +{ + if (!po || pos >= NR_PARTICLE_POSITIONS || !po->position[pos] || unit >= NR_PARTICLE_POSITION_UNITS) + return NULL; + return &po->position[pos]->units[unit]; +} + +int RE_particle_get_pos_unit_type(struct particle_object *po, int pos, int unit) +{ + struct particle_position_unit *u = get_position_unit(po, pos, unit); + return u ? u->type : 0; +} + +int RE_particle_get_pos_unit_index(struct particle_object *po, int pos, int unit) +{ + struct particle_position_unit *u = get_position_unit(po, pos, unit); + if (!u) + return 0; + switch (u->type) { + case PARTICLE_POS_UNIT_BONE: + return u->bone.n; + case PARTICLE_POS_UNIT_TARGET: + return u->target.n; + default: + return 0; + } +} + +int RE_particle_get_num_texture(struct particle_object *po) +{ + return po ? po->nr_textures : 0; +} + +const char *RE_particle_get_texture(struct particle_object *po, int texture) +{ + if (!po || texture >= po->nr_textures) + return NULL; + return po->textures[texture]; +} + +bool RE_particle_get_size(struct particle_object *po, float *begin_size, float *end_size) +{ + if (!po) + return false; + *begin_size = po->size[0]; + *end_size = po->size[1]; + return true; +} + +bool RE_particle_get_size2(struct particle_object *po, int frame, float *size) +{ + if (!po || frame >= po->nr_sizes2) + return false; + *size = po->sizes2[frame]; + return true; +} + +bool RE_particle_get_size_x(struct particle_object *po, int frame, float *size) +{ + if (!po || frame >= po->nr_sizes_x) + return false; + *size = po->sizes_x[frame]; + return true; +} + +bool RE_particle_get_size_y(struct particle_object *po, int frame, float *size) +{ + if (!po || frame >= po->nr_sizes_y) + return false; + *size = po->sizes_y[frame]; + return true; +} + +bool RE_particle_get_size_type(struct particle_object *po, int frame, int *type) +{ + if (!po || frame >= po->nr_size_types) + return false; + *type = po->size_types[frame]; + return true; +} + +bool RE_particle_get_size_x_type(struct particle_object *po, int frame, int *type) +{ + if (!po || frame >= po->nr_size_x_types) + return false; + *type = po->size_x_types[frame]; + return true; +} + +bool RE_particle_get_size_y_type(struct particle_object *po, int frame, int *type) +{ + if (!po || frame >= po->nr_size_y_types) + return false; + *type = po->size_y_types[frame]; + return true; +} + +int RE_particle_get_num_size2(struct particle_object *po) +{ + return po ? po->nr_sizes2 : 0; +} + +int RE_particle_get_num_size_x(struct particle_object *po) +{ + return po ? po->nr_sizes_x : 0; +} + +int RE_particle_get_num_size_y(struct particle_object *po) +{ + return po ? po->nr_sizes_y : 0; +} + +int RE_particle_get_num_size_type(struct particle_object *po) +{ + return po ? po->nr_size_types : 0; +} + +int RE_particle_get_num_size_x_type(struct particle_object *po) +{ + return po ? po->nr_size_x_types : 0; +} + +int RE_particle_get_num_size_y_type(struct particle_object *po) +{ + return po ? po->nr_size_y_types : 0; +} + +int RE_particle_get_blend_type(struct particle_object *po) +{ + return po ? po->blend_type : 0; +} + +const char *RE_particle_get_polygon_name(struct particle_object *po) +{ + return po ? po->polygon_name : NULL; +} + +int RE_particle_get_num_particles(struct particle_object *po) +{ + return po ? po->nr_particles : 0; +} + +int RE_particle_get_alpha_fadein_time(struct particle_object *po) +{ + return po ? po->alpha_fadein_time : 0; +} + +int RE_particle_get_alpha_fadeout_time(struct particle_object *po) +{ + return po ? po->alpha_fadeout_time : 0; +} + +int RE_particle_get_texture_anime_time(struct particle_object *po) +{ + return po ? po->texture_anime_time : 0; +} + +float RE_particle_get_alpha_fadein_frame(struct particle_object *po) +{ + return po ? po->alpha_fadein_frame : 0.0; +} + +float RE_particle_get_alpha_fadeout_frame(struct particle_object *po) +{ + return po ? po->alpha_fadeout_frame : 0.0; +} + +float RE_particle_get_texture_anime_frame(struct particle_object *po) +{ + return po ? po->texture_anime_frame : 0.0; +} + +int RE_particle_get_frame_ref_type(struct particle_object *po) +{ + return po ? po->frame_ref_type : 0; +} + +int RE_particle_get_frame_ref_param(struct particle_object *po) +{ + return po ? po->frame_ref_param : 0; +} + +void RE_particle_get_x_rotation_angle(struct particle_object *po, float *begin_angle, float *end_angle) +{ + if (!po) + return; + *begin_angle = po->rotation[0][0]; + *end_angle = po->rotation[1][0]; +} + +void RE_particle_get_y_rotation_angle(struct particle_object *po, float *begin_angle, float *end_angle) +{ + if (!po) + return; + *begin_angle = po->rotation[0][1]; + *end_angle = po->rotation[1][1]; +} + +void RE_particle_get_z_rotation_angle(struct particle_object *po, float *begin_angle, float *end_angle) +{ + if (!po) + return; + *begin_angle = po->rotation[0][2]; + *end_angle = po->rotation[1][2]; +} + +void RE_particle_get_x_revolution_angle(struct particle_object *po, float *begin_angle, float *end_angle) +{ + if (!po) + return; + *begin_angle = po->revolution_angle[0][0]; + *end_angle = po->revolution_angle[1][0]; +} + +void RE_particle_get_x_revolution_distance(struct particle_object *po, float *begin_distance, float *end_distance) +{ + if (!po) + return; + *begin_distance = po->revolution_distance[0][0]; + *end_distance = po->revolution_distance[1][0]; +} + +void RE_particle_get_y_revolution_angle(struct particle_object *po, float *begin_angle, float *end_angle) +{ + if (!po) + return; + *begin_angle = po->revolution_angle[0][1]; + *end_angle = po->revolution_angle[1][1]; +} + +void RE_particle_get_y_revolution_distance(struct particle_object *po, float *begin_distance, float *end_distance) +{ + if (!po) + return; + *begin_distance = po->revolution_distance[0][1]; + *end_distance = po->revolution_distance[1][1]; +} + +void RE_particle_get_z_revolution_angle(struct particle_object *po, float *begin_angle, float *end_angle) +{ + if (!po) + return; + *begin_angle = po->revolution_angle[0][2]; + *end_angle = po->revolution_angle[1][2]; +} + +void RE_particle_get_z_revolution_distance(struct particle_object *po, float *begin_distance, float *end_distance) +{ + if (!po) + return; + *begin_distance = po->revolution_distance[0][2]; + *end_distance = po->revolution_distance[1][2]; +} + +bool RE_particle_get_curve_length(struct particle_object *po, vec3 out) +{ + if (!po) + return false; + glm_vec3_copy(po->curve_length, out); + return true; +} + +int RE_particle_get_child_frame(struct particle_object *po) +{ + return po ? po->child_frame : 0; +} + +float RE_particle_get_child_length(struct particle_object *po) +{ + return po ? po->child_length : 0.0; +} + +float RE_particle_get_child_begin_slope(struct particle_object *po) +{ + return po ? po->child_begin_slope : 0.0; +} + +float RE_particle_get_child_end_slope(struct particle_object *po) +{ + return po ? po->child_end_slope : 0.0; +} + +float RE_particle_get_child_create_begin_frame(struct particle_object *po) +{ + return po ? po->child_create_begin_frame : 0.0; +} + +float RE_particle_get_child_create_end_frame(struct particle_object *po) +{ + return po ? po->child_create_end_frame : 0.0; +} + +int RE_particle_get_child_move_dir_type(struct particle_object *po) +{ + return po ? po->child_move_dir_type : 0; +} + +int RE_particle_get_dir_type(struct particle_object *po) +{ + return po ? po->dir_type : 0; +} + +int RE_particle_get_num_damage(struct particle_object *po) +{ + return po ? po->nr_damages : 0; +} + +int RE_particle_get_damage(struct particle_object *po, int frame) +{ + if (!po || frame >= po->nr_damages) + return 0; + return po->damages[frame]; +} + +float RE_particle_get_offset_x(struct particle_object *po) +{ + return po ? po->offset_x : 0.0; +} + +float RE_particle_get_offset_y(struct particle_object *po) +{ + return po ? po->offset_y : 0.0; +} + bool RE_back_cg_set(struct RE_back_cg *bcg, int no) { if (!bcg) diff --git a/src/hll/ReignEngine.c b/src/hll/ReignEngine.c index 423bf2b..9954bed 100644 --- a/src/hll/ReignEngine.c +++ b/src/hll/ReignEngine.c @@ -55,6 +55,17 @@ static struct motion *get_next_motion(unsigned plugin, unsigned instance) return inst ? inst->next_motion : NULL; } +static struct particle_effect *get_effect(unsigned plugin, unsigned instance) +{ + struct RE_instance *inst = get_instance(plugin, instance); + return inst ? inst->effect : NULL; +} + +static struct particle_object *get_particle(unsigned plugin, unsigned instance, unsigned object) +{ + return RE_get_effect_object(get_effect(plugin, instance), object); +} + static struct RE_back_cg *get_back_cg(unsigned plugin, unsigned num) { struct RE_plugin *p = get_plugin(plugin); @@ -551,57 +562,256 @@ static bool ReignEngine_SetInstanceShadowVolumeBoneRadius(int plugin, int instan //bool ReignEngine_SetInstanceDebugDrawShadowVolume(int plugin, int instance, bool flag); //bool ReignEngine_SaveEffect(int plugin, int instance); HLL_WARN_UNIMPLEMENTED(false, bool, ReignEngine, GetEffectFrameRange, int plugin, int instance, int *begin_frame, int *end_frame); -//int ReignEngine_GetEffectObjectType(int plugin, int instance, int nObject); -//int ReignEngine_GetEffectObjectMoveType(int plugin, int instance, int nObject); -//int ReignEngine_GetEffectObjectUpVecType(int plugin, int instance, int nObject); -//float ReignEngine_GetEffectObjectMoveCurve(int plugin, int instance, int nObject); -//void ReignEngine_GetEffectObjectFrame(int plugin, int instance, int nObject, int *pnBeginFrame, int *pnEndFrame); -//int ReignEngine_GetEffectObjectStopFrame(int plugin, int instance, int nObject); -HLL_WARN_UNIMPLEMENTED(0, int, ReignEngine, GetEffectNumofObject, int plugin, int instance); -//void ReignEngine_GetEffectObjectName(int plugin, int instance, int nObject, struct string **pIName); -//int ReignEngine_GetEffectNumofObjectPos(int plugin, int instance, int nObject); -//int ReignEngine_GetEffectNumofObjectPosUnit(int plugin, int instance, int nObject, int nPos); -//int ReignEngine_GetEffectObjectPosUnitType(int plugin, int instance, int nObject, int nPos, int nPosUnit); -//int ReignEngine_GetEffectObjectPosUnitIndex(int plugin, int instance, int nObject, int nPos, int nPosUnit); + +static int ReignEngine_GetEffectObjectType(int plugin, int instance, int object) +{ + return RE_particle_get_type(get_particle(plugin, instance, object)); +} + +static int ReignEngine_GetEffectObjectMoveType(int plugin, int instance, int object) +{ + return RE_particle_get_move_type(get_particle(plugin, instance, object)); +} + +static int ReignEngine_GetEffectObjectUpVecType(int plugin, int instance, int object) +{ + return RE_particle_get_up_vec_type(get_particle(plugin, instance, object)); +} + +static float ReignEngine_GetEffectObjectMoveCurve(int plugin, int instance, int object) +{ + return RE_particle_get_move_curve(get_particle(plugin, instance, object)); +} + +static void ReignEngine_GetEffectObjectFrame(int plugin, int instance, int object, int *begin_frame, int *end_frame) +{ + RE_particle_get_frame(get_particle(plugin, instance, object), begin_frame, end_frame); +} + +static int ReignEngine_GetEffectObjectStopFrame(int plugin, int instance, int object) +{ + return RE_particle_get_stop_frame(get_particle(plugin, instance, object)); +} + +static int ReignEngine_GetEffectNumofObject(int plugin, int instance) +{ + return RE_effect_get_num_object(get_effect(plugin, instance)); +} + +static void ReignEngine_GetEffectObjectName(int plugin, int instance, int object, struct string **name) +{ + if (*name) + free_string(*name); + const char *s = RE_particle_get_name(get_particle(plugin, instance, object)); + *name = s ? cstr_to_string(s) : string_ref(&EMPTY_STRING); +} + +static int ReignEngine_GetEffectNumofObjectPos(int plugin, int instance, int object) +{ + return RE_particle_get_num_pos(get_particle(plugin, instance, object)); +} + +static int ReignEngine_GetEffectNumofObjectPosUnit(int plugin, int instance, int object, int pos) +{ + return RE_particle_get_num_pos_unit(get_particle(plugin, instance, object), pos); +} + +static int ReignEngine_GetEffectObjectPosUnitType(int plugin, int instance, int object, int pos, int pos_unit) +{ + return RE_particle_get_pos_unit_type(get_particle(plugin, instance, object), pos, pos_unit); +} + +static int ReignEngine_GetEffectObjectPosUnitIndex(int plugin, int instance, int object, int pos, int pos_unit) +{ + return RE_particle_get_pos_unit_index(get_particle(plugin, instance, object), pos, pos_unit); +} + //int ReignEngine_GetEffectNumofObjectPosUnitParam(int plugin, int instance, int nObject, int nPos, int nPosUnit); //float ReignEngine_GetEffectObjectPosUnitParam(int plugin, int instance, int nObject, int nPos, int nPosUnit, int nParam); //int ReignEngine_GetEffectNumofObjectPosUnitString(int plugin, int instance, int nObject, int nPos, int nPosUnit); //void ReignEngine_GetEffectObjectPosUnitString(int plugin, int instance, int nObject, int nPos, int nPosUnit, int nParam, struct string **pIResult); -//int ReignEngine_GetEffectNumofObjectTexture(int plugin, int instance, int nObject); -//void ReignEngine_GetEffectObjectTexture(int plugin, int instance, int nObject, int nTexture, struct string **pIName); -//bool ReignEngine_GetEffectObjectSize(int plugin, int instance, int nObject, float *pfBeginSize, float *pfEndSize); -//bool ReignEngine_GetEffectObjectSize2(int plugin, int instance, int nObject, int nFrame, float *pfSize); -//bool ReignEngine_GetEffectObjectSizeX(int plugin, int instance, int nObject, int nFrame, float *pfSize); -//bool ReignEngine_GetEffectObjectSizeY(int plugin, int instance, int nObject, int nFrame, float *pfSize); -//bool ReignEngine_GetEffectObjectSizeType(int plugin, int instance, int nObject, int nFrame, int *nType); -//bool ReignEngine_GetEffectObjectSizeXType(int plugin, int instance, int nObject, int nFrame, int *nType); -//bool ReignEngine_GetEffectObjectSizeYType(int plugin, int instance, int nObject, int nFrame, int *nType); -//int ReignEngine_GetEffectNumofObjectSize2(int plugin, int instance, int nObject); -//int ReignEngine_GetEffectNumofObjectSizeX(int plugin, int instance, int nObject); -//int ReignEngine_GetEffectNumofObjectSizeY(int plugin, int instance, int nObject); -//int ReignEngine_GetEffectNumofObjectSizeType(int plugin, int instance, int nObject); -//int ReignEngine_GetEffectNumofObjectSizeXType(int plugin, int instance, int nObject); -//int ReignEngine_GetEffectNumofObjectSizeYType(int plugin, int instance, int nObject); -//int ReignEngine_GetEffectObjectBlendType(int plugin, int instance, int nObject); -//void ReignEngine_GetEffectObjectPolygonName(int plugin, int instance, int nObject, struct string **pIResult); -//int ReignEngine_GetEffectNumofObjectParticle(int plugin, int instance, int nObject); -//int ReignEngine_GetEffectObjectAlphaFadeInTime(int plugin, int instance, int nObject); -//int ReignEngine_GetEffectObjectAlphaFadeOutTime(int plugin, int instance, int nObject); -//int ReignEngine_GetEffectObjectTextureAnimeTime(int plugin, int instance, int nObject); -//float ReignEngine_GetEffectObjectAlphaFadeInFrame(int plugin, int instance, int nObject); -//float ReignEngine_GetEffectObjectAlphaFadeOutFrame(int plugin, int instance, int nObject); -//float ReignEngine_GetEffectObjectTextureAnimeFrame(int plugin, int instance, int nObject); -//int ReignEngine_GetEffectObjectFrameReferenceType(int plugin, int instance, int nObject); -//int ReignEngine_GetEffectObjectFrameReferenceParam(int plugin, int instance, int nObject); -//void ReignEngine_GetEffectObjectXRotationAngle(int plugin, int instance, int nObject, float *pfBeginAngle, float *pfEndAngle); -//void ReignEngine_GetEffectObjectYRotationAngle(int plugin, int instance, int nObject, float *pfBeginAngle, float *pfEndAngle); -//void ReignEngine_GetEffectObjectZRotationAngle(int plugin, int instance, int nObject, float *pfBeginAngle, float *pfEndAngle); -//void ReignEngine_GetEffectObjectXRevolutionAngle(int plugin, int instance, int nObject, float *pfBeginAngle, float *pfEndAngle); -//void ReignEngine_GetEffectObjectXRevolutionDistance(int plugin, int instance, int nObject, float *pfBeginDistance, float *pfEndDistance); -//void ReignEngine_GetEffectObjectYRevolutionAngle(int plugin, int instance, int nObject, float *pfBeginAngle, float *pfEndAngle); -//void ReignEngine_GetEffectObjectYRevolutionDistance(int plugin, int instance, int nObject, float *pfBeginDistance, float *pfEndDistance); -//void ReignEngine_GetEffectObjectZRevolutionAngle(int plugin, int instance, int nObject, float *pfBeginAngle, float *pfEndAngle); -//void ReignEngine_GetEffectObjectZRevolutionDistance(int plugin, int instance, int nObject, float *pfBeginDistance, float *pfEndDistance); + +static int ReignEngine_GetEffectNumofObjectTexture(int plugin, int instance, int object) +{ + return RE_particle_get_num_texture(get_particle(plugin, instance, object)); +} + +static void ReignEngine_GetEffectObjectTexture(int plugin, int instance, int object, int texture, struct string **name) +{ + if (*name) + free_string(*name); + const char *s = RE_particle_get_texture(get_particle(plugin, instance, object), texture); + *name = s ? cstr_to_string(s) : string_ref(&EMPTY_STRING); +} + +static bool ReignEngine_GetEffectObjectSize(int plugin, int instance, int object, float *begin_size, float *end_size) +{ + return RE_particle_get_size(get_particle(plugin, instance, object), begin_size, end_size); +} + +static bool ReignEngine_GetEffectObjectSize2(int plugin, int instance, int object, int frame, float *size) +{ + return RE_particle_get_size2(get_particle(plugin, instance, object), frame, size); +} + +static bool ReignEngine_GetEffectObjectSizeX(int plugin, int instance, int object, int frame, float *size) +{ + return RE_particle_get_size_x(get_particle(plugin, instance, object), frame, size); +} + +static bool ReignEngine_GetEffectObjectSizeY(int plugin, int instance, int object, int frame, float *size) +{ + return RE_particle_get_size_y(get_particle(plugin, instance, object), frame, size); +} + +static bool ReignEngine_GetEffectObjectSizeType(int plugin, int instance, int object, int frame, int *type) +{ + return RE_particle_get_size_type(get_particle(plugin, instance, object), frame, type); +} + +static bool ReignEngine_GetEffectObjectSizeXType(int plugin, int instance, int object, int frame, int *type) +{ + return RE_particle_get_size_x_type(get_particle(plugin, instance, object), frame, type); +} + +static bool ReignEngine_GetEffectObjectSizeYType(int plugin, int instance, int object, int frame, int *type) +{ + return RE_particle_get_size_y_type(get_particle(plugin, instance, object), frame, type); +} + +static int ReignEngine_GetEffectNumofObjectSize2(int plugin, int instance, int object) +{ + return RE_particle_get_num_size2(get_particle(plugin, instance, object)); +} + +static int ReignEngine_GetEffectNumofObjectSizeX(int plugin, int instance, int object) +{ + return RE_particle_get_num_size_x(get_particle(plugin, instance, object)); +} + +static int ReignEngine_GetEffectNumofObjectSizeY(int plugin, int instance, int object) +{ + return RE_particle_get_num_size_y(get_particle(plugin, instance, object)); +} + +static int ReignEngine_GetEffectNumofObjectSizeType(int plugin, int instance, int object) +{ + return RE_particle_get_num_size_type(get_particle(plugin, instance, object)); +} + +static int ReignEngine_GetEffectNumofObjectSizeXType(int plugin, int instance, int object) +{ + return RE_particle_get_num_size_x_type(get_particle(plugin, instance, object)); +} + +static int ReignEngine_GetEffectNumofObjectSizeYType(int plugin, int instance, int object) +{ + return RE_particle_get_num_size_y_type(get_particle(plugin, instance, object)); +} + +static int ReignEngine_GetEffectObjectBlendType(int plugin, int instance, int object) +{ + return RE_particle_get_blend_type(get_particle(plugin, instance, object)); +} + +static void ReignEngine_GetEffectObjectPolygonName(int plugin, int instance, int object, struct string **result) +{ + if (*result) + free_string(*result); + const char *s = RE_particle_get_polygon_name(get_particle(plugin, instance, object)); + *result = s ? cstr_to_string(s) : string_ref(&EMPTY_STRING); +} + +static int ReignEngine_GetEffectNumofObjectParticle(int plugin, int instance, int object) +{ + return RE_particle_get_num_particles(get_particle(plugin, instance, object)); +} + +static int ReignEngine_GetEffectObjectAlphaFadeInTime(int plugin, int instance, int object) +{ + return RE_particle_get_alpha_fadein_time(get_particle(plugin, instance, object)); +} + +static int ReignEngine_GetEffectObjectAlphaFadeOutTime(int plugin, int instance, int object) +{ + return RE_particle_get_alpha_fadeout_time(get_particle(plugin, instance, object)); +} + +static int ReignEngine_GetEffectObjectTextureAnimeTime(int plugin, int instance, int object) +{ + return RE_particle_get_texture_anime_time(get_particle(plugin, instance, object)); +} + +static float ReignEngine_GetEffectObjectAlphaFadeInFrame(int plugin, int instance, int object) +{ + return RE_particle_get_alpha_fadein_frame(get_particle(plugin, instance, object)); +} + +static float ReignEngine_GetEffectObjectAlphaFadeOutFrame(int plugin, int instance, int object) +{ + return RE_particle_get_alpha_fadeout_frame(get_particle(plugin, instance, object)); +} + +static float ReignEngine_GetEffectObjectTextureAnimeFrame(int plugin, int instance, int object) +{ + return RE_particle_get_texture_anime_frame(get_particle(plugin, instance, object)); +} + +static int ReignEngine_GetEffectObjectFrameReferenceType(int plugin, int instance, int object) +{ + return RE_particle_get_frame_ref_type(get_particle(plugin, instance, object)); +} + +static int ReignEngine_GetEffectObjectFrameReferenceParam(int plugin, int instance, int object) +{ + return RE_particle_get_frame_ref_param(get_particle(plugin, instance, object)); +} + +static void ReignEngine_GetEffectObjectXRotationAngle(int plugin, int instance, int object, float *begin_angle, float *end_angle) +{ + RE_particle_get_x_rotation_angle(get_particle(plugin, instance, object), begin_angle, end_angle); +} + +static void ReignEngine_GetEffectObjectYRotationAngle(int plugin, int instance, int object, float *begin_angle, float *end_angle) +{ + RE_particle_get_y_rotation_angle(get_particle(plugin, instance, object), begin_angle, end_angle); +} + +static void ReignEngine_GetEffectObjectZRotationAngle(int plugin, int instance, int object, float *begin_angle, float *end_angle) +{ + RE_particle_get_z_rotation_angle(get_particle(plugin, instance, object), begin_angle, end_angle); +} + +static void ReignEngine_GetEffectObjectXRevolutionAngle(int plugin, int instance, int object, float *begin_angle, float *end_angle) +{ + RE_particle_get_x_revolution_angle(get_particle(plugin, instance, object), begin_angle, end_angle); +} + +static void ReignEngine_GetEffectObjectXRevolutionDistance(int plugin, int instance, int object, float *begin_distance, float *end_distance) +{ + RE_particle_get_x_revolution_distance(get_particle(plugin, instance, object), begin_distance, end_distance); +} + +static void ReignEngine_GetEffectObjectYRevolutionAngle(int plugin, int instance, int object, float *begin_angle, float *end_angle) +{ + RE_particle_get_y_revolution_angle(get_particle(plugin, instance, object), begin_angle, end_angle); +} + +static void ReignEngine_GetEffectObjectYRevolutionDistance(int plugin, int instance, int object, float *begin_distance, float *end_distance) +{ + RE_particle_get_y_revolution_distance(get_particle(plugin, instance, object), begin_distance, end_distance); +} + +static void ReignEngine_GetEffectObjectZRevolutionAngle(int plugin, int instance, int object, float *begin_angle, float *end_angle) +{ + RE_particle_get_z_revolution_angle(get_particle(plugin, instance, object), begin_angle, end_angle); +} + +static void ReignEngine_GetEffectObjectZRevolutionDistance(int plugin, int instance, int object, float *begin_distance, float *end_distance) +{ + RE_particle_get_z_revolution_distance(get_particle(plugin, instance, object), begin_distance, end_distance); +} + //bool ReignEngine_AddEffectObject(int plugin, int instance); //bool ReignEngine_DeleteEffectObject(int plugin, int instance, int nObject); //bool ReignEngine_SetEffectObjectName(int plugin, int instance, int nObject, struct string *pIName); @@ -643,15 +853,55 @@ HLL_WARN_UNIMPLEMENTED(0, int, ReignEngine, GetEffectNumofObject, int plugin, in //bool ReignEngine_SetEffectObjectYRevolutionDistance(int plugin, int instance, int nObject, float fBeginDistance, float fEndDistance); //bool ReignEngine_SetEffectObjectZRevolutionAngle(int plugin, int instance, int nObject, float fBeginAngle, float fEndAngle); //bool ReignEngine_SetEffectObjectZRevolutionDistance(int plugin, int instance, int nObject, float fBeginDistance, float fEndDistance); -//bool ReignEngine_GetEffectObjectCurveLength(int plugin, int instance, int nObject, float *pfX, float *pfY, float *pfZ); + +static bool ReignEngine_GetEffectObjectCurveLength(int plugin, int instance, int object, float *x, float *y, float *z) +{ + vec3 result; + if (!RE_particle_get_curve_length(get_particle(plugin, instance, object), result)) + return false; + *x = result[0]; + *y = result[1]; + *z = result[2]; + return true; +} + //bool ReignEngine_SetEffectObjectCurveLength(int plugin, int instance, int nObject, float x, float y, float z); -//int ReignEngine_GetEffectObjectChildFrame(int plugin, int instance, int nObject); -//float ReignEngine_GetEffectObjectChildLength(int plugin, int instance, int nObject); -//float ReignEngine_GetEffectObjectChildBeginSlope(int plugin, int instance, int nObject); -//float ReignEngine_GetEffectObjectChildEndSlope(int plugin, int instance, int nObject); -//float ReignEngine_GetEffectObjectChildCreateBeginFrame(int plugin, int instance, int nObject); -//float ReignEngine_GetEffectObjectChildCreateEndFrame(int plugin, int instance, int nObject); -//int ReignEngine_GetEffectObjectChildMoveDirType(int plugin, int instance, int nObject); + +static int ReignEngine_GetEffectObjectChildFrame(int plugin, int instance, int object) +{ + return RE_particle_get_child_frame(get_particle(plugin, instance, object)); +} + +static float ReignEngine_GetEffectObjectChildLength(int plugin, int instance, int object) +{ + return RE_particle_get_child_length(get_particle(plugin, instance, object)); +} + +static float ReignEngine_GetEffectObjectChildBeginSlope(int plugin, int instance, int object) +{ + return RE_particle_get_child_begin_slope(get_particle(plugin, instance, object)); +} + +static float ReignEngine_GetEffectObjectChildEndSlope(int plugin, int instance, int object) +{ + return RE_particle_get_child_end_slope(get_particle(plugin, instance, object)); +} + +static float ReignEngine_GetEffectObjectChildCreateBeginFrame(int plugin, int instance, int object) +{ + return RE_particle_get_child_create_begin_frame(get_particle(plugin, instance, object)); +} + +static float ReignEngine_GetEffectObjectChildCreateEndFrame(int plugin, int instance, int object) +{ + return RE_particle_get_child_create_end_frame(get_particle(plugin, instance, object)); +} + +static int ReignEngine_GetEffectObjectChildMoveDirType(int plugin, int instance, int object) +{ + return RE_particle_get_child_move_dir_type(get_particle(plugin, instance, object)); +} + //bool ReignEngine_SetEffectObjectChildFrame(int plugin, int instance, int nObject, int nFrame); //bool ReignEngine_SetEffectObjectChildLength(int plugin, int instance, int nObject, float fLength); //bool ReignEngine_SetEffectObjectChildBeginSlope(int plugin, int instance, int nObject, float fSlope); @@ -659,15 +909,38 @@ HLL_WARN_UNIMPLEMENTED(0, int, ReignEngine, GetEffectNumofObject, int plugin, in //bool ReignEngine_SetEffectObjectChildCreateBeginFrame(int plugin, int instance, int nObject, float fFrame); //bool ReignEngine_SetEffectObjectChildCreateEndFrame(int plugin, int instance, int nObject, float fFrame); //bool ReignEngine_SetEffectObjectChildMoveDirType(int plugin, int instance, int nObject, int type); -//int ReignEngine_GetEffectObjectDirType(int plugin, int instance, int nObject); + +static int ReignEngine_GetEffectObjectDirType(int plugin, int instance, int object) +{ + return RE_particle_get_dir_type(get_particle(plugin, instance, object)); +} + //bool ReignEngine_SetEffectObjectDirType(int plugin, int instance, int nObject, int type); -//int ReignEngine_GetEffectNumofObjectDamage(int plugin, int instance, int nObject); -//int ReignEngine_GetEffectObjectDamage(int plugin, int instance, int nObject, int nFrame); + +static int ReignEngine_GetEffectNumofObjectDamage(int plugin, int instance, int object) +{ + return RE_particle_get_num_damage(get_particle(plugin, instance, object)); +} + +static int ReignEngine_GetEffectObjectDamage(int plugin, int instance, int object, int frame) +{ + return RE_particle_get_damage(get_particle(plugin, instance, object), frame); +} + //bool ReignEngine_SetEffectObjectDamage(int plugin, int instance, int nObject, int nFrame, int nData); //bool ReignEngine_GetEffectObjectDraw(int plugin, int instance, int nObject); //bool ReignEngine_SetEffectObjectDraw(int plugin, int instance, int nObject, bool bDraw); -//float ReignEngine_GetEffectObjectOffsetX(int plugin, int instance, int nObject); -//float ReignEngine_GetEffectObjectOffsetY(int plugin, int instance, int nObject); + +static float ReignEngine_GetEffectObjectOffsetX(int plugin, int instance, int object) +{ + return RE_particle_get_offset_x(get_particle(plugin, instance, object)); +} + +static float ReignEngine_GetEffectObjectOffsetY(int plugin, int instance, int object) +{ + return RE_particle_get_offset_y(get_particle(plugin, instance, object)); +} + //bool ReignEngine_SetEffectObjectOffsetX(int plugin, int instance, int nObject, float fOffsetX); //bool ReignEngine_SetEffectObjectOffsetY(int plugin, int instance, int nObject, float fOffsetY); HLL_WARN_UNIMPLEMENTED(false, bool, ReignEngine, GetCameraQuakeEffectFlag, int plugin, int instance); @@ -1525,57 +1798,57 @@ HLL_LIBRARY(ReignEngine, HLL_TODO_EXPORT(SetInstanceDebugDrawShadowVolume, ReignEngine_SetInstanceDebugDrawShadowVolume), HLL_TODO_EXPORT(SaveEffect, ReignEngine_SaveEffect), HLL_EXPORT(GetEffectFrameRange, ReignEngine_GetEffectFrameRange), - HLL_TODO_EXPORT(GetEffectObjectType, ReignEngine_GetEffectObjectType), - HLL_TODO_EXPORT(GetEffectObjectMoveType, ReignEngine_GetEffectObjectMoveType), - HLL_TODO_EXPORT(GetEffectObjectUpVecType, ReignEngine_GetEffectObjectUpVecType), - HLL_TODO_EXPORT(GetEffectObjectMoveCurve, ReignEngine_GetEffectObjectMoveCurve), - HLL_TODO_EXPORT(GetEffectObjectFrame, ReignEngine_GetEffectObjectFrame), - HLL_TODO_EXPORT(GetEffectObjectStopFrame, ReignEngine_GetEffectObjectStopFrame), + HLL_EXPORT(GetEffectObjectType, ReignEngine_GetEffectObjectType), + HLL_EXPORT(GetEffectObjectMoveType, ReignEngine_GetEffectObjectMoveType), + HLL_EXPORT(GetEffectObjectUpVecType, ReignEngine_GetEffectObjectUpVecType), + HLL_EXPORT(GetEffectObjectMoveCurve, ReignEngine_GetEffectObjectMoveCurve), + HLL_EXPORT(GetEffectObjectFrame, ReignEngine_GetEffectObjectFrame), + HLL_EXPORT(GetEffectObjectStopFrame, ReignEngine_GetEffectObjectStopFrame), HLL_EXPORT(GetEffectNumofObject, ReignEngine_GetEffectNumofObject), - HLL_TODO_EXPORT(GetEffectObjectName, ReignEngine_GetEffectObjectName), - HLL_TODO_EXPORT(GetEffectNumofObjectPos, ReignEngine_GetEffectNumofObjectPos), - HLL_TODO_EXPORT(GetEffectNumofObjectPosUnit, ReignEngine_GetEffectNumofObjectPosUnit), - HLL_TODO_EXPORT(GetEffectObjectPosUnitType, ReignEngine_GetEffectObjectPosUnitType), - HLL_TODO_EXPORT(GetEffectObjectPosUnitIndex, ReignEngine_GetEffectObjectPosUnitIndex), + HLL_EXPORT(GetEffectObjectName, ReignEngine_GetEffectObjectName), + HLL_EXPORT(GetEffectNumofObjectPos, ReignEngine_GetEffectNumofObjectPos), + HLL_EXPORT(GetEffectNumofObjectPosUnit, ReignEngine_GetEffectNumofObjectPosUnit), + HLL_EXPORT(GetEffectObjectPosUnitType, ReignEngine_GetEffectObjectPosUnitType), + HLL_EXPORT(GetEffectObjectPosUnitIndex, ReignEngine_GetEffectObjectPosUnitIndex), HLL_TODO_EXPORT(GetEffectNumofObjectPosUnitParam, ReignEngine_GetEffectNumofObjectPosUnitParam), HLL_TODO_EXPORT(GetEffectObjectPosUnitParam, ReignEngine_GetEffectObjectPosUnitParam), HLL_TODO_EXPORT(GetEffectNumofObjectPosUnitString, ReignEngine_GetEffectNumofObjectPosUnitString), HLL_TODO_EXPORT(GetEffectObjectPosUnitString, ReignEngine_GetEffectObjectPosUnitString), - HLL_TODO_EXPORT(GetEffectNumofObjectTexture, ReignEngine_GetEffectNumofObjectTexture), - HLL_TODO_EXPORT(GetEffectObjectTexture, ReignEngine_GetEffectObjectTexture), - HLL_TODO_EXPORT(GetEffectObjectSize, ReignEngine_GetEffectObjectSize), - HLL_TODO_EXPORT(GetEffectObjectSize2, ReignEngine_GetEffectObjectSize2), - HLL_TODO_EXPORT(GetEffectObjectSizeX, ReignEngine_GetEffectObjectSizeX), - HLL_TODO_EXPORT(GetEffectObjectSizeY, ReignEngine_GetEffectObjectSizeY), - HLL_TODO_EXPORT(GetEffectObjectSizeType, ReignEngine_GetEffectObjectSizeType), - HLL_TODO_EXPORT(GetEffectObjectSizeXType, ReignEngine_GetEffectObjectSizeXType), - HLL_TODO_EXPORT(GetEffectObjectSizeYType, ReignEngine_GetEffectObjectSizeYType), - HLL_TODO_EXPORT(GetEffectNumofObjectSize2, ReignEngine_GetEffectNumofObjectSize2), - HLL_TODO_EXPORT(GetEffectNumofObjectSizeX, ReignEngine_GetEffectNumofObjectSizeX), - HLL_TODO_EXPORT(GetEffectNumofObjectSizeY, ReignEngine_GetEffectNumofObjectSizeY), - HLL_TODO_EXPORT(GetEffectNumofObjectSizeType, ReignEngine_GetEffectNumofObjectSizeType), - HLL_TODO_EXPORT(GetEffectNumofObjectSizeXType, ReignEngine_GetEffectNumofObjectSizeXType), - HLL_TODO_EXPORT(GetEffectNumofObjectSizeYType, ReignEngine_GetEffectNumofObjectSizeYType), - HLL_TODO_EXPORT(GetEffectObjectBlendType, ReignEngine_GetEffectObjectBlendType), - HLL_TODO_EXPORT(GetEffectObjectPolygonName, ReignEngine_GetEffectObjectPolygonName), - HLL_TODO_EXPORT(GetEffectNumofObjectParticle, ReignEngine_GetEffectNumofObjectParticle), - HLL_TODO_EXPORT(GetEffectObjectAlphaFadeInTime, ReignEngine_GetEffectObjectAlphaFadeInTime), - HLL_TODO_EXPORT(GetEffectObjectAlphaFadeOutTime, ReignEngine_GetEffectObjectAlphaFadeOutTime), - HLL_TODO_EXPORT(GetEffectObjectTextureAnimeTime, ReignEngine_GetEffectObjectTextureAnimeTime), - HLL_TODO_EXPORT(GetEffectObjectAlphaFadeInFrame, ReignEngine_GetEffectObjectAlphaFadeInFrame), - HLL_TODO_EXPORT(GetEffectObjectAlphaFadeOutFrame, ReignEngine_GetEffectObjectAlphaFadeOutFrame), - HLL_TODO_EXPORT(GetEffectObjectTextureAnimeFrame, ReignEngine_GetEffectObjectTextureAnimeFrame), - HLL_TODO_EXPORT(GetEffectObjectFrameReferenceType, ReignEngine_GetEffectObjectFrameReferenceType), - HLL_TODO_EXPORT(GetEffectObjectFrameReferenceParam, ReignEngine_GetEffectObjectFrameReferenceParam), - HLL_TODO_EXPORT(GetEffectObjectXRotationAngle, ReignEngine_GetEffectObjectXRotationAngle), - HLL_TODO_EXPORT(GetEffectObjectYRotationAngle, ReignEngine_GetEffectObjectYRotationAngle), - HLL_TODO_EXPORT(GetEffectObjectZRotationAngle, ReignEngine_GetEffectObjectZRotationAngle), - HLL_TODO_EXPORT(GetEffectObjectXRevolutionAngle, ReignEngine_GetEffectObjectXRevolutionAngle), - HLL_TODO_EXPORT(GetEffectObjectXRevolutionDistance, ReignEngine_GetEffectObjectXRevolutionDistance), - HLL_TODO_EXPORT(GetEffectObjectYRevolutionAngle, ReignEngine_GetEffectObjectYRevolutionAngle), - HLL_TODO_EXPORT(GetEffectObjectYRevolutionDistance, ReignEngine_GetEffectObjectYRevolutionDistance), - HLL_TODO_EXPORT(GetEffectObjectZRevolutionAngle, ReignEngine_GetEffectObjectZRevolutionAngle), - HLL_TODO_EXPORT(GetEffectObjectZRevolutionDistance, ReignEngine_GetEffectObjectZRevolutionDistance), + HLL_EXPORT(GetEffectNumofObjectTexture, ReignEngine_GetEffectNumofObjectTexture), + HLL_EXPORT(GetEffectObjectTexture, ReignEngine_GetEffectObjectTexture), + HLL_EXPORT(GetEffectObjectSize, ReignEngine_GetEffectObjectSize), + HLL_EXPORT(GetEffectObjectSize2, ReignEngine_GetEffectObjectSize2), + HLL_EXPORT(GetEffectObjectSizeX, ReignEngine_GetEffectObjectSizeX), + HLL_EXPORT(GetEffectObjectSizeY, ReignEngine_GetEffectObjectSizeY), + HLL_EXPORT(GetEffectObjectSizeType, ReignEngine_GetEffectObjectSizeType), + HLL_EXPORT(GetEffectObjectSizeXType, ReignEngine_GetEffectObjectSizeXType), + HLL_EXPORT(GetEffectObjectSizeYType, ReignEngine_GetEffectObjectSizeYType), + HLL_EXPORT(GetEffectNumofObjectSize2, ReignEngine_GetEffectNumofObjectSize2), + HLL_EXPORT(GetEffectNumofObjectSizeX, ReignEngine_GetEffectNumofObjectSizeX), + HLL_EXPORT(GetEffectNumofObjectSizeY, ReignEngine_GetEffectNumofObjectSizeY), + HLL_EXPORT(GetEffectNumofObjectSizeType, ReignEngine_GetEffectNumofObjectSizeType), + HLL_EXPORT(GetEffectNumofObjectSizeXType, ReignEngine_GetEffectNumofObjectSizeXType), + HLL_EXPORT(GetEffectNumofObjectSizeYType, ReignEngine_GetEffectNumofObjectSizeYType), + HLL_EXPORT(GetEffectObjectBlendType, ReignEngine_GetEffectObjectBlendType), + HLL_EXPORT(GetEffectObjectPolygonName, ReignEngine_GetEffectObjectPolygonName), + HLL_EXPORT(GetEffectNumofObjectParticle, ReignEngine_GetEffectNumofObjectParticle), + HLL_EXPORT(GetEffectObjectAlphaFadeInTime, ReignEngine_GetEffectObjectAlphaFadeInTime), + HLL_EXPORT(GetEffectObjectAlphaFadeOutTime, ReignEngine_GetEffectObjectAlphaFadeOutTime), + HLL_EXPORT(GetEffectObjectTextureAnimeTime, ReignEngine_GetEffectObjectTextureAnimeTime), + HLL_EXPORT(GetEffectObjectAlphaFadeInFrame, ReignEngine_GetEffectObjectAlphaFadeInFrame), + HLL_EXPORT(GetEffectObjectAlphaFadeOutFrame, ReignEngine_GetEffectObjectAlphaFadeOutFrame), + HLL_EXPORT(GetEffectObjectTextureAnimeFrame, ReignEngine_GetEffectObjectTextureAnimeFrame), + HLL_EXPORT(GetEffectObjectFrameReferenceType, ReignEngine_GetEffectObjectFrameReferenceType), + HLL_EXPORT(GetEffectObjectFrameReferenceParam, ReignEngine_GetEffectObjectFrameReferenceParam), + HLL_EXPORT(GetEffectObjectXRotationAngle, ReignEngine_GetEffectObjectXRotationAngle), + HLL_EXPORT(GetEffectObjectYRotationAngle, ReignEngine_GetEffectObjectYRotationAngle), + HLL_EXPORT(GetEffectObjectZRotationAngle, ReignEngine_GetEffectObjectZRotationAngle), + HLL_EXPORT(GetEffectObjectXRevolutionAngle, ReignEngine_GetEffectObjectXRevolutionAngle), + HLL_EXPORT(GetEffectObjectXRevolutionDistance, ReignEngine_GetEffectObjectXRevolutionDistance), + HLL_EXPORT(GetEffectObjectYRevolutionAngle, ReignEngine_GetEffectObjectYRevolutionAngle), + HLL_EXPORT(GetEffectObjectYRevolutionDistance, ReignEngine_GetEffectObjectYRevolutionDistance), + HLL_EXPORT(GetEffectObjectZRevolutionAngle, ReignEngine_GetEffectObjectZRevolutionAngle), + HLL_EXPORT(GetEffectObjectZRevolutionDistance, ReignEngine_GetEffectObjectZRevolutionDistance), HLL_TODO_EXPORT(AddEffectObject, ReignEngine_AddEffectObject), HLL_TODO_EXPORT(DeleteEffectObject, ReignEngine_DeleteEffectObject), HLL_TODO_EXPORT(SetEffectObjectName, ReignEngine_SetEffectObjectName), @@ -1617,15 +1890,15 @@ HLL_LIBRARY(ReignEngine, HLL_TODO_EXPORT(SetEffectObjectYRevolutionDistance, ReignEngine_SetEffectObjectYRevolutionDistance), HLL_TODO_EXPORT(SetEffectObjectZRevolutionAngle, ReignEngine_SetEffectObjectZRevolutionAngle), HLL_TODO_EXPORT(SetEffectObjectZRevolutionDistance, ReignEngine_SetEffectObjectZRevolutionDistance), - HLL_TODO_EXPORT(GetEffectObjectCurveLength, ReignEngine_GetEffectObjectCurveLength), + HLL_EXPORT(GetEffectObjectCurveLength, ReignEngine_GetEffectObjectCurveLength), HLL_TODO_EXPORT(SetEffectObjectCurveLength, ReignEngine_SetEffectObjectCurveLength), - HLL_TODO_EXPORT(GetEffectObjectChildFrame, ReignEngine_GetEffectObjectChildFrame), - HLL_TODO_EXPORT(GetEffectObjectChildLength, ReignEngine_GetEffectObjectChildLength), - HLL_TODO_EXPORT(GetEffectObjectChildBeginSlope, ReignEngine_GetEffectObjectChildBeginSlope), - HLL_TODO_EXPORT(GetEffectObjectChildEndSlope, ReignEngine_GetEffectObjectChildEndSlope), - HLL_TODO_EXPORT(GetEffectObjectChildCreateBeginFrame, ReignEngine_GetEffectObjectChildCreateBeginFrame), - HLL_TODO_EXPORT(GetEffectObjectChildCreateEndFrame, ReignEngine_GetEffectObjectChildCreateEndFrame), - HLL_TODO_EXPORT(GetEffectObjectChildMoveDirType, ReignEngine_GetEffectObjectChildMoveDirType), + HLL_EXPORT(GetEffectObjectChildFrame, ReignEngine_GetEffectObjectChildFrame), + HLL_EXPORT(GetEffectObjectChildLength, ReignEngine_GetEffectObjectChildLength), + HLL_EXPORT(GetEffectObjectChildBeginSlope, ReignEngine_GetEffectObjectChildBeginSlope), + HLL_EXPORT(GetEffectObjectChildEndSlope, ReignEngine_GetEffectObjectChildEndSlope), + HLL_EXPORT(GetEffectObjectChildCreateBeginFrame, ReignEngine_GetEffectObjectChildCreateBeginFrame), + HLL_EXPORT(GetEffectObjectChildCreateEndFrame, ReignEngine_GetEffectObjectChildCreateEndFrame), + HLL_EXPORT(GetEffectObjectChildMoveDirType, ReignEngine_GetEffectObjectChildMoveDirType), HLL_TODO_EXPORT(SetEffectObjectChildFrame, ReignEngine_SetEffectObjectChildFrame), HLL_TODO_EXPORT(SetEffectObjectChildLength, ReignEngine_SetEffectObjectChildLength), HLL_TODO_EXPORT(SetEffectObjectChildBeginSlope, ReignEngine_SetEffectObjectChildBeginSlope), @@ -1633,15 +1906,15 @@ HLL_LIBRARY(ReignEngine, HLL_TODO_EXPORT(SetEffectObjectChildCreateBeginFrame, ReignEngine_SetEffectObjectChildCreateBeginFrame), HLL_TODO_EXPORT(SetEffectObjectChildCreateEndFrame, ReignEngine_SetEffectObjectChildCreateEndFrame), HLL_TODO_EXPORT(SetEffectObjectChildMoveDirType, ReignEngine_SetEffectObjectChildMoveDirType), - HLL_TODO_EXPORT(GetEffectObjectDirType, ReignEngine_GetEffectObjectDirType), + HLL_EXPORT(GetEffectObjectDirType, ReignEngine_GetEffectObjectDirType), HLL_TODO_EXPORT(SetEffectObjectDirType, ReignEngine_SetEffectObjectDirType), - HLL_TODO_EXPORT(GetEffectNumofObjectDamage, ReignEngine_GetEffectNumofObjectDamage), - HLL_TODO_EXPORT(GetEffectObjectDamage, ReignEngine_GetEffectObjectDamage), + HLL_EXPORT(GetEffectNumofObjectDamage, ReignEngine_GetEffectNumofObjectDamage), + HLL_EXPORT(GetEffectObjectDamage, ReignEngine_GetEffectObjectDamage), HLL_TODO_EXPORT(SetEffectObjectDamage, ReignEngine_SetEffectObjectDamage), HLL_TODO_EXPORT(GetEffectObjectDraw, ReignEngine_GetEffectObjectDraw), HLL_TODO_EXPORT(SetEffectObjectDraw, ReignEngine_SetEffectObjectDraw), - HLL_TODO_EXPORT(GetEffectObjectOffsetX, ReignEngine_GetEffectObjectOffsetX), - HLL_TODO_EXPORT(GetEffectObjectOffsetY, ReignEngine_GetEffectObjectOffsetY), + HLL_EXPORT(GetEffectObjectOffsetX, ReignEngine_GetEffectObjectOffsetX), + HLL_EXPORT(GetEffectObjectOffsetY, ReignEngine_GetEffectObjectOffsetY), HLL_TODO_EXPORT(SetEffectObjectOffsetX, ReignEngine_SetEffectObjectOffsetX), HLL_TODO_EXPORT(SetEffectObjectOffsetY, ReignEngine_SetEffectObjectOffsetY), HLL_EXPORT(GetCameraQuakeEffectFlag, ReignEngine_GetCameraQuakeEffectFlag), diff --git a/src/meson.build b/src/meson.build index fd4aecd..fe4dc47 100644 --- a/src/meson.build +++ b/src/meson.build @@ -34,6 +34,7 @@ xsystem4 = [version_h, '3d/debug.c', '3d/model.c', '3d/parser.c', + '3d/particle.c', '3d/reign.c', '3d/renderer.c',