qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-10 15:22:04 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/libs/ruamoko/rua_scene.c

668 lines
18 KiB
C
Raw Normal View History

[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
/*
bi_scene.c
Ruamoko scene builtins
Copyright (C) 2022 Bill Currie <bill@taniwha.org>
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, write to:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <stdlib.h>
#ifdef HAVE_STRING_H
# include <string.h>
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif
#include "QF/cmem.h"
#include "QF/hash.h"
[ruamoko] Allow entity model to be set And add header and function definitions for scene to libcsqc.
2022-05-04 08:38:38 +00:00
#include "QF/model.h"
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
#include "QF/progs.h"
[ruamoko] Allow entity model to be set And add header and function definitions for scene to libcsqc.
2022-05-04 08:38:38 +00:00
#include "QF/render.h"
#include "QF/plugin/vid_render.h"
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
[scene] Move entity_t etc into scene headers I meant to do this a while ago but forgot about it. Things are a bit of a mess in that the renderer knows too much about entities, but eventually the renderer will know about only things to render (meshes, particles, etc).
2022-03-29 05:40:48 +00:00
#include "QF/scene/entity.h"
[ruamoko] Add builtins for adding lights to scenes Pretty much just raw wrappers around the C versions. I'm not sure about Light_EnableSun (even in C), but it does build the sky surf pvs.
2022-05-05 14:43:39 +00:00
#include "QF/scene/light.h"
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
#include "QF/scene/scene.h"
#include "QF/scene/transform.h"
#include "rua_internal.h"
typedef struct rua_scene_s {
struct rua_scene_s *next;
struct rua_scene_s **prev;
scene_t *scene;
} rua_scene_t;
[ruamoko] Add builtins for adding lights to scenes Pretty much just raw wrappers around the C versions. I'm not sure about Light_EnableSun (even in C), but it does build the sky surf pvs.
2022-05-05 14:43:39 +00:00
typedef struct rua_lighting_s {
struct rua_lighting_s *next;
struct rua_lighting_s **prev;
lightingdata_t *ldata;
} rua_lighting_t;
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
typedef struct rua_scene_resources_s {
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
progs_t *pr;
PR_RESMAP (rua_scene_t) scene_map;
[ruamoko] Add builtins for adding lights to scenes Pretty much just raw wrappers around the C versions. I'm not sure about Light_EnableSun (even in C), but it does build the sky surf pvs.
2022-05-05 14:43:39 +00:00
PR_RESMAP (rua_lighting_t) lighting_map;
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
rua_scene_t *scenes;
[ruamoko] Add builtins for adding lights to scenes Pretty much just raw wrappers around the C versions. I'm not sure about Light_EnableSun (even in C), but it does build the sky surf pvs.
2022-05-05 14:43:39 +00:00
rua_lighting_t *ldatas;
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
} rua_scene_resources_t;
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
static rua_scene_t *
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_new (rua_scene_resources_t *res)
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
{
return PR_RESNEW (res->scene_map);
}
static void
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_free (rua_scene_resources_t *res, rua_scene_t *scene)
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
{
if (scene->next) {
scene->next->prev = scene->prev;
}
*scene->prev = scene->next;
scene->prev = 0;
PR_RESFREE (res->scene_map, scene);
}
[ruamoko] Pass some more purity tests Separate because I want to cherry-pick the other commit.
2022-02-14 10:56:56 +00:00
static rua_scene_t * __attribute__((pure))
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
rua__scene_get (rua_scene_resources_t *res, pr_ulong_t id, const char *name)
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
{
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
rua_scene_t *scene = 0;
if (id <= 0xffffffffu) {
scene = PR_RESGET (res->scene_map, (pr_int_t) id);
}
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
// scene->prev will be null if the handle is unallocated
if (!scene || !scene->prev) {
PR_RunError (res->pr, "invalid scene passed to %s", name + 3);
}
return scene;
}
#define rua_scene_get(res, id) rua__scene_get(res, id, __FUNCTION__)
[ruamoko] Add builtins for adding lights to scenes Pretty much just raw wrappers around the C versions. I'm not sure about Light_EnableSun (even in C), but it does build the sky surf pvs.
2022-05-05 14:43:39 +00:00
static int __attribute__((pure))
rua_scene_index (rua_scene_resources_t *res, rua_scene_t *scene)
{
return PR_RESINDEX (res->scene_map, scene);
}
[ruamoko] Pass some more purity tests Separate because I want to cherry-pick the other commit.
2022-02-14 10:56:56 +00:00
static entity_t * __attribute__((pure))
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
rua__entity_get (rua_scene_resources_t *res, pr_ulong_t id, const char *name)
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
{
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
pr_ulong_t scene_id = id & 0xffffffff;
entity_t *ent = 0;
rua_scene_t *scene = rua__scene_get (res, scene_id, name);
if (scene) {
pr_int_t entity_id = id >> 32;
ent = Scene_GetEntity (scene->scene, entity_id);
}
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
if (!ent) {
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
PR_RunError (res->pr, "invalid entity passed to %s", name + 3);
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
}
return ent;
}
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
#define rua_entity_get(res, id) rua__entity_get(res, id, __FUNCTION__)
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
static transform_t * __attribute__((pure))
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
rua__transform_get (rua_scene_resources_t *res, pr_ulong_t id, const char *name)
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
{
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
pr_ulong_t scene_id = id & 0xffffffff;
transform_t *transform = 0;
rua_scene_t *scene = rua_scene_get (res, scene_id);
if (scene) {
pr_int_t transform_id = id >> 32;
transform = Scene_GetTransform (scene->scene, transform_id);
}
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
if (!transform) {
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
PR_RunError (res->pr, "invalid transform passed to %s", name + 3);
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
}
return transform;
}
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
#define rua_transform_get(res, id) rua__transform_get(res, id, __FUNCTION__)
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
[ruamoko] Add builtins for adding lights to scenes Pretty much just raw wrappers around the C versions. I'm not sure about Light_EnableSun (even in C), but it does build the sky surf pvs.
2022-05-05 14:43:39 +00:00
static rua_lighting_t *
rua_lighting_new (rua_scene_resources_t *res)
{
return PR_RESNEW (res->lighting_map);
}
static void
rua_lighting_free (rua_scene_resources_t *res, rua_lighting_t *ldata)
{
if (ldata->next) {
ldata->next->prev = ldata->prev;
}
*ldata->prev = ldata->next;
ldata->prev = 0;
PR_RESFREE (res->lighting_map, ldata);
}
static rua_lighting_t * __attribute__((pure))
rua__lighting_get (rua_scene_resources_t *res, pr_ulong_t id, const char *name)
{
rua_lighting_t *ldata = 0;
if (id <= 0xffffffffu) {
ldata = PR_RESGET (res->lighting_map, (pr_int_t) id);
}
// ldata->prev will be null if the handle is unallocated
if (!ldata || !ldata->prev) {
PR_RunError (res->pr, "invalid lighting passed to %s", name + 3);
}
return ldata;
}
#define rua_lighting_get(res, id) rua__lighting_get(res, id, __FUNCTION__)
[ruamoko] Pass some more purity tests Separate because I want to cherry-pick the other commit.
2022-02-14 10:56:56 +00:00
static int __attribute__((pure))
[ruamoko] Add builtins for adding lights to scenes Pretty much just raw wrappers around the C versions. I'm not sure about Light_EnableSun (even in C), but it does build the sky surf pvs.
2022-05-05 14:43:39 +00:00
rua_lighting_index (rua_scene_resources_t *res, rua_lighting_t *ldata)
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
{
[ruamoko] Add builtins for adding lights to scenes Pretty much just raw wrappers around the C versions. I'm not sure about Light_EnableSun (even in C), but it does build the sky surf pvs.
2022-05-05 14:43:39 +00:00
return PR_RESINDEX (res->lighting_map, ldata);
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
}
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
#define MAKE_ID(id, sc_id) ((((pr_ulong_t) (id)) << 32) \
| ((sc_id) & 0xffffffff))
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
static void
bi_Scene_NewScene (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
rua_scene_t *scene = rua_scene_new (res);
scene->scene = Scene_NewScene ();
scene->next = res->scenes;
if (res->scenes) {
res->scenes->prev = &scene->next;
}
scene->prev = &res->scenes;
res->scenes = scene;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
// scene id in lower 32-bits for all handles
// zero upper 32-bits zero means scene, otherwise transform or entity
R_ULONG (pr) = MAKE_ID (0, rua_scene_index (res, scene));
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
}
static void
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_delete_scene (rua_scene_resources_t *res, rua_scene_t *scene)
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
{
Scene_DeleteScene (scene->scene);
rua_scene_free (res, scene);
}
static void
bi_Scene_DeleteScene (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
rua_scene_t *scene = rua_scene_get (res, P_ULONG (pr, 0));
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
rua_delete_scene (res, scene);
}
[ruamoko] Allow scenes to be fetched by C code Need to clean up that part of the API, though.
2022-05-05 12:26:18 +00:00
scene_t *
Scene_GetScene (progs_t *pr, pr_ulong_t handle)
{
if (!handle) {
return 0;
}
rua_scene_resources_t *res = PR_Resources_Find (pr, "Scene");
rua_scene_t *scene = rua_scene_get (res, P_ULONG (pr, 0));
return scene->scene;
}
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
static void
bi_Scene_CreateEntity (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
pr_ulong_t scene_id = P_ULONG (pr, 0);
rua_scene_t *scene = rua_scene_get (res, scene_id);
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
entity_t *ent = Scene_CreateEntity (scene->scene);
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
R_ULONG (pr) = MAKE_ID (ent->id, scene_id);
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
}
static void
bi_Scene_DestroyEntity (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
pr_ulong_t id = P_ULONG (pr, 0);
entity_t *ent = rua_entity_get (res, id);
pr_ulong_t scene_id = id & 0xffffffff;
[ruamoko] Clear efrags when destroying an entity This ensures the rendering system won't attempt to draw the entity after it has been destroyed.
2022-05-07 00:53:26 +00:00
R_RemoveEfrags (ent);
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
// bad scene caught above
rua_scene_t *scene = rua_scene_get (res, scene_id);
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
Scene_DestroyEntity (scene->scene, ent);
}
[ruamoko] Add builtins for adding lights to scenes Pretty much just raw wrappers around the C versions. I'm not sure about Light_EnableSun (even in C), but it does build the sky surf pvs.
2022-05-05 14:43:39 +00:00
static void
bi_Scene_SetLighting (progs_t *pr, void *_res)
{
rua_scene_resources_t *res = _res;
pr_ulong_t scene_id = P_ULONG (pr, 0);
rua_scene_t *scene = rua_scene_get (res, scene_id);
pr_ulong_t ldata_id = P_ULONG (pr, 1);
rua_lighting_t *ldata = 0;
if (ldata_id) {
ldata = rua_lighting_get (res, ldata_id);
}
scene->scene->lights = ldata->ldata;
}
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
static void
bi_Entity_GetTransform (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
pr_ulong_t ent_id = P_ULONG (pr, 0);
entity_t *ent = rua_entity_get (res, ent_id);
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
// ent_id contains scene id
R_ULONG (pr) = MAKE_ID (ent->transform->id, ent_id);
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
}
[ruamoko] Allow entity model to be set And add header and function definitions for scene to libcsqc.
2022-05-04 08:38:38 +00:00
static void
bi_Entity_SetModel (progs_t *pr, void *_res)
{
rua_scene_resources_t *res = _res;
pr_ulong_t ent_id = P_ULONG (pr, 0);
pr_int_t model_id = P_INT (pr, 1);
entity_t *ent = rua_entity_get (res, ent_id);
model_t *model = Model_GetModel (pr, model_id);
[ruamoko] Allow scenes to be fetched by C code Need to clean up that part of the API, though.
2022-05-05 12:26:18 +00:00
pr_ulong_t scene_id = ent_id & 0xffffffff;
// bad scene caught above
rua_scene_t *scene = rua_scene_get (res, scene_id);
[ruamoko] Allow entity model to be set And add header and function definitions for scene to libcsqc.
2022-05-04 08:38:38 +00:00
R_RemoveEfrags (ent);
ent->renderer.model = model;
[ruamoko] Allow scenes to be fetched by C code Need to clean up that part of the API, though.
2022-05-05 12:26:18 +00:00
R_AddEfrags (&scene->scene->worldmodel->brush, ent);
[ruamoko] Allow entity model to be set And add header and function definitions for scene to libcsqc.
2022-05-04 08:38:38 +00:00
}
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
static void
bi_Transform_ChildCount (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
transform_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
R_UINT (pr) = Transform_ChildCount (transform);
}
static void
bi_Transform_GetChild (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
transform_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
transform_t *child = Transform_GetChild (transform, P_UINT (pr, 2));
R_UINT (pr) = child ? child->id : 0;
}
static void
bi_Transform_SetParent (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
transform_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
transform_t *parent = rua_transform_get (res, P_ULONG (pr, 1));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
Transform_SetParent (transform, parent);
}
static void
bi_Transform_GetParent (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
pr_ulong_t transform_id = P_ULONG (pr, 0);
transform_t *transform = rua_transform_get (res, transform_id);
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
transform_t *parent = Transform_GetParent (transform);
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
// transform_id contains scene id
R_ULONG (pr) = parent ? MAKE_ID (parent->id, transform_id) : 0;
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
}
static void
bi_Transform_SetTag (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
transform_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
pr_uint_t tag = P_UINT (pr, 2);
Transform_SetTag (transform, tag);
}
static void
bi_Transform_GetTag (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
transform_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
R_UINT (pr) = Transform_GetTag (transform);
}
static void
bi_Transform_GetLocalMatrix (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
transform_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
Transform_GetLocalMatrix (transform, &R_PACKED (pr, pr_vec4_t));
}
static void
bi_Transform_GetLocalInverse (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
transform_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
Transform_GetLocalInverse (transform, &R_PACKED (pr, pr_vec4_t));
}
static void
bi_Transform_GetWorldMatrix (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
transform_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
Transform_GetWorldMatrix (transform, &R_PACKED (pr, pr_vec4_t));
}
static void
bi_Transform_GetWorldInverse (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
transform_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
Transform_GetWorldInverse (transform, &R_PACKED (pr, pr_vec4_t));
}
static void
bi_Transform_SetLocalPosition (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
transform_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
Transform_SetLocalPosition (transform, P_PACKED (pr, pr_vec4_t, 1));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
}
static void
bi_Transform_GetLocalPosition (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
transform_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
R_PACKED (pr, pr_vec4_t) = Transform_GetLocalPosition (transform);
}
static void
bi_Transform_SetLocalRotation (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
transform_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
Transform_SetLocalRotation (transform, P_PACKED (pr, pr_vec4_t, 1));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
}
static void
bi_Transform_GetLocalRotation (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
transform_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
R_PACKED (pr, pr_vec4_t) = Transform_GetLocalRotation (transform);
}
static void
bi_Transform_SetLocalScale (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
transform_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
Transform_SetLocalScale (transform, P_PACKED (pr, pr_vec4_t, 1));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
}
static void
bi_Transform_GetLocalScale (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
transform_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
R_PACKED (pr, pr_vec4_t) = Transform_GetLocalScale (transform);
}
static void
bi_Transform_SetWorldPosition (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
transform_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
Transform_SetWorldPosition (transform, P_PACKED (pr, pr_vec4_t, 1));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
}
static void
bi_Transform_GetWorldPosition (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
transform_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
R_PACKED (pr, pr_vec4_t) = Transform_GetWorldPosition (transform);
}
static void
bi_Transform_SetWorldRotation (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
transform_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
Transform_SetWorldRotation (transform, P_PACKED (pr, pr_vec4_t, 1));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
}
static void
bi_Transform_GetWorldRotation (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
transform_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
R_PACKED (pr, pr_vec4_t) = Transform_GetWorldRotation (transform);
}
static void
bi_Transform_GetWorldScale (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
transform_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
R_PACKED (pr, pr_vec4_t) = Transform_GetWorldScale (transform);
}
static void
bi_Transform_SetLocalTransform (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
transform_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
Transform_SetLocalTransform (transform, P_PACKED (pr, pr_vec4_t, 1),
P_PACKED (pr, pr_vec4_t, 2), P_PACKED (pr, pr_vec4_t, 3));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
}
static void
bi_Transform_Forward (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
transform_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
R_PACKED (pr, pr_vec4_t) = Transform_Forward (transform);
}
static void
bi_Transform_Right (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
transform_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
R_PACKED (pr, pr_vec4_t) = Transform_Right (transform);
}
static void
bi_Transform_Up (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
transform_t *transform = rua_transform_get (res, P_ULONG (pr, 0));
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
R_PACKED (pr, pr_vec4_t) = Transform_Up (transform);
}
[ruamoko] Add builtins for adding lights to scenes Pretty much just raw wrappers around the C versions. I'm not sure about Light_EnableSun (even in C), but it does build the sky surf pvs.
2022-05-05 14:43:39 +00:00
static void
bi_Light_CreateLightingData (progs_t *pr, void *_res)
{
rua_scene_resources_t *res = _res;
pr_ulong_t scene_id = P_ULONG (pr, 0);
rua_scene_t *scene = rua_scene_get (res, scene_id);
rua_lighting_t *ldata = rua_lighting_new (res);
ldata->ldata = Light_CreateLightingData (scene->scene);
ldata->next = res->ldatas;
if (res->ldatas) {
res->ldatas->prev = &ldata->next;
}
ldata->prev = &res->ldatas;
res->ldatas = ldata;
// ldata id in lower 32-bits for all handles
// upper 32-bits reserved
R_ULONG (pr) = MAKE_ID (0, rua_lighting_index (res, ldata));
}
static void
rua_delete_lighting (rua_scene_resources_t *res, rua_lighting_t *ldata)
{
Light_DestroyLightingData (ldata->ldata);
rua_lighting_free (res, ldata);
}
static void
bi_Light_DestroyLightingData (progs_t *pr, void *_res)
{
rua_scene_resources_t *res = _res;
rua_lighting_t *ldata = rua_lighting_get (res, P_ULONG (pr, 0));
rua_delete_lighting (res, ldata);
}
static void
bi_Light_ClearLights (progs_t *pr, void *_res)
{
rua_scene_resources_t *res = _res;
rua_lighting_t *ldata = rua_lighting_get (res, P_ULONG (pr, 0));
Light_ClearLights (ldata->ldata);
}
static void
bi_Light_AddLight (progs_t *pr, void *_res)
{
rua_scene_resources_t *res = _res;
rua_lighting_t *ldata = rua_lighting_get (res, P_ULONG (pr, 0));
light_t *light = &P_PACKED (pr, light_t, 1);
int style = P_INT (pr, 5);
Light_AddLight (ldata->ldata, light, style);
}
static void
bi_Light_EnableSun (progs_t *pr, void *_res)
{
rua_scene_resources_t *res = _res;
rua_lighting_t *ldata = rua_lighting_get (res, P_ULONG (pr, 0));
Light_EnableSun (ldata->ldata);
}
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
#define p(type) PR_PARAM(type)
#define P(a, s) { .size = (s), .alignment = BITOP_LOG2 (a), }
#define bi(x,np,params...) {#x, bi_##x, -1, np, {params}}
static builtin_t builtins[] = {
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
bi(Scene_NewScene, 0),
bi(Scene_DeleteScene, 1, p(ulong)),
bi(Scene_CreateEntity, 1, p(ulong)),
bi(Scene_DestroyEntity, 1, p(ulong)),
[ruamoko] Add builtins for adding lights to scenes Pretty much just raw wrappers around the C versions. I'm not sure about Light_EnableSun (even in C), but it does build the sky surf pvs.
2022-05-05 14:43:39 +00:00
bi(Scene_SetLighting , 2, p(ulong), p(ulong)),
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
bi(Entity_GetTransform, 1, p(ulong)),
[ruamoko] Allow entity model to be set And add header and function definitions for scene to libcsqc.
2022-05-04 08:38:38 +00:00
bi(Entity_SetModel, 2, p(ulong), p(int)),
[ruamoko] Switch to 64-bit handles for scene objects The scene id is in the lower 32-bits for all objects (upper 32-bits are 0 for actual scene objects) and entity/transform ids are in the upper 32-bits. Saves having to pass around a second parameter in progs code.
2022-04-26 08:40:06 +00:00
bi(Transform_ChildCount, 1, p(ulong)),
bi(Transform_GetChild, 2, p(ulong), p(int)),
bi(Transform_SetParent, 2, p(ulong), p(ulong)),
bi(Transform_GetParent, 1, p(ulong)),
bi(Transform_SetTag, 2, p(ulong), p(uint)),
bi(Transform_GetTag, 1, p(ulong)),
bi(Transform_GetLocalMatrix, 1, p(ulong)),
bi(Transform_GetLocalInverse, 1, p(ulong)),
bi(Transform_GetWorldMatrix, 1, p(ulong)),
bi(Transform_GetWorldInverse, 1, p(ulong)),
bi(Transform_SetLocalPosition, 2, p(ulong), p(vec4)),
bi(Transform_GetLocalPosition, 1, p(ulong)),
bi(Transform_SetLocalRotation, 2, p(ulong), p(vec4)),
bi(Transform_GetLocalRotation, 1, p(ulong)),
bi(Transform_SetLocalScale, 2, p(ulong), p(vec4)),
bi(Transform_GetLocalScale, 1, p(ulong)),
bi(Transform_SetWorldPosition, 2, p(ulong), p(vec4)),
bi(Transform_GetWorldPosition, 1, p(ulong)),
bi(Transform_SetWorldRotation, 2, p(ulong), p(vec4)),
bi(Transform_GetWorldRotation, 1, p(ulong)),
bi(Transform_GetWorldScale, 1, p(ulong)),
bi(Transform_SetLocalTransform, 4, p(ulong), p(vec4), p(vec4), p(vec4)),
bi(Transform_Forward, 1, p(ulong)),
bi(Transform_Right, 1, p(ulong)),
bi(Transform_Up, 1, p(ulong)),
[ruamoko] Wrap the transform fuctions Except for get/set name as I'm still pondering strings.
2022-02-14 15:06:39 +00:00
[ruamoko] Add builtins for adding lights to scenes Pretty much just raw wrappers around the C versions. I'm not sure about Light_EnableSun (even in C), but it does build the sky surf pvs.
2022-05-05 14:43:39 +00:00
bi(Light_CreateLightingData, 1, p(ulong)),
bi(Light_DestroyLightingData, 1, p(ulong)),
bi(Light_ClearLights, 1, p(ulong)),
bi(Light_AddLight, 5, p(ulong),// really, 3
p(vec4), p(vec4), p(vec4), p(vec4), p(int)),
bi(Light_EnableSun, 1, p(ulong)),
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
{0}
};
static void
bi_scene_clear (progs_t *pr, void *_res)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = _res;
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
[ruamoko] Clean up lighting data blocks Don't want to leak memory.
2022-05-05 23:26:55 +00:00
while (res->ldatas) {
rua_delete_lighting (res, res->ldatas);
}
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
while (res->scenes) {
rua_delete_scene (res, res->scenes);
}
}
void
RUA_Scene_Init (progs_t *pr, int secure)
{
[ruamoko] Give the scene resource block a rua prefix No effect on the code itself, but it makes debugging much easier when there aren't two very different structs with the same name.
2022-03-04 17:05:59 +00:00
rua_scene_resources_t *res = calloc (sizeof (rua_scene_resources_t), 1);
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
res->pr = pr;
[ruamoko] Allow scenes to be fetched by C code Need to clean up that part of the API, though.
2022-05-05 12:26:18 +00:00
PR_Resources_Register (pr, "Scene", res, bi_scene_clear);
[ruamoko] Add wrappers for the existing scene functions I've run into a bit of an issue with transform management (really, just need to make them owned by the scene, but that means creating a scene for quake and quakeworld).
2022-02-14 07:43:10 +00:00
PR_RegisterBuiltins (pr, builtins, res);
}
Reference in a new issue Copy permalink