void _al_set_new_display_settings(ALLEGRO_EXTRA_DISPLAY_SETTINGS *settings)
{
thread_local_state *tls;
if ((tls = tls_get()) == NULL)
return;
memmove(&tls->new_display_settings, settings, sizeof(ALLEGRO_EXTRA_DISPLAY_SETTINGS));
}
void OSLShader::eval_volume(KernelGlobals *kg, ShaderData *sd, float randb, int path_flag)
{
/* gather pointers */
OSL::pvt::ShadingSystemImpl *ssi = (OSL::pvt::ShadingSystemImpl*)kg->osl.ss;
OSLGlobals::ThreadData *tdata = tls_get(OSLGlobals::ThreadData, kg->osl.thread_data);
OSL::ShaderGlobals *globals = &tdata->globals;
OSL::pvt::ShadingContext *ctx = ssi->get_context(tdata->thread_info);
/* setup shader globals from shader data */
sd->osl_ctx = ctx;
shaderdata_to_shaderglobals(kg, sd, path_flag, globals);
/* execute shader */
int shader = sd->shader & SHADER_MASK;
if(kg->osl.volume_state[shader])
ctx->execute(OSL::pvt::ShadUseSurface, *(kg->osl.volume_state[shader]), *globals);
/* retrieve resulting closures */
sd->osl_closure.volume_sample_sum = 0.0f;
sd->osl_closure.num_volume = 0;
sd->osl_closure.randb = randb;
if(globals->Ci)
flatten_volume_closure_tree(sd, globals->Ci);
}
void *str_alloc_debug(size_t size, const char *file, int line) {
TLS_DATA *tls_data;
ALLOC_LIST *alloc_list;
if(!tls_initialized)
fatal_debug("str not initialized", file, line);
tls_data=tls_get();
if(!tls_data) {
tls_data=tls_alloc(NULL, NULL, "alloc");
s_log(LOG_ERR, "INTERNAL ERROR: Uninitialized TLS at %s, line %d",
file, line);
}
alloc_list=(ALLOC_LIST *)str_alloc_detached_debug(size, file, line)-1;
alloc_list->prev=NULL;
alloc_list->next=tls_data->alloc_head;
alloc_list->tls=tls_data;
if(tls_data->alloc_head)
tls_data->alloc_head->prev=alloc_list;
tls_data->alloc_head=alloc_list;
tls_data->alloc_bytes+=size;
tls_data->alloc_blocks++;
return alloc_list+1;
}
int *_al_tls_get_dtor_owner_count(void)
{
thread_local_state *tls;
tls = tls_get();
return &tls->dtor_owner_count;
}
/*
GetContextSuspended
Returns the currently active Context, in a locked state
*/
ALCcontext *GetContextSuspended(void)
{
ALCcontext *pContext = NULL;
SuspendContext(NULL);
pContext = tls_get(LocalContext);
if(pContext && !IsContext(pContext))
{
tls_set(LocalContext, NULL);
pContext = NULL;
}
if(!pContext)
{
pContext = g_pContextList;
while(pContext && !pContext->InUse)
pContext = pContext->next;
}
if(pContext)
SuspendContext(pContext);
ProcessContext(NULL);
return pContext;
}
void OSLShader::release(KernelGlobals *kg, const ShaderData *sd)
{
OSL::pvt::ShadingSystemImpl *ssi = (OSL::pvt::ShadingSystemImpl*)kg->osl.ss;
OSLGlobals::ThreadData *tdata = tls_get(OSLGlobals::ThreadData, kg->osl.thread_data);
ssi->release_context((OSL::pvt::ShadingContext*)sd->osl_ctx, tdata->thread_info);
}
void load_ply_info_cb(struct db_result *result)
{
//数据导入后的回调函数
if(result){
player_t ply = result->ud;
if(result->result_set){
redisReply *r = (redisReply*)result->result_set;
if(r->type != REDIS_REPLY_NIL){
lua_State *L = tls_get(LUASTATE);
if(0 != CALL_LUA_FUNC2(L,"CreateLuaPlayer",1,
PUSH_LUSRDATA(L,ply),
PUSH_TABLE3(L,
PUSH_STRING(L,r->element[0]->str),
PUSH_STRING(L,r->element[1]->str),
PUSH_STRING(L,r->element[2]->str))))
{
const char * error = lua_tostring(L, -1);
lua_pop(L,1);
printf("%s\n",error);
}else
ply->_luaply = create_luaObj(L,-1);
}else{
//没有角色，通知客户端创建角色
shortmsg2gate(CMD_GAME2C_CREATE,ply->_agentsession);
}
}else{
//数据库访问出错
shortmsg2gate(CMD_GAME2GATE_BUSY,ply->_agentsession);
remove_player(ply);
}
}
}
/* Function: al_get_separate_blender
*/
void al_get_separate_blender(int *op, int *src, int *dst,
int *alpha_op, int *alpha_src, int *alpha_dst)
{
thread_local_state *tls;
ALLEGRO_BLENDER *b;
if ((tls = tls_get()) == NULL)
return;
b = &tls->current_blender;
if (op)
*op = b->blend_op;
if (src)
*src = b->blend_source;
if (dst)
*dst = b->blend_dest;
if (alpha_op)
*alpha_op = b->blend_alpha_op;
if (alpha_src)
*alpha_src = b->blend_alpha_source;
if (alpha_dst)
*alpha_dst = b->blend_alpha_dest;
}
void OSLShader::eval_surface(KernelGlobals *kg, ShaderData *sd, float randb, int path_flag)
{
/* gather pointers */
OSL::pvt::ShadingSystemImpl *ssi = (OSL::pvt::ShadingSystemImpl*)kg->osl.ss;
OSLGlobals::ThreadData *tdata = tls_get(OSLGlobals::ThreadData, kg->osl.thread_data);
OSL::ShaderGlobals *globals = &tdata->globals;
OSL::pvt::ShadingContext *ctx = ssi->get_context(tdata->thread_info);
/* setup shader globals from shader data */
sd->osl_ctx = ctx;
shaderdata_to_shaderglobals(kg, sd, path_flag, globals);
/* execute shader for this point */
int shader = sd->shader & SHADER_MASK;
if(kg->osl.surface_state[shader])
ctx->execute(OSL::pvt::ShadUseSurface, *(kg->osl.surface_state[shader]), *globals);
/* flatten closure tree */
sd->num_closure = 0;
sd->randb_closure = randb;
if(globals->Ci) {
bool no_glossy = (path_flag & PATH_RAY_DIFFUSE) && kernel_data.integrator.no_caustics;
flatten_surface_closure_tree(sd, no_glossy, globals->Ci);
}
}
/* Function: al_set_errno
*/
void al_set_errno(int errnum)
{
thread_local_state *tls;
if ((tls = tls_get()) == NULL)
return;
tls->allegro_errno = errnum;
}
/* Function: al_get_errno
*/
int al_get_errno(void)
{
thread_local_state *tls;
if ((tls = tls_get()) == NULL)
return 0;
return tls->allegro_errno;
}
/* Function: al_set_fs_interface
*/
void al_set_fs_interface(const ALLEGRO_FS_INTERFACE *fs_interface)
{
thread_local_state *tls;
if ((tls = tls_get()) == NULL)
return;
tls->fs_interface = fs_interface;
}
/* Function: al_set_new_display_flags
*/
void al_set_new_display_flags(int flags)
{
thread_local_state *tls;
if ((tls = tls_get()) == NULL)
return;
tls->new_display_flags = flags;
}
/* Function: al_get_target_bitmap
*/
ALLEGRO_BITMAP *al_get_target_bitmap(void)
{
thread_local_state *tls;
if ((tls = tls_get()) == NULL)
return 0;
return tls->target_bitmap;
}
/* Function: al_get_current_display
*/
ALLEGRO_DISPLAY *al_get_current_display(void)
{
thread_local_state *tls;
if ((tls = tls_get()) == NULL)
return NULL;
return tls->current_display;
}
/* Function: al_get_new_display_adapter
*/
int al_get_new_display_adapter(void)
{
thread_local_state *tls;
if ((tls = tls_get()) == NULL)
return ALLEGRO_DEFAULT_DISPLAY_ADAPTER;
return tls->new_display_adapter;
}
/* Function: al_get_new_display_refresh_rate
*/
int al_get_new_display_refresh_rate(void)
{
thread_local_state *tls;
if ((tls = tls_get()) == NULL)
return 0;
return tls->new_display_refresh_rate;
}
/* Function: al_set_new_display_refresh_rate
*/
void al_set_new_display_refresh_rate(int refresh_rate)
{
thread_local_state *tls;
if ((tls = tls_get()) == NULL)
return;
tls->new_display_refresh_rate = refresh_rate;
}
/* Function: _al_android_get_jnienv
*/
JNIEnv *_al_android_get_jnienv(void)
{
thread_local_state *tls;
if ((tls = tls_get()) == NULL)
return 0;
return tls->jnienv;
}
/* Function: _al_android_set_jnienv
*/
void _al_android_set_jnienv(JNIEnv *jnienv)
{
thread_local_state *tls;
if ((tls = tls_get()) == NULL)
return;
tls->jnienv = jnienv;
}
/* Function: al_add_new_bitmap_flag
*/
void al_add_new_bitmap_flag(int flag)
{
thread_local_state *tls;
if ((tls = tls_get()) == NULL)
return;
tls->new_bitmap_flags |= flag;
}
void *
u_tsd_get(struct u_tsd *tsd)
{
if (tsd->initMagic != (int) INIT_MAGIC) {
u_tsd_init(tsd);
}
return tls_get(tsd->key);
}
/* Function: al_get_new_bitmap_flags
*/
int al_get_new_bitmap_flags(void)
{
thread_local_state *tls;
if ((tls = tls_get()) == NULL)
return 0;
return tls->new_bitmap_flags;
}
/* Function: al_set_new_bitmap_format
*/
void al_set_new_bitmap_format(int format)
{
thread_local_state *tls;
if ((tls = tls_get()) == NULL)
return;
tls->new_bitmap_format = format;
}
ALLEGRO_EXTRA_DISPLAY_SETTINGS *_al_get_new_display_settings(void)
{
thread_local_state *tls;
if ((tls = tls_get()) == NULL)
return 0;
return &tls->new_display_settings;
}
void *
_glthread_GetTSD(_glthread_TSD *tsd)
{
if (tsd->initMagic != (int) INIT_MAGIC) {
_glthread_InitTSD(tsd);
}
return tls_get(tsd->key);
}
/* Function: al_set_new_file_interface
*/
void al_set_new_file_interface(const ALLEGRO_FILE_INTERFACE *file_interface)
{
thread_local_state *tls;
if ((tls = tls_get()) == NULL)
return;
tls->new_file_interface = file_interface;
}
/*! \brief Returns the current debug indentation level for the
current thread.
NOTE: indentation is currently unsupported for R5::kernelland due
to lack of thread local storage support.
*/
int32
_get_debug_indent_level()
{
#ifdef USER
return (int32)tls_get(get_tls_handle());
#else
return 1;
#endif
}
/* Function: al_set_new_window_position
*/
void al_set_new_window_position(int x, int y)
{
thread_local_state *tls;
if ((tls = tls_get()) == NULL)
return;
tls->new_window_x = x;
tls->new_window_y = y;
}
void tls<Type_t>::set(const Type_t &value)
{
Type_t *new_value = new Type_t(value);
Type_t *old_value = static_cast<Type_t *>(tls_get(_key.get()));
delete old_value;
tls_set(_key.get(), new_value);
}
