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;
}
