/// \brief Read the saved file
/// \param boards The number of the saved board.NA for not to use
/// \return void
void c_readFromDisk(int boards,bool info){
char name[20];
int ver=c_version();
if(boards!=NA){
boards=abs(boards%MAX_BOARD_NUM);
sprintf(name,"2048.%d.%X.save",boards,ver);
}else{
sprintf(name,"2048.%X.save",ver);
boards=curs;
}
boards=abs(boards%MAX_BOARD_NUM);
FILE *fp;
if((fp=fopen(name,"r"))) {
int iptN;
int iptVer=0;
fscanf(fp,"%X",&iptVer);
char w[1024];
if(iptVer!=ver){
sprintf(w,"Librazy found that the game's version dosen't match!\nYour version:%X, saved:%X",ver,iptVer);
c_warning(w);
return ;
}
sprintf(w,"Opening %s",name);
if(info)c_info(w);
fscanf(fp,"%d",&iptN);
c_loadStr(iptN%MAX_BOARD_SIZE,fp,info);
}else{
char str[1000];
sprintf(str,"Librazy don't know how to open %s,\n read file failed",name);
c_warning(str);
}
fclose(fp);
}
/// \brief Show and handle commands inputed by :
/// \return void
void x_netCommand(){
char cmd[MAX_BOARD_SIZE*MAX_BOARD_SIZE*4];
echo();
move(0,0);
clrtoeol();
attron(A_STANDOUT);
mvprintw(0,MENU_POSITION_X,":");
attroff(A_STANDOUT);
int arg=NA,arg2=NA;
scanw("%s %d %d",cmd,&arg,&arg2);cmd[15]='\0';
noecho();
if(attacktimes[0]<7){
if(strcmp(cmd,"boom")==0){
x_boom(arg,arg2);
}else if(strcmp(cmd,"del")==0){
x_del(arg,arg2);
}else if(strcmp(cmd,"u")==0){
x_up();
}else if(strcmp(cmd,"d")==0){
x_down();
}else if(strcmp(cmd,"l")==0){
x_left();
}else if(strcmp(cmd,"r")==0){
x_right();
}else{
char str[1000];
sprintf(str,"Librazy don't know how to %s,\nresume game now",cmd);
str[99]='\0';
c_warning(str);
}
}else{
c_warning("Max attack time limit exceeded");
}
pthread_cond_signal(&CBoard);
}
void
rig_pb_stream_accept_tcp_connection(rig_pb_stream_t *stream,
uv_tcp_t *server)
{
uv_loop_t *loop = rut_uv_shell_get_loop(stream->shell);
struct sockaddr name;
int namelen;
int err;
c_return_if_fail(stream->type == STREAM_TYPE_DISCONNECTED);
c_return_if_fail(stream->hostname == NULL);
c_return_if_fail(stream->port == NULL);
c_return_if_fail(stream->resolving == false);
uv_tcp_init(loop, &stream->tcp.socket);
stream->tcp.socket.data = stream;
err = uv_accept((uv_stream_t *)server, (uv_stream_t *)&stream->tcp.socket);
if (err != 0) {
c_warning("Failed to accept tcp connection: %s", uv_strerror(err));
uv_close((uv_handle_t *)&stream->tcp.socket, NULL);
return;
}
err = uv_tcp_getpeername(&stream->tcp.socket, &name, &namelen);
if (err != 0) {
c_warning("Failed to query peer address of tcp socket: %s",
uv_strerror(err));
stream->hostname = c_strdup("unknown");
stream->port = c_strdup("0");
} else if (name.sa_family != AF_INET) {
c_warning("Accepted connection isn't ipv4");
stream->hostname = c_strdup("unknown");
stream->port = c_strdup("0");
} else {
struct sockaddr_in *addr = (struct sockaddr_in *)&name;
char ip_address[17] = {'\0'};
uv_ip4_name(addr, ip_address, 16);
stream->hostname = c_strdup(ip_address);
stream->port = c_strdup_printf("%u", ntohs(addr->sin_port));
}
stream->type = STREAM_TYPE_TCP;
set_connected(stream);
}
static void
on_connect(uv_connect_t *connection_request, int status)
{
rig_pb_stream_t *stream = connection_request->data;
c_return_if_fail(stream->connecting);
stream->connecting = false;
if (status < 0) {
c_warning("Failed to connect to %s:%s - %s",
stream->hostname,
stream->port,
uv_strerror(status));
rut_closure_list_invoke(&stream->on_error_closures,
rig_pb_stream_callback_t,
stream);
goto exit;
}
stream->type = STREAM_TYPE_TCP;
set_connected(stream);
exit:
/* NB: we were at least keeping the stream alive while
* waiting for the connection request to finish... */
stream->connecting = false;
rut_object_unref(stream);
}
static void
_cg_winsys_egl_onscreen_deinit(cg_onscreen_t *onscreen)
{
cg_framebuffer_t *framebuffer = CG_FRAMEBUFFER(onscreen);
cg_device_t *dev = framebuffer->dev;
cg_renderer_t *renderer = dev->display->renderer;
cg_xlib_renderer_t *xlib_renderer = _cg_xlib_renderer_get_data(renderer);
cg_xlib_trap_state_t old_state;
cg_onscreen_egl_t *egl_onscreen = onscreen->winsys;
cg_onscreen_xlib_t *xlib_onscreen = egl_onscreen->platform;
_cg_xlib_renderer_trap_errors(renderer, &old_state);
if (!xlib_onscreen->is_foreign_xwin && xlib_onscreen->xwin != None) {
XDestroyWindow(xlib_renderer->xdpy, xlib_onscreen->xwin);
xlib_onscreen->xwin = None;
} else
xlib_onscreen->xwin = None;
XSync(xlib_renderer->xdpy, False);
if (_cg_xlib_renderer_untrap_errors(renderer, &old_state) != Success)
c_warning("X Error while destroying X window");
c_slice_free(cg_onscreen_xlib_t, xlib_onscreen);
}
void SystemCore_release(const emlrtStack *sp, comm_SDRuReceiver *obj)
{
static const char_T cv9[7] = { 'r', 'e', 'l', 'e', 'a', 's', 'e' };
comm_SDRuReceiver *b_obj;
boolean_T disconnected;
int32_T driverApiH;
int32_T errMsg_size[2];
char_T errMsg_data[1024];
UsrpErrorCapiEnumT errStatus;
int32_T tmp_size[2];
char_T tmp_data[128];
emlrtStack st;
emlrtStack b_st;
emlrtStack c_st;
emlrtStack d_st;
st.prev = sp;
st.tls = sp->tls;
b_st.prev = &st;
b_st.tls = st.tls;
c_st.prev = &b_st;
c_st.tls = b_st.tls;
d_st.prev = &c_st;
d_st.tls = c_st.tls;
if (obj->isInitialized != 2) {
} else {
emlrtErrorWithMessageIdR2012b(sp, &c_emlrtRTEI,
"MATLAB:system:methodCalledWhenReleasedCodegen", 3, 4, 7, cv9);
}
if (obj->isInitialized == 1) {
obj->isInitialized = 2;
st.site = &k_emlrtRSI;
b_obj = obj;
b_st.site = &h_emlrtRSI;
disconnected = true;
if (b_obj->pConnected) {
c_st.site = &h_emlrtRSI;
driverApiH = b_obj->pDriverHandle;
/* Copyright 2011-2012 The MathWorks, Inc. */
d_st.site = &w_emlrtRSI;
b_mapiPrivate(&d_st, driverApiH, &errStatus, errMsg_data, errMsg_size);
if (errStatus == UsrpDriverSuccess) {
b_obj->pDriverHandle = 0;
} else {
c_st.site = &h_emlrtRSI;
reportDrivers(&c_st, tmp_data, tmp_size);
if (!(tmp_size[1] == 0)) {
disconnected = false;
c_st.site = &h_emlrtRSI;
c_warning(&c_st, errMsg_data, errMsg_size);
}
}
b_obj->pConnected = !disconnected;
}
}
}
/// \brief Ask player whether to quit
/// \return void
void c_tryQuit(){
c_warning("You game progress won't be saved!\nPress q to quit, others to resume");
int ch=0;
ch=getch();
if(ch=='q'||ch=='Q'){
c_forceQuit();
}
c_info("");
}
/// \brief Show and handle commands inputed by :
/// \return void
void command(){
char cmd[MAX_BOARD_SIZE*MAX_BOARD_SIZE*4];
echo();
//curs_set(1);
move(0,0);
clrtoeol();
attron(A_STANDOUT);
mvprintw(0,MENU_POSITION_X,":");
attroff(A_STANDOUT);
int arg=NA,arg2=NA;
scanw("%s %d %d",cmd,&arg,&arg2);cmd[15]='\0';
noecho();
//curs_set(0);
if(strcmp(cmd,"r")==0||strcmp(cmd,"read")==0){
c_readBoard(arg);
}else if(strcmp(cmd,"s")==0||strcmp(cmd,"save")==0){
c_saveBoard(arg,true);
}else if(strcmp(cmd,"s!")==0||strcmp(cmd,"saveto")==0){
c_saveBoard(arg,false);
}else if(strcmp(cmd,"q")==0||strcmp(cmd,"quit")==0){
c_tryQuit();
}else if(strcmp(cmd,"w")==0||strcmp(cmd,"write")==0){
c_writeBoardToDisk(NA,true);
}else if(strcmp(cmd,"wb")==0||strcmp(cmd,"writeboard")==0){
if(NA==arg){
c_warning("Librazy don't know which board should be saved");
}else{
c_writeBoardToDisk(arg,true);
}
}else if(strcmp(cmd,"wq")==0||strcmp(cmd,"writequit")==0){
if(c_writeBoardToDisk(NA,true))c_forceQuit();
}else if(strcmp(cmd,"q!")==0||strcmp(cmd,"quit!")==0){
c_forceQuit();
}else if(strcmp(cmd,"o")==0||strcmp(cmd,"open")==0){
c_readFromDisk(arg,true);
}else if(strcmp(cmd,"boom")==0){
c_boom(arg,arg2);
}else{
char str[1000];
sprintf(str,"Librazy don't know how to %s,\nresume game now",cmd);
str[99]='\0';
c_warning(str);
}
}
static void
warn_about_midscene_changes(void)
{
static bool seen = false;
if (!seen) {
c_warning("Mid-scene modification of indices has "
"undefined results\n");
seen = true;
}
}
static void g_Error(dyad_Event *e) {
connecting=false;
c_warning(e->msg);
dyad_end(e->stream);
dyad_shutdown();
pthread_cancel(TInfo);
pthread_cond_signal (&CInfo);
pthread_join(TInfo, NULL);
getch();
c_forceQuit();
}
void EMSCRIPTEN_KEEPALIVE
rig_pb_stream_websocket_error_cb(int fd,
int error,
const char *msg,
void *user_data)
{
rig_pb_stream_t *stream = user_data;
c_warning("websocket error message: %s\n", msg);
rig_pb_stream_disconnect(stream);
}
static void
on_address_resolved(uv_getaddrinfo_t *resolver,
int status,
struct addrinfo *result)
{
rig_pb_stream_t *stream = rut_container_of(resolver, stream, resolver);
uv_loop_t *loop = rut_uv_shell_get_loop(stream->shell);
char ip_address[17] = {'\0'};
c_return_if_fail(stream->resolving);
if (status < 0) {
c_warning("Failed to resolve slave address \"%s\": %s",
stream->hostname, uv_strerror(status));
rut_closure_list_invoke(&stream->on_error_closures,
rig_pb_stream_callback_t,
stream);
/* NB: we were at least keeping the stream alive while
* waiting for the resolve request to finish... */
stream->resolving = false;
rut_object_unref(stream);
return;
}
uv_ip4_name((struct sockaddr_in*)result->ai_addr, ip_address, 16);
c_message("stream: Resolved address of \"%s\" = %s",
stream->hostname, ip_address);
uv_tcp_init(loop, &stream->tcp.socket);
stream->tcp.socket.data = stream;
/* NB: we took a reference to keep the stream alive while
* resolving the address, so conceptually we are now handing
* the reference over to keep the stream alive while waiting
* for it to connect... */
stream->resolving = false;
stream->connecting = true;
stream->connection_request.data = stream;
uv_tcp_connect(&stream->connection_request,
&stream->tcp.socket,
result->ai_addr,
on_connect);
uv_freeaddrinfo(result);
}
/// \brief Handle when no empty grid present
/// \return If restart
bool die(){
c_warning("You are dead!\nPress q to quit or r to restart");
int ch;
while((ch=getch())){
switch(ch){
case 'r':case 'R':
return 1;
break;
case 'q':case 'Q':
c_forceQuit();
break;
}
}
return 0;
}
/// \brief Read the saved board
/// \param from The number of board to read from
/// \return void
void c_readBoard(int from){
if(from==NA){
from=abs((16+curs-1)%MAX_BOARD_NUM);
}
from%=MAX_BOARD_NUM;
boardseed[curs]=Rando(RAND_MAX);
char str[1000];
if(boardseed[from]==NA){
sprintf(str,"Librazy found board#%d empty",from);
c_warning(str);
return;
}
curs=from;
srand(boardseed[from]);
sprintf(str,"Load board#%d",curs);
c_info(str);
}
static void n_Init(dyad_Event *e) {
if (!memcmp(e->data, "INCOMP", 6)) {
c_warning("Incompatiable version!Quit.");
dyad_end(e->stream);
dyad_shutdown();
pthread_cancel(TInfo);
pthread_cond_signal (&CInfo);
pthread_join(TInfo, NULL);
getch();
c_forceQuit();
}else{
SGaming=e->stream;
dyad_removeAllListeners(e->stream, DYAD_EVENT_DATA);
dyad_addListener(e->stream, DYAD_EVENT_DATA, g_Data, NULL);
dyad_addListener(e->stream, DYAD_EVENT_CLOSE, g_Close, NULL);
pthread_mutex_unlock(&MNetC);
}
}
/// \brief Write the board to disk
/// \param boards The number of board to save
/// \return Whether the file is saved successfully
bool c_writeBoardToDisk(char boards,bool info){
char name[20];
int ver=c_version();
if(boards!=NA){
boards=abs(boards%MAX_BOARD_NUM);
sprintf(name,"2048.%d.%X.save",boards,ver);
}else{
sprintf(name,"2048.%X.save",ver);
boards=curs;
}
boards=abs(boards%MAX_BOARD_NUM);
FILE *fp;
if((fp=fopen(name,"w+"))) {
fprintf(fp,"%X\n",ver);
char tmp=curs;
curs=boards;
c_currentStr(false);
fprintf(fp,"%d\n",N);
for(int i=0;i!=N;++i){
for(int j=0;j!=N;++j){
fprintf(fp,"%s",boardstr[i][j]);
}
}
boardseed[curs]=Rando(RAND_MAX);
srand(boardseed[curs]);
fprintf(fp,"\n%d\n",boardseed[curs]);
int checksum=c_checksum();
fprintf(fp,"%d\n",checksum+boardseed[curs]);
curs=tmp;
char str[1000];
sprintf(str,"Saved board#%d at %s",boards,name);
if(info)c_info(str);
fclose(fp);
return true;
}else{
char str[1000];
sprintf(str,"Librazy don't know how to open %s,\nsave failed",name);
c_warning(str);
fclose(fp);
return false;
}
}
bool
_cg_texture_2d_gl_can_create(cg_device_t *dev,
int width,
int height,
cg_pixel_format_t internal_format)
{
GLenum gl_intformat;
GLenum gl_format;
GLenum gl_type;
#if defined(C_PLATFORM_WEB)
/* XXX: Although webgl has limited supported from NOP textures, this
* is a hack to help find places to try and convert over to using
* NPOT textures... */
if (!(_cg_util_is_pot(width) && _cg_util_is_pot(height))) {
c_warning("WARNING: NPOT texture: width=%d height=%d", width, height);
_c_web_console_trace();
}
#endif
/* If NPOT textures aren't supported then the size must be a power
of two */
if (!cg_has_feature(dev, CG_FEATURE_ID_TEXTURE_NPOT_BASIC) &&
(!_cg_util_is_pot(width) || !_cg_util_is_pot(height)))
return false;
dev->driver_vtable->pixel_format_to_gl(dev, internal_format,
&gl_intformat, &gl_format,
&gl_type);
/* Check that the driver can create a texture with that size */
if (!dev->texture_driver->size_supported(dev,
GL_TEXTURE_2D,
gl_intformat,
gl_format,
gl_type,
width,
height))
return false;
return true;
}
static void s_Init(dyad_Event *e) {
int cliver=0,val=0,cliN;
val=sscanf(e->data,"VERSION %X %d",&cliver,&cliN);
if(cliver!=c_version()||val!=2){
dyad_writef(e->stream,"INCOMP\n");
c_warning("Incompatiable version!Quit.");
dyad_update();
dyad_end(SServ);
getch();
c_forceQuit();
}else{
SGaming=e->stream;
N=cliN;
dyad_writef(e->stream,"OK\n");dyad_update();
dyad_removeAllListeners(e->stream, DYAD_EVENT_DATA);
dyad_addListener(e->stream, DYAD_EVENT_DATA, g_Data, NULL);
dyad_addListener(e->stream, DYAD_EVENT_CLOSE, g_Close, NULL);
pthread_mutex_unlock(&MNetC);
}
}
void
rut_headless_shell_handle_stream_event(rut_shell_t *shell,
rut_stream_event_t *stream_event)
{
rut_input_event_t *event = c_slice_alloc0(sizeof(rut_input_event_t));
event->native = stream_event;
event->type = 0;
event->camera_entity = stream_event->camera_entity;
event->onscreen = shell->headless_onscreen;
switch (stream_event->type) {
case RUT_STREAM_EVENT_POINTER_MOVE:
case RUT_STREAM_EVENT_POINTER_DOWN:
case RUT_STREAM_EVENT_POINTER_UP:
event->type = RUT_INPUT_EVENT_TYPE_MOTION;
break;
case RUT_STREAM_EVENT_KEY_DOWN:
case RUT_STREAM_EVENT_KEY_UP:
event->type = RUT_INPUT_EVENT_TYPE_KEY;
break;
}
/* Note: we don't use a default: case since we want the
* compiler to warn us when we forget to handle a new
* enum */
if (!event->type) {
c_warning("Shell: Spurious stream event type %d\n", stream_event->type);
c_slice_free(rut_input_event_t, event);
return;
}
rut_input_queue_append(shell->input_queue, event);
/* FIXME: we need a separate status so we can trigger a new
* frame, but if the input doesn't affect anything then we
* want to avoid any actual rendering. */
rut_shell_queue_redraw(shell);
}
static void
_cg_winsys_onscreen_swap_buffers_with_damage(
cg_onscreen_t *onscreen, const int *rectangles, int n_rectangles)
{
cg_device_t *dev = CG_FRAMEBUFFER(onscreen)->dev;
cg_renderer_t *renderer = dev->display->renderer;
cg_renderer_egl_t *egl_renderer = renderer->winsys;
cg_onscreen_egl_t *egl_onscreen = onscreen->winsys;
/* The specification for EGL (at least in 1.4) says that the surface
needs to be bound to the current context for the swap to work
although it may change in future. Mesa explicitly checks for this
and just returns an error if this is not the case so we can't
just pretend this isn't in the spec. */
_cg_framebuffer_flush_state(CG_FRAMEBUFFER(onscreen),
CG_FRAMEBUFFER(onscreen),
CG_FRAMEBUFFER_STATE_BIND);
if (egl_renderer->pf_eglSwapBuffersWithDamage) {
cg_framebuffer_t *fb = CG_FRAMEBUFFER(onscreen);
size_t size = n_rectangles * sizeof(int) * 4;
int *flipped = alloca(size);
int i;
memcpy(flipped, rectangles, size);
for (i = 0; i < n_rectangles; i++) {
const int *rect = rectangles + 4 * i;
int *flip_rect = flipped + 4 * i;
flip_rect[1] = fb->height - rect[1] - rect[3];
}
if (!egl_renderer->pf_eglSwapBuffersWithDamage(egl_renderer->edpy,
egl_onscreen->egl_surface,
flipped,
n_rectangles))
c_warning("Error reported by eglSwapBuffersWithDamage");
} else
eglSwapBuffers(egl_renderer->edpy, egl_onscreen->egl_surface);
}
/// \brief Load the string representing saved board
/// \param iptN The N in the saved game
/// \param fp The file stream to read from
/// \return void
void c_loadStr(int iptN,FILE* fp,bool info){
N=iptN;
Clrboard(curs);
char str[256*3+2];
fscanf(fp,"%s",str);
int checksum;int seed;
fscanf(fp,"%d",&seed);
fscanf(fp,"%d",&checksum);
boardseed[curs]=seed;
srand(seed);
checksum-=seed;
int offset=0;
for(int i=0;i!=N;++i){
for(int j=0;j!=N;++j){
if(('@'<=str[i*N+j+offset])&&('Z'>=str[i*N+j+offset])){
board[curs][i][j]=str[i*N+j+offset]-'A';
continue;
}
if(('a'<=str[i*N+j+offset])&&('z'>=str[i*N+j+offset])){
board[curs][i][j]=str[i*N+j+offset]-'a';
continue;
}
if(('0'<=str[i*N+j+offset])&&('9'>=str[i*N+j+offset])){
board[curs][i][j]=(str[i*N+j+offset]-'0')*100+
(str[i*N+j+offset+1]-'0')*10+
(str[i*N+j+offset+2]-'0');
offset+=2;
continue;
}
}
}
if(c_checksum()==checksum){
if(info)c_info("Game progress loaded successful!");
}else{
Clrboard(curs);
c_warning("Librazy found you are cheating!");
}
}
static void
_cg_winsys_onscreen_deinit(cg_onscreen_t *onscreen)
{
cg_framebuffer_t *framebuffer = CG_FRAMEBUFFER(onscreen);
cg_device_t *dev = framebuffer->dev;
cg_display_egl_t *egl_display = dev->display->winsys;
cg_renderer_t *renderer = dev->display->renderer;
cg_renderer_egl_t *egl_renderer = renderer->winsys;
cg_onscreen_egl_t *egl_onscreen = onscreen->winsys;
/* If we never successfully allocated then there's nothing to do */
if (egl_onscreen == NULL)
return;
if (egl_onscreen->egl_surface != EGL_NO_SURFACE) {
/* CGlib always needs a valid context bound to something so if we
* are destroying the onscreen that is currently bound we'll
* switch back to the dummy drawable. */
if (egl_display->dummy_surface != EGL_NO_SURFACE &&
(egl_display->current_draw_surface == egl_onscreen->egl_surface ||
egl_display->current_read_surface == egl_onscreen->egl_surface)) {
_cg_winsys_egl_make_current(dev->display,
egl_display->dummy_surface,
egl_display->dummy_surface,
egl_display->current_context);
}
if (!eglDestroySurface(egl_renderer->edpy, egl_onscreen->egl_surface))
c_warning("Failed to destroy EGL surface");
egl_onscreen->egl_surface = EGL_NO_SURFACE;
}
if (egl_renderer->platform_vtable->onscreen_deinit)
egl_renderer->platform_vtable->onscreen_deinit(onscreen);
c_slice_free(cg_onscreen_egl_t, onscreen->winsys);
onscreen->winsys = NULL;
}
static void
read_cb(uv_stream_t *uv_stream, ssize_t len, const uv_buf_t *buf)
{
rig_pb_stream_t *stream = uv_stream->data;
if (len < 0) {
c_warning("stream error: %s", uv_strerror(len));
rig_pb_stream_disconnect(stream);
return;
}
if (len == UV_EOF) {
rig_pb_stream_disconnect(stream);
return;
}
if (len > 0)
stream->read_callback(stream, (uint8_t *)buf->base, len,
stream->read_data);
if (buf->base)
c_free(buf->base);
}
static void
_cg_winsys_onscreen_swap_region(cg_onscreen_t *onscreen,
const int *user_rectangles,
int n_rectangles)
{
cg_device_t *dev = CG_FRAMEBUFFER(onscreen)->dev;
cg_renderer_t *renderer = dev->display->renderer;
cg_renderer_egl_t *egl_renderer = renderer->winsys;
cg_onscreen_egl_t *egl_onscreen = onscreen->winsys;
cg_framebuffer_t *framebuffer = CG_FRAMEBUFFER(onscreen);
int framebuffer_height = cg_framebuffer_get_height(framebuffer);
int *rectangles = c_alloca(sizeof(int) * n_rectangles * 4);
int i;
/* eglSwapBuffersRegion expects rectangles relative to the
* bottom left corner but we are given rectangles relative to
* the top left so we need to flip them... */
memcpy(rectangles, user_rectangles, sizeof(int) * n_rectangles * 4);
for (i = 0; i < n_rectangles; i++) {
int *rect = &rectangles[4 * i];
rect[1] = framebuffer_height - rect[1] - rect[3];
}
/* At least for eglSwapBuffers the EGL spec says that the surface to
swap must be bound to the current context. It looks like Mesa
also validates that this is the case for eglSwapBuffersRegion so
we must bind here too */
_cg_framebuffer_flush_state(CG_FRAMEBUFFER(onscreen),
CG_FRAMEBUFFER(onscreen),
CG_FRAMEBUFFER_STATE_BIND);
if (!egl_renderer->pf_eglSwapBuffersRegion(egl_renderer->edpy,
egl_onscreen->egl_surface,
n_rectangles,
rectangles))
c_warning("Error reported by eglSwapBuffersRegion");
}
static bool
flush_layers_common_gl_state_cb(cg_pipeline_layer_t *layer,
void *user_data)
{
cg_pipeline_flush_layer_state_t *flush_state = user_data;
cg_device_t *dev = flush_state->dev;
int unit_index = flush_state->i;
cg_texture_unit_t *unit = _cg_get_texture_unit(dev, unit_index);
unsigned long layers_difference =
flush_state->layer_differences[unit_index];
/* There may not be enough texture units so we can bail out if
* that's the case...
*/
if (C_UNLIKELY(unit_index >= get_max_activateable_texture_units(dev))) {
static bool shown_warning = false;
if (!shown_warning) {
c_warning("Your hardware does not have enough texture units"
"to handle this many texture layers");
shown_warning = true;
}
return false;
}
if (layers_difference & CG_PIPELINE_LAYER_STATE_TEXTURE_DATA) {
cg_texture_t *texture = _cg_pipeline_layer_get_texture_real(layer);
GLuint gl_texture;
GLenum gl_target;
if (texture == NULL)
switch (_cg_pipeline_layer_get_texture_type(layer)) {
case CG_TEXTURE_TYPE_2D:
texture = CG_TEXTURE(dev->default_gl_texture_2d_tex);
break;
case CG_TEXTURE_TYPE_3D:
texture = CG_TEXTURE(dev->default_gl_texture_3d_tex);
break;
}
cg_texture_get_gl_texture(texture, &gl_texture, &gl_target);
set_active_texture_unit(dev, unit_index);
/* NB: There are several CGlib components and some code in
* Clutter that will temporarily bind arbitrary GL textures to
* query and modify texture object parameters. If you look at
* _cg_bind_gl_texture_transient() you can see we make sure
* that such code always binds to texture unit 1 which means we
* can't rely on the unit->gl_texture state if unit->index == 1.
*
* Because texture unit 1 is a bit special we actually defer any
* necessary glBindTexture for it until the end of
* _cg_pipeline_flush_gl_state().
*
* NB: we get notified whenever glDeleteTextures is used (see
* _cg_delete_gl_texture()) where we invalidate
* unit->gl_texture references to deleted textures so it's safe
* to compare unit->gl_texture with gl_texture. (Without the
* hook it would be possible to delete a GL texture and create a
* new one with the same name and comparing unit->gl_texture and
* gl_texture wouldn't detect that.)
*
* NB: for foreign textures we don't know how the deletion of
* the GL texture objects correspond to the deletion of the
* cg_texture_ts so if there was previously a foreign texture
* associated with the texture unit then we can't assume that we
* aren't seeing a recycled texture name so we have to bind.
*/
if (unit->gl_texture != gl_texture || unit->is_foreign) {
if (unit_index == 1)
unit->dirty_gl_texture = true;
else
GE(dev, glBindTexture(gl_target, gl_texture));
unit->gl_texture = gl_texture;
unit->gl_target = gl_target;
}
unit->is_foreign = _cg_texture_is_foreign(texture);
/* The texture_storage_changed boolean indicates if the
* cg_texture_t's underlying GL texture storage has changed since
* it was flushed to the texture unit. We've just flushed the
* latest state so we can reset this. */
unit->texture_storage_changed = false;
}
if ((layers_difference & CG_PIPELINE_LAYER_STATE_SAMPLER) &&
_cg_has_private_feature(dev, CG_PRIVATE_FEATURE_SAMPLER_OBJECTS)) {
const cg_sampler_cache_entry_t *sampler_state;
sampler_state = _cg_pipeline_layer_get_sampler_state(layer);
GE(dev, glBindSampler(unit_index, sampler_state->sampler_object));
}
cg_object_ref(layer);
if (unit->layer != NULL)
cg_object_unref(unit->layer);
unit->layer = layer;
unit->layer_changes_since_flush = 0;
flush_state->i++;
return true;
}
cg_texture_t *
rig_downsampler_downsample(rig_downsampler_t *downsampler,
cg_texture_t *source,
int scale_factor_x,
int scale_factor_y)
{
cg_texture_components_t components;
int src_w, src_h;
int dest_width, dest_height;
cg_pipeline_t *pipeline;
/* validation */
src_w = cg_texture_get_width(source);
src_h = cg_texture_get_height(source);
if (src_w % scale_factor_x != 0) {
c_warning("downsample: the width of the texture (%d) is not a "
"multiple of the scale factor (%d)",
src_w,
scale_factor_x);
}
if (src_h % scale_factor_y != 0) {
c_warning("downsample: the height of the texture (%d) is not a "
"multiple of the scale factor (%d)",
src_h,
scale_factor_y);
}
/* create the destination texture up front */
dest_width = src_w / scale_factor_x;
dest_height = src_h / scale_factor_y;
components = cg_texture_get_components(source);
if (downsampler->dest == NULL ||
cg_texture_get_width(downsampler->dest) != dest_width ||
cg_texture_get_height(downsampler->dest) != dest_height ||
cg_texture_get_components(downsampler->dest) != components) {
cg_offscreen_t *offscreen;
cg_texture_2d_t *texture_2d = cg_texture_2d_new_with_size(
downsampler->engine->shell->cg_device, dest_width, dest_height);
cg_texture_set_components(texture_2d, components);
_rig_downsampler_reset(downsampler);
downsampler->dest = texture_2d;
/* create the FBO to render the downsampled texture */
offscreen = cg_offscreen_new_with_texture(downsampler->dest);
downsampler->fb = offscreen;
/* create the camera that will setup the scene for the render */
downsampler->camera = rig_camera_new(downsampler->engine,
dest_width, /* ortho width */
dest_height, /* ortho height */
downsampler->fb);
rut_camera_set_near_plane(downsampler->camera, -1.f);
rut_camera_set_far_plane(downsampler->camera, 1.f);
}
pipeline = cg_pipeline_copy(downsampler->pipeline);
cg_pipeline_set_layer_texture(pipeline, 0, source);
rut_camera_flush(downsampler->camera);
cg_framebuffer_draw_rectangle(
downsampler->fb, pipeline, 0, 0, dest_width, dest_height);
rut_camera_end_frame(downsampler->camera);
cg_object_unref(pipeline);
return cg_object_ref(downsampler->dest);
}
