C++ BG函数代码示例

static inline int object_common2(UNSERIALIZE_PARAMETER, zend_long elements)
{
	zval retval;
	zval fname;

	if (Z_TYPE_P(rval) != IS_OBJECT) {
		return 0;
	}

	//??? TODO: resize before
	if (!process_nested_data(UNSERIALIZE_PASSTHRU, Z_OBJPROP_P(rval), elements, 1)) {
		return 0;
	}

	ZVAL_DEREF(rval);
	if (Z_OBJCE_P(rval) != PHP_IC_ENTRY &&
		zend_hash_str_exists(&Z_OBJCE_P(rval)->function_table, "__wakeup", sizeof("__wakeup")-1)) {
		ZVAL_STRINGL(&fname, "__wakeup", sizeof("__wakeup") - 1);
		BG(serialize_lock)++;
		call_user_function_ex(CG(function_table), rval, &fname, &retval, 0, 0, 1, NULL);
		BG(serialize_lock)--;
		zval_dtor(&fname);
		zval_dtor(&retval);
	}

	if (EG(exception)) {
		return 0;
	}

	return finish_nested_data(UNSERIALIZE_PASSTHRU);

}

static inline int object_common2(UNSERIALIZE_PARAMETER, zend_long elements)
{
	zval retval;
	zval fname;
	HashTable *ht;

	if (Z_TYPE_P(rval) != IS_OBJECT) {
		return 0;
	}

	ht = Z_OBJPROP_P(rval);
	zend_hash_extend(ht, zend_hash_num_elements(ht) + elements, (ht->u.flags & HASH_FLAG_PACKED));
	if (!process_nested_data(UNSERIALIZE_PASSTHRU, ht, elements, 1)) {
		return 0;
	}

	ZVAL_DEREF(rval);
	if (Z_OBJCE_P(rval) != PHP_IC_ENTRY &&
		zend_hash_str_exists(&Z_OBJCE_P(rval)->function_table, "__wakeup", sizeof("__wakeup")-1)) {
		ZVAL_STRINGL(&fname, "__wakeup", sizeof("__wakeup") - 1);
		BG(serialize_lock)++;
		call_user_function_ex(CG(function_table), rval, &fname, &retval, 0, 0, 1, NULL);
		BG(serialize_lock)--;
		zval_dtor(&fname);
		zval_dtor(&retval);
	}

	if (EG(exception)) {
		return 0;
	}

	return finish_nested_data(UNSERIALIZE_PASSTHRU);

}

static inline int object_common2(UNSERIALIZE_PARAMETER, long elements)
{
	zval *retval_ptr = NULL;
	zval fname;

	if (Z_TYPE_PP(rval) != IS_OBJECT) {
		return 0;
	}

	if (!process_nested_data(UNSERIALIZE_PASSTHRU, Z_OBJPROP_PP(rval), elements, 1)) {
		return 0;
	}

	if (Z_OBJCE_PP(rval) != PHP_IC_ENTRY &&
		zend_hash_exists(&Z_OBJCE_PP(rval)->function_table, "__wakeup", sizeof("__wakeup"))) {
		INIT_PZVAL(&fname);
		ZVAL_STRINGL(&fname, "__wakeup", sizeof("__wakeup") - 1, 0);
		BG(serialize_lock)++;
		call_user_function_ex(CG(function_table), rval, &fname, &retval_ptr, 0, 0, 1, NULL TSRMLS_CC);
		BG(serialize_lock)--;
	}

	if (retval_ptr) {
		zval_ptr_dtor(&retval_ptr);
	}

	if (EG(exception)) {
		return 0;
	}

	return finish_nested_data(UNSERIALIZE_PASSTHRU);

}

PHPAPI void var_destroy(php_unserialize_data_t *var_hashx)
{
	void *next;
	zend_long i;
	var_entries *var_hash = (*var_hashx)->first;
	var_dtor_entries *var_dtor_hash = (*var_hashx)->first_dtor;
	zend_bool wakeup_failed = 0;
	zval wakeup_name;
	ZVAL_UNDEF(&wakeup_name);

#if VAR_ENTRIES_DBG
	fprintf(stderr, "var_destroy(%ld)\n", var_hash?var_hash->used_slots:-1L);
#endif

	while (var_hash) {
		next = var_hash->next;
		efree_size(var_hash, sizeof(var_entries));
		var_hash = next;
	}

	while (var_dtor_hash) {
		for (i = 0; i < var_dtor_hash->used_slots; i++) {
			zval *zv = &var_dtor_hash->data[i];
#if VAR_ENTRIES_DBG
			fprintf(stderr, "var_destroy dtor(%p, %ld)\n", var_dtor_hash->data[i], Z_REFCOUNT_P(var_dtor_hash->data[i]));
#endif

			/* Perform delayed __wakeup calls */
			if (Z_EXTRA_P(zv) == VAR_WAKEUP_FLAG) {
				if (!wakeup_failed) {
					zval retval;
					if (Z_ISUNDEF(wakeup_name)) {
						ZVAL_STRINGL(&wakeup_name, "__wakeup", sizeof("__wakeup") - 1);
					}

					BG(serialize_lock)++;
					if (call_user_function_ex(CG(function_table), zv, &wakeup_name, &retval, 0, 0, 1, NULL) == FAILURE || Z_ISUNDEF(retval)) {
						wakeup_failed = 1;
						GC_FLAGS(Z_OBJ_P(zv)) |= IS_OBJ_DESTRUCTOR_CALLED;
					}
					BG(serialize_lock)--;

					zval_ptr_dtor(&retval);
				} else {
					GC_FLAGS(Z_OBJ_P(zv)) |= IS_OBJ_DESTRUCTOR_CALLED;
				}
			}

			i_zval_ptr_dtor(zv ZEND_FILE_LINE_CC);
		}
		next = var_dtor_hash->next;
		efree_size(var_dtor_hash, sizeof(var_dtor_entries));
		var_dtor_hash = next;
	}

	zval_ptr_dtor_nogc(&wakeup_name);
}

PHPAPI void php_var_unserialize_destroy(php_unserialize_data_t d) {
	/* fprintf(stderr, "UNSERIALIZE_DESTROY == lock: %u, level: %u\n", BG(serialize_lock), BG(unserialize).level); */
	if (BG(serialize_lock) || BG(unserialize).level == 1) {
		var_destroy(&d);
		efree(d);
	}
	if (!BG(serialize_lock) && !--BG(unserialize).level) {
		BG(unserialize).data = NULL;
	}
}

t_bool			ft_parse(t_buff *buff, const char *parse)
{
	if (ft_strchr(parse, BG(buff)) == NULL)
		return (false);
	buff->i++;
	while (!BEOF(buff))
	{
		if (ft_strchr(parse, BG(buff)) == NULL)
			break ;
		buff->i++;
	}
	return (true);
}

static int php_url_scanner_ex_activate(int type)
{
	url_adapt_state_ex_t *ctx;

	if (type) {
		ctx = &BG(url_adapt_session_ex);
	} else {
		ctx = &BG(url_adapt_output_ex);
	}

	memset(ctx, 0, ((size_t) &((url_adapt_state_ex_t *)0)->tags));

	return SUCCESS;
}

static int php_ini_on_update_tags(zend_ini_entry *entry, zend_string *new_value, void *mh_arg1, void *mh_arg2, void *mh_arg3, int stage, int type)
{
	url_adapt_state_ex_t *ctx;
	char *key;
	char *tmp;
	char *lasts = NULL;

	if (type) {
		ctx = &BG(url_adapt_session_ex);
	} else {
		ctx = &BG(url_adapt_output_ex);
	}

	tmp = estrndup(ZSTR_VAL(new_value), ZSTR_LEN(new_value));

	if (ctx->tags)
		zend_hash_destroy(ctx->tags);
	else {
		ctx->tags = malloc(sizeof(HashTable));
		if (!ctx->tags) {
			efree(tmp);
			return FAILURE;
		}
	}

	zend_hash_init(ctx->tags, 0, NULL, tag_dtor, 1);

	for (key = php_strtok_r(tmp, ",", &lasts);
		 key;
		 key = php_strtok_r(NULL, ",", &lasts)) {
		char *val;

		val = strchr(key, '=');
		if (val) {
			char *q;
			size_t keylen;

			*val++ = '\0';
			for (q = key; *q; q++) {
				*q = tolower(*q);
			}
			keylen = q - key;
			zend_hash_str_add_mem(ctx->tags, key, keylen, val, strlen(val)+1);
		}
	}

	efree(tmp);

	return SUCCESS;
}

static inline void php_url_scanner_reset_vars_impl(int type) {
	url_adapt_state_ex_t *url_state;

	if (type) {
		url_state = &BG(url_adapt_session_ex);
	} else {
		url_state = &BG(url_adapt_output_ex);
	}

	if (url_state->form_app.s) {
		ZSTR_LEN(url_state->form_app.s) = 0;
	}
	if (url_state->url_app.s) {
		ZSTR_LEN(url_state->url_app.s) = 0;
	}
}

t_bool			ft_parsespace(t_buff *buff)
{
	if (!BIF(buff, &ft_isspace))
		return (false);
	while (ft_isspace(BG(buff)))
		buff->i++;
	return (true);
}

// タイトル画面
void game_title(AppEnv& app_env) {
  // 画像読み込み
  Texture title("res/png/sys01_logo.png");    // タイトルロゴ
  Texture start("res/png/sys02_start.png");   // スタートボタン
  Texture BG("res/png/bg01_gradation.png");   // 背景

  // この処理内だけで使う変数
  const short One_Second = 60;   // 1秒 = 60.frame
  const short Logo_Line = 8;     // 描画サイズ

  const short Draw_Limit = Logo_Ha - Logo_Line;   // 描画アニメの終了判定

  short time_count = 0;   // タイマー
  short blink = 0;        // 点滅アニメーション
  float draw_y = 0;       // ロゴ変化アニメ：描画位置

  while (1) {
    if (!app_env.isOpen()) { return; }

    // 左クリックでループ終了
    if (app_env.isPushButton(Mouse::LEFT)) { app_env.flushInput(); return; }

    // 画像の点滅処理
    {
      blink = (time_count / 30) % 2;
      time_count++;
      if (time_count == One_Second) { time_count = 0; }   // 1秒カウントしたらリセット
    }

    // タイトルロゴに変化をつける処理
    {
      draw_y += 1.5;
      if (draw_y >= Draw_Limit) { draw_y = 0; }   // 描画位置をリセット
    }

    app_env.setupDraw();

    // 背景表示
    drawTextureBox((-Window::WIDTH / 2), (-Window::HEIGHT / 2), Window::WIDTH, Window::HEIGHT,
      0, 0, Bg_W, Bg_H,
      BG, Color(0, 0, 0, 0.5));

    // タイトルロゴ表示
    drawTextureBox((-Logo_W * 1), (Logo_Ha * 1), Logo_W * 2, Logo_Ha,
      0, 0, Logo_W, Logo_Ha,
      title, Color(1, 0.75, 0.5));
    drawTextureBox((-Logo_W * 1), (Logo_Ha * 1) + draw_y, Logo_W * 2, Logo_Line,
      0, (Logo_Ha - Logo_Line) - draw_y, Logo_W, Logo_Line,
      title, Color(1, 1, 1));

    // クリックスタート
    drawTextureBox((-Logo_W * 0.5), (-Logo_Hb * 2), Logo_W, Logo_Hb,
      0, 0, Logo_W, Logo_Hb,
      start, Color(1, 1, 0.5, blink));

    app_env.update();
  }
}

static int php_url_scanner_ex_deactivate(int type)
{
	url_adapt_state_ex_t *ctx;

	if (type) {
		ctx = &BG(url_adapt_session_ex);
	} else {
		ctx = &BG(url_adapt_output_ex);
	}

	smart_str_free(&ctx->result);
	smart_str_free(&ctx->buf);
	smart_str_free(&ctx->tag);
	smart_str_free(&ctx->arg);
	smart_str_free(&ctx->attr_val);

	return SUCCESS;
}

void
drawtext(DC *dc, const char *text, Color col[ColLast], int x_offs, int force_width, int breaklines) {
    XSetForeground(dc->dpy, dc->gc, BG(dc, col));
    XFillRectangle(dc->dpy, dc->canvas, dc->gc, dc->x, dc->y, dc->w, dc->h);
    if(!text)
        return;
    set_text(dc, text, force_width, breaklines);
    pango_xft_render_layout(dc->xftdrawable, &col[ColFG].xft, dc->plo, (dc->x + x_offs) * PANGO_SCALE, dc->y * PANGO_SCALE);
}

static int check_host_whitelist(url_adapt_state_ex_t *ctx)
{
	php_url *url_parts = NULL;
	HashTable *allowed_hosts = ctx->type ? &BG(url_adapt_session_hosts_ht) : &BG(url_adapt_output_hosts_ht);

	ZEND_ASSERT(ctx->tag_type == TAG_FORM);

	if (ctx->attr_val.s && ZSTR_LEN(ctx->attr_val.s)) {
		url_parts = php_url_parse_ex(ZSTR_VAL(ctx->attr_val.s), ZSTR_LEN(ctx->attr_val.s));
	} else {
		return SUCCESS; /* empty URL is valid */
	}

	if (!url_parts) {
		return FAILURE;
	}
	if (url_parts->scheme) {
		/* Only http/https should be handled.
		   A bit hacky check this here, but saves a URL parse. */
		if (strcasecmp(url_parts->scheme, "http") &&
			strcasecmp(url_parts->scheme, "https")) {
		php_url_free(url_parts);
		return FAILURE;
		}
	}
	if (!url_parts->host) {
		php_url_free(url_parts);
		return SUCCESS;
	}
	if (!zend_hash_num_elements(allowed_hosts) &&
		check_http_host(url_parts->host) == SUCCESS) {
		php_url_free(url_parts);
		return SUCCESS;
	}
	if (!zend_hash_str_find(allowed_hosts,
							url_parts->host,
							strlen(url_parts->host))) {
		php_url_free(url_parts);
		return FAILURE;
	}
	php_url_free(url_parts);
	return SUCCESS;
}

int main(int argc, char * argv[])
{
	//Load the config and apply
		//Load the configs of screen
	win_w = cfg.Load(KEY_WINWIDTH);
	win_h = cfg.Load(KEY_WINHEIGHT);
		//Load the volumn and apply
	snd.ApplyCfg(BGMCN, cfg.Load(BGMCN));
	snd.ApplyCfg(SECN,  cfg.Load(SECN));
	snd.ApplyCfg(VCECN, cfg.Load(VCECN));

	//Init
	SDL_Init(SDL_INIT_EVENTS);
	win = SDL_CreateWindow("MaikazeSekai", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, win_w, win_h, SDL_WINDOW_OPENGL);
	ren = SDL_CreateRenderer(win, -1, 0);
	SDL_RenderSetLogicalSize(ren, 1280, 720);
	blk = SDL_CreateTexture(ren, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, win_w, win_h);
		//sent the renderer to Class Image as a stage and init them with the FileMgr
	img.Init(ren, &file);
	snd.Init(&file);

    
    auto *rw = SDL_RWFromFile("z:/star.png", "r");
    auto sur = IMG_Load_RW(rw, AUTOFREE);
    auto tex = SDL_CreateTextureFromSurface(ren, sur);
    SDL_FreeSurface(sur);
    SDL_Rect rt = { 0, 0, 2362, 7087 };
    SDL_RenderCopy(ren, tex, NULL, &rt);
    SDL_RenderPresent(ren);
    SDL_DestroyTexture(tex);

    auto *rw2 = SDL_RWFromFile("z:/1.png", "r");
    auto sur2 = IMG_Load_RW(rw2, AUTOFREE);
    auto tex2 = SDL_CreateTextureFromSurface(ren, sur2);
    SDL_FreeSurface(sur2);
    SDL_Rect rt2 = { 0, 0, 800, 900 };
    SDL_RenderCopy(ren, tex2, NULL, &rt2);
    SDL_RenderPresent(ren);
    //SDL_DestroyTexture(tex);
    
	
	//
	BGM("yui.wav", 1, 0);
	BG("sample.png");
	img.OnDraw();

	//Refresh the textures on renderer
	SDL_RenderPresent(ren);
    UnLoadBG();
    //SDL_DestroyTexture()
	//Logo();
	//Title();
	SDL_Quit();
	return 0;
}