C++ VG_RETURN函数代码示例

VG_API_CALL void vgLoadMatrix(const VGfloat * mm)
{
    SHMatrix3x3 *m;
    VG_GETCONTEXT(VG_NO_RETVAL);

    VG_RETURN_ERR_IF(!mm, VG_ILLEGAL_ARGUMENT_ERROR, VG_NO_RETVAL);
    /* TODO: check matrix array alignment */

    m = shCurrentMatrix(context);

    if (context->matrixMode == VG_MATRIX_IMAGE_USER_TO_SURFACE) {

        SETMAT((*m),
               mm[0], mm[3], mm[6],
               mm[1], mm[4], mm[7],
               mm[2], mm[5], mm[8]);
    } else {

        SETMAT((*m),
               mm[0], mm[3], mm[6],
               mm[1], mm[4], mm[7],
               0.0f,  0.0f,  1.0f);
    }

    VG_RETURN(VG_NO_RETVAL);
}

VG_API_CALL void vgResizeSurfaceSH(VGint width, VGint height)
{
  VG_GETCONTEXT(VG_NO_RETVAL);
  
  /* update surface info */
  context->surfaceWidth = width;
  context->surfaceHeight = height;
  
  /* setup GL projection */
  
#ifdef ANDROIDVG
	glViewport(0,0,width,height);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glOrthof(0,(GLfloat) width,0,(GLfloat) height, -1, 1);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
#else
	glViewport(0,0,width,height);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluOrtho2D(0,width,0,height);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
#endif
  
  VG_RETURN(VG_NO_RETVAL);
}

VG_API_CALL VGint vgGetVectorSize(VGParamType type)
{
  int retval = 0;
  VG_GETCONTEXT(retval);
  
  switch(type)
  {
  case VG_MATRIX_MODE:
  case VG_FILL_RULE:
  case VG_IMAGE_QUALITY:
  case VG_RENDERING_QUALITY:
  case VG_BLEND_MODE:
  case VG_IMAGE_MODE:
  case VG_STROKE_CAP_STYLE:
  case VG_STROKE_JOIN_STYLE:
  case VG_PIXEL_LAYOUT:
  case VG_FILTER_CHANNEL_MASK:
  case VG_FILTER_FORMAT_LINEAR:
  case VG_FILTER_FORMAT_PREMULTIPLIED:
  case VG_STROKE_DASH_PHASE_RESET:
  case VG_MASKING:
  case VG_SCISSORING:
  case VG_STROKE_LINE_WIDTH:
  case VG_STROKE_MITER_LIMIT:
  case VG_STROKE_DASH_PHASE:
  case VG_MAX_SCISSOR_RECTS:
  case VG_MAX_DASH_COUNT:
  case VG_MAX_KERNEL_SIZE:
  case VG_MAX_SEPARABLE_KERNEL_SIZE:
  case VG_MAX_COLOR_RAMP_STOPS:
  case VG_MAX_IMAGE_WIDTH:
  case VG_MAX_IMAGE_HEIGHT:
  case VG_MAX_IMAGE_PIXELS:
  case VG_MAX_IMAGE_BYTES:
  case VG_MAX_FLOAT:
  case VG_MAX_GAUSSIAN_STD_DEVIATION:
    retval = 1;
    break;
    
  case VG_TILE_FILL_COLOR:
  case VG_CLEAR_COLOR:
    retval = 4;
    break;
    
  case VG_STROKE_DASH_PATTERN:
    retval = context->strokeDashPattern.size;
    break;
    
  case VG_SCISSOR_RECTS:
    retval = context->scissor.size * 4;
    break;
    
  default:
    /* Invalid VGParamType */
    VG_RETURN_ERR(VG_ILLEGAL_ARGUMENT_ERROR, retval);
  }
  
  VG_RETURN(retval);
}

VG_API_CALL const VGubyte * vgGetString(VGStringID name)
{
  VG_GETCONTEXT(NULL);
  
  switch(name) {
  case VG_VENDOR:
    VG_RETURN((const VGubyte*)context->vendor);
  case VG_RENDERER:
    VG_RETURN((const VGubyte*)context->renderer);
  case VG_VERSION:
    VG_RETURN((const VGubyte*)context->version);
  case VG_EXTENSIONS:
    VG_RETURN((const VGubyte*)context->extensions);
  default:
    VG_RETURN(NULL);
  }
}

VG_API_CALL VGErrorCode vgGetError(void)
{
    VGErrorCode error;
    VG_GETCONTEXT(VG_NO_CONTEXT_ERROR);
    error = context->error;
    context->error = VG_NO_ERROR;
    VG_RETURN(error);
}

VG_API_CALL void vgTranslate(VGfloat tx, VGfloat ty)
{
    SHMatrix3x3 *m;
    VG_GETCONTEXT(VG_NO_RETVAL);

    m = shCurrentMatrix(context);
    TRANSLATEMATR((*m), tx, ty);

    VG_RETURN(VG_NO_RETVAL);
}

VG_API_CALL void vgShear(VGfloat shx, VGfloat shy)
{
    SHMatrix3x3 *m;
    VG_GETCONTEXT(VG_NO_RETVAL);

    m = shCurrentMatrix(context);
    SHEARMATR((*m), shx, shy);

    VG_RETURN(VG_NO_RETVAL);
}

VG_API_CALL void vgLoadIdentity(void)
{
    SHMatrix3x3 *m;
    VG_GETCONTEXT(VG_NO_RETVAL);

    m = shCurrentMatrix(context);
    IDMAT((*m));

    VG_RETURN(VG_NO_RETVAL);
}

VG_API_CALL void vgGetiv(VGParamType type, VGint count, VGint * values)
{
  VG_GETCONTEXT(VG_NO_RETVAL);
  
  /* TODO: check output array alignment */
  
  /* Error code will be set by shGet */
  shGet(context, type, count, values, 0);
  VG_RETURN(VG_NO_RETVAL);
}

VG_API_CALL void vgScale(VGfloat sx, VGfloat sy)
{
    SHMatrix3x3 *m;
    VG_GETCONTEXT(VG_NO_RETVAL);

    m = shCurrentMatrix(context);
    SCALEMATR((*m), sx, sy);

    VG_RETURN(VG_NO_RETVAL);
}

VG_API_CALL void vgSetfv(VGParamType type, VGint count,
                         const VGfloat * values)
{
  VG_GETCONTEXT(VG_NO_RETVAL);
  
  /* TODO: check input array alignment */
  
  /* Error code will be set by shSet */
  shSet(context, type, count, values, 1);
  VG_RETURN(VG_NO_RETVAL);
}

VG_API_CALL void vgRotate(VGfloat angle)
{
    SHfloat a;
    SHMatrix3x3 *m;
    VG_GETCONTEXT(VG_NO_RETVAL);

    a = SH_DEG2RAD(angle);
    m = shCurrentMatrix(context);
    ROTATEMATR((*m), a);

    VG_RETURN(VG_NO_RETVAL);
}

VG_API_CALL void vgSeti (VGParamType type, VGint value)
{
  VG_GETCONTEXT(VG_NO_RETVAL);
  
  /* Check if target vector */
  VG_RETURN_ERR_IF(shIsParamVector(type),
                   VG_ILLEGAL_ARGUMENT_ERROR,
                   VG_NO_RETVAL);
  
  /* Error code will be set by shSet */
  shSet(context, type, 1, &value, 0);
  VG_RETURN(VG_NO_RETVAL);
}

VG_API_CALL VGint vgGeti(VGParamType type)
{
  VGint retval = 0;
  VG_GETCONTEXT(retval);
  
  /* Check if target vector */
  VG_RETURN_ERR_IF(shIsParamVector(type),
                   VG_ILLEGAL_ARGUMENT_ERROR,
                   retval);
  
  /* Error code will be set by shGet */
  shGet(context, type, 1, &retval, 0);
  VG_RETURN(retval);
}

VG_API_CALL VGPaint vgCreatePaint(void)
{
  SHPaint *p = NULL;
  VG_GETCONTEXT(VG_INVALID_HANDLE);
  
  /* Create new paint object */
  SH_NEWOBJ(SHPaint, p);
  VG_RETURN_ERR_IF(!p, VG_OUT_OF_MEMORY_ERROR,
                   VG_INVALID_HANDLE);
  
  /* Add to resource list */
  shPaintArrayPushBack(&context->paints, p);
  
  VG_RETURN((VGPaint)p);
}