We are currently migrating Bugzilla to GitHub issues.
Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.
When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.

the GameOfLife simulator code

main.cpp (text/x-csrc), 14.45 KB, created by mrsamsh on 2019-08-18 08:24:19 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: mrsamsh

Created: 2019-08-18 08:24:19 UTC

Size: 14.45 KB

patch

obsolete

>#include <SDL2/SDL.h>
>#include <vector>
>#include <iostream>
>#include <cstdint>
>#include <cmath>
>
>const int WINDOW_WIDTH = 1280 * 2;
>const int WINDOW_HEIGHT = 720 * 2;
>const int SIDE = 4;
>const int GRID_WIDTH = WINDOW_WIDTH  / SIDE;
>const int GRID_HEIGHT = WINDOW_HEIGHT  / SIDE;
>const int FPS = 30;
>const int STARTING_CELLS = (WINDOW_WIDTH * WINDOW_HEIGHT) / 125;
>
>struct Cell {
>	Cell()
>	: v(0)
>	, f(0)
>	, nw(nullptr)
>	, n(nullptr)
>	, ne(nullptr)
>	, w(nullptr)
>	, e(nullptr)
>	, sw(nullptr)
>	, s(nullptr)
>	, se(nullptr)
>	{ }
>	int8_t v;
>	int8_t f;
>	Cell *nw;
>	Cell *n;
>	Cell *ne;
>	Cell *w;
>	Cell *e;
>	Cell *sw;
>	Cell *s;
>	Cell *se;
>	inline int8_t calculate()
>	{
>		return nw->v + n->v + ne->v + w->v + e->v + sw->v + s->v + se->v;
>	}
>};
>
>class GameOfLife {
>public:
>	GameOfLife()
>	: state1(GRID_WIDTH * GRID_HEIGHT)
>	, state2(GRID_WIDTH * GRID_HEIGHT)
>	, current(state1)
>	, next(state2)
>	{
>		for (int y = 1; y < GRID_HEIGHT - 1; ++y) {
>			for (int x = 1; x < GRID_WIDTH - 1; ++x) {
>				int i = x + y * GRID_WIDTH;
>				state1[i].w  = &state1[i - 1];
>				state1[i].e  = &state1[i + 1];
>				state1[i].n  = &state1[i - GRID_WIDTH];
>				state1[i].s  = &state1[i + GRID_WIDTH];
>				state1[i].nw = &state1[i - GRID_WIDTH - 1];
>				state1[i].ne = &state1[i - GRID_WIDTH + 1];
>				state1[i].sw = &state1[i + GRID_WIDTH - 1];
>				state1[i].se = &state1[i + GRID_WIDTH + 1];
>				
>				state2[i].w  = &state2[i - 1];
>				state2[i].e  = &state2[i + 1];
>				state2[i].n  = &state2[i - GRID_WIDTH];
>				state2[i].s  = &state2[i + GRID_WIDTH];
>				state2[i].nw = &state2[i - GRID_WIDTH - 1];
>				state2[i].ne = &state2[i - GRID_WIDTH + 1];
>				state2[i].sw = &state2[i + GRID_WIDTH - 1];
>				state2[i].se = &state2[i + GRID_WIDTH + 1];
>			}
>		}
>		for (int x = 1; x < GRID_WIDTH - 1; ++x) {
>			int itop = x;
>			int ibot = x + GRID_WIDTH * (GRID_HEIGHT - 1);
>			state1[itop].w  = &state1[itop - 1];
>			state1[itop].e  = &state1[itop + 1];
>			state1[itop].s  = &state1[itop + GRID_WIDTH];
>			state1[itop].n  = &state1[ibot];
>			state1[itop].sw = &state1[itop + GRID_WIDTH - 1];
>			state1[itop].se = &state1[itop + GRID_WIDTH + 1];
>			state1[itop].nw = &state1[ibot - 1];
>			state1[itop].ne = &state1[ibot + 1];
>			
>			state2[itop].w  = &state2[itop - 1];
>			state2[itop].e  = &state2[itop + 1];
>			state2[itop].s  = &state2[itop + GRID_WIDTH];
>			state2[itop].n  = &state2[ibot];
>			state2[itop].sw = &state2[itop + GRID_WIDTH - 1];
>			state2[itop].se = &state2[itop + GRID_WIDTH + 1];
>			state2[itop].nw = &state2[ibot - 1];
>			state2[itop].ne = &state2[ibot + 1];
>			
>			state1[ibot].w  = &state1[ibot - 1];
>			state1[ibot].e  = &state1[ibot + 1];
>			state1[ibot].n  = &state1[ibot - GRID_WIDTH];
>			state1[ibot].s  = &state1[itop];
>			state1[ibot].nw = &state1[ibot - GRID_WIDTH - 1];
>			state1[ibot].ne = &state1[ibot - GRID_WIDTH + 1];
>			state1[ibot].sw = &state1[itop - 1];
>			state1[ibot].se = &state1[itop + 1];
>			
>			state2[ibot].w  = &state2[ibot - 1];
>			state2[ibot].e  = &state2[ibot + 1];
>			state2[ibot].n  = &state2[ibot - GRID_WIDTH];
>			state2[ibot].s  = &state2[itop];
>			state2[ibot].nw = &state2[ibot - GRID_WIDTH - 1];
>			state2[ibot].ne = &state2[ibot - GRID_WIDTH + 1];
>			state2[ibot].sw = &state2[itop - 1];
>			state2[ibot].se = &state2[itop + 1];
>		}
>		
>		for (int y = 1; y < GRID_HEIGHT - 1; ++y) {
>			int il = y * GRID_WIDTH;
>			int ir = y * GRID_WIDTH + GRID_WIDTH - 1;
>			
>			state1[il].n  = &state1[il - GRID_WIDTH];
>			state1[il].s  = &state1[il + GRID_WIDTH];
>			state1[il].e  = &state1[il + 1];
>			state1[il].w  = &state1[ir];
>			state1[il].ne = &state1[il - GRID_WIDTH + 1];
>			state1[il].se = &state1[il + GRID_WIDTH + 1];
>			state1[il].nw = &state1[ir - GRID_WIDTH];
>			state1[il].sw = &state1[ir + GRID_WIDTH];
>			
>			state2[il].n  = &state2[il - GRID_WIDTH];
>			state2[il].s  = &state2[il + GRID_WIDTH];
>			state2[il].e  = &state2[il + 1];
>			state2[il].w  = &state2[ir];
>			state2[il].ne = &state2[il - GRID_WIDTH + 1];
>			state2[il].se = &state2[il + GRID_WIDTH + 1];
>			state2[il].nw = &state2[ir - GRID_WIDTH];
>			state2[il].sw = &state2[ir + GRID_WIDTH];
>			
>			state1[ir].n  = &state1[ir - GRID_WIDTH];
>			state1[ir].s  = &state1[ir + GRID_WIDTH];
>			state1[ir].w  = &state1[ir - 1];
>			state1[ir].e  = &state1[il];
>			state1[ir].nw = &state1[ir - GRID_WIDTH - 1];
>			state1[ir].sw = &state1[ir + GRID_WIDTH - 1];
>			state1[ir].ne = &state1[il - GRID_WIDTH];
>			state1[ir].se = &state1[il + GRID_WIDTH];
>			
>			state2[ir].n  = &state2[ir - GRID_WIDTH];
>			state2[ir].s  = &state2[ir + GRID_WIDTH];
>			state2[ir].w  = &state2[ir - 1];
>			state2[ir].e  = &state2[il];
>			state2[ir].nw = &state2[ir - GRID_WIDTH - 1];
>			state2[ir].sw = &state2[ir + GRID_WIDTH - 1];
>			state2[ir].ne = &state2[il - GRID_WIDTH];
>			state2[ir].se = &state2[il + GRID_WIDTH];
>		}
>		
>		// state1[0]
>		state1[0].e  = &state1[1];
>		state1[0].w  = &state1[GRID_WIDTH - 1];
>		state1[0].s  = &state1[GRID_WIDTH];
>		state1[0].n  = &state1[GRID_WIDTH * (GRID_HEIGHT - 1)];
>		state1[0].se = &state1[GRID_WIDTH + 1];
>		state1[0].sw = &state1[GRID_WIDTH + GRID_WIDTH - 1];
>		state1[0].ne = &state1[GRID_WIDTH * (GRID_HEIGHT - 1) + 1];
>		state1[0].nw = &state1[GRID_WIDTH * GRID_HEIGHT - 1];
>		
>		state2[0].e  = &state2[1];
>		state2[0].w  = &state2[GRID_WIDTH - 1];
>		state2[0].s  = &state2[GRID_WIDTH];
>		state2[0].n  = &state2[GRID_WIDTH * (GRID_HEIGHT - 1)];
>		state2[0].se = &state2[GRID_WIDTH + 1];
>		state2[0].sw = &state2[GRID_WIDTH + GRID_WIDTH - 1];
>		state2[0].ne = &state2[GRID_WIDTH * (GRID_HEIGHT - 1) + 1];
>		state2[0].nw = &state2[GRID_WIDTH * GRID_HEIGHT - 1];
>		
>		// state1[GRID_WIDTH - 1]
>		state1[GRID_WIDTH - 1].w  = &state1[GRID_WIDTH - 2];
>		state1[GRID_WIDTH - 1].e  = &state1[0];
>		state1[GRID_WIDTH - 1].n  = &state1[GRID_WIDTH * GRID_HEIGHT - 1];
>		state1[GRID_WIDTH - 1].s  = &state1[GRID_WIDTH * 2 - 1];
>		state1[GRID_WIDTH - 1].sw = &state1[GRID_WIDTH * 2 - 2];
>		state1[GRID_WIDTH - 1].se = &state1[GRID_WIDTH];
>		state1[GRID_WIDTH - 1].nw = &state1[GRID_WIDTH * GRID_HEIGHT - 2];
>		state1[GRID_WIDTH - 1].ne = &state1[GRID_WIDTH * (GRID_HEIGHT - 1)];
>		
>		state2[GRID_WIDTH - 1].w  = &state2[GRID_WIDTH - 2];
>		state2[GRID_WIDTH - 1].e  = &state2[0];
>		state2[GRID_WIDTH - 1].n  = &state2[GRID_WIDTH * GRID_HEIGHT - 1];
>		state2[GRID_WIDTH - 1].s  = &state2[GRID_WIDTH * 2 - 1];
>		state2[GRID_WIDTH - 1].sw = &state2[GRID_WIDTH * 2 - 2];
>		state2[GRID_WIDTH - 1].se = &state2[GRID_WIDTH];
>		state2[GRID_WIDTH - 1].nw = &state2[GRID_WIDTH * GRID_HEIGHT - 2];
>		state2[GRID_WIDTH - 1].ne = &state2[GRID_WIDTH * (GRID_HEIGHT - 1)];
>		
>		// state1[GRID_WIDTH * (GRID_HEIGHT - 1)]
>		state1[GRID_WIDTH * (GRID_HEIGHT - 1)].n  = &state1[GRID_WIDTH * (GRID_HEIGHT - 2)];
>		state1[GRID_WIDTH * (GRID_HEIGHT - 1)].s  = &state1[0];
>		state1[GRID_WIDTH * (GRID_HEIGHT - 1)].e  = &state1[GRID_WIDTH * (GRID_HEIGHT - 1) + 1];
>		state1[GRID_WIDTH * (GRID_HEIGHT - 1)].w  = &state1[GRID_WIDTH * GRID_HEIGHT - 1];
>		state1[GRID_WIDTH * (GRID_HEIGHT - 1)].ne = &state1[GRID_WIDTH * (GRID_HEIGHT - 2) + 1];
>		state1[GRID_WIDTH * (GRID_HEIGHT - 1)].nw = &state1[GRID_WIDTH * (GRID_HEIGHT - 1) - 1];
>		state1[GRID_WIDTH * (GRID_HEIGHT - 1)].se = &state1[1];
>		state1[GRID_WIDTH * (GRID_HEIGHT - 1)].sw = &state1[GRID_WIDTH - 1];
>		
>		state2[GRID_WIDTH * (GRID_HEIGHT - 1)].n  = &state2[GRID_WIDTH * (GRID_HEIGHT - 2)];
>		state2[GRID_WIDTH * (GRID_HEIGHT - 1)].s  = &state2[0];
>		state2[GRID_WIDTH * (GRID_HEIGHT - 1)].e  = &state2[GRID_WIDTH * (GRID_HEIGHT - 1) + 1];
>		state2[GRID_WIDTH * (GRID_HEIGHT - 1)].w  = &state2[GRID_WIDTH * GRID_HEIGHT - 1];
>		state2[GRID_WIDTH * (GRID_HEIGHT - 1)].ne = &state2[GRID_WIDTH * (GRID_HEIGHT - 2) + 1];
>		state2[GRID_WIDTH * (GRID_HEIGHT - 1)].nw = &state2[GRID_WIDTH * (GRID_HEIGHT - 1) - 1];
>		state2[GRID_WIDTH * (GRID_HEIGHT - 1)].se = &state2[1];
>		state2[GRID_WIDTH * (GRID_HEIGHT - 1)].sw = &state2[GRID_WIDTH - 1];
>		
>		// state1[GRID_WIDTH * GRID_HEIGHT - 1]
>		state1[GRID_WIDTH * GRID_HEIGHT - 1].n  = &state1[GRID_WIDTH * (GRID_HEIGHT - 1) - 1];
>		state1[GRID_WIDTH * GRID_HEIGHT - 1].s  = &state1[GRID_WIDTH - 1];
>		state1[GRID_WIDTH * GRID_HEIGHT - 1].e  = &state1[GRID_WIDTH * (GRID_HEIGHT - 1)];
>		state1[GRID_WIDTH * GRID_HEIGHT - 1].w  = &state1[GRID_WIDTH * GRID_HEIGHT - 2];
>		state1[GRID_WIDTH * GRID_HEIGHT - 1].nw = &state1[GRID_WIDTH * (GRID_HEIGHT - 1) - 2];
>		state1[GRID_WIDTH * GRID_HEIGHT - 1].ne = &state1[GRID_WIDTH * (GRID_HEIGHT - 2)];
>		state1[GRID_WIDTH * GRID_HEIGHT - 1].sw = &state1[GRID_WIDTH - 2];
>		state1[GRID_WIDTH * GRID_HEIGHT - 1].se = &state1[0];
>		
>		state2[GRID_WIDTH * GRID_HEIGHT - 1].n  = &state2[GRID_WIDTH * (GRID_HEIGHT - 1) - 1];
>		state2[GRID_WIDTH * GRID_HEIGHT - 1].s  = &state2[GRID_WIDTH - 1];
>		state2[GRID_WIDTH * GRID_HEIGHT - 1].e  = &state2[GRID_WIDTH * (GRID_HEIGHT - 1)];
>		state2[GRID_WIDTH * GRID_HEIGHT - 1].w  = &state2[GRID_WIDTH * GRID_HEIGHT - 2];
>		state2[GRID_WIDTH * GRID_HEIGHT - 1].nw = &state2[GRID_WIDTH * (GRID_HEIGHT - 1) - 2];
>		state2[GRID_WIDTH * GRID_HEIGHT - 1].ne = &state2[GRID_WIDTH * (GRID_HEIGHT - 2)];
>		state2[GRID_WIDTH * GRID_HEIGHT - 1].sw = &state2[GRID_WIDTH - 2];
>		state2[GRID_WIDTH * GRID_HEIGHT - 1].se = &state2[0];
>	}
>	
>	void initWithRandom()
>	{
>		std::srand((unsigned int)std::time(nullptr));
>		
>		for (int i = 0; i < STARTING_CELLS; ++i) {
>			int x = std::rand() % (GRID_WIDTH);
>			int y = std::rand() % (GRID_HEIGHT);
>			current[x + y * GRID_WIDTH].v = 1;
>		}
>	}
>	
>	void insertPattern(int xpos, int ypos, int width, int height, const int8_t* pattern)
>	{
>		int pi = 0;
>		for (int y = ypos; y < ypos + height; ++y) {
>			for (int x = xpos; x < xpos + width; ++x) {
>				int i = x + y * GRID_WIDTH;
>				current[i].v = pattern[pi++];
>			}
>		}
>	}
>	
>	void update()
>	{
>		evaluateCells();
>		swap();
>	}
>	
>	void draw(SDL_Renderer* renderer)
>	{
>		for (int i = 0; i < current.size(); ++i) {
>			int x = (i % GRID_WIDTH) * SIDE + 1;
>			int y = (i / GRID_WIDTH) * SIDE + 1;
>			SDL_Rect r  = { x, y, SIDE - 1, SIDE - 1 };
>			
>			if (current[i].f != 0) {
>				SDL_SetRenderDrawColor(renderer, 0x01 * current[i].f / 2, 0x01 * current[i].f / 2, 0x02 * current[i].f, 0xff);
>				SDL_RenderFillRect(renderer, &r);
>			} else if (current[i].v != 0) {
>				SDL_SetRenderDrawColor(renderer, 0xff, 0xff, 0xff, 0xff);
>				SDL_RenderFillRect(renderer, &r);
>			}
>		}
>	}
>	
>private:
>	void swap()
>	{
>		current.swap(next);
>	}
>	
>	void evaluateCells()
>	{
>		for (int i = 0 ; i < current.size(); ++i) {
>			int count = current[i].calculate();
>			if ((count < 2 || count > 3) && current[i].v == 1) {
>				next[i].v = 0;
>				next[i].f = 60;
>			} else if (count == 3 && current[i].v != 1) {
>				next[i].v = 1;
>				next[i].f = 0;
>			} else {
>				next[i].v = current[i].v;
>				next[i].f = std::max(current[i].f - 1, 0);
>			}
>		}
>	}
>	
>private:
>	std::vector<Cell> state1;
>	std::vector<Cell> state2;
>	std::vector<Cell> &current;
>	std::vector<Cell> &next;
>};
>
>int main() {
>	GameOfLife game;
>	int8_t hammerHead[] = {
>		1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
>		1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0,
>		1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1,
>		0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1,
>		0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0,
>		0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0,
>		0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0,
>		0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
>		0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
>		0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0,
>		0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0,
>		0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0,
>		0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1,
>		1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1,
>		1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0,
>		1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
>	};
>	
>	int8_t cloverField[] = {
>		0, 0, 0, 1, 0, 1, 0, 0, 0,
>		0, 1, 1, 1, 0, 1, 1, 1, 0,
>		1, 0, 0, 0, 1, 0, 0, 0, 1,
>		1, 0, 1, 0, 0, 0, 1, 0, 1,
>		0, 1, 1, 0, 1, 0, 1, 1, 0,
>		0, 0, 0, 0, 0, 0, 0, 0, 0,
>		0, 1, 1, 0, 1, 0, 1, 1, 0,
>		1, 0, 1, 0, 0, 0, 1, 0, 1,
>		1, 0, 0, 0, 1, 0, 0, 0, 1,
>		0, 1, 1, 1, 0, 1, 1, 1, 0,
>		0, 0, 0, 1, 0, 1, 0, 0, 0
>	};
>	int8_t glider[] = {
>		0, 1, 0,
>		1, 0, 0,
>		1, 1, 1
>	};
>	
>	int8_t square[] = {
>		1, 1,
>		1, 1
>	};
>	game.initWithRandom();
>	//    game.insertPattern(50, 50,  9, 11, &cloverField[0]);
>	//    game.insertPattern(200, 100, 18, 16, &hammerHead[0]);
>	
>	game.insertPattern(100, 100, 3, 3, &glider[0]);
>	game.insertPattern(88, 110, 2, 2, &square[0]);
>	SDL_Init(SDL_INIT_EVERYTHING);
>	SDL_Window* window = SDL_CreateWindow(
>										  "Game of Life",
>										  SDL_WINDOWPOS_CENTERED,
>										  SDL_WINDOWPOS_CENTERED,
>										  WINDOW_WIDTH / 2,
>										  WINDOW_HEIGHT/ 2,
>										  SDL_WINDOW_SHOWN
>										  | SDL_WINDOW_ALLOW_HIGHDPI
>										  //      | SDL_WINDOW_FULLSCREEN_DESKTOP
>										  | SDL_WINDOW_RESIZABLE
>										  );
>	
>	SDL_Renderer* renderer = SDL_CreateRenderer(
>												window,
>												-1,
>												SDL_RENDERER_ACCELERATED
>												//		| SDL_RENDERER_PRESENTVSYNC
>												);
>	
>	SDL_ShowCursor(SDL_DISABLE);
>//	SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "1");
>	if (SDL_SetHintWithPriority(SDL_HINT_RENDER_DRIVER, "opengl", SDL_HINT_OVERRIDE) == SDL_TRUE) printf("Done\n");
>	Uint32 last, current;
>	Uint32 mspf = 1000 / FPS;
>	last = SDL_GetTicks();
>	bool running = true;
>	while (running) {
>		SDL_Event event;
>		while (SDL_PollEvent(&event)) {
>			if (event.type == SDL_QUIT) {
>				running = false;
>			} else if (event.type== SDL_WINDOWEVENT) {
>				if (event.window.event == SDL_WINDOWEVENT_RESIZED) {
>					int x, y;
>					SDL_GetWindowSize(window, &x, &y);
>					SDL_Rect viewport;
>					float ratio = (float)WINDOW_WIDTH / (float)WINDOW_HEIGHT;
>					float newRation = (float)x / (float)y;
>					float scale;
>					if (newRation > ratio) {
>						scale = 2.f * (float)y / (float)WINDOW_HEIGHT;
>						viewport.w = (int)((float)WINDOW_WIDTH * scale);
>						viewport.h = y * 2;
>						viewport.x = (int)(x * 2 - viewport.w) / 2;
>						viewport.y = 0;
>					} else {
>						scale = 2.f * (float)x / (float)WINDOW_WIDTH;
>						viewport.w = x * 2;
>						viewport.h = (int)((float)WINDOW_HEIGHT * scale);
>						viewport.x = 0;
>						viewport.y = (int)(y * 2 - viewport.h) / 2;
>					}
>					SDL_RenderSetScale(renderer, scale, scale);
>					SDL_RenderSetViewport(renderer, &viewport);
>				}
>			}
>		}
>		game.update();
>		
>		SDL_SetRenderDrawColor(renderer, 0x00, 0x00, 0x00, 0xff);
>		SDL_RenderClear(renderer);
>		
>		game.draw(renderer);
>		
>		SDL_RenderPresent(renderer);
>		current = SDL_GetTicks();
>		auto delta = current - last;
>		if (mspf > delta)
>			SDL_Delay(mspf - delta);
>		last = SDL_GetTicks();
>	}
>	SDL_DestroyWindow(window);
>	SDL_DestroyRenderer(renderer);
>	SDL_Quit();
>	return EXIT_SUCCESS;
>}
>

Actions: View

Attachments on bug 4764: 3926

We are currently migrating Bugzilla to GitHub issues.Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.

We are currently migrating Bugzilla to GitHub issues.
Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.
When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.