<?php
// gets file from repositories listed in repositories.list

// params: $filename (string, input), $depends (integer, input)
//         $status (integer, output)

// This script must be placed in "rayphp" sub-directory.

require("libfile.php");

$status=0; // sets status to "error", by default

//$filename="buggy.tri"; // used when debugging outside of Raydium

$repos=read_repositories_file("repositories.upload");

if($depends)
{
  $deps = depends_find($filename);
}
else
{
  $deps[] = $filename;
}

// for each file to upload
for($j=0;$j<count($deps);$j++)
{
  filename_cut($deps[$j],$file,$path);

  if(!file_exists($path.$file) || !is_readable($path.$file))
    {
      echo "Cannot upload '$path$file': file do not exist or invalid rights";
      continue;
    }

  echo "Using repositories to upload '$file' file...";
  
  // for each repository
  for($i=0;$i<count($repos);$i++)
    {
      $r = $repos[$i];
      if(valid_entry($r))
        {
          // http or ftp ?
          $type=parse_url($r);
          $type=$type["scheme"];
          
          if(($type=="ftp" ||
              $type=="ftps" )
             && ftp_upload($r,$path.$file,$file))
            {
              touch($path.$file);
              $status++;
              break;
            }
          
          if(($type=="http" ||
              $type=="https" )
             && http_upload($r,$path.$file,$file))
            {
              touch($path.$file);
              $status++;
              break;
            }   
        }
    }
}

if($status==count($deps))
{
  echo "All files uploaded ($status)";
  return;
}    

if($status==0)
{
  echo "No file uploaded";
  return;
}    

echo "Only $status/".count($deps)." file(s) uploaded";

?>
ag);
        return -1;
        }

    free(str_vert);
    free(str_frag);

    raydium_shader_shaders[i].prog=glCreateProgramObjectARB();
    glAttachObjectARB(raydium_shader_shaders[i].prog,raydium_shader_shaders[i].vert);
    glAttachObjectARB(raydium_shader_shaders[i].prog,raydium_shader_shaders[i].frag);

    glLinkProgramARB(raydium_shader_shaders[i].prog);
    glGetObjectParameterivARB(raydium_shader_shaders[i].prog,GL_OBJECT_LINK_STATUS_ARB,&ret);
    if(ret!=1)
        {
        raydium_log("shader: '%s': Linking FAILED",name);
        raydium_shader_infolog(raydium_shader_shaders[i].prog);
        glDeleteObjectARB(raydium_shader_shaders[i].vert);
        glDeleteObjectARB(raydium_shader_shaders[i].frag);
        glDeleteObjectARB(raydium_shader_shaders[i].prog);
        return -1;
        }

    curr=glGetHandleARB(GL_PROGRAM_OBJECT_ARB);
    glUseProgramObjectARB(raydium_shader_shaders[i].prog);
    raydium_shader_shaders[i].attrib_tangent=glGetAttribLocationARB(
                                             raydium_shader_shaders[i].prog,
                                             RAYDIUM_SHADER_TANGENT_ATTRIB_NAME);
    glUseProgramObjectARB(curr);

    raydium_shader_shaders[i].state=1;
    strcpy(raydium_shader_shaders[i].name,name);
    raydium_log("shader: shader %i (%s) loaded (%s,%s%s)",
                i,name,file_vert,file_frag,
                ((raydium_shader_shaders[i].attrib_tangent==-1)?"":",tangent"));
    return i;
    }

raydium_log("shader: Error: No more slots ! aborting \"%s\" creation",name);
return -1;
}

signed char raydium_shader_delete(int shader)
{
int i;

if(!raydium_shader_support)
    return 0;

if(!raydium_shader_isvalid(shader))
    {
    raydium_log("shader: cannot delete: Invalid shader index or name");
    return 0;
    }

glDetachObjectARB(raydium_shader_shaders[shader].prog,raydium_shader_shaders[shader].vert);
glDeleteObjectARB(raydium_shader_shaders[shader].vert);
glDetachObjectARB(raydium_shader_shaders[shader].prog,raydium_shader_shaders[shader].frag);
glDeleteObjectARB(raydium_shader_shaders[shader].frag);
glDeleteObjectARB(raydium_shader_shaders[shader].prog);
raydium_shader_shaders[shader].state=0;

// detach from texture
for(i=1;i<RAYDIUM_MAX_TEXTURES;i++)
    if(raydium_texture_used[i] && raydium_texture_shader[i]==shader)
        raydium_texture_shader[i]=-1;

return 1;
}

void raydium_shader_delete_all(void)
{
int i;

for(i=0;i<RAYDIUM_MAX_SHADERS;i++)
    if(raydium_shader_shaders[i].state)
        raydium_shader_delete(i);
}

int raydium_shader_variable(int shader, char *name)
{
int ret;

if(!raydium_shader_support)
    return -1;

if(!raydium_shader_isvalid(shader))
    {
    raydium_log("shader: cannot get variable: Invalid shader index or name");
    return -1;
    }

ret=glGetUniformLocationARB(raydium_shader_shaders[shader].prog,name);
if(ret<0)
    {
    raydium_log("shader: cannot get variable: Invalid variable name '%s'",name);
    return -1;
    }
return ret;
}

signed char raydium_shader_var_i(int var_id, int value)
{
if(!raydium_shader_support)
    return 0;

glUniform1iARB(var_id,value);
return 1;
}

signed char raydium_shader_var_i_name(char *shader, char *variable, int value)
{
signed char ret;
GLhandleARB curr;
int sid;

if(!raydium_shader_support)
    return 0;

curr=glGetHandleARB(GL_PROGRAM_OBJECT_ARB);
sid=raydium_shader_find(shader);
raydium_shader_current(sid);
ret=raydium_shader_var_i(raydium_shader_variable(sid,variable),value);
glUseProgramObjectARB(curr);
return ret;
}

signed char raydium_shader_var_fv(int var_id, int num,float value[])
{
if(!raydium_shader_support)
    return 0;

glUniform1fvARB(var_id,num,value);
return 1;
}

signed char raydium_shader_var_fv_name(char *shader, char *variable, int num, float value[])
{
signed char ret;
GLhandleARB curr;
int sid;

if(!raydium_shader_support)
    return 0;

curr=glGetHandleARB(GL_PROGRAM_OBJECT_ARB);
sid=raydium_shader_find(shader);
raydium_shader_current(sid);
ret=raydium_shader_var_fv(raydium_shader_variable(sid,variable),num,value);
glUseProgramObjectARB(curr);
return ret;
}

signed char raydium_shader_var_matrix4fv(int var_id, int num,int transpose,float value[])
{
if(!raydium_shader_support)
    return 0;

glUniformMatrix4fvARB(var_id,num,transpose,value);
return 1;
}

signed char raydium_shader_var_matrix4fv_name(char *shader, char *variable, int num, int transpose, float value[])
{
signed char ret;
GLhandleARB curr;
int sid;

if(!raydium_shader_support)
    return 0;

curr=glGetHandleARB(GL_PROGRAM_OBJECT_ARB);
sid=raydium_shader_find(shader);
raydium_shader_current(sid);
ret=raydium_shader_var_matrix4fv(raydium_shader_variable(sid,variable),num,transpose,value);
glUseProgramObjectARB(curr);
return ret;
}

signed char raydium_shader_var_f(int var_id, float value)
{
if(!raydium_shader_support)
    return 0;

glUniform1fARB(var_id,value);
return 1;
}

signed char raydium_shader_var_f_name(char *shader, char *variable, float value)
{
signed char ret;
GLhandleARB curr;
int sid;

if(!raydium_shader_support)
    return 0;

curr=glGetHandleARB(GL_PROGRAM_OBJECT_ARB);
sid=raydium_shader_find(shader);
raydium_shader_current(sid);
ret=raydium_shader_var_f(raydium_shader_variable(sid,variable),value);
glUseProgramObjectARB(curr);
return ret;
}

signed char raydium_shader_var_2f(int var_id, float value1, float value2)
{
if(!raydium_shader_support)
    return 0;

glUniform2fARB(var_id,value1,value2);
return 1;
}

signed char raydium_shader_var_2f_name(char *shader, char *variable, float value1, float value2)
{
signed char ret;
GLhandleARB curr;
int sid;

if(!raydium_shader_support)
    return 0;

curr=glGetHandleARB(GL_PROGRAM_OBJECT_ARB);
sid=raydium_shader_find(shader);
raydium_shader_current(sid);
ret=raydium_shader_var_2f(raydium_shader_variable(sid,variable),value1,value2);
glUseProgramObjectARB(curr);
return ret;
}

signed char raydium_shader_var_3f(int var_id, float value1, float value2, float value3)
{
if(!raydium_shader_support)
    return 0;

glUniform3fARB(var_id,value1,value2,value3);
return 1;
}

signed char raydium_shader_var_3f_name(char *shader, char *variable, float value1, float value2, float value3)
{
signed char ret;
GLhandleARB curr;
int sid;

if(!raydium_shader_support)
    return 0;

curr=glGetHandleARB(GL_PROGRAM_OBJECT_ARB);
sid=raydium_shader_find(shader);
raydium_shader_current(sid);
ret=raydium_shader_var_3f(raydium_shader_variable(sid,variable),value1,value2,value3);
glUseProgramObjectARB(curr);
return ret;
}

signed char raydium_shader_var_4f(int var_id, float value1, float value2, float value3, float value4)
{
if(!raydium_shader_support)
    return 0;

glUniform4fARB(var_id,value1,value2,value3,value4);
return 1;
}

signed char raydium_shader_var_4f_name(char *shader, char *variable, float value1, float value2, float value3, float value4)
{
signed char ret;
GLhandleARB curr;
int sid;

if(!raydium_shader_support)
    return 0;

curr=glGetHandleARB(GL_PROGRAM_OBJECT_ARB);
sid=raydium_shader_find(shader);
raydium_shader_current(sid);
ret=raydium_shader_var_4f(raydium_shader_variable(sid,variable),value1,value2,value3,value4);
glUseProgramObjectARB(curr);
return ret;
}


// -1 = off
signed char raydium_shader_current(int shader)
{
if(!raydium_shader_support)
    return 0;

raydium_shader_active=shader;

if(shader==-1)
    {
    glUseProgramObjectARB(0);
    return 1;
    }

if(!raydium_shader_isvalid(shader))
    {
    raydium_log("shader: cannot use shader: Invalid index or name");
    return 0;
    }

glUseProgramObjectARB(raydium_shader_shaders[shader].prog);
return 1;
}

signed char raydium_shader_current_name(char *shader)
{
return raydium_shader_current(raydium_shader_find(shader));
}

signed char raydium_shader_attach_texture(int shader, int texture)
{
if(shader!=-1 && !raydium_shader_isvalid(shader)) // -1 to disable shader
    {
    raydium_log("shader: cannot attach shader: Invalid shader");
    return 0;
    }
//if(texture<=0 || texture>=(int)raydium_texture_index)
if(!raydium_texture_is_slot_used(texture))
    {
    raydium_log("shader: cannot attach shader: Invalid texture");
    return 0;
    }
raydium_texture_shader[texture]=shader;
return 1;
}

signed char raydium_shader_attach_texture_name(char *shader, char *texture)
{
return raydium_shader_attach_texture(raydium_shader_find(shader),
                                     raydium_texture_find_by_name(texture));
}

void raydium_shader_internal_vertex_attributes(int i)
{
// shader with "tangent" attribute active ?
if(raydium_shader_support && raydium_shader_active>=0 &&
   raydium_shader_shaders[raydium_shader_active].attrib_tangent!=-1)
    {
     glVertexAttrib3fARB(raydium_shader_shaders[raydium_shader_active].attrib_tangent,
                         raydium_vertex_tangent_x(i),
                         raydium_vertex_tangent_y(i),
                         raydium_vertex_tangent_z(i));
     //printf("%f %f %f\n",raydium_vertex_tangent_x[i],raydium_vertex_tangent_y[i],raydium_vertex_tangent_z[i]);
    }
}