void ScriptController::loadScript(const char* path, bool forceReload)
{
GP_ASSERT(path);
std::set<std::string>::iterator iter = _loadedScripts.find(path);
if (iter == _loadedScripts.end() || forceReload)
{
#ifdef __ANDROID__
const char* scriptContents = FileSystem::readAll(path);
if (luaL_dostring(_lua, scriptContents))
{
GP_WARN("Failed to run Lua script with error: '%s'.", lua_tostring(_lua, -1));
}
SAFE_DELETE_ARRAY(scriptContents);
#else
std::string fullPath;
if (!FileSystem::isAbsolutePath(path))
{
fullPath.append(FileSystem::getResourcePath());
}
fullPath.append(path);
if (luaL_dofile(_lua, fullPath.c_str()))
{
GP_WARN("Failed to run Lua script with error: '%s'.", lua_tostring(_lua, -1));
}
#endif
if (iter == _loadedScripts.end())
{
_loadedScripts.insert(path);
}
}
}
void printProperties(Properties* properties, unsigned int tabCount)
{
// Print the name and ID of the current namespace.
const char* spacename = properties->getNamespace();
const char* id = properties->getId();
std::string tabs;
for (unsigned int i = 0; i < tabCount; i++)
{
tabs.append("\t");
}
GP_WARN("\n%s%s %s\n%s{", tabs.c_str(), spacename, id, tabs.c_str());
// Print all properties in this namespace.
const char* name = properties->getNextProperty();
const char* value = NULL;
while (name != NULL)
{
value = properties->getString(name);
GP_WARN("%s\t%s = %s", tabs.c_str(), name, value);
name = properties->getNextProperty();
}
// Print the properties of every namespace within this one.
Properties* space = properties->getNextNamespace();
while (space != NULL)
{
printProperties(space, tabCount+1);
space = properties->getNextNamespace();
}
GP_WARN("%s}", tabs.c_str());
}
void Mode::gestureEvent(Gesture::GestureEvent evt, int x, int y, ...)
{
if(app->hasOverlay()) return;
va_list arguments;
va_start(arguments, y);
switch(evt) {
case Gesture::GESTURE_TAP: {
if(isSelecting()) {
MyNode *node = getTouchNode();
Vector3 point = getTouchPoint();
if(node) {
node->updateTransform();
node->setBase();
}
setSelectedNode(node, point);
if(node) GP_WARN("selected %s at %s", node->getId(), app->pv(point).c_str());
}
break;
}
case Gesture::GESTURE_LONG_TAP:
break;
case Gesture::GESTURE_PINCH: {
float scale = (float) va_arg(arguments, double);
if(app->_navMode >= 0) {
float baseRadius = _cameraStateBase->radius;
app->setCameraZoom(fminf(300.0f, fmaxf(3.0f, baseRadius / fmaxf(scale, 0.01f))));
}
break;
}
case Gesture::GESTURE_DRAG: {
if(app->_navMode >= 0) {
Vector2 touch = getTouchPix(), delta(x - touch.x, y - touch.y);
float radius = _cameraStateBase->radius, theta = _cameraStateBase->theta, phi = _cameraStateBase->phi;
GP_WARN("drag delta %f, %f", delta.x, delta.y);
GP_WARN("camera from %f, %f, %f", radius, theta, phi);
float deltaPhi = delta.y * M_PI / 400.0f, deltaTheta = delta.x * M_PI / 400.0f;
phi = fmin(89.9f * M_PI/180, fmax(-89.9f * M_PI/180, phi + deltaPhi));
theta += deltaTheta;
GP_WARN("to %f, %f, %f", radius, theta, phi);
app->setCameraEye(radius, theta, phi);
}
break;
}
case Gesture::GESTURE_DROP: {
break;
}
case Gesture::GESTURE_ROTATE: {
float rotation = (float) va_arg(arguments, double), velocity = (float) va_arg(arguments, double);
if(app->_navMode >= 0) {
float theta = _cameraStateBase->theta;
app->setCameraTheta(theta - rotation);
}
break;
}
default: break;
}
va_end(arguments);
}
Stream* FileSystem::open(const char* path, size_t streamMode, bool external)
{
bool useExternal = (streamMode & WRITE) != 0 || external;
char modeStr[] = "rb";
if ((streamMode & WRITE) != 0)
modeStr[0] = 'w';
#ifdef __ANDROID__
std::string fullPath(__resourcePath);
fullPath += resolvePath(path);
if (useExternal)
{
// Open a file on the SD card
size_t index = fullPath.rfind('/');
if (index != std::string::npos)
{
std::string directoryPath = fullPath.substr(0, index);
gp_stat_struct s;
if (stat(directoryPath.c_str(), &s) != 0)
makepath(directoryPath, 0777);
}
return FileStream::create(fullPath.c_str(), modeStr);
}
else
{
// First try the SD card
Stream* stream = FileStream::create(fullPath.c_str(), modeStr);
if (!stream)
{
// Otherwise fall-back to assets loaded via the AssetManager
fullPath = __assetPath;
fullPath += resolvePath(path);
stream = FileStreamAndroid::create(fullPath.c_str(), modeStr);
}
return stream;
}
#else
std::string fullPath;
getFullPath(path, fullPath, useExternal);
if(useExternal && __externalPath.compare(__resourcePath) != 0) {
size_t index = fullPath.rfind('/');
if(index != std::string::npos) {
std::string directoryPath = fullPath.substr(0, index);
gp_stat_struct s;
if(stat(directoryPath.c_str(), &s) != 0)
makepath(directoryPath, 0777);
}
}
GP_WARN("Opening file %s", fullPath.c_str());
if(useExternal) GP_WARN("External file");
FileStream* stream = FileStream::create(fullPath.c_str(), modeStr);
return stream;
#endif
}
/* Seek to the current position */
static void seek_cur_pos(struct zip_priv *priv)
{
unsigned int cur_table = priv->cur_pos / ZIP_CHUNKS_IN_TABLE;
unsigned int cur_pos;
if (priv->cur_table_pos != cur_table) {
unsigned int i;
GP_DEBUG(3, "cur_pos %u out of cur table %u",
priv->cur_pos, priv->cur_table_pos);
priv->cur_table = &priv->table;
for (i = 0; i < cur_table; i++) {
if (priv->cur_table->next)
priv->cur_table = priv->cur_table->next;
else
GP_WARN("The cur_pos points after last table");
}
priv->cur_table_pos = cur_table;
}
//TODO: Asert that we are not in last table and cur_pos < table_used
cur_pos = priv->cur_pos % ZIP_CHUNKS_IN_TABLE;
GP_DEBUG(2, "Setting current position to %u (%li)",
priv->cur_pos, priv->cur_table->offsets[cur_pos]);
gp_io_seek(priv->io, priv->cur_table->offsets[cur_pos], GP_IO_SEEK_SET);
}
static int parse_fb_params(char *params, int *flags, const char **fb)
{
char *param;
if (!params)
return 0;
do {
param = params;
params = next_param(params);
if (!strcasecmp(param, "no_shadow")) {
*flags &= ~GP_FB_SHADOW;
GP_DEBUG(1, "Shadow framebuffer disabled");
continue;
}
if (!strcasecmp(param, "new_console")) {
*flags |= GP_FB_ALLOC_CON;
GP_DEBUG(1, "Console allocation enabled");
continue;
}
*fb = param;
if (strncmp(*fb, "/dev/", 5))
GP_WARN("Console dev set to '%s', are you sure?", *fb);
GP_DEBUG(1, "Framebuffer console set to '%s'", *fb);
} while (params);
return 0;
}
gp_pixmap *gp_filter_resize_alloc(const gp_pixmap *src,
gp_size w, gp_size h,
gp_interpolation_type type,
gp_progress_cb *callback)
{
gp_pixmap *res;
if (!w && !h) {
GP_WARN("Invalid result size 0x0!");
errno = EINVAL;
return NULL;
}
if (!w)
w = (h * src->w + src->h/2) / src->h;
if (!h)
h = (w * src->h + src->w/2) / src->w;
res = gp_pixmap_alloc(w, h, src->pixel_type);
if (!res)
return NULL;
if (resize(src, res, type, callback)) {
gp_pixmap_free(res);
return NULL;
}
return res;
}
static int zip_seek(gp_container *self, int offset,
enum gp_container_whence whence)
{
struct zip_priv *priv = GP_CONTAINER_PRIV(self);
unsigned int where;
int ret;
GP_DEBUG(1, "Seek offset=%i whence=%i", offset, whence);
switch (whence) {
case GP_CONT_CUR:
if (offset < 0 && priv->cur_pos < (unsigned int)-offset) {
GP_WARN("Current position %u offset %i",
priv->cur_pos, offset);
where = 0;
} else {
where = priv->cur_pos + offset;
}
break;
case GP_CONT_FIRST:
where = offset;
break;
default:
return ENOSYS;
}
ret = set_cur_pos(priv, where);
self->cur_img = priv->cur_pos;
return ret;
}
void MaterialParameter::bind(Effect* effect)
{
GP_ASSERT(effect);
// If we had a Uniform cached that is not from the passed in effect,
// we need to update our uniform to point to the new effect's uniform.
if (!_uniform || _uniform->getEffect() != effect)
{
_uniform = effect->getUniform(_name.c_str());
if (!_uniform)
{
// This parameter was not found in the specified effect, so do nothing.
GP_WARN("Warning: Material parameter '%s' not found in effect '%s'.", _name.c_str(), effect->getId());
return;
}
}
switch (_type)
{
case MaterialParameter::FLOAT:
effect->setValue(_uniform, _value.floatValue);
break;
case MaterialParameter::FLOAT_ARRAY:
effect->setValue(_uniform, _value.floatPtrValue, _count);
break;
case MaterialParameter::INT:
effect->setValue(_uniform, _value.intValue);
break;
case MaterialParameter::INT_ARRAY:
effect->setValue(_uniform, _value.intPtrValue, _count);
break;
case MaterialParameter::VECTOR2:
effect->setValue(_uniform, reinterpret_cast<Vector2*>(_value.floatPtrValue), _count);
break;
case MaterialParameter::VECTOR3:
effect->setValue(_uniform, reinterpret_cast<Vector3*>(_value.floatPtrValue), _count);
break;
case MaterialParameter::VECTOR4:
effect->setValue(_uniform, reinterpret_cast<Vector4*>(_value.floatPtrValue), _count);
break;
case MaterialParameter::MATRIX:
effect->setValue(_uniform, reinterpret_cast<Matrix*>(_value.floatPtrValue), _count);
break;
case MaterialParameter::SAMPLER:
effect->setValue(_uniform, _value.samplerValue);
break;
case MaterialParameter::SAMPLER_ARRAY:
effect->setValue(_uniform, _value.samplerArrayValue, _count);
break;
case MaterialParameter::METHOD:
GP_ASSERT(_value.method);
_value.method->setValue(effect);
break;
default:
GP_ERROR("Unsupported material parameter type (%d).", _type);
break;
}
}
Text* Text::create(Properties* properties)
{
// Check if the Properties is valid and has a valid namespace.
if (!properties || strcmp(properties->getNamespace(), "text") != 0)
{
GP_ERROR("Properties object must be non-null and have namespace equal to 'text'.");
return NULL;
}
// Get font path.
const char* fontPath = properties->getString("font");
if (fontPath == NULL || strlen(fontPath) == 0)
{
GP_ERROR("Text is missing required font file path.");
return NULL;
}
// Get text
const char* text = properties->getString("text");
if (text == NULL || strlen(text) == 0)
{
GP_ERROR("Text is missing required 'text' value.");
return NULL;
}
// Get size
int size = properties->getInt("size"); // Default return is 0 if a value doesn't exist
if (size < 0)
{
GP_WARN("Text size must be a positive value, with zero being default font size. Using default font size.");
size = 0;
}
// Get text color
kmVec4 color = { 1.0f, 1.0f ,1.0f, 1.0f };
if (properties->exists("color"))
{
switch (properties->getType("color"))
{
case Properties::VECTOR3:
color.w = 1.0f;
properties->getVector3("color", (kmVec3*)&color);
break;
case Properties::VECTOR4:
properties->getVector4("color", &color);
break;
case Properties::STRING:
default:
properties->getColor("color", &color);
break;
}
}
// Create
return Text::create(fontPath, text, color, size);
}
static int parse_x11_params(char *params, GP_Size *w, GP_Size *h,
enum GP_BackendX11Flags *flags)
{
char *param;
if (!params)
return 0;
do {
param = params;
params = next_param(params);
if (!strcasecmp(param, "use_root")) {
*flags |= GP_X11_USE_ROOT_WIN;
GP_DEBUG(1, "X11: Using root window");
continue;
}
if (!strcasecmp(param, "create_root")) {
*flags |= GP_X11_CREATE_ROOT_WIN;
GP_DEBUG(1, "X11: Creating root window");
continue;
}
if (!strcasecmp(param, "disable_shm")) {
*flags |= GP_X11_DISABLE_SHM;
GP_DEBUG(1, "X11: Disabling SHM");
continue;
}
if (!strcasecmp(param, "fs")) {
*flags |= GP_X11_FULLSCREEN;
GP_DEBUG(1, "X11: Enabling fullscreen");
continue;
}
/*
* Accepts only string with format "intxint" or "intXint"
*/
int sw, sh;
unsigned int n;
if (sscanf(param, "%i%*[xX]%i%n", &sw, &sh, &n) == 2 && n == strlen(param)) {
*w = sw;
*h = sh;
continue;
}
GP_WARN("X11: Invalid parameters '%s'", param);
errno = EINVAL;
return 1;
} while (params);
return 0;
}
static void free_console(struct fb_priv *fb)
{
/* restore blinking cursor */
if (ioctl(fb->con_fd, KDSETMODE, KD_TEXT))
GP_WARN("Failed to ioctl KDSETMODE (restore KDMODE)");
/* switch back console */
if (fb->last_con_nr != -1)
ioctl(fb->con_fd, VT_ACTIVATE, fb->last_con_nr);
close(fb->con_fd);
}
int gp_filter_resize(const gp_pixmap *src, gp_pixmap *dst,
gp_interpolation_type type,
gp_progress_cb *callback)
{
if (src->pixel_type != dst->pixel_type) {
GP_WARN("The src and dst pixel types must match");
errno = EINVAL;
return 1;
}
return resize(src, dst, type, callback);
}
int gp_io_writef(gp_io *io, uint16_t *types, ...)
{
va_list va;
uint8_t *ptr, t;
int32_t i4;
int16_t i2;
va_start(va, types);
while (*types != GP_IO_END) {
switch (TYPE(*types)) {
case GP_IO_CONST:
t = VAL(*types);
if (gp_io_write(io, &t, 1) != 1)
goto err;
break;
case GP_IO_L2:
case GP_IO_B2:
i2 = va_arg(va, int);
ptr = (void*)&i2;
if (needs_swap(*types))
GP_SWAP(ptr[0], ptr[1]);
if (gp_io_write(io, ptr, 2) != 2)
goto err;
break;
case GP_IO_L4:
case GP_IO_B4:
i4 = va_arg(va, int);
ptr = (void*)&i4;
if (needs_swap(*types)) {
GP_SWAP(ptr[0], ptr[3]);
GP_SWAP(ptr[1], ptr[2]);
}
if (gp_io_write(io, ptr, 4) != 4)
goto err;
break;
default:
GP_WARN("Invalid type %"PRIu16"\n", *types);
goto err;
}
types++;
}
va_end(va);
return 0;
err:
va_end(va);
return -1;
}
float PhysicsRigidBody::getHeight(float x, float z) const
{
GP_ASSERT(_collisionShape);
GP_ASSERT(_node);
// If our node has a terrain, call getHeight() on it since we need to factor in local
// scaling on the terrain into the height calculation.
Terrain* terrain = dynamic_cast<Terrain*>(_node->getDrawable());
if (terrain)
return terrain->getHeight(x, z);
// This function is only supported for heightfield rigid bodies.
if (_collisionShape->getType() != PhysicsCollisionShape::SHAPE_HEIGHTFIELD)
{
GP_WARN("Attempting to get the height of a non-heightfield rigid body.");
return 0.0f;
}
GP_ASSERT(_collisionShape->_shapeData.heightfieldData);
// Ensure inverse kmMat4 is updated so we can transform from world back into local heightfield coordinates for indexing
if (_collisionShape->_shapeData.heightfieldData->inverseIsDirty)
{
_collisionShape->_shapeData.heightfieldData->inverseIsDirty = false;
//_node->getWorldMatrix().invert(&_collisionShape->_shapeData.heightfieldData->inverse);
kmMat4Invert(&_collisionShape->_shapeData.heightfieldData->inverse, &_node->getWorldMatrix());
}
// Calculate the correct x, z position relative to the heightfield data.
float cols = _collisionShape->_shapeData.heightfieldData->heightfield->getColumnCount();
float rows = _collisionShape->_shapeData.heightfieldData->heightfield->getRowCount();
GP_ASSERT(cols > 0);
GP_ASSERT(rows > 0);
//kmVec3 v = _collisionShape->_shapeData.heightfieldData->inverse * Vector3(x, 0.0f, z);
kmVec3 v = vec3Zero;
kmMat3Transform(&v, &_collisionShape->_shapeData.heightfieldData->inverse, x, 0.0f, z, 0.0f);
x = v.x + (cols - 1) * 0.5f;
z = v.z + (rows - 1) * 0.5f;
// Get the unscaled height value from the HeightField
float height = _collisionShape->_shapeData.heightfieldData->heightfield->getHeight(x, z);
// Apply scale back to height
kmVec3 worldScale = vec3Zero;
//_node->getWorldMatrix().getScale(&worldScale);
kmMat4Decompose(&_node->getWorldMatrix(), &worldScale, NULL, NULL);
height *= worldScale.y;
return height;
}
void ScriptController::registerCallback(const char* callback, const char* function)
{
ScriptCallback scb = toCallback(callback);
if (scb < INVALID_CALLBACK)
{
_callbacks[scb].push_back(function);
}
else
{
GP_WARN("Invalid script callback function specified: %s", callback);
}
}
void ParticleEmitter::setTexture(const char* texturePath, BlendMode blendMode)
{
Texture* texture = Texture::create(texturePath, true);
if (texture)
{
setTexture(texture, blendMode);
texture->release();
}
else
{
GP_WARN("Failed set new texture on particle emitter: %s", texturePath);
}
}
static off_t sub_seek(gp_io *io, off_t off, enum gp_io_whence whence)
{
struct sub_io *sub_io = GP_IO_PRIV(io);
off_t io_size, ret, poff;
switch (whence) {
case GP_IO_SEEK_CUR:
//TODO: Overflow
poff = sub_io->cur + off;
if (poff < sub_io->start || poff > sub_io->end) {
errno = EINVAL;
return -1;
}
ret = gp_io_seek(sub_io->io, off, whence);
break;
case GP_IO_SEEK_SET:
io_size = sub_io->end - sub_io->start;
if (off > io_size || off < 0) {
errno = EINVAL;
return -1;
}
ret = gp_io_seek(sub_io->io, sub_io->start + off, whence);
break;
case GP_IO_SEEK_END:
io_size = sub_io->end - sub_io->start;
if (off + io_size < 0 || off > 0) {
errno = EINVAL;
return -1;
}
ret = gp_io_seek(sub_io->io, sub_io->end + off, GP_IO_SEEK_SET);
break;
default:
GP_WARN("Invalid whence");
errno = EINVAL;
return -1;
}
if (ret == -1)
return -1;
sub_io->cur = ret;
return sub_io->cur - sub_io->start;
}
int gp_io_mark(gp_io *self, enum gp_io_mark_types type)
{
off_t ret;
switch (type) {
case GP_IO_MARK:
ret = gp_io_seek(self, 0, GP_IO_SEEK_CUR);
break;
case GP_IO_REWIND:
ret = gp_io_seek(self, self->mark, SEEK_SET);
break;
default:
GP_WARN("Invalid mark type");
return -1;
}
if (ret == -1) {
GP_WARN("Failed to seek I/O Stream");
return -1;
}
self->mark = ret;
return 0;
}
void ScriptController::loadScript(const char* path, bool forceReload)
{
std::set<std::string>::iterator iter = _loadedScripts.find(path);
if (iter == _loadedScripts.end() || forceReload)
{
const char* scriptContents = FileSystem::readAll(path);
if (luaL_dostring(_lua, scriptContents))
GP_WARN("Failed to run Lua script with error: '%s'.", lua_tostring(_lua, -1));
SAFE_DELETE_ARRAY(scriptContents);
if (iter == _loadedScripts.end())
_loadedScripts.insert(path);
}
}
void ScriptController::unregisterCallback(const char* callback, const char* function)
{
ScriptCallback scb = toCallback(callback);
if (scb < INVALID_CALLBACK)
{
std::vector<std::string>& list = _callbacks[scb];
std::vector<std::string>::iterator itr = std::find(list.begin(), list.end(), std::string(function));
if (itr != list.end())
list.erase(itr);
}
else
{
GP_WARN("Invalid script callback function specified: %s", callback);
}
}
/*
* Restore console and keyboard mode to whatever was there before.
*/
static void exit_kbd(struct fb_priv *fb)
{
if (ioctl(fb->con_fd, KDSKBMODE, fb->saved_kb_mode) < 0) {
GP_DEBUG(1, "Failed to ioctl KDSKBMODE (restore KBMODE)"
" /dev/tty%i: %s", fb->con_nr,
strerror(errno));
}
if (fb->restore_termios) {
if (tcsetattr(fb->con_fd, TCSANOW, &fb->ts) < 0) {
GP_WARN("Failed to tcsetattr() (restore termios): %s",
strerror(errno));
}
}
}
static boolean fill_input_buffer(struct jpeg_decompress_struct *cinfo)
{
int ret;
struct my_source_mgr* src = (void*)cinfo->src;
ret = GP_IORead(src->io, src->buffer, src->size);
if (ret <= 0) {
GP_WARN("Failed to fill buffer, IORead returned %i", ret);
return FALSE;
}
src->mgr.next_input_byte = src->buffer;
src->mgr.bytes_in_buffer = ret;
return TRUE;
}
static off_t file_seek(gp_io *self, off_t off, enum gp_io_whence whence)
{
struct file_io *file_io = GP_IO_PRIV(self);
switch (whence) {
case GP_IO_SEEK_SET:
case GP_IO_SEEK_CUR:
case GP_IO_SEEK_END:
break;
default:
GP_WARN("Invalid whence");
errno = EINVAL;
return -1;
}
return lseek(file_io->fd, off, whence);
}
Gamepad::ButtonMapping Gamepad::getButtonMappingFromString(const char* string)
{
if (strcmp(string, "A") == 0 || strcmp(string, "BUTTON_A") == 0)
return BUTTON_A;
else if (strcmp(string, "B") == 0 || strcmp(string, "BUTTON_B") == 0)
return BUTTON_B;
else if (strcmp(string, "C") == 0 || strcmp(string, "BUTTON_C") == 0)
return BUTTON_C;
else if (strcmp(string, "X") == 0 || strcmp(string, "BUTTON_X") == 0)
return BUTTON_X;
else if (strcmp(string, "Y") == 0 || strcmp(string, "BUTTON_Y") == 0)
return BUTTON_Y;
else if (strcmp(string, "Z") == 0 || strcmp(string, "BUTTON_Z") == 0)
return BUTTON_Z;
else if (strcmp(string, "MENU1") == 0 || strcmp(string, "BUTTON_MENU1") == 0)
return BUTTON_MENU1;
else if (strcmp(string, "MENU2") == 0 || strcmp(string, "BUTTON_MENU2") == 0)
return BUTTON_MENU2;
else if (strcmp(string, "MENU3") == 0 || strcmp(string, "BUTTON_MENU3") == 0)
return BUTTON_MENU3;
else if (strcmp(string, "MENU4") == 0 || strcmp(string, "BUTTON_MENU4") == 0)
return BUTTON_MENU4;
else if (strcmp(string, "L1") == 0 || strcmp(string, "BUTTON_L1") == 0)
return BUTTON_L1;
else if (strcmp(string, "L2") == 0 || strcmp(string, "BUTTON_L2") == 0)
return BUTTON_L2;
else if (strcmp(string, "L3") == 0 || strcmp(string, "BUTTON_L3") == 0)
return BUTTON_L3;
else if (strcmp(string, "R1") == 0 || strcmp(string, "BUTTON_R1") == 0)
return BUTTON_R1;
else if (strcmp(string, "R2") == 0 || strcmp(string, "BUTTON_R2") == 0)
return BUTTON_R2;
else if (strcmp(string, "R3") == 0 || strcmp(string, "BUTTON_R3") == 0)
return BUTTON_R3;
else if (strcmp(string, "UP") == 0 || strcmp(string, "BUTTON_UP") == 0)
return BUTTON_UP;
else if (strcmp(string, "DOWN") == 0 || strcmp(string, "BUTTON_DOWN") == 0)
return BUTTON_DOWN;
else if (strcmp(string, "LEFT") == 0 || strcmp(string, "BUTTON_LEFT") == 0)
return BUTTON_LEFT;
else if (strcmp(string, "RIGHT") == 0 || strcmp(string, "BUTTON_RIGHT") == 0)
return BUTTON_RIGHT;
GP_WARN("Unknown GamepadButton string.");
return BUTTON_A;
}
Vector3 PhysicsConstraint::getWorldCenterOfMass(const Node* node)
{
GP_ASSERT(node);
const BoundingSphere& sphere = node->getBoundingSphere();
if (!(sphere.center.isZero() && sphere.radius == 0))
{
// The world-space center of mass is the sphere's center.
return sphere.center;
}
// Warn the user that the node has no bounding volume.
GP_WARN("Node %s' has no bounding volume - center of mass is defaulting to local coordinate origin.", node->getId());
Vector3 center;
node->getWorldMatrix().transformPoint(¢er);
return center;
}
static void read_jpg_metadata(struct jpeg_decompress_struct *cinfo,
GP_DataStorage *storage)
{
jpeg_saved_marker_ptr marker;
GP_DataStorageAddInt(storage, NULL, "Width", cinfo->image_width);
GP_DataStorageAddInt(storage, NULL, "Height", cinfo->image_height);
GP_DataStorageAddInt(storage, NULL, "Channels", cinfo->num_components);
GP_DataStorageAddString(storage, NULL, "Color Space",
get_colorspace(cinfo->out_color_space));
for (marker = cinfo->marker_list; marker != NULL; marker = marker->next) {
switch (marker->marker) {
case JPEG_COM: {
//TODO: Is comment NULL terminated?
char buf[marker->data_length+1];
GP_DEBUG(3, "JPEG_COM comment block, size %u",
(unsigned int)marker->data_length);
memcpy(buf, marker->data, marker->data_length);
buf[marker->data_length] = '\0';
GP_DataStorageAddString(storage, NULL, "Comment", buf);
//GP_MetaDataCreateString(data, "comment", (void*)marker->data,
// marker->data_length, 1);
} break;
case JPEG_APP0:
GP_TODO("JFIF");
break;
case JPEG_APP0 + 1: {
GP_IO *io = GP_IOMem(marker->data, marker->data_length, NULL);
if (!io) {
GP_WARN("Failed to create MemIO");
return;
}
GP_ReadExif(io, storage);
GP_IOClose(io);
} break;
}
}
}
/*
* Save console mode and set the mode to raw.
*/
static int init_kbd(struct fb_priv *fb)
{
struct termios t;
int fd = fb->con_fd;
if (tcgetattr(fd, &fb->ts)) {
GP_WARN("Failed to tcgetattr(): %s", strerror(errno));
fb->restore_termios = 0;
} else {
fb->restore_termios = 1;
}
cfmakeraw(&t);
if (tcsetattr(fd, TCSANOW, &t) < 0) {
GP_DEBUG(1, "Failed to tcsetattr(): %s",
strerror(errno));
close(fd);
return -1;
}
if (ioctl(fd, KDGKBMODE, &fb->saved_kb_mode)) {
GP_DEBUG(1, "Failed to ioctl KDGKBMODE tty%i: %s",
fb->con_nr, strerror(errno));
close(fd);
return -1;
}
GP_DEBUG(2, "Previous keyboard mode was '%i'",
fb->saved_kb_mode);
if (ioctl(fd, KDSKBMODE, K_MEDIUMRAW) < 0) {
GP_DEBUG(1, "Failed to ioctl KDSKBMODE tty%i: %s",
fb->con_nr, strerror(errno));
close(fd);
return -1;
}
return 0;
}
static int resize(const gp_pixmap *src, gp_pixmap *dst,
gp_interpolation_type type,
gp_progress_cb *callback)
{
switch (type) {
case GP_INTERP_NN:
return gp_filter_resize_nn(src, dst, callback);
case GP_INTERP_LINEAR_INT:
return gp_filter_resize_linear_int(src, dst, callback);
case GP_INTERP_LINEAR_LF_INT:
return gp_filter_resize_linear_lf_int(src, dst, callback);
case GP_INTERP_CUBIC:
return gp_filter_resize_cubic(src, dst, callback);
case GP_INTERP_CUBIC_INT:
return gp_filter_resize_cubic_int(src, dst, callback);
}
GP_WARN("Invalid interpolation type %u", (unsigned int)type);
errno = EINVAL;
return 1;
}
int lua_Uniform_getType(lua_State* state)
{
// Get the number of parameters.
int paramCount = lua_gettop(state);
// Attempt to match the parameters to a valid binding.
switch (paramCount)
{
case 1:
{
if ((lua_type(state, 1) == LUA_TUSERDATA))
{
Uniform* instance = getInstance(state);
GLenum result = instance->getType();
// Push the return value onto the stack.
GP_WARN("Attempting to return value with unrecognized type GLenum as an unsigned integer.");
lua_pushunsigned(state, result);
return 1;
}
else
{
lua_pushstring(state, "lua_Uniform_getType - Failed to match the given parameters to a valid function signature.");
lua_error(state);
}
break;
}
default:
{
lua_pushstring(state, "Invalid number of parameters (expected 1).");
lua_error(state);
break;
}
}
return 0;
}
