bool CgShaderProgramGL::setConstant(const io::stringc &Name, const f32* Buffer, s32 Count)
{
    if (!Buffer)
        return false;

    /* Get top-level parameter */
    CGparameter Param = cgGetNamedParameter(cgProgram_, Name.c_str());

    if (!Param)
        return false;

    /* Get array parameter */
    if (cgGetParameterType(Param) != CG_ARRAY)
        return false;

    s32 ArraySize = cgGetArraySize(Param, 0);

    for (s32 i = 0; i < ArraySize; ++i)
    {
        /* Get array element parameter */
        CGparameter ElementParam = cgGetArrayParameter(Param, i);

        switch (cgGetParameterType(ElementParam))
        {
        case CG_FLOAT:
            cgGLSetParameterArray1f(Param, 0, Count, Buffer);
            return true;
        case CG_FLOAT2:
            cgGLSetParameterArray2f(Param, 0, Count/2, Buffer);
            return true;
        case CG_FLOAT3:
            cgGLSetParameterArray3f(Param, 0, Count/3, Buffer);
            return true;
        case CG_FLOAT4:
            cgGLSetParameterArray4f(Param, 0, Count/4, Buffer);
            return true;
        case CG_FLOAT4x4:
            cgGLSetMatrixParameterArrayfc(Param, 0, Count/16, Buffer);
            return true;

        case CG_STRUCT:
        {
            /* Get structure field parameter */
            CGparameter FieldParam = cgGetFirstStructParameter(ElementParam);

            while (FieldParam)
            {
                switch (cgGetParameterType(FieldParam))
                {
                case CG_FLOAT:
                    cgGLSetParameter1f(FieldParam, *Buffer);
                    Buffer += 1;
                    break;
                case CG_FLOAT2:
                    cgGLSetParameter2fv(FieldParam, Buffer);
                    Buffer += 2;
                    break;
                case CG_FLOAT3:
                    cgGLSetParameter3fv(FieldParam, Buffer);
                    Buffer += 3;
                    break;
                case CG_FLOAT4:
                    cgGLSetParameter4fv(FieldParam, Buffer);
                    Buffer += 4;
                    break;
                case CG_FLOAT4x4:
                    cgGLSetMatrixParameterfc(FieldParam, Buffer);
                    Buffer += 16;
                    break;
                case CG_INT:
                    cgSetParameter1i(FieldParam, *((s32*)Buffer));
                    Buffer += 1;
                    break;
                default:
                    break;
                }

                FieldParam = cgGetNextParameter(FieldParam);
            }
        }
        break;

        default:
            break;
        }
    }

    return true;
}
예제 #2
0
static void gl_cg_set_uniform_parameter(
      void *data,
      struct uniform_info *param,
      void *uniform_data)
{
   CGparameter location;
   cg_shader_data_t *cg        = (cg_shader_data_t*)data;

   if (!param || !param->enabled)
      return;

   if (param->lookup.enable)
   {
      char ident[64];
      CGprogram prog = 0;

      switch (param->lookup.type)
      {
         case SHADER_PROGRAM_VERTEX:
            prog = cg->prg[param->lookup.idx].vprg;
            break;
         case SHADER_PROGRAM_FRAGMENT:
         default:
            prog = cg->prg[param->lookup.idx].fprg;
            break;
      }

      if (param->lookup.add_prefix)
         snprintf(ident, sizeof(ident), "IN.%s", param->lookup.ident);
      location = cgGetNamedParameter(prog, param->lookup.add_prefix ? ident : param->lookup.ident);
   }
   else
   {
      struct uniform_cg *cg_param = (struct uniform_cg*)uniform_data;
      location = cg_param->loc;
   }

   switch (param->type)
   {
      case UNIFORM_1F:
         cgGLSetParameter1f(location, param->result.f.v0);
         break;
      case UNIFORM_2F:
         cgGLSetParameter2f(location, param->result.f.v0, param->result.f.v1);
         break;
      case UNIFORM_3F:
         cgGLSetParameter3f(location, param->result.f.v0, param->result.f.v1,
               param->result.f.v2);
         break;
      case UNIFORM_4F:
         cgGLSetParameter4f(location, param->result.f.v0, param->result.f.v1,
               param->result.f.v2, param->result.f.v3);
         break;
      case UNIFORM_1FV:
         cgGLSetParameter1fv(location, param->result.floatv);
         break;
      case UNIFORM_2FV:
         cgGLSetParameter2fv(location, param->result.floatv);
         break;
      case UNIFORM_3FV:
         cgGLSetParameter3fv(location, param->result.floatv);
         break;
      case UNIFORM_4FV:
         cgGLSetParameter3fv(location, param->result.floatv);
         break;
      case UNIFORM_1I:
         /* Unimplemented - Cg limitation */
         break;
   }
}