void er_wbuf ( int *iret )
/************************************************************************
* er_wbuf *
* *
* This routine writes all of the error messages in the error message *
* buffer to the terminal. The buffer is then re-initialized. *
* *
* er_wbuf ( iret ) *
* *
* Output parameters: *
* *iret int Return code *
* 0 = normal return *
* +1 = no msgs in buffer *
** *
* Log: *
* K. Tyle/GSC 12/96 *
* K. Tyle/GSC 1/97 Change nstr to nermsg *
* C. Lin/EAI 1/97 Change msgstr to errmsg *
* S. Maxwell/GSC 6/97 Documentation changes *
* M. Linda/GSC 10/97 Corrected the prologue format *
***********************************************************************/
{
short int i;
int ier;
/*---------------------------------------------------------------------*/
*iret = 0;
/*
* Return error if there are no messages.
*/
if ( nermsg == 0 ) {
*iret = 1;
}
/*
* Write messages to the buffer.
*/
else {
for ( i = 1; i <= nermsg; i++ ) {
printf ("%s\n",errmsg[i-1]);
}
/*
* Re-initialize message buffer.
*/
er_init ( &ier );
}
}
/*
* Initialization of buffers and EduRaster structures.
*/
static void setup(){
/* Allocate depth buffer */
depth_buffer = (float*)malloc(window_width*window_height*sizeof(float));
if(depth_buffer == NULL){
fprintf(stderr, "Unable to create depth buffer. Out of memory\n");
quit();
}
/* Allocate color buffer */
color_buffer = (unsigned int*)malloc(window_width*window_height*sizeof(unsigned int));
if(color_buffer == NULL){
fprintf(stderr, "Unable to create color buffer. Out of memory\n");
quit();
}
/* Init EduRaster */
if(er_init() != 0) {
fprintf(stderr, "Unable to init eduraster: %s\n", er_get_error_string(er_get_error()));
quit();
}
er_viewport(0, 0, window_width, window_height);
/* Set Perspective Projection */
er_matrix_mode(ER_PROJECTION);
er_load_identity();
er_perspective(60.0f, (float)window_width / (float)window_height, 2.0f, 50.0f);
er_matrix_mode(ER_MODELVIEW);
/* Allocate buffer for vertex data */
points = (float *)malloc(sizeof(float) * 6 * samples_t * samples_s);
if(points == NULL){
fprintf(stderr, "Unable to create vertex data for surface. Out of memory\n");
quit();
}
/* Allocate buffer for indices */
index_size = (samples_s - 1) * (samples_t - 1) * 6;
index_data = (unsigned int*)malloc( index_size * sizeof(unsigned int));
if(index_data == NULL){
fprintf(stderr, "Unable to create indices for surface. Out of memory\n");
quit();
}
/* Calculate indices */
int width = (samples_t-1) * 6, i ,j;
for(i = 0; i < samples_s - 1; i++){
for(j = 0; j < samples_t - 1; j++){
// Up Triangle
index_data[i*width + j*6 ] = i * samples_t + j;
index_data[i*width + j*6 + 1] = (i+1) * samples_t + j;
index_data[i*width + j*6 + 2] = i * samples_t + (j + 1);
// Down Triangle
index_data[i*width + j*6 + 3] = i * samples_t + (j+1);
index_data[i*width + j*6 + 4] = (i+1) * samples_t + j;
index_data[i*width + j*6 + 5] = (i+1) * samples_t + (j+1);
}
}
/* Evaluate surface equations */
calculate_surface();
/* Create vertex array for surface */
va = er_create_vertex_array();
if(va == NULL){
fprintf(stderr, "Unable to create vertex array: %s\n", er_get_error_string(er_get_error()));
quit();
}
er_use_vertex_array(va);
er_vertex_pointer(va, 6, 3, points );
er_normal_pointer(va, 6, &points[3] );
er_enable_attribute_array(va, ER_VERTEX_ARRAY, ER_TRUE);
er_enable_attribute_array(va, ER_NORMAL_ARRAY, ER_TRUE);
/* Create program for surface lighting */
program_surface_light = er_create_program();
if(program_surface_light == NULL){
fprintf(stderr, "Unable to create eduraster program: %s\n", er_get_error_string(er_get_error()));
quit();
}
er_use_program(program_surface_light);
er_varying_attributes(program_surface_light, 6);
er_load_fragment_shader(program_surface_light, fragment_shader_light);
er_load_vertex_shader(program_surface_light, vertex_shader_light);
er_load_homogeneous_division(program_surface_light, homogeneous_division_light);
er_uniformf(program_surface_light, 0, 0.5773503f);
er_uniformf(program_surface_light, 1, 0.5773503f);
er_uniformf(program_surface_light, 2, 0.5773503f);
/* Create program for axis */
program_axis = er_create_program();
if(program_axis == NULL){
fprintf(stderr, "Unable to create eduraster program: %s\n", er_get_error_string(er_get_error()));
quit();
}
er_use_program(program_axis);
er_varying_attributes(program_axis, 4);
er_load_fragment_shader(program_axis, fragment_shader_axis);
er_load_vertex_shader(program_axis, vertex_shader_axis);
er_load_homogeneous_division(program_axis, homogeneous_division_axis);
/* Create program for surface color */
program_surface_color = er_create_program();
if(program_surface_color == NULL){
fprintf(stderr, "Unable to create eduraster program: %s\n", er_get_error_string(er_get_error()));
quit();
}
er_use_program(program_surface_color);
er_varying_attributes(program_surface_color, 3);
er_load_fragment_shader(program_surface_color, fragment_shader_color);
er_load_vertex_shader(program_surface_color, vertex_shader_color);
er_load_homogeneous_division(program_surface_color, homogeneous_division_color);
/* Default program */
current_surface_program = program_surface_light;
}
/*
* loaddb_internal - internal main loaddb function
* return: NO_ERROR if successful, error code otherwise
* argc(in): argc of main
* argv(in): argv of main
* dba_mode(in):
*/
static int
loaddb_internal (UTIL_FUNCTION_ARG * arg, int dba_mode)
{
UTIL_ARG_MAP *arg_map = arg->arg_map;
int error = NO_ERROR;
/* set to static to avoid copiler warning (clobbered by longjump) */
static FILE *schema_file = NULL;
static FILE *index_file = NULL;
static FILE *object_file = NULL;
FILE *error_file = NULL;
int status = 0;
int errors, objects, defaults;
#if !defined (LDR_OLD_LOADDB)
int lastcommit = 0;
#endif /* !LDR_OLD_LOADDB */
char *passwd;
/* set to static to avoid copiler warning (clobbered by longjump) */
static int interrupted = false;
int au_save = 0;
extern bool obt_Enable_autoincrement;
char log_file_name[PATH_MAX];
LOADDB_INIT_DEBUG ();
obt_Enable_autoincrement = false;
Volume = utility_get_option_string_value (arg_map, OPTION_STRING_TABLE, 0);
Input_file = utility_get_option_string_value (arg_map, OPTION_STRING_TABLE,
1);
User_name = utility_get_option_string_value (arg_map, LOAD_USER_S, 0);
Password = utility_get_option_string_value (arg_map, LOAD_PASSWORD_S, 0);
Syntax_check = utility_get_option_bool_value (arg_map, LOAD_CHECK_ONLY_S);
Load_only = utility_get_option_bool_value (arg_map, LOAD_LOAD_ONLY_S);
Estimated_size = utility_get_option_int_value (arg_map,
LOAD_ESTIMATED_SIZE_S);
Verbose = utility_get_option_bool_value (arg_map, LOAD_VERBOSE_S);
Disable_statistics =
utility_get_option_bool_value (arg_map, LOAD_NO_STATISTICS_S);
Periodic_commit = utility_get_option_int_value (arg_map,
LOAD_PERIODIC_COMMIT_S);
Verbose_commit = Periodic_commit > 0 ? true : false;
No_oid_hint = utility_get_option_bool_value (arg_map, LOAD_NO_OID_S);
Schema_file = utility_get_option_string_value (arg_map, LOAD_SCHEMA_FILE_S,
0);
Index_file = utility_get_option_string_value (arg_map, LOAD_INDEX_FILE_S,
0);
Object_file = utility_get_option_string_value (arg_map, LOAD_DATA_FILE_S,
0);
Error_file = utility_get_option_string_value (arg_map,
LOAD_ERROR_CONTROL_FILE_S, 0);
Ignore_logging = utility_get_option_bool_value (arg_map,
LOAD_IGNORE_LOGGING_S);
#if !defined (LDR_OLD_LOADDB)
Ignore_class_file = utility_get_option_string_value (arg_map,
LOAD_IGNORE_CLASS_S,
0);
#endif
Input_file = Input_file ? Input_file : "";
Schema_file = Schema_file ? Schema_file : "";
Index_file = Index_file ? Index_file : "";
Object_file = Object_file ? Object_file : "";
Error_file = Error_file ? Error_file : "";
if (ldr_validate_object_file (stderr, arg->argv0))
{
goto error_return;
}
/* error message log file */
sprintf (log_file_name, "%s_%s.err", Volume, arg->command_name);
er_init (log_file_name, ER_NEVER_EXIT);
if (Index_file[0] != '\0'
&& PRM_SR_NBUFFERS < LOAD_INDEX_MIN_SORT_BUFFER_PAGES)
{
sysprm_set_force (PRM_NAME_SR_NBUFFERS,
LOAD_INDEX_MIN_SORT_BUFFER_PAGES_STRING);
}
sysprm_set_force (PRM_NAME_JAVA_STORED_PROCEDURE, "no");
/* login */
if (User_name != NULL || !dba_mode)
{
(void) db_login (User_name, Password);
if ((error = db_restart (arg->command_name, true, Volume)))
{
if (error == ER_AU_INVALID_PASSWORD)
{
/* prompt for password and try again */
error = NO_ERROR;
passwd = getpass (msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_PASSWORD_PROMPT));
if (!strlen (passwd))
passwd = NULL;
(void) db_login (User_name, passwd);
error = db_restart (arg->command_name, true, Volume);
}
}
}
else
{
/* if we're in the protected dba mode, just login without
authorization */
AU_DISABLE_PASSWORDS ();
db_set_client_type (DB_CLIENT_TYPE_ADMIN_UTILITY);
(void) db_login ("dba", NULL);
error = db_restart (arg->command_name, true, Volume);
}
/* open loaddb log file */
sprintf (log_file_name, "%s_loaddb.log", Volume);
loaddb_log_file = fopen (log_file_name, "w+");
if (loaddb_log_file == NULL)
{
printf ("Cannot open log file %s\n", log_file_name);
status = 2;
goto error_return;
}
#if 0
#if !defined (LDR_OLD_LOADDB)
/* Execute old loaddb if no optimization flag is set true
* or LOADDB_NOPT is set, we must pass the argv except
* -no option and invoke execvp() for no optimized loaddb
*/
if (No_optimization || envvar_get ("LOADDB_NOPT"))
{
char **tmp;
char *lastslash, path[PATH_MAX];
int i = 1, j = 1;
tmp = (char **) malloc (sizeof (char *) * (argc + 1));
tmp[0] = (char *) "loaddb";
while (j < argc)
{
if (!strcmp (argv[j], "-no"))
j++;
else
tmp[i++] = argv[j++];
};
tmp[i] = 0;
strcpy (path, argv[0]);
lastslash = strrchr (path, (int) '/');
#if defined(WINDOWS)
{
char *p, exec_path[1024], cmd_line[1024 * 8];
int cp_len = 0;
db_shutdown ();
p = envvar_root ();
if (p == NULL)
{
printf ("The `CUBRID' environment variable is not set.\n");
}
else
{
sprintf (exec_path, "%s/migdb_o.exe", p);
for (i = 0; tmp[i]; i++)
{
cp_len += sprintf (cmd_line + cp_len, "\"%s\" ", tmp[i]);
}
if (envvar_get ("FRONT_DEBUG") != NULL)
{
printf ("Executing:%s %s\n", exec_path, cmd_line);
}
run_proc (exec_path, cmd_line);
}
exit (0);
}
#else /* !WINDOWS */
if (lastslash != NULL)
strcpy (lastslash + 1, "migdb_o");
else
strcpy (path, "migdb_o");
if (execvp (path, tmp) == -1)
{
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_NOPT_ERR));
exit (0);
};
#endif /* WINDOWS */
}
#endif /* !LDR_OLD_LOADDB */
#endif
/* check if schema/index/object files exist */
ldr_check_file_name_and_line_no ();
if (Schema_file[0] != 0)
{
schema_file = fopen (Schema_file, "r");
if (schema_file == NULL)
{
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_BAD_INFILE),
Schema_file);
status = 2;
goto error_return;
}
}
if (Index_file[0] != 0)
{
index_file = fopen (Index_file, "r");
if (index_file == NULL)
{
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_BAD_INFILE),
Index_file);
status = 2;
goto error_return;
}
}
if (Object_file[0] != 0)
{
object_file = fopen_ex (Object_file, "rb"); /* keep out ^Z */
if (object_file == NULL)
{
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_BAD_INFILE),
Object_file);
status = 2;
goto error_return;
}
}
#if !defined (LDR_OLD_LOADDB)
if (Ignore_class_file)
{
int retval;
retval = get_ignore_class_list (Ignore_class_file);
if (retval < 0)
{
status = 2;
goto error_return;
}
}
#endif
/* Disallow syntax only and load only options together */
if (Load_only && Syntax_check)
{
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_INCOMPATIBLE_ARGS),
"--" LOAD_LOAD_ONLY_L, "--" LOAD_CHECK_ONLY_L);
status = 1; /* parsing error */
goto error_return;
}
if (Error_file[0] != 0)
{
if (Syntax_check)
{
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_INCOMPATIBLE_ARGS),
"--" LOAD_ERROR_CONTROL_FILE_L,
"--" LOAD_CHECK_ONLY_L);
status = 1; /* parsing error */
goto error_return;
}
error_file = fopen_ex (Error_file, "rt");
if (error_file == NULL)
{
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_BAD_INFILE),
Error_file);
status = 2;
goto error_return;
}
er_filter_fileset (error_file);
fclose (error_file);
}
/* check if no log option can be applied */
if (error
|| (Ignore_logging != 0 && locator_log_force_nologging () != NO_ERROR))
{
/* couldn't log in */
print_log_msg (1, "%s\n", db_error_string (3));
status = 3;
db_shutdown ();
goto error_return;
}
/* change "print_key_value_on_unique_error" parameter */
sysprm_change_server_parameters ("print_key_value_on_unique_error=1");
/* if schema file is specified, do schema loading */
if (schema_file != NULL)
{
print_log_msg (1, "\nStart schema loading.\n");
/*
* CUBRID 8.2 should be compatible with earlier versions of CUBRID.
* Therefore, we do not perform user authentication when the loader
* is executing by DBA group user.
*/
if (au_is_dba_group_member (Au_user))
{
AU_DISABLE (au_save);
}
if (ldr_exec_query_from_file (Schema_file, schema_file,
&schema_file_start_line,
Periodic_commit) != 0)
{
print_log_msg (1, "\nError occurred during schema loading."
"\nAborting current transaction...");
status = 3;
db_shutdown ();
print_log_msg (1,
" done.\n\nRestart loaddb with '-%c %s:%d' option\n",
LOAD_SCHEMA_FILE_S, Schema_file,
schema_file_start_line);
goto error_return;
}
if (au_is_dba_group_member (Au_user))
{
AU_ENABLE (au_save);
}
print_log_msg (1, "Schema loading from %s finished.\n", Schema_file);
/* update catalog statistics */
AU_DISABLE (au_save);
sm_update_all_catalog_statistics ();
AU_ENABLE (au_save);
print_log_msg (1,
"Statistics for Catalog classes have been updated.\n\n");
db_commit_transaction ();
fclose (schema_file);
schema_file = NULL;
}
/* if index file is specified, do index creation */
if (object_file != NULL)
{
#if defined (SA_MODE)
locator_Dont_check_foreign_key = true;
#endif
print_log_msg (1, "\nStart object loading.\n");
ldr_init (Verbose);
/* set the flag to indicate what type of interrupts to raise
* If logging has been disabled set commit flag.
* If logging is enabled set abort flag.
*/
if (Ignore_logging)
Interrupt_type = LDR_STOP_AND_COMMIT_INTERRUPT;
else
Interrupt_type = LDR_STOP_AND_ABORT_INTERRUPT;
if (Periodic_commit)
{
/* register the post commit function */
#if defined(LDR_OLD_LOADDB)
ldr_register_post_commit_handler (&loaddb_report_num_of_commits);
#else /* !LDR_OLD_LOADDB */
ldr_register_post_commit_handler (&loaddb_report_num_of_commits,
NULL);
#endif /* LDR_OLD_LOADDB */
}
/* Check if we need to perform syntax checking. */
if (!Load_only)
{
print_log_msg ((int) Verbose, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_CHECKING));
do_loader_parse (object_file);
#if defined(LDR_OLD_LOADDB)
ldr_stats (&errors, &objects, &defaults);
#else /* !LDR_OLD_LOADDB */
ldr_stats (&errors, &objects, &defaults, &lastcommit);
#endif /* LDR_OLD_LOADDB */
}
else
errors = 0;
if (errors)
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_ERROR_COUNT), errors);
else if (!Syntax_check)
{
/* now do it for real if there were no errors and we aren't
doing a simple syntax check */
ldr_start (Periodic_commit);
fclose (object_file);
object_file = fopen_ex (Object_file, "rb"); /* keep out ^Z */
if (object_file != NULL)
{
print_log_msg ((int) Verbose,
msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_INSERTING));
/* make sure signals are caught */
util_arm_signal_handlers (signal_handler, signal_handler);
/* register function to call and jmp environment to longjmp to
* after aborting or committing.
*/
ldr_register_post_interrupt_handler
(&loaddb_get_num_of_inserted_objects, &loaddb_jmp_buf);
if (setjmp (loaddb_jmp_buf) != 0)
{
/* We have had an interrupt, the transaction should have
* been already been aborted or committed by the loader.
* If Total_objects_loaded is -1 an error occurred during
* rollback or commit.
*/
if (Total_objects_loaded != -1)
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_OBJECT_COUNT),
Total_objects_loaded);
#if !defined(LDR_OLD_LOADDB)
ldr_stats (&errors, &objects, &defaults, &lastcommit);
if (lastcommit > 0)
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_LAST_COMMITTED_LINE),
lastcommit);
#endif /* !LDR_OLD_LOADDB */
interrupted = true;
}
else
{
do_loader_parse (object_file);
#if defined(LDR_OLD_LOADDB)
ldr_stats (&errors, &objects, &defaults);
#else /* !LDR_OLD_LOADDB */
ldr_stats (&errors, &objects, &defaults, &lastcommit);
#endif /* LDR_OLD_LOADDB */
if (errors)
{
#if defined(LDR_OLD_LOADDB)
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_ERROR_COUNT),
errors);
#else /* !LDR_OLD_LOADDB */
if (lastcommit > 0)
print_log_msg (1,
msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_LAST_COMMITTED_LINE),
lastcommit);
#endif /* LDR_OLD_LOADDB */
/*
* don't allow the transaction to be committed at
* this point, note that if we ever move to a scheme
* where we write directly to the heap without the
* transaction context, we will have to unwind the
* changes made if errors are detected !
*/
db_abort_transaction ();
}
else
{
if (objects)
print_log_msg (1,
msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_OBJECT_COUNT),
objects);
if (defaults)
print_log_msg (1,
msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_DEFAULT_COUNT),
defaults);
print_log_msg ((int) Verbose,
msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_COMMITTING));
/* commit the transaction and then update statistics */
if (!db_commit_transaction ())
{
if (!Disable_statistics)
{
if (Verbose)
print_log_msg (1,
msgcat_message
(MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_UPDATING_STATISTICS));
if (!ldr_update_statistics ())
{
/*
* would it be faster to update statistics
* before the first commit and just have a
* single commit ?
*/
print_log_msg ((int) Verbose,
msgcat_message
(MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_COMMITTING));
(void) db_commit_transaction ();
}
}
}
}
}
}
}
ldr_final ();
if (object_file != NULL)
{
fclose (object_file);
object_file = NULL;
}
}
/* create index */
if (!interrupted && index_file != NULL)
{
print_log_msg (1, "\nStart index loading.\n");
if (ldr_exec_query_from_file (Index_file, index_file,
&index_file_start_line,
Periodic_commit) != 0)
{
print_log_msg (1, "\nError occurred during index loading."
"\nAborting current transaction...");
status = 3;
db_shutdown ();
print_log_msg (1,
" done.\n\nRestart loaddb with '-%c %s:%d' option\n",
LOAD_INDEX_FILE_S, Index_file,
index_file_start_line);
goto error_return;
}
/* update catalog statistics */
AU_DISABLE (au_save);
sm_update_catalog_statistics (CT_INDEX_NAME);
sm_update_catalog_statistics (CT_INDEXKEY_NAME);
AU_ENABLE (au_save);
print_log_msg (1, "Index loading from %s finished.\n", Index_file);
db_commit_transaction ();
}
print_log_msg ((int) Verbose, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_CLOSING));
(void) db_shutdown ();
#if !defined (LDR_OLD_LOADDB)
free_ignoreclasslist ();
#endif
return (status);
error_return:
if (schema_file != NULL)
fclose (schema_file);
if (object_file != NULL)
fclose (object_file);
if (index_file != NULL)
fclose (index_file);
#if !defined (LDR_OLD_LOADDB)
free_ignoreclasslist ();
#endif
return status;
}
/*
* Initialization of buffers and EduRaster structures.
*/
static void setup(){
/* Allocate color buffer */
color_buffer = (unsigned int*)malloc(window_width*window_height*sizeof(unsigned int));
if(color_buffer == NULL){
fprintf(stderr, "Unable to allocate color buffer. Out of memory\n");
quit();
}
/* Allocate depth buffer */
depth_buffer = (float* )malloc(window_width*window_height*sizeof(float));
if(depth_buffer == NULL){
fprintf(stderr, "Unable to allocate depth buffer. Out of memory\n");
quit();
}
/* Init EduRaster */
if(er_init() != 0) {
fprintf(stderr, "Unable to init eduraster: %s\n", er_get_error_string(er_get_error()));
quit();
}
er_viewport(0 , 0 , window_width, window_height);
/* Set perspective projection */
er_matrix_mode(ER_PROJECTION);
er_load_identity();
er_perspective(60.0f, (float)window_width / (float)window_height, 2.0f, 40.0f);
er_matrix_mode(ER_MODELVIEW);
/* Load image and create texture */
const char *image_path = "textures/lenna.bmp";
SDL_Surface *image = SDL_LoadBMP(image_path);
if(image == NULL){
fprintf(stderr, "Unable to load image %s. Error: %s\n", SDL_GetError());
quit();
}
tex = er_create_texture2D(image->w, image->h, ER_RGB32F);
if(tex == NULL){
fprintf(stderr, "Unable to create texture %s. Error: %s\n", er_get_error_string(er_get_error()));
quit();
}
er_texture_filtering(tex, ER_MAGNIFICATION_FILTER, ER_LINEAR);
er_texture_filtering(tex, ER_MINIFICATION_FILTER, ER_LINEAR_MIPMAP_LINEAR);
er_texture_wrap_mode(tex, ER_WRAP_S, ER_REPEAT);
er_texture_wrap_mode(tex, ER_WRAP_T, ER_REPEAT);
SDL_PixelFormat *format = image->format;
SDL_LockSurface(image);
unsigned char *src_data = image->pixels;
float *dst_data = er_texture_ptr(tex, ER_TEXTURE_2D, 0);
int i, j;
unsigned int src_color = 0;
unsigned char r, g, b;
for(i = 0; i < image->h;i++){
for(j = 0; j < image->w; j++){
memcpy(&src_color, &src_data[(image->h-1-i)*image->pitch+j*format->BytesPerPixel], format->BytesPerPixel);
SDL_GetRGB(src_color, format, &r, &g, &b);
dst_data[i*image->w*3+j*3] = (float)r / 255.0f;
dst_data[i*image->w*3+j*3+1] = (float)g / 255.0f;
dst_data[i*image->w*3+j*3+2] = (float)b / 255.0f;
}
}
SDL_UnlockSurface(image);
SDL_FreeSurface(image);
/* Generate mipmaps */
er_generate_mipmaps(tex);
int error = er_get_error();
if(error != ER_NO_ERROR){
fprintf(stderr, "%s\n",er_get_error_string(error));
quit();
}
/* Create program for texture */
prog = er_create_program();
if(prog == NULL){
fprintf(stderr, "Unable to create eduraster program: %s\n", er_get_error_string(er_get_error()));
quit();
}
er_use_program(prog);
er_varying_attributes(prog, 2);
er_load_vertex_shader(prog, vs_cube);
er_load_homogeneous_division(prog, hd_cube);
er_load_fragment_shader(prog, fs_cube);
er_uniform_texture_ptr(prog, 0, tex);
/* Enable backface culling */
er_cull_face(ER_BACK);
er_enable(ER_CULL_FACE, ER_TRUE);
}
