void CShTPSPlayer::Initialize(const CShIdentifier & levelIdentifier, CShTPSGun * defaultGun) { if (!m_bInitialized) { m_bInitialized = true; // Load a sprite in 2D in the Sprite attribute m_pSprite = shNULL; m_pSprite = ShEntity2::Find(levelIdentifier, CShIdentifier(PLAYER_SPRITE_NAME)); float radius = CHARACTER_CONTROLLER_RADIUS_2D; // radius for the character controller if (shNULL == m_pSprite) // if no player sprite is on the map, one is created for 3D, to manage collision between invisible 2D stuff { m_pSprite = ShEntity2::Create(levelIdentifier, CShIdentifier("player_sprite_forced_2D"), GID(layer_default), CShIdentifier("tps"), CShIdentifier("player"), CShVector3(0.0f,0.0f,1.0f), CShEulerAngles(0.0f, 0.0f, 0.0f), CShVector3(1.0f, 1.0f, 1.0f)); } SH_ASSERT(shNULL != m_pSprite); m_pModel = shNULL; m_pModel = ShEntity3::Find(levelIdentifier, CShIdentifier(PLAYER_SPRITE_NAME)); if(shNULL != m_pModel) { m_3d = true; m_pAnimIdle = ShAnimation::Find(CShIdentifier(PLAYER_ANIM_IDLE)); SH_ASSERT(shNULL != m_pAnimIdle); m_pAnimRun = ShAnimation::Find(CShIdentifier(PLAYER_ANIM_RUN)); SH_ASSERT(shNULL != m_pAnimRun); /*m_pAnimAttack = ShAnimation::Find(CShIdentifier(PLAYER_ANIM_ATTACK)); SH_ASSERT(shNULL != m_pAnimAttack);*/ ShEntity3::AnimationPlay(m_pModel, m_pAnimIdle,true); radius= CHARACTER_CONTROLLER_RADIUS_3D; } else { m_3d = false; } if(m_3d) { ShObject::SetShow(m_pSprite, false); ShObject::SetShow(m_pModel, true); } else { ShObject::SetShow(m_pSprite, true); } CShTPSCharacter::Initialize(levelIdentifier, CShIdentifier(PLAYER_SPRITE_NAME), defaultGun); // Initialize the character controller with the level, the identifier, the position, the radius, the direction, the speed. ShCharacterController * pCharacterController = shNULL; pCharacterController = ShCharacterController::Create(levelIdentifier, CShIdentifier("character_controller_character_001"), m_Position, radius, m_Direction, m_Speed); m_pCharacterController = pCharacterController; SH_ASSERT(shNULL != m_pCharacterController); } else { Spawn(); } }
/** * Called when the plugin is started */ void CShPluginGame::OnPlayStart(void) { m_fScale = 1.0f; m_pBackground = ShEntity2::Find(m_levelIdentifier, CShIdentifier("sprite_tps_background")); SH_ASSERT(shNULL != m_pBackground); m_pPlayer = ShEntity2::Find(m_levelIdentifier, CShIdentifier("sprite_tps_player")); SH_ASSERT(shNULL != m_pPlayer); }
/** * Called after engine initialization */ void OnPostInitialize(void) { CShIdentifier levelIdentifier("memory"); bool loaded = ShLevel::Load(levelIdentifier); SH_ASSERT(loaded); // // Create Camera g_pCamera = ShCamera::Create(GID(global), GID(camera_free), false); SH_ASSERT(NULL != g_pCamera); ShCamera::SetPosition(g_pCamera, CShVector3(0, 0.0f, 1000.0f)); ShCamera::SetTarget(g_pCamera, CShVector3(0.0f, 0.0f, 0.0f)); ShCamera::SetFarPlaneDistance(g_pCamera, 3000.0f); ShCamera::SetViewport(g_pCamera, 256*WIDTH, 256*HEIGHT); ShCamera::SetProjectionOrtho(g_pCamera); ShCamera::SetCurrent2D(g_pCamera); ratio = CShVector2((256*WIDTH)/(float)ShDisplay::GetWidth(), (256*HEIGHT)/(float)ShDisplay::GetHeight()); g_pWinEntity = ShEntity2::Find(levelIdentifier, CShIdentifier("sprite_memory_win_001")); SH_ASSERT(shNULL != g_pWinEntity); ShEntity2::SetShow(g_pWinEntity, false); // // Create all sprites for (int i = 0; i < HEIGHT; ++i) { for (int j = 0; j < WIDTH; ++j) { CShVector3 pos; pos.m_x = (256.0f * j) - (128.0f + (((WIDTH/2)-1) * 256.0f)); pos.m_y = (256.0f * i) - (128.0f + (((HEIGHT/2)-1) * 256.0f)); int c = i*WIDTH+j; aCards[c].pEntityRecto = ShEntity2::Create(levelIdentifier, CShIdentifier(), GID(layer_default), CShIdentifier("memory"), aIdentifier[c/2], pos, CShEulerAngles(0.0f, 0.0f, 0.0f), CShVector3(1.0f, 1.0f, 1.0f)); SH_ASSERT(shNULL != aCards[c].pEntityRecto); aCards[c].pEntityVerso = ShEntity2::Create(levelIdentifier, CShIdentifier(), GID(layer_default), CShIdentifier("memory"), CShIdentifier("verso"), pos, CShEulerAngles(0.0f, 0.0f, 0.0f), CShVector3(1.0f, 1.0f, 1.0f)); SH_ASSERT(shNULL != aCards[c].pEntityVerso); aCards[c].type = c/2; } } for (int i = 0; i < PIECES; ++i) { ShEntity2::SetShow(aCards[i].pEntityRecto, false); } shuffle(); }
/** * Called after engine initialization */ void OnPostInitialize(void) { CShIdentifier levelIdentifier("character_controller"); // this is the level name // // Load level bool loaded = ShLevel::Load(levelIdentifier); SH_ASSERT(loaded); // // Create camera g_pCamera = ShCamera::Create(GID(global), GID(camera_free), false); SH_ASSERT(NULL != g_pCamera); ShCamera::SetPosition(g_pCamera, CShVector3(-300.0f,-1500.0f, 1000.0f)); ShCamera::SetTarget(g_pCamera, CShVector3(0.0f, 0.0f, 100.0f)); ShCamera::SetFarPlaneDistance(g_pCamera, 3000.0f); ShCamera::SetCurrent2D(g_pCamera); ShCamera::SetCurrent3D(g_pCamera); // // Find the character entity g_pCharacter = ShEntity3::Find(levelIdentifier, CShIdentifier("entitypc_warrior")); SH_ASSERT(shNULL != g_pCharacter); // // Initialize the character controller with the level, the identifier, the position, the radius, the direction, the speed. g_pCharacterController = ShCharacterController::Create(levelIdentifier, CShIdentifier("character_controller_character_001"), ShObject::GetPosition2(g_pCharacter), 50.0, g_direction, g_speed); SH_ASSERT(shNULL != g_pCharacterController); // // Create the moving input (arrow up). // Using JustPressed function in order to change each time the button is pressed and not continuously. g_pInputUp = ShInput::CreateInputPressed(ShInput::e_input_device_keyboard, ShInput::e_input_device_control_pc_key_up, 0.1f); SH_ASSERT(shNULL != g_pInputUp); // // Create the rotation inputs (right and left). // Using InputPressed function in order to change until the button is released. g_pInputLeft = ShInput::CreateInputPressed(ShInput::e_input_device_keyboard, ShInput::e_input_device_control_pc_key_left, 0.1f); SH_ASSERT(NULL != g_pInputLeft); g_pInputRight = ShInput::CreateInputPressed(ShInput::e_input_device_keyboard, ShInput::e_input_device_control_pc_key_right, 0.1f); SH_ASSERT(NULL != g_pInputRight); // Find tyhe two animations : warrior idle and warrior run. pAnimationWarriorStop = ShAnimation::Find(CShIdentifier("pc_warrior.pc_warrior.idle.01")); SH_ASSERT(NULL != pAnimationWarriorStop); pAnimationWarriorRun = ShAnimation::Find(CShIdentifier("pc_warrior.pc_warrior.run.01")); SH_ASSERT(NULL != pAnimationWarriorRun); // By default, we play the idle animation, allowing it to loop. ShEntity3::AnimationPlay(g_pCharacter, pAnimationWarriorStop, true); }
void CShTPSEnemy::Initialize(const CShIdentifier & levelIdentifier, const CShIdentifier & characterIdentifier, CShTPSGun * defaultGun, ShEntity2 * sprite, CShString enemyCharacterControlleridentifier, ShEntity3 * model) { if(!m_bInitialized) { m_bInitialized = false; if (model != shNULL) { m_pModel = model; m_3d = true; } m_pSprite = sprite; SH_ASSERT(shNULL != m_pSprite); if (m_3d) { ShObject::SetShow(m_pSprite, false); ShObject::SetShow(m_pModel, true); } else { ShObject::SetShow(m_pSprite, true); } float radius = CHARACTER_CONTROLLER_RADIUS_2D; if(m_3d) { m_pAnimIdle = ShAnimation::Find(CShIdentifier(ENEMY_ANIM_IDLE)); SH_ASSERT(shNULL != m_pAnimIdle); m_pAnimRun = ShAnimation::Find(CShIdentifier(ENEMY_ANIM_RUN)); SH_ASSERT(shNULL != m_pAnimRun); /*m_pAnimAttack = ShAnimation::Find(CShIdentifier(ENEMY_ANIM_ATTACK)); SH_ASSERT(shNULL != m_pAnimAttack);*/ ShEntity3::AnimationPlay(m_pModel, m_pAnimIdle,true); radius= CHARACTER_CONTROLLER_RADIUS_3D; } CShTPSCharacter::Initialize(levelIdentifier,characterIdentifier, defaultGun); // Initialize the character controller with the level, the identifier, the position, the radius, the direction, the speed. ShCharacterController * pCharacterController = shNULL; pCharacterController = ShCharacterController::Create(levelIdentifier, CShIdentifier(enemyCharacterControlleridentifier), m_Position, radius, m_Direction, m_Speed); m_pCharacterController = pCharacterController; SH_ASSERT(shNULL != m_pCharacterController); m_Target = m_Position; } }
/*virtual*/ void GameStateIntro::OnInitialize() { ShLevel::Load(m_levelIdentifier); GameStateManager::SetMultiresolution(m_levelIdentifier); nextBtn = ShEntity2::Find(m_levelIdentifier, CShIdentifier("next")); for(int i = 0; i < 2; ++i) { CShString id; if(i < 10) { id = CShString("ecran0") + CShString::FromInt(i+1); } else { id = CShString("ecran") + CShString::FromInt(i+1); } ShEntity2* fond = ShEntity2::Find(m_levelIdentifier, CShIdentifier(id)); SH_ASSERT(NULL != fond); ecrans.Add(fond); } m_cursor = ShEntity2::Create( m_levelIdentifier, CShIdentifier("cursor"), CShIdentifier("layer_default"), CShIdentifier("ggj"), CShIdentifier("cursor"), CShVector3(), CShEulerAngles(), CShVector3(1.0f, 1.0f, 1.0f)); ShEntity2::SetPivotTopLeft(m_cursor); }
//-------------------------------------------------------------------------------------------------- /// @todo comment //-------------------------------------------------------------------------------------------------- void Game::Push(EState state) { SH_ASSERT(m_iCurrentState < MAX_GAME_STATES); if (m_iCurrentState >= 0) { m_aStates[m_iCurrentState]->Obscuring(); } ++m_iCurrentState; m_aStates[m_iCurrentState] = get(state); m_aStates[m_iCurrentState]->Entered(); }
//-------------------------------------------------------------------------------------------------- /// @todo comment //-------------------------------------------------------------------------------------------------- void Game::Pop(void) { SH_ASSERT(m_iCurrentState >= 0); m_aStates[m_iCurrentState]->Exiting(); #if SH_DEBUG m_aStates[m_iCurrentState] = nullptr; #endif --m_iCurrentState; if (m_iCurrentState >= 0) { m_aStates[m_iCurrentState]->Revealed(); } }
void shUpdateColorRampTexture(SHPaint *p) { SHint s=0; SHStop *stop1, *stop2; SHfloat rgba[SH_GRADIENT_TEX_COORDSIZE]; SHint x1=0, x2=0, dx, x; SHColor dc, c; SHfloat k; /* Write first pixel color */ stop1 = &p->stops.items[0]; CSTORE_RGBA1D_F(stop1->color, rgba, x1); /* Walk stops */ for (s=1; s<p->stops.size; ++s, x1=x2, stop1=stop2) { /* Pick next stop */ stop2 = &p->stops.items[s]; x2 = (SHint)(stop2->offset * (SH_GRADIENT_TEX_SIZE-1)); SH_ASSERT(x1 >= 0 && x1 < SH_GRADIENT_TEX_SIZE && x2 >= 0 && x2 < SH_GRADIENT_TEX_SIZE && x1 <= x2); dx = x2 - x1; CSUBCTO(stop2->color, stop1->color, dc); /* Interpolate inbetween */ for (x=x1+1; x<=x2; ++x) { k = (SHfloat)(x-x1)/dx; CSETC(c, stop1->color); CADDCK(c, dc, k); CSTORE_RGBA1D_F(c, rgba, x); } } /* Update texture image */ glBindTexture(GL_TEXTURE_1D, p->texture); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glTexSubImage1D(GL_TEXTURE_1D, 0, 0, SH_GRADIENT_TEX_SIZE, GL_RGBA, GL_FLOAT, rgba); }
static int checkExtension(const char *extensions, const char *name) { int nlen = (int)strlen(name); int elen = (int)strlen(extensions); const char *e = extensions; SH_ASSERT(nlen > 0); while (1) { /* Try to find sub-string */ e = strstr(e, name); if (e == NULL) return 0; /* Check if last */ if (e == extensions + elen - nlen) return 1; /* Check if space follows (avoid same names with a suffix) */ if (*(e + nlen) == ' ') return 1; e += nlen; } return 0; }
/** * Called when the plugin is started */ void CShPluginTranslate::OnPlayStart(void) { CShArray<ShEntity2*> aEntity; // Get Every Entity2 in the level ShEntity2::GetEntity2Array(m_levelIdentifier, aEntity); // Loop through every every Entity2 int entityCount = aEntity.GetCount(); for (int i = 0; i < entityCount; ++i) { STranslatingEntity elmt; elmt.entity = aEntity[i]; // Loop through every DataSet int dataSetCount = ShEntity2::GetDataSetCount(elmt.entity); for (int i = 0; i < dataSetCount; ++i) { ShDataSet * pDataSet = ShEntity2::GetDataSet(elmt.entity, i); // Check this is a "rotation" DataSet const CShIdentifier & dataSetIdentifier = ShDataSet::GetDataSetIdentifier(pDataSet); if (dataSetIdentifier == dataSetTranslateIdentifier) { // check count int count = ShDataSet::GetDataCount(pDataSet); SH_ASSERT(1 == count); // Get the velocity from the dataset ShDataSet::GetDataValue(pDataSet, 0, elmt.velocity); // Add the element in the array of entity to rotate m_aTranslatingEntities.Add(elmt); } } } }
/** * Called after engine initialization */ void Game::OnPostInitialize(void) { instance(); instance_->m_registeredAction.action = e_action_none; // Create the Camera ShCamera * pCamera = ShCamera::Create(GID(global), GID(camera), false); SH_ASSERT(shNULL != pCamera); ShCamera::SetPosition(pCamera, CShVector3(0.0f, 0.0f, 100.0f)); ShCamera::SetTarget(pCamera, CShVector3(0.0f, 0.0f, 0.0f)); ShCamera::SetUp(pCamera, CShVector3(0.0f, 1.0f, 0.0f)); ShCamera::SetProjectionOrtho(pCamera); ShCamera::SetNearPlaneDistance(pCamera, 0.0f); ShCamera::SetFarPlaneDistance(pCamera, 200.0f); instance_->m_fRescaleRatio = ShDisplay::GetHeight() / (float)ShDisplay::GetWidth(); ShCamera::SetViewport(pCamera, DISPLAY_WIDTH, DISPLAY_WIDTH * instance_->m_fRescaleRatio); ShCamera::SetCurrent2D(pCamera); // Initialize Sound instance_->m_sound.Initialize(); // Initialize Transition instance_->m_transition.Initialize(); // Initialize states instance_->m_stateMainMenu.Initialize(); instance_->m_stateCredits.Initialize(); instance_->m_stateGame.Initialize(); instance_->Push(MENU); }
static void shSetParameter(VGContext *context, VGHandle object, SHResourceType rtype, VGint ptype, SHint count, const void *values, SHint floats) { SHfloat fvalue = 0.0f; SHint ivalue = 0; VGboolean bvalue = VG_FALSE; int i; /* Check for negative count */ SH_RETURN_ERR_IF(count<0, VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); /* Check for empty vector */ SH_RETURN_ERR_IF(!values && count!=0, VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); /* Pre-convert first value for non-vector params */ if (count == 1) { fvalue = shParamToFloat(values, floats, 0); ivalue = shParamToInt(values, floats, 0); bvalue = (ivalue ? VG_TRUE : VG_FALSE); } switch (rtype) { case SH_RESOURCE_PATH: switch (ptype) { /* Path parameters */ case VG_PATH_FORMAT: case VG_PATH_DATATYPE: case VG_PATH_SCALE: case VG_PATH_BIAS: case VG_PATH_NUM_SEGMENTS: case VG_PATH_NUM_COORDS: /* Read-only */ break; default: /* Invalid VGParamType */ SH_RETURN_ERR(VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); } break; case SH_RESOURCE_PAINT: switch (ptype) { /* Paint parameters */ case VG_PAINT_TYPE: SH_RETURN_ERR_IF(count != 1, VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); SH_RETURN_ERR_IF(!shIsEnumValid(ptype,ivalue), VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); ((SHPaint*)object)->type = (VGPaintType)ivalue; break; case VG_PAINT_COLOR: SH_RETURN_ERR_IF(count != 4, VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); ((SHPaint*)object)->color.r = shParamToFloat(values, floats, 0); ((SHPaint*)object)->color.g = shParamToFloat(values, floats, 1); ((SHPaint*)object)->color.b = shParamToFloat(values, floats, 2); ((SHPaint*)object)->color.a = shParamToFloat(values, floats, 3); break; case VG_PAINT_COLOR_RAMP_SPREAD_MODE: SH_RETURN_ERR_IF(count != 1, VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); SH_RETURN_ERR_IF(!shIsEnumValid(ptype,ivalue), VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); ((SHPaint*)object)->spreadMode = (VGColorRampSpreadMode)ivalue; break; case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: SH_RETURN_ERR_IF(count != 1, VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); SH_RETURN_ERR_IF(!shIsEnumValid(ptype,ivalue), VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); ((SHPaint*)object)->premultiplied = (VGboolean)ivalue; break; case VG_PAINT_COLOR_RAMP_STOPS: { int max; SHPaint *paint; SHStop stop; SH_RETURN_ERR_IF(count % 5, VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); max = SH_MIN(count, SH_MAX_COLOR_RAMP_STOPS * 5); paint = (SHPaint*)object; shStopArrayClear(&paint->instops); for (i=0; i<max; i+=5) { stop.offset = shParamToFloat(values, floats, i+0); CSET(stop.color, shParamToFloat(values, floats, i+1), shParamToFloat(values, floats, i+2), shParamToFloat(values, floats, i+3), shParamToFloat(values, floats, i+4)); shStopArrayPushBackP(&paint->instops, &stop); } shValidateInputStops(paint); break;} case VG_PAINT_LINEAR_GRADIENT: SH_RETURN_ERR_IF(count != 4, VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); for (i=0; i<4; ++i) ((SHPaint*)object)->linearGradient[i] = shParamToFloat(values, floats, i); break; case VG_PAINT_RADIAL_GRADIENT: SH_RETURN_ERR_IF(count != 5, VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); for (i=0; i<5; ++i) ((SHPaint*)object)->radialGradient[i] = shParamToFloat(values, floats, i); break; case VG_PAINT_PATTERN_TILING_MODE: SH_RETURN_ERR_IF(count != 1, VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); SH_RETURN_ERR_IF(!shIsEnumValid(ptype,ivalue), VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); ((SHPaint*)object)->tilingMode = (VGTilingMode)ivalue; break; default: /* Invalid VGParamType */ SH_RETURN_ERR(VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); } break; case SH_RESOURCE_IMAGE: switch (ptype) {/* Image parameters */ case VG_IMAGE_FORMAT: case VG_IMAGE_WIDTH: case VG_IMAGE_HEIGHT: /* Read-only */ break; default: /* Invalid VGParamType */ SH_RETURN_ERR(VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); } break; default: /* Invalid resource handle */ SH_ASSERT(rtype!=SH_RESOURCE_INVALID); break; } SH_RETURN(SH_NO_RETVAL); }
VG_API_CALL VGint vgGetParameterVectorSize(VGHandle object, VGint ptype) { int retval = 0; SHResourceType rtype; VG_GETCONTEXT(retval); /* Validate object */ rtype = shGetResourceType(context, object); VG_RETURN_ERR_IF(rtype == SH_RESOURCE_INVALID, VG_BAD_HANDLE_ERROR, retval); switch (rtype) { case SH_RESOURCE_PATH: switch (ptype) { /* Path parameters */ case VG_PATH_FORMAT: case VG_PATH_DATATYPE: case VG_PATH_SCALE: case VG_PATH_BIAS: case VG_PATH_NUM_SEGMENTS: case VG_PATH_NUM_COORDS: retval = 1; break; default: /* Invalid VGParamType */ VG_RETURN_ERR(VG_ILLEGAL_ARGUMENT_ERROR, retval); } break; case SH_RESOURCE_PAINT: switch (ptype) { /* Paint parameters */ case VG_PAINT_TYPE: retval = 1; break; case VG_PAINT_COLOR: retval = 4; break; case VG_PAINT_COLOR_RAMP_SPREAD_MODE: retval = 1; break; case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: retval = 1; break; case VG_PAINT_COLOR_RAMP_STOPS: retval = ((SHPaint*)object)->stops.size*5; break; case VG_PAINT_LINEAR_GRADIENT: retval = 4; break; case VG_PAINT_RADIAL_GRADIENT: retval = 5; break; case VG_PAINT_PATTERN_TILING_MODE: retval = 1; break; default: /* Invalid VGParamType */ VG_RETURN_ERR(VG_ILLEGAL_ARGUMENT_ERROR, retval); } break; case SH_RESOURCE_IMAGE: switch (ptype) { /* Image parameters */ case VG_IMAGE_FORMAT: case VG_IMAGE_WIDTH: case VG_IMAGE_HEIGHT: retval = 1; break; default: /* Invalid VGParamType */ VG_RETURN_ERR(VG_ILLEGAL_ARGUMENT_ERROR, retval); } break; default: /* Invalid resource handle */ SH_ASSERT(rtype!=SH_RESOURCE_INVALID); break; } VG_RETURN(retval); }
static void shGetParameter(VGContext *context, VGHandle object, SHResourceType rtype, VGint ptype, SHint count, void *values, SHint floats) { int i; /* Check for invalid array / count */ SH_RETURN_ERR_IF(!values || count<=0, VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); switch (rtype) { case SH_RESOURCE_PATH: switch (ptype) { /* Path parameters */ case VG_PATH_FORMAT: SH_RETURN_ERR_IF(count != 1, VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); shIntToParam(((SHPath*)object)->format, count, values, floats, 0); break; case VG_PATH_DATATYPE: SH_RETURN_ERR_IF(count != 1, VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); shIntToParam(((SHPath*)object)->datatype, count, values, floats, 0); break; case VG_PATH_SCALE: SH_RETURN_ERR_IF(count != 1, VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); shFloatToParam(((SHPath*)object)->scale, count, values, floats, 0); break; case VG_PATH_BIAS: SH_RETURN_ERR_IF(count != 1, VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); shFloatToParam(((SHPath*)object)->bias, count, values, floats, 0); break; case VG_PATH_NUM_SEGMENTS: SH_RETURN_ERR_IF(count != 1, VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); shIntToParam(((SHPath*)object)->segCount, count, values, floats, 0); break; case VG_PATH_NUM_COORDS: SH_RETURN_ERR_IF(count != 1, VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); shIntToParam(((SHPath*)object)->dataCount, count, values, floats, 0); break; default: /* Invalid VGParamType */ SH_RETURN_ERR(VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); } break; case SH_RESOURCE_PAINT: switch (ptype) { /* Paint parameters */ case VG_PAINT_TYPE: SH_RETURN_ERR_IF(count != 1, VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); shIntToParam(((SHPaint*)object)->type, count, values, floats, 0); break; case VG_PAINT_COLOR: SH_RETURN_ERR_IF(count > 4, VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); shFloatToParam(((SHPaint*)object)->color.r, count, values, floats, 0); shFloatToParam(((SHPaint*)object)->color.g, count, values, floats, 1); shFloatToParam(((SHPaint*)object)->color.b, count, values, floats, 2); shFloatToParam(((SHPaint*)object)->color.a, count, values, floats, 3); break; case VG_PAINT_COLOR_RAMP_SPREAD_MODE: SH_RETURN_ERR_IF(count != 1, VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); shIntToParam(((SHPaint*)object)->spreadMode, count, values, floats, 0); break; case VG_PAINT_COLOR_RAMP_PREMULTIPLIED: SH_RETURN_ERR_IF(count != 1, VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); shIntToParam(((SHPaint*)object)->spreadMode, count, values, floats, 0); break; case VG_PAINT_COLOR_RAMP_STOPS:{ int i; SHPaint* paint = (SHPaint*)object; SHStop *stop; SH_RETURN_ERR_IF(count > paint->stops.size * 5, VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); for (i=0; i<paint->stops.size; ++i) { stop = &paint->stops.items[i]; shFloatToParam(stop->offset, count, values, floats, i*5+0); shFloatToParam(stop->color.r, count, values, floats, i*5+1); shFloatToParam(stop->color.g, count, values, floats, i*5+2); shFloatToParam(stop->color.b, count, values, floats, i*5+3); shFloatToParam(stop->color.a, count, values, floats, i*5+4); } break;} case VG_PAINT_LINEAR_GRADIENT: SH_RETURN_ERR_IF(count > 4, VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); for (i=0; i<4; ++i) shFloatToParam(((SHPaint*)object)->linearGradient[i], count, values, floats, i); break; case VG_PAINT_RADIAL_GRADIENT: SH_RETURN_ERR_IF(count > 5, VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); for (i=0; i<5; ++i) shFloatToParam(((SHPaint*)object)->radialGradient[i], count, values, floats, i); break; case VG_PAINT_PATTERN_TILING_MODE: SH_RETURN_ERR_IF(count != 1, VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); shIntToParam(((SHPaint*)object)->tilingMode, count, values, floats, 0); break; default: /* Invalid VGParamType */ SH_RETURN_ERR(VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); } break; case SH_RESOURCE_IMAGE: switch (ptype) { /* Image parameters */ /* TODO: output image parameters when image implemented */ case VG_IMAGE_FORMAT: break; case VG_IMAGE_WIDTH: break; case VG_IMAGE_HEIGHT: break; default: /* Invalid VGParamType */ SH_RETURN_ERR(VG_ILLEGAL_ARGUMENT_ERROR, SH_NO_RETVAL); } break; default: /* Invalid resource handle */ SH_ASSERT(rtype!=SH_RESOURCE_INVALID); break; } SH_RETURN(SH_NO_RETVAL); }
VGContext* shGetContext() { SH_ASSERT(g_context); return g_context; }