lg_scene.c File Reference

Functions
LG_Scene	lg_scene_new (int id, LG_Camera *cam1, LG_Light light1, Rec2Df landscape_rec, uint16_t grid_width, const char *euler_ang_rot_order)
void	lg_scene_free (LG_Scene *scene)
LG_SceneNode *	lg_scenenode_new_and_set (int id, LG_SceneNode *parent_node, const char *mesh_file, LG_LoadMesh_Flags flags, vec3_t transl, LG_Quat orientation, vec3_t scaling)
void	lg_fill_node_NTOS_from_local_matrix (LG_Node_NTOS *ntos, mat4_t *local_matrix, const char *euler_ang_rot_order, zboolean set_quat)
void	lg_fill_node_NTOS_from_scenenode (LG_Node_NTOS *ntos, LG_SceneNode *node, const char *euler_ang_rot_order, zboolean set_quat)
zboolean	lg_generate_scene_data_from_scenenodes (LG_Scene *scene, LG_SceneNode *top_node)
LG_SceneNode *	lg_generate_scenenodes_from_scene_data (LG_Scene *scene, LG_SceneNode *top_node, LG_LoadMesh_Flags flags)
zboolean	lg_set_TRS_matrix_from_node_NTOS_euler (mat4_t *m_TRS, LG_Node_NTOS *ntos, const char *euler_ang_rot_order)
void	lg_set_NTOS_array_euler_angs_from_quats (LG_Scene *scene)
void	lg_node_NTOS_info (LG_Node_NTOS *ntos)
void	lg_node_NTOS_info_to_stream (LG_Node_NTOS *ntos, FILE *s)
void	lg_node_NTOS_array_info (LG_Scene *scene)
void	lg_node_NTOS_array_info_to_stream (LG_Scene *scene, FILE *s)
zboolean	lg_scene_load_data_from_assets (LG_Scene *scene, const char *path)
zboolean	lg_scene_load_data_from_file (LG_Scene *scene, const char *path)
zboolean	lg_scene_save_data_to_file (LG_Scene *scene, const char *path)
zboolean	lg_create_wr_scenes_dir ()
const char *	lg_get_reversed_rot_order (const char *rot_order)
zboolean	lg_rot_order_is_valid (const char *rot_order)

Detailed Description

=== Higher level scene/frame stuff ===

The starting point for scenes

SERIALIZING nodes (scene graph, including hierarchy) with LG_Node_NTOS[]

NOTE:

• LG_Node_NTOS x/y/z_oe -> orientation as Euler ang (as 3 doubles) - TO BE USED IN GAME LOOP UI
• LG_Node_NTOS x/y/z/w_oq -> orientation as a quat (as 4 floats) - TO BE USED WHEN SAVING/LOADING

Function Documentation

lg_scene_new()

LG_Scene lg_scene_new	(	int	id,
		LG_Camera *	cam1,
		LG_Light	light1,
		Rec2Df	landscape_rec,
		uint16_t	grid_width,
		const char *	euler_ang_rot_order
	)

Create and init a new scene

Can not contain more than NODE_NTOS_MAX_NUM mesh references

LG_Node_NTOS and LG_Scene are defined in lg_scene_graph.h

// === Scene node serializable data ===
// NTOS stands for (mesh file) Name and (scene node) TOS (Transl/Orientation/Scaling)
// Use float for LG_EulerAng
 
typedef union {
   struct {
           // Name
           char            name[LG_MESH_NAME_MAX_LEN + 1];         // OBJ/FBX basename
           int32_t         id;                                     // User-defined - SHOULD BE UNIQUE -> always > 0, 0 = top node
           int32_t         parent_id;                              // Set to < 0 if node = top node
           // Transl.
           float           x_t;
           float           y_t;
           float           z_t;
           // Orientation as Euler ang (as 3 floats) - TO BE USED IN GAME LOOP UI
           float           x_oe;
           float           y_oe;
           float           z_oe;
           // Scaling
           float           x_s;
           float           y_s;
           float           z_s;
           double  x_oq;
           double  y_oq;
           double  z_oq;
           double  w_oq;
   };
   struct {
           char            name2[LG_MESH_NAME_MAX_LEN + 1];
           int32_t         id2;
           int32_t         parent_id2;
           float           v[17];
   };
} LG_Node_NTOS;
 
// New nodes/nodes ids added to the scene should start at or above first_obj_node/SCENE_FIRST_OBJ_NODE_ID (id = 3)
enum {
   SCENE_ROOT_NODE_ID = 0,
   SCENE_GRID_NODE_ID,
   SCENE_XYZ_ARROWS_NODE_ID,
   SCENE_FIRST_OBJ_NODE_ID
};
 
typedef struct {
   // All serializable data
   int32_t         id;             // Set to -1 on error
   LG_Light        light1;
   Rec2Df          landscape_rec;
   LG_Node_NTOS    nodes_ntos[NODE_NTOS_MAX_NUM];
   int32_t         n_node_ntos;
   char            euler_ang_rot_order[4];
   // Not serializable data
   LG_Camera       *cam1;
   LG_SceneNode    *root;
   LG_SceneNode    *grid;
   LG_SceneNode    *xyz_arrows;
   LG_SceneNode    *first_obj_node;
} LG_Scene;

Generated nodes:

• root -> parent of grid and xyz_arrows, id = 0, type = ROOT
• grid -> with an initialized Lines3D_VB horizontal grid, id = 1, type = GRID
• xyz_arrows -> with an initialized Lines3D_VB xyz_arrows, id = 2, type = LINES3D

New nodes ids added to the scene should start at or above SCENE_FIRST_OBJ_NODE_ID (id = 3)

Parameters

id	Scene's id, set to -1 on error
cam1	A pointer to a LG_Camera
light1	A LG_Light
landscape_rec	A Rec2Df, should be centered
grid_width	Grid width, ie number of units along one row or one column, should be even - if odd, we substract one
euler_ang_rot_order	One of "XYZ", "YXZ", "ZXY", "ZYX", "YZX", "XZY"

Returns

An initialized LG_Scene if OK, id set to -1 on error

lg_scene_free()

void lg_scene_free

(

LG_Scene *

scene

)

Free scene root, grid, and xyz_arrows nodes

Parameters

scene

A LG_Scene

lg_scenenode_new_and_set()

LG_SceneNode* lg_scenenode_new_and_set	(	int	id,
		LG_SceneNode *	parent_node,
		const char *	mesh_file,
		LG_LoadMesh_Flags	flags,
		vec3_t	transl,
		LG_Quat	orientation,
		vec3_t	scaling
	)

Helper func to create and set a new LG_SceneNode instance

Create node, add node to scene graph, load node's mesh, and set node's local matrix

Helper macros for less confusion:

#define transl_v3(x, y, z)     vec3(x, y, z)
#define scaling_v3(x, y, z)    vec3(x, y, z)

Mesh must be freed when done with the scene

Parameters

id	Node's id
parent_node	A pointer to a scene graph node
mesh_file	Relative path to mesh file to load, inside the mesh folder
flags	Apply to mesh: force_reload, invert_z, normalize_xyz, horiz_center, vert_center, vert_bottom
transl	Translation/position vec3
orientation	Orientation quat
scaling	Scaling vec3

Returns

A pointer to a LG_SceneNode if OK, NULL on error - must be freed afterwards

lg_fill_node_NTOS_from_local_matrix()

void lg_fill_node_NTOS_from_local_matrix	(	LG_Node_NTOS *	ntos,
		mat4_t *	local_matrix,
		const char *	euler_ang_rot_order,
		zboolean	set_quat
	)

Fill a LG_Node_NTOS's TOS (Transl./Orientation/Scaling) from a local matrix

Parameters

ntos	Pointer to a LG_Node_NTOS
local_matrix	Pointer to a mat4_t
euler_ang_rot_order	One of "XYZ", "YXZ", "ZXY", "ZYX", "YZX", "XZY"
set_quat	Whether to compute quat or leave it un touched

lg_fill_node_NTOS_from_scenenode()

void lg_fill_node_NTOS_from_scenenode	(	LG_Node_NTOS *	ntos,
		LG_SceneNode *	node,
		const char *	euler_ang_rot_order,
		zboolean	set_quat
	)

Fill a LG_Node_NTOS from a LG_SceneNode

Parameters

ntos	Pointer to a LG_Node_NTOS
node	Pointer to a LG_SceneNode
euler_ang_rot_order	One of "XYZ", "YXZ", "ZXY", "ZYX", "YZX", "XZY"
set_quat	Whether to compute quat or not

lg_generate_scene_data_from_scenenodes()

zboolean lg_generate_scene_data_from_scenenodes	(	LG_Scene *	scene,
		LG_SceneNode *	top_node
	)

Generate LG_Scene serializable data, ie scene's (LG_Node_NTOS) nodes_ntos[NODE_NTOS_MAX_NUM] from a scene graph top node (LG_SceneNode *) by traversing it and calling fill_node_ntos(node, scene) for each node, which generate TOS values from node's local matrix

Will fill an array of LG_Node_NTOS from scene nodes from (serializing hierachical nodes tree)

NOTE: scene->euler_ang_rot_order must have been initialized first with a correct value

Parameters

scene	Pointer to a LG_Scene
top_node	The top scene node

Returns

Actually always return TRUE (so far)

lg_generate_scenenodes_from_scene_data()

LG_SceneNode* lg_generate_scenenodes_from_scene_data	(	LG_Scene *	scene,
		LG_SceneNode *	top_node,
		LG_LoadMesh_Flags	flags
	)

Generate scene nodes (LG_SceneNode *) from a LG_Scene serializable data and mesh files by parsing scene's (LG_Node_NTOS) nodes_ntos[NODE_NTOS_MAX_NUM]

Will create and set scene nodes from an array of LG_Node_NTOS (deserializing nodes tree)

NTOS stands for (mesh file) Name and (scene node) TOS (Transl/Orientation/Scaling)

Generated scene nodes id should start at or above SCENE_FIRST_OBJ_NODE_ID (id = 3)

You can then add top_node to your scene root node

Example code:

LG_LoadMesh_Flags flags1 = lg_loadmesh_flags(FALSE, FALSE, NORMALIZE_XYZ, HORIZ_CENTER, FALSE, VERT_BOTTOM);
 
// Load scene1 serializable data from file
loaded_from_file = lg_scene_load_data_from_file(&lev->scene, lg_app_wr_file("scenes/scene_1.scene"));
if (!loaded_from_file) {
   if (question_win("'scenes/scene_1.scene' not found\nCreate, save to file, and use default one") == YES) {
           INFO_ERR("No scene file available - will create, save to file, and use default one\n")
           // SCENE_FIRST_OBJ_NODE_ID
           LG_Node_NTOS node_ntos_set1[] = {
                   {{"obj/shark1.obj",     4, 3,   0, 40, 0,       0, 0, 0,        25, 25, 25,     0, 0, 0, 1}},
                   {{"obj/pikachu2.obj",   5, 3,   -50, 0, 50,     0, 0, 0,        25, 25, 25,     0, 0, 0, 1}},
                   {{"obj/tree2.obj",      6, 3,   50, 0, 50,      0, 0, 0,        25, 25, 25,     0, 0, 0, 1}},
                   {{"obj/windmill1.obj",  7, 3,   -50, 0, -50,    0, 0, 0,        25, 25, 25,     0, 0, 0, 1}},
                   {{"obj/cube3.obj",      8, 3,   50, 0, -50,     0, 0, 0,        12, 12, 12,     0, 0, 0, 1}},
                   {{"obj/airplane.obj",   9, 6,   4, 1, -2,       0, 0, 0,        1.5, 1.5, 1.5,  0, 0, 0, 1}}};
 
           lev->scene.n_node_ntos = (int)(sizeof(node_ntos_set1) / sizeof(LG_Node_NTOS));
 
           for (i = 0; i < lev->scene.n_node_ntos; i++) {
                   lev->scene.nodes_ntos[i] = node_ntos_set1[i];
           }
   }
}
 
// Meshes - continue
lev->scene.first_obj_node = lg_scenenode_new(SCENE_FIRST_OBJ_NODE_ID, "first_obj_node", FIRST_OBJ);
if (lev->scene.first_obj_node == NULL) return;
lev->scene.first_obj_node = lg_generate_scenenodes_from_scene_data(&lev->scene, lev->scene.first_obj_node, lev->flags1);
if (lev->scene.first_obj_node == NULL) return;
lg_scenenode_add_child(lev->scene.root, lev->scene.first_obj_node);
if (!loaded_from_file) {
   lg_scene_save_data_to_file(&lev->scene, lg_app_wr_file("scenes/scene_1.scene"));
}

Parameters

scene	Pointer to a LG_Scene
top_node	A scene node
flags	Mesh loading flags

Returns

top_node

lg_set_TRS_matrix_from_node_NTOS_euler()

zboolean lg_set_TRS_matrix_from_node_NTOS_euler	(	mat4_t *	m_TRS,
		LG_Node_NTOS *	ntos,
		const char *	euler_ang_rot_order
	)

Set an existing TRS matrix (Transl/Rotation/Scaling) from a LG_Node_NTOS, using Euler angles (x_oe, y_oe, z_oe) for rotation

Parameters

m_TRS	Pointer to a mat4_t
ntos	Pointer to a LG_Node_NTOS
euler_ang_rot_order	One of "XYZ", "YXZ", "ZXY", "ZYX", "YZX", "XZY"

Returns

TRUE if OK, FALSE otherwise

lg_set_NTOS_array_euler_angs_from_quats()

void lg_set_NTOS_array_euler_angs_from_quats

(

LG_Scene *

scene

)

Set a scene LG_Node_NTOS array (scene->nodes_ntos[])'s Euler angles from quats

Parameters

scene

Pointer to a LG_Scene

lg_node_NTOS_info()

void lg_node_NTOS_info

(

LG_Node_NTOS *

ntos

)

Print out LG_Node_NTOS info

Parameters

ntos	Pointer to a LG_Node_NTOS

lg_node_NTOS_info_to_stream()

void lg_node_NTOS_info_to_stream	(	LG_Node_NTOS *	ntos,
		FILE *	s
	)

SendLG_Node_NTOS info to stream (as text)

Parameters

ntos	Pointer to a LG_Node_NTOS
s	Stream

lg_node_NTOS_array_info()

void lg_node_NTOS_array_info

(

LG_Scene *

scene

)

Print out LG_Scene's nodes_ntos[] info

Parameters

scene

A pointer to a LG_Scene

lg_node_NTOS_array_info_to_stream()

void lg_node_NTOS_array_info_to_stream	(	LG_Scene *	scene,
		FILE *	s
	)

Send LG_Scene's nodes_ntos[] info to stream (as text)

Parameters

scene	A pointer to a LG_Scene
s	Stream

lg_scene_load_data_from_assets()

zboolean lg_scene_load_data_from_assets	(	LG_Scene *	scene,
		const char *	path
	)

Load LG_Scene serializable data from a file in the ASSETS/SCENES_DIR folder

Parameters

scene	Pointer to a LG_Scene
path	Relative path to scene file, inside env->assets_dir/scenes

Returns

A new LG_Scene, id set to -1 on error

lg_scene_load_data_from_file()

zboolean lg_scene_load_data_from_file	(	LG_Scene *	scene,
		const char *	path
	)

Load LG_Scene serializable data from a file in the APP WRITABLE folder

Parameters

scene	Pointer to a LG_Scene
path	Path to scene file, inside env->app_wr_dir

Returns

TRUE if OK, FALSE otherwise

lg_scene_save_data_to_file()

zboolean lg_scene_save_data_to_file	(	LG_Scene *	scene,
		const char *	path
	)

Save LG_Scene serializable data to a file in the APP WRITABLE folder

Parameters

scene	Pointer a to LG_Scene
path	Path to scene file, inside env->app_wr_dir

Returns

TRUE if OK, FALSE on error

lg_create_wr_scenes_dir()

zboolean lg_create_wr_scenes_dir

(

)

Create the scene folder (SCENES_DIR) in the APP WRITABLE folder

Returns

TRUE if OK, FALSE on error

lg_get_reversed_rot_order()

const char* lg_get_reversed_rot_order

(

const char *

rot_order

)

Return reversed rot order string, ie "XYZ" -> "ZYX"

Parameters

rot_order

A 3 chars long string, expected to be a valid rot sequence

Returns

The reversed string, or an empty string if rot_order is not valid

lg_rot_order_is_valid()

zboolean lg_rot_order_is_valid

(

const char *

rot_order

)

Check if rot order string is valid, ie one of "XYZ", "YXZ", "ZXY", "ZYX", "YZX", "XZY"

Parameters

rot_order

A 3 chars long string

Returns

TRUE if rot_order ist valid, FALSE otherwise