コード例 #1
0
ファイル: files.c プロジェクト: kodephys/cdogs-sdl
const char *GetHomeDirectory(void)
{
	const char *p;

	if (cdogs_homepath != NULL)
	{
		return cdogs_homepath;
	}

	p = getenv("CDOGS_CONFIG_DIR");
	if (p != NULL && strlen(p) != 0)
	{
		CSTRDUP(cdogs_homepath, p);
		return cdogs_homepath;
	}

	p = getenv(HOME_DIR_ENV);
	if (p != NULL && strlen(p) != 0)
	{
		CCALLOC(cdogs_homepath, strlen(p) + 2);
		strcpy(cdogs_homepath, p);
		cdogs_homepath[strlen(p)] = '/';
		return cdogs_homepath;
	}

	fprintf(stderr,"%s%s%s%s",
	"##############################################################\n",
	"# You don't have the environment variables HOME or USER set. #\n",
	"# It is suggested you get a better shell. :D                 #\n",
	"##############################################################\n");
	return "";
}
コード例 #2
0
ファイル: AStar.c プロジェクト: ChunHungLiu/cdogs-sdl
static inline ASNeighborList NeighborListCreate(const ASPathNodeSource *source)
{
	ASNeighborList list;
	CCALLOC(list, sizeof(struct __ASNeighborList));
    list->source = source;
    return list;
}
コード例 #3
0
ファイル: ui_object.c プロジェクト: depoorterp/cdogs-sdl
UIObject *UIObjectCreate(UIType type, int id, Vec2i pos, Vec2i size)
{
	UIObject *o;
	CCALLOC(o, sizeof *o);
	o->Type = type;
	o->Id = id;
	o->Pos = pos;
	o->Size = size;
	o->IsVisible = true;
	switch (type)
	{
	case UITYPE_TEXTBOX:
		o->u.Textbox.IsEditable = 1;
		o->ChangesData = 1;
		break;
	case UITYPE_TAB:
		CArrayInit(&o->u.Tab.Labels, sizeof(char *));
		o->u.Tab.Index = 0;
		break;
	case UITYPE_CONTEXT_MENU:
		// Context menu always starts as invisible
		o->IsVisible = false;
		break;
	default:
		// do nothing
		break;
	}
	CArrayInit(&o->Children, sizeof o);
	return o;
}
コード例 #4
0
static json_t *SaveStaticTiles(Mission *m)
{
	// Create a text buffer for CSV
	// The buffer will contain n*5 chars (tiles, allow 5 chars each),
	// and n - 1 commas, so 6n total
	const int size = (int)m->u.Static.Tiles.size;
	if (size == 0)
	{
		return json_new_string("");
	}
	char *bigbuf;
	CCALLOC(bigbuf, size * 6);
	char *pBuf = bigbuf;
	CASSERT(pBuf != NULL, "memory error");
	for (int i = 0; i < size; i++)
	{
		char buf[32];
		sprintf(buf, "%d", *(unsigned short *)CArrayGet(
			&m->u.Static.Tiles, i));
		strcpy(pBuf, buf);
		pBuf += strlen(buf);
		if (i < size - 1)
		{
			*pBuf = ',';
			pBuf++;
		}
	}
	json_t *node = json_new_string(bigbuf);
	CFREE(bigbuf);
	return node;
}
コード例 #5
0
ファイル: briefing_screens.c プロジェクト: Wuzzy2/cdogs-sdl
bool ScreenMissionBriefing(const struct MissionOptions *m)
{
	const int w = gGraphicsDevice.cachedConfig.Res.x;
	const int h = gGraphicsDevice.cachedConfig.Res.y;
	const int y = h / 4;
	MissionBriefingData mData;
	memset(&mData, 0, sizeof mData);
	mData.IsOK = true;

	// Title
	CMALLOC(mData.Title, strlen(m->missionData->Title) + 32);
	sprintf(mData.Title, "Mission %d: %s",
		m->index + 1, m->missionData->Title);
	mData.TitleOpts = FontOptsNew();
	mData.TitleOpts.HAlign = ALIGN_CENTER;
	mData.TitleOpts.Area = gGraphicsDevice.cachedConfig.Res;
	mData.TitleOpts.Pad.y = y - 25;

	// Password
	if (m->index > 0)
	{
		sprintf(
			mData.Password, "Password: %s", gAutosave.LastMission.Password);
		mData.PasswordOpts = FontOptsNew();
		mData.PasswordOpts.HAlign = ALIGN_CENTER;
		mData.PasswordOpts.Area = gGraphicsDevice.cachedConfig.Res;
		mData.PasswordOpts.Pad.y = y - 15;
	}

	// Split the description, and prepare it for typewriter effect
	mData.TypewriterCount = 0;
	// allow some slack for newlines
	CMALLOC(mData.Description, strlen(m->missionData->Description) * 2 + 1);
	CCALLOC(mData.TypewriterBuf, strlen(m->missionData->Description) * 2 + 1);
	// Pad about 1/6th of the screen width total (1/12th left and right)
	FontSplitLines(m->missionData->Description, mData.Description, w * 5 / 6);
	mData.DescriptionPos = Vec2iNew(w / 12, y);

	// Objectives
	mData.ObjectiveDescPos =
		Vec2iNew(w / 6, y + FontStrH(mData.Description) + h / 10);
	mData.ObjectiveInfoPos =
		Vec2iNew(w - (w / 6), mData.ObjectiveDescPos.y + FontH());
	mData.ObjectiveHeight = h / 12;
	mData.MissionOptions = m;

	GameLoopData gData = GameLoopDataNew(
		&mData, MissionBriefingUpdate,
		&mData, MissionBriefingDraw);
	GameLoop(&gData);
	if (mData.IsOK)
	{
		SoundPlay(&gSoundDevice, StrSound("mg"));
	}

	CFREE(mData.Title);
	CFREE(mData.Description);
	CFREE(mData.TypewriterBuf);
	return mData.IsOK;
}
コード例 #6
0
ファイル: triggers.c プロジェクト: cxong/cdogs-sdl
Trigger *TriggerNew(void)
{
	Trigger *t;
	CCALLOC(t, sizeof *t);
	t->isActive = 1;
	CArrayInit(&t->actions, sizeof(Action));
	return t;
}
コード例 #7
0
ファイル: AStar.c プロジェクト: ChunHungLiu/cdogs-sdl
static inline VisitedNodes VisitedNodesCreate(const ASPathNodeSource *source, void *context)
{
	VisitedNodes nodes;
	CCALLOC(nodes, sizeof(struct __VisitedNodes));
    nodes->source = source;
    nodes->context = context;
    return nodes;
}
コード例 #8
0
ファイル: menu.c プロジェクト: Wuzzy2/cdogs-sdl
menu_t *MenuCreate(const char *name, menu_type_e type)
{
	menu_t *menu;
	CCALLOC(menu, sizeof(menu_t));
	CSTRDUP(menu->name, name);
	menu->type = type;
	menu->parentMenu = NULL;
	return menu;
}
コード例 #9
0
ファイル: ai_context.c プロジェクト: ChunHungLiu/cdogs-sdl
AIContext *AIContextNew(void)
{
	AIContext *c;
	CCALLOC(c, sizeof *c);
	// Initialise chatter counter so we don't say anything in the background
	c->ChatterCounter = 2;
	c->EnemyId = -1;
	c->GunRangeScalar = 1.0;
	return c;
}
コード例 #10
0
ファイル: triggers.c プロジェクト: Wuzzy2/cdogs-sdl
TWatch *WatchNew(void)
{
	TWatch *t;
	CCALLOC(t, sizeof(TWatch));
	t->index = watchIndex++;
	t->next = inactiveWatches;
	inactiveWatches = t;
	CArrayInit(&t->actions, sizeof(Action));
	CArrayInit(&t->conditions, sizeof(Condition));
	return t;
}
コード例 #11
0
ファイル: triggers.c プロジェクト: bugamn/cdogs-sdl
TWatch *AddWatch(int conditionCount, int actionCount)
{
	TWatch *t;
	CCALLOC(t, sizeof(TWatch));
	t->index = watchIndex++;
	t->next = inactiveWatches;
	inactiveWatches = t;
	t->actions = AddActions(actionCount);
	t->conditions = AddConditions(conditionCount);
	return t;
}
コード例 #12
0
static char *ReadFileIntoBuf(const char *path, const char *mode, long *len)
{
	char *buf = NULL;
	FILE *f = fopen(path, mode);
	if (f == NULL)
	{
		debug(D_NORMAL, "Did not open file %s: %s.\n", path, strerror(errno));
		goto bail;
	}

	// Read into buffer
	if (fseek(f, 0L, SEEK_END) != 0)
	{
		debug(D_NORMAL, "Cannot seek file %s: %s.\n", path, strerror(errno));
		goto bail;
	}
	*len = ftell(f);
	if (*len == -1)
	{
		debug(D_NORMAL, "Cannot tell file %s: %s.\n", path, strerror(errno));
		goto bail;
	}
	CCALLOC(buf, *len + 1);
	if (fseek(f, 0L, SEEK_SET) != 0)
	{
		debug(D_NORMAL, "Cannot seek file %s: %s.\n", path, strerror(errno));
		goto bail;
	}
	if (fread(buf, 1, *len, f) == 0)
	{
		debug(D_NORMAL, "Cannot read file %s: %s.\n", path, strerror(errno));
		goto bail;
	}

	goto end;

bail:
	CFREE(buf);
	buf = NULL;

end:
	if (f != NULL && fclose(f) != 0)
	{
		debug(D_NORMAL, "Cannot close file %s: %s.\n", path, strerror(errno));
	}
	return buf;
}
コード例 #13
0
ファイル: triggers.c プロジェクト: bugamn/cdogs-sdl
TTrigger *AddTrigger(int x, int y, int actionCount)
{
	TTrigger *t;
	TTrigger **h;

	CCALLOC(t, sizeof(TTrigger));
	t->x = x;
	t->y = y;

	h = &root;
	while (*h) {
		if ((*h)->y < y || ((*h)->y == y && (*h)->x < x))
			h = &((*h)->right);
		else
			h = &((*h)->left);
	}
	*h = t;
	t->actions = AddActions(actionCount);
	return t;
}
コード例 #14
0
ファイル: triggers.c プロジェクト: bugamn/cdogs-sdl
static TCondition *AddConditions(int count)
{
	TCondition *a;
	CCALLOC(a, sizeof(TCondition) * (count + 1));
	return a;
}
コード例 #15
0
ファイル: grafx.c プロジェクト: kodephys/cdogs-sdl
// Initialises the video subsystem.
// To prevent needless screen flickering, config is compared with cache
// to see if anything changed. If not, don't recreate the screen.
void GraphicsInitialize(
	GraphicsDevice *device, GraphicsConfig *config, TPalette palette,
	int force)
{
	int sdl_flags = 0;
	unsigned int w, h = 0;
	unsigned int rw, rh;

	if (!IsRestartRequiredForConfig(device, config))
	{
		return;
	}

	if (!device->IsWindowInitialized)
	{
		/* only do this the first time */
		char title[32];
		debug(D_NORMAL, "setting caption and icon...\n");
		sprintf(title, "C-Dogs SDL %s%s",
			config->IsEditor ? "Editor " : "",
			CDOGS_SDL_VERSION);
		SDL_WM_SetCaption(title, NULL);
		device->icon = SDL_LoadBMP(GetDataFilePath("cdogs_icon.bmp"));
		SDL_WM_SetIcon(device->icon, NULL);
		AddSupportedGraphicsModes(device);
	}

	device->IsInitialized = 0;

	sdl_flags |= SDL_SWSURFACE;
	sdl_flags |= config->IsEditor ? SDL_RESIZABLE : 0;
	if (config->Fullscreen)
	{
		sdl_flags |= SDL_FULLSCREEN;
	}

	rw = w = config->Res.x;
	rh = h = config->Res.y;

	if (config->ScaleFactor > 1)
	{
		rw *= config->ScaleFactor;
		rh *= config->ScaleFactor;
	}

	if (!force && !config->IsEditor)
	{
		device->modeIndex = FindValidMode(device, w, h, config->ScaleFactor);
		if (device->modeIndex == -1)
		{
			device->modeIndex = 0;
			printf("!!! Invalid Video Mode %dx%d\n", w, h);
			return;
		}
	}
	else
	{
		printf("\n");
		printf("  BIG FAT WARNING: If this blows up in your face,\n");
		printf("  and mutilates your cat, please don't cry.\n");
		printf("\n");
	}

	printf("Graphics mode:\t%dx%d %dx (actual %dx%d)\n",
		w, h, config->ScaleFactor, rw, rh);
	SDL_FreeSurface(device->screen);
	device->screen = SDL_SetVideoMode(rw, rh, 32, sdl_flags);
	if (device->screen == NULL)
	{
		printf("ERROR: InitVideo: %s\n", SDL_GetError());
		return;
	}
	SDL_PixelFormat *f = device->screen->format;
	device->Amask = -1 & ~(f->Rmask | f->Gmask | f->Bmask);
	Uint32 aMask = device->Amask;
	device->Ashift = 0;
	while (aMask != 0xff)
	{
		device->Ashift += 8;
		aMask >>= 8;
	}

	CFREE(device->buf);
	CCALLOC(device->buf, GraphicsGetMemSize(config));
	CFREE(device->bkg);
	CCALLOC(device->bkg, GraphicsGetMemSize(config));

	debug(D_NORMAL, "Changed video mode...\n");

	GraphicsSetBlitClip(
		device,
		0, 0, config->Res.x - 1,config->Res.y - 1);
	debug(D_NORMAL, "Internal dimensions:\t%dx%d\n",
		config->Res.x, config->Res.y);

	device->IsInitialized = 1;
	device->IsWindowInitialized = 1;
	device->cachedConfig = *config;
	device->cachedConfig.Res.x = w;
	device->cachedConfig.Res.y = h;
	CDogsSetPalette(palette);
}
コード例 #16
0
ファイル: grafx.c プロジェクト: gallegretti/cdogs-sdl
// Initialises the video subsystem.
// To prevent needless screen flickering, config is compared with cache
// to see if anything changed. If not, don't recreate the screen.
void GraphicsInitialize(GraphicsDevice *g, const bool force)
{
#ifdef __GCWZERO__
	int sdl_flags = SDL_HWSURFACE | SDL_TRIPLEBUF;
#else
	int sdl_flags = SDL_SWSURFACE;
#endif
	unsigned int w, h = 0;
	unsigned int rw, rh;

	if (g->IsInitialized && !g->cachedConfig.needRestart)
	{
		return;
	}

	if (!g->IsWindowInitialized)
	{
		/* only do this the first time */
		char title[32];
		debug(D_NORMAL, "setting caption and icon...\n");
		sprintf(title, "C-Dogs SDL %s%s",
			g->cachedConfig.IsEditor ? "Editor " : "",
			CDOGS_SDL_VERSION);
		SDL_WM_SetCaption(title, NULL);
		char buf[CDOGS_PATH_MAX];
		GetDataFilePath(buf, "cdogs_icon.bmp");
		g->icon = SDL_LoadBMP(buf);
		SDL_WM_SetIcon(g->icon, NULL);
		AddSupportedGraphicsModes(g);
	}

	g->IsInitialized = false;

	sdl_flags |= g->cachedConfig.IsEditor ? SDL_RESIZABLE : 0;
	if (g->cachedConfig.Fullscreen)
	{
		sdl_flags |= SDL_FULLSCREEN;
	}

	rw = w = g->cachedConfig.Res.x;
	rh = h = g->cachedConfig.Res.y;

	if (g->cachedConfig.ScaleFactor > 1)
	{
		rw *= g->cachedConfig.ScaleFactor;
		rh *= g->cachedConfig.ScaleFactor;
	}

	if (!force && !g->cachedConfig.IsEditor)
	{
		g->modeIndex = FindValidMode(g, w, h, g->cachedConfig.ScaleFactor);
		if (g->modeIndex == -1)
		{
			g->modeIndex = 0;
			printf("!!! Invalid Video Mode %dx%d\n", w, h);
			return;
		}
	}

	printf("Graphics mode:\t%dx%d %dx (actual %dx%d)\n",
		w, h, g->cachedConfig.ScaleFactor, rw, rh);
	SDL_FreeSurface(g->screen);
	g->screen = SDL_SetVideoMode(rw, rh, 32, sdl_flags);
	if (g->screen == NULL)
	{
		printf("ERROR: InitVideo: %s\n", SDL_GetError());
		return;
	}
	SDL_PixelFormat *f = g->screen->format;
	g->Amask = -1 & ~(f->Rmask | f->Gmask | f->Bmask);
	Uint32 aMask = g->Amask;
	g->Ashift = 0;
	while (aMask != 0xff)
	{
		g->Ashift += 8;
		aMask >>= 8;
	}

	CFREE(g->buf);
	CCALLOC(g->buf, GraphicsGetMemSize(&g->cachedConfig));
	CFREE(g->bkg);
	CCALLOC(g->bkg, GraphicsGetMemSize(&g->cachedConfig));

	debug(D_NORMAL, "Changed video mode...\n");

	GraphicsSetBlitClip(
		g, 0, 0, g->cachedConfig.Res.x - 1, g->cachedConfig.Res.y - 1);
	debug(D_NORMAL, "Internal dimensions:\t%dx%d\n",
		g->cachedConfig.Res.x, g->cachedConfig.Res.y);

	g->IsInitialized = true;
	g->IsWindowInitialized = true;
	g->cachedConfig.Res.x = w;
	g->cachedConfig.Res.y = h;
	g->cachedConfig.needRestart = false;
}
コード例 #17
0
ファイル: editor_ui_common.c プロジェクト: cxong/cdogs-sdl
static void CreateAddMapItemSubObjs(UIObject *c, void *vData)
{
	const CreateAddMapItemObjsImplData *data = vData;
	const int pageSize = data->GridSize.x * data->GridSize.y;
	// Check if we need to recreate the objs
	// TODO: this is a very heavyweight way to do it
	int count = 0;
	bool allChildrenSame = true;
	for (int i = 0; i < MapObjectsCount(&gMapObjects); i++)
	{
		MapObject *mo = IndexMapObject(i);
		UIObject *o2 =
			UIObjectCreate(UITYPE_CUSTOM, 0, svec2i_zero(), data->GridItemSize);
		o2->IsDynamicData = true;
		CCALLOC(o2->Data, data->DataSize);
		if (!data->ObjFunc(o2, mo, data->Data))
		{
			UIObjectDestroy(o2);
			continue;
		}
		const int pageIdx = count / pageSize;
		if (pageIdx >= (int)c->Children.size)
		{
			allChildrenSame = false;
			break;
		}
		const UIObject **op = CArrayGet(&c->Children, pageIdx);
		const UIObject **octx = CArrayGet(&(*op)->Children, 0);
		const int idx = count % pageSize;
		if (idx >= (int)(*octx)->Children.size)
		{
			allChildrenSame = false;
			break;
		}
		const UIObject **oc = CArrayGet(&(*octx)->Children, idx);
		if (memcmp(o2->Data, (*oc)->Data, data->DataSize) != 0)
		{
			allChildrenSame = false;
			UIObjectDestroy(o2);
			break;
		}
		count++;
		UIObjectDestroy(o2);
	}
	int cCount = CountAddMapItemSubObjs(c);
	if (cCount == count && allChildrenSame)
	{
		return;
	}

	// Recreate the child UI objects
	c->Highlighted = NULL;
	UIObject **objs = c->Children.data;
	for (int i = 0; i < (int)c->Children.size; i++, objs++)
	{
		UIObjectDestroy(*objs);
	}
	CArrayClear(&c->Children);

	// Create pagination
	int pageNum = 1;
	UIObject *pageLabel = NULL;
	UIObject *page = NULL;
	UIObject *o =
		UIObjectCreate(UITYPE_CUSTOM, 0, svec2i_zero(), data->GridItemSize);
	o->ChangesData = true;
	const struct vec2i gridStart = svec2i_zero();
	struct vec2i pos = svec2i_zero();
	count = 0;
	for (int i = 0; i < MapObjectsCount(&gMapObjects); i++)
	{
		// Only add normal map objects
		MapObject *mo = IndexMapObject(i);
		UIObject *o2 = UIObjectCopy(o);
		o2->IsDynamicData = true;
		CCALLOC(o2->Data, data->DataSize);
		if (!data->ObjFunc(o2, mo, data->Data))
		{
			UIObjectDestroy(o2);
			continue;
		}
		o2->Pos = pos;
		if (count == 0)
		{
			pageLabel = UIObjectCreate(
				UITYPE_LABEL, 0,
				svec2i((pageNum - 1) * 10, 0), svec2i(10, FontH()));
			char buf[32];
			sprintf(buf, "%d", pageNum);
			UIObjectSetDynamicLabel(pageLabel, buf);
			page = UIObjectCreate(
				UITYPE_CONTEXT_MENU, 0,
				svec2i_add(data->PageOffset, pageLabel->Size), svec2i_zero());
			UIObjectAddChild(pageLabel, page);
			pageNum++;
		}
		UIObjectAddChild(page, o2);
		pos.x += o->Size.x;
		if (((count + 1) % data->GridSize.x) == 0)
		{
			pos.x = gridStart.x;
			pos.y += o->Size.y;
		}
		count++;
		if (count == pageSize)
		{
			count = 0;
			pos = gridStart;
			UIObjectAddChild(c, pageLabel);
		}
	}
	if (pageLabel != NULL)
	{
		UIObjectAddChild(c, pageLabel);
	}

	UIObjectDestroy(o);
}
コード例 #18
0
ファイル: grafx.c プロジェクト: cxong/cdogs-sdl
void GraphicsInitialize(GraphicsDevice *g)
{
    if (g->IsInitialized && !g->cachedConfig.RestartFlags)
    {
        return;
    }

    if (!g->IsWindowInitialized)
    {
        char buf[CDOGS_PATH_MAX];
        GetDataFilePath(buf, "cdogs_icon.bmp");
        g->icon = IMG_Load(buf);
        AddSupportedGraphicsModes(g);
        g->IsWindowInitialized = true;
    }

    g->IsInitialized = false;

    const int w = g->cachedConfig.Res.x;
    const int h = g->cachedConfig.Res.y;

    const bool initRenderer =
        !!(g->cachedConfig.RestartFlags & RESTART_RESOLUTION);
    const bool initTextures =
        !!(g->cachedConfig.RestartFlags &
           (RESTART_RESOLUTION | RESTART_SCALE_MODE));
    const bool initBrightness =
        !!(g->cachedConfig.RestartFlags &
           (RESTART_RESOLUTION | RESTART_SCALE_MODE | RESTART_BRIGHTNESS));

    if (initRenderer)
    {
        Uint32 sdlFlags = SDL_WINDOW_RESIZABLE;
        if (g->cachedConfig.Fullscreen)
        {
            sdlFlags |= SDL_WINDOW_FULLSCREEN;
        }

        LOG(LM_GFX, LL_INFO, "graphics mode(%dx%d %dx)",
            w, h, g->cachedConfig.ScaleFactor);
        // Get the previous window's size and recreate it
        Vec2i windowSize = Vec2iNew(
                               w * g->cachedConfig.ScaleFactor, h * g->cachedConfig.ScaleFactor);
        if (g->window)
        {
            SDL_GetWindowSize(g->window, &windowSize.x, &windowSize.y);
        }
        LOG(LM_GFX, LL_DEBUG, "destroying previous renderer");
        SDL_DestroyTexture(g->screen);
        SDL_DestroyTexture(g->bkg);
        SDL_DestroyTexture(g->brightnessOverlay);
        SDL_DestroyRenderer(g->renderer);
        SDL_FreeFormat(g->Format);
        SDL_DestroyWindow(g->window);
        LOG(LM_GFX, LL_DEBUG, "creating window %dx%d flags(%X)",
            windowSize.x, windowSize.y, sdlFlags);
        if (SDL_CreateWindowAndRenderer(
                    windowSize.x, windowSize.y, sdlFlags,
                    &g->window, &g->renderer) == -1 ||
                g->window == NULL || g->renderer == NULL)
        {
            LOG(LM_GFX, LL_ERROR, "cannot create window or renderer: %s",
                SDL_GetError());
            return;
        }
        char title[32];
        sprintf(title, "C-Dogs SDL %s%s",
                g->cachedConfig.IsEditor ? "Editor " : "",
                CDOGS_SDL_VERSION);
        LOG(LM_GFX, LL_DEBUG, "setting title(%s) and icon", title);
        SDL_SetWindowTitle(g->window, title);
        SDL_SetWindowIcon(g->window, g->icon);
        g->Format = SDL_AllocFormat(SDL_PIXELFORMAT_ARGB8888);

        if (SDL_RenderSetLogicalSize(g->renderer, w, h) != 0)
        {
            LOG(LM_GFX, LL_ERROR, "cannot set renderer logical size: %s",
                SDL_GetError());
            return;
        }

        GraphicsSetBlitClip(
            g, 0, 0, g->cachedConfig.Res.x - 1, g->cachedConfig.Res.y - 1);
    }

    if (initTextures)
    {
        if (!initRenderer)
        {
            SDL_DestroyTexture(g->screen);
            SDL_DestroyTexture(g->bkg);
            SDL_DestroyTexture(g->brightnessOverlay);
        }

        // Set render scale mode
        const char *renderScaleQuality = "nearest";
        switch ((ScaleMode)ConfigGetEnum(&gConfig, "Graphics.ScaleMode"))
        {
        case SCALE_MODE_NN:
            renderScaleQuality = "nearest";
            break;
        case SCALE_MODE_BILINEAR:
            renderScaleQuality = "linear";
            break;
        default:
            CASSERT(false, "unknown scale mode");
            break;
        }
        LOG(LM_GFX, LL_DEBUG, "setting scale quality %s", renderScaleQuality);
        if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, renderScaleQuality))
        {
            LOG(LM_GFX, LL_WARN, "cannot set render quality hint: %s",
                SDL_GetError());
        }

        g->screen = CreateTexture(
                        g->renderer, SDL_TEXTUREACCESS_STREAMING, Vec2iNew(w, h),
                        SDL_BLENDMODE_BLEND, 255);
        if (g->screen == NULL)
        {
            return;
        }

        CFREE(g->buf);
        CCALLOC(g->buf, GraphicsGetMemSize(&g->cachedConfig));
        g->bkg = CreateTexture(
                     g->renderer, SDL_TEXTUREACCESS_STATIC, Vec2iNew(w, h),
                     SDL_BLENDMODE_NONE, 255);
        if (g->bkg == NULL)
        {
            return;
        }
    }

    if (initBrightness)
    {
        if (!initRenderer && !initTextures)
        {
            SDL_DestroyTexture(g->brightnessOverlay);
        }

        const int brightness = ConfigGetInt(&gConfig, "Graphics.Brightness");
        // Alpha is approximately 50% max
        const Uint8 alpha = (Uint8)(brightness > 0 ? brightness : -brightness) * 13;
        g->brightnessOverlay = CreateTexture(
                                   g->renderer, SDL_TEXTUREACCESS_STATIC, Vec2iNew(w, h),
                                   SDL_BLENDMODE_BLEND, alpha);
        if (g->brightnessOverlay == NULL)
        {
            return;
        }
        const color_t overlayColour = brightness > 0 ? colorWhite : colorBlack;
        DrawRectangle(g, Vec2iZero(), g->cachedConfig.Res, overlayColour, 0);
        SDL_UpdateTexture(
            g->brightnessOverlay, NULL, g->buf,
            g->cachedConfig.Res.x * sizeof(Uint32));
        memset(g->buf, 0, GraphicsGetMemSize(&g->cachedConfig));
        g->cachedConfig.Brightness = brightness;
    }

    g->IsInitialized = true;
    g->cachedConfig.Res.x = w;
    g->cachedConfig.Res.y = h;
    g->cachedConfig.RestartFlags = 0;
}
コード例 #19
0
ファイル: files.c プロジェクト: kodephys/cdogs-sdl
int LoadCampaignOld(const char *filename, CampaignSettingOld *setting)
{
	FILE *f = NULL;
	int32_t i;
	int err = 0;

	debug(D_NORMAL, "f: %s\n", filename);
	f = fopen(filename, "rb");
	if (f == NULL)
	{
		err = -1;
		goto bail;
	}

	f_read32(f, &i, sizeof(i));
	if (i != CAMPAIGN_MAGIC)
	{
		debug(D_NORMAL, "LoadCampaign - bad file!\n");
		err = -1;
		goto bail;
	}

	f_read32(f, &i, sizeof(i));
	if (i != CAMPAIGN_VERSION)
	{
		debug(D_NORMAL, "LoadCampaign - version mismatch!\n");
		err = -1;
		goto bail;
	}

	f_read(f, setting->title, sizeof(setting->title));
	f_read(f, setting->author, sizeof(setting->author));
	f_read(f, setting->description, sizeof(setting->description));

	f_read32(f, &setting->missionCount, sizeof(int32_t));
	CCALLOC(
		setting->missions,
		setting->missionCount * sizeof *setting->missions);
	debug(D_NORMAL, "No. missions: %d\n", setting->missionCount);
	for (i = 0; i < setting->missionCount; i++)
	{
		load_mission(f, &setting->missions[i]);
	}

	f_read32(f, &setting->characterCount, sizeof(int32_t));
	CCALLOC(
		setting->characters,
		setting->characterCount * sizeof *setting->characters);
	debug(D_NORMAL, "No. characters: %d\n", setting->characterCount);
	for (i = 0; i < setting->characterCount; i++)
	{
		load_character(f, &setting->characters[i]);
	}

bail:
	if (f != NULL)
	{
		fclose(f);
	}
	return err;
}
コード例 #20
0
ファイル: triggers.c プロジェクト: bugamn/cdogs-sdl
static TAction *AddActions(int count)
{
	TAction *a;
	CCALLOC(a, sizeof(TAction) * (count + 1));
	return a;
}
コード例 #21
0
ファイル: files.c プロジェクト: bugamn/cdogs-sdl
int LoadCampaign(
	const char *filename, CampaignSetting *setting,
	int max_missions, int max_characters)
{
	FILE *f = NULL;
	int i;
	int err = CAMPAIGN_OK;
	int numMissions = max_missions;
	int numCharacters = max_characters;

	debug(D_NORMAL, "f: %s\n", filename);
	f = fopen(filename, "rb");
	if (f == NULL)
	{
		err = CAMPAIGN_BADPATH;
		goto bail;
	}

	f_read32(f, &i, sizeof(i));
	if (i != CAMPAIGN_MAGIC)
	{
		debug(D_NORMAL, "LoadCampaign - bad file!\n");
		err = CAMPAIGN_BADFILE;
		goto bail;
	}

	f_read32(f, &i, sizeof(i));
	if (i != CAMPAIGN_VERSION)
	{
		debug(D_NORMAL, "LoadCampaign - version mismatch!\n");
		err = CAMPAIGN_VERSIONMISMATCH;
		goto bail;
	}

	f_read(f, setting->title, sizeof(setting->title));
	f_read(f, setting->author, sizeof(setting->author));
	f_read(f, setting->description, sizeof(setting->description));

	f_read32(f, &setting->missionCount, sizeof(setting->missionCount));

	if (max_missions <= 0)
	{
		size_t size = setting->missionCount * sizeof(struct Mission);
		CCALLOC(setting->missions, size);
		numMissions = setting->missionCount;
	}
	else if (setting->missionCount < max_missions)
	{
		numMissions = setting->missionCount;
	}

	debug(D_NORMAL, "No. missions: %d\n", numMissions);
	for (i = 0; i < numMissions; i++)
	{
		load_mission(f, &setting->missions[i]);
	}

	f_read32(f, &setting->characterCount, sizeof(setting->characterCount));

	if (max_characters <= 0)
	{
		size_t size = setting->characterCount * sizeof(TBadGuy);
		CCALLOC(setting->characters, size);
		numCharacters = setting->characterCount;
	}
	else if (setting->characterCount < max_characters)
	{
		numCharacters = setting->characterCount;
	}

	debug(D_NORMAL, "No. characters: %d\n", numCharacters);
	for (i = 0; i < numCharacters; i++)
	{
		load_character(f, &setting->characters[i]);
	}

bail:
	if (f != NULL)
	{
		fclose(f);
	}
	return err;
}