Esempio n. 1
0
/* PaletteEntryPanel::loadEntry
 * Reads all palettes in the PLAYPAL entry and shows the first one
 *******************************************************************/
bool PaletteEntryPanel::loadEntry(ArchiveEntry* entry)
{
	// Clear any existing palettes
	for (size_t a = 0; a < palettes.size(); a++)
		delete palettes[a];
	palettes.clear();

	// Determine how many palettes are in the entry
	int n_palettes = entry->getSize() / 768;

	// Load each palette
	entry->seek(0, SEEK_SET);
	uint8_t pal_data[768];
	for (int a = 0; a < n_palettes; a++)
	{
		// Read palette data
		entry->read(&pal_data, 768);

		// Create palette
		Palette8bit* pal = new Palette8bit();
		pal->loadMem(pal_data, 768);

		// Add palette
		palettes.push_back(pal);
	}

	// Show first palette
	cur_palette = 0;
	showPalette(0);

	setModified(false);

	return true;
}
Esempio n. 2
0
/* PaletteEntryPanel::move
 * Shifts the current palette's position in the list
 *******************************************************************/
bool PaletteEntryPanel::move(bool infront)
{
	// Avoid invalid moves
	if (palettes.size() == 1)
		return false;
	uint32_t newpos = cur_palette;
	if (infront)
	{
		if (newpos == 0)
			newpos = palettes.size() - 1;
		else --newpos;
	}
	else /* behind*/
	{
		if (newpos + 1 == palettes.size())
			newpos = 0;
		else ++newpos;
	}
	Palette8bit* tmp = palettes[cur_palette];
	palettes[cur_palette] = palettes[newpos];
	palettes[newpos] = tmp;

	// Refresh the display to show the updated amount of palettes
	cur_palette = newpos;
	showPalette(newpos);
	setModified();
	return true;
}
Esempio n. 3
0
/* PaletteEntryPanel::clearOne
 * Deletes all palettes except the current one from the list
 *******************************************************************/
bool PaletteEntryPanel::clearOthers()
{
	// Nothing to do if there's already only one
	if (palettes.size() == 1)
		return true;

	// Keeping a pointer to the palette we keep
	Palette8bit* pal = palettes[cur_palette];

	// Swap current palette with the first one if needed
	if (cur_palette != 0)
	{
		palettes[cur_palette] = palettes[0];
		palettes[0] = pal;
	}

	// Delete all palettes after the first
	for (size_t i = 1; i < palettes.size(); ++i)
	{
		delete palettes[i];
	}
	// Empty the palette list and add back the single palette
	palettes.clear();
	palettes.push_back(pal);

	// Display the only remaining palette
	cur_palette = 0;
	showPalette(0);
	setModified();
	return true;
}
Esempio n. 4
0
/* PaletteEntryPanel::generatePalettes
 * Generates the full complement of palettes needed by the game
 *******************************************************************/
bool PaletteEntryPanel::generatePalettes()
{
	GeneratePalettesDialog gpd(theMainWindow);
	if (gpd.ShowModal() == wxID_OK)
	{
		// Get choice
		int choice = gpd.getChoice();
		if (choice == 0) return false;

		// Make sure the current palette is the only one
		clearOthers();

		// The first thirteen palettes are common

		// Generate the eight REDPALS
		for (int a = 1; a < 9; ++a)
			generatePalette(255, 0, 0, a, 9);

		// Then the four BONUSPALS
		for (int a = 1; a < 5; ++a)
			generatePalette(215, 186, 69, a, 8);

		// And here we are at the crossroad
		if (choice == 1)
		{
			// Write the Doom/Heretic/Strife palettes, that is to say:

			// Write RADIATIONPAL with its oversaturated green
			generatePalette(0, 256, 0, 1, 8);

		}
		else
		{
			// Write all the Hexen palettes

			// Starting with the eight POISONPALS
			for (int a = 1; a < 9; ++a)
				generatePalette(44, 92, 36, a, 10);

			// Then the ICEPAL
			generatePalette(0, 0, 224, 1, 2);

			// The three HOLYPALS
			generatePalette(130, 130, 130, 1, 2);
			generatePalette(100, 100, 100, 1, 2);
			generatePalette(70, 70, 70, 1, 2);

			// And lastly the three SCOURGEPAL
			generatePalette(150, 110, 0, 1, 2);
			generatePalette(125, 92, 0, 1, 2);
			generatePalette(100, 73, 0, 1, 2);
		}

		// Refresh view to show changed amount of palettes
		cur_palette = 0;
		showPalette(0);
		setModified();
	}
	return true;
}
Esempio n. 5
0
/* PaletteEntryPanel::toolbarButtonClick
 * Called when a (EntryPanel) toolbar button is clicked
 *******************************************************************/
void PaletteEntryPanel::toolbarButtonClick(string action_id)
{
	// Prev. palette
	if (action_id == "pal_prev")
	{
		if (cur_palette == 0)
			cur_palette = palettes.size();
		if (showPalette(cur_palette - 1))
			cur_palette--;
	}

	// Next palette
	else if (action_id == "pal_next")
	{
		if (cur_palette + 1 == palettes.size())
			cur_palette = -1;
		if (showPalette(cur_palette + 1))
			cur_palette++;
	}
}
Esempio n. 6
0
/* PaletteEntryPanel::refreshPanel
 * Redraws the panel
 *******************************************************************/
void PaletteEntryPanel::refreshPanel()
{
	if (entry)
	{
		uint32_t our_palette = cur_palette;
		//loadEntry(entry);
		if (our_palette > 0 && our_palette < palettes.size())
			showPalette(our_palette);
	}
	Update();
	Refresh();
}
Esempio n. 7
0
/* PaletteEntryPanel::duplicate
 * Make a copy of the current palette and add it to the list
 *******************************************************************/
bool PaletteEntryPanel::duplicate()
{
	Palette8bit* newpalette = new Palette8bit;
	if (!newpalette)
		return false;

	newpalette->copyPalette(palettes[cur_palette]);
	palettes.push_back(newpalette);

	// Refresh the display to show the updated amount of palettes
	showPalette(cur_palette);
	setModified();
	return true;
}
Esempio n. 8
0
/* PaletteEntryPanel::tweak
 * Tweaks the colours of the current palette
 *******************************************************************/
bool PaletteEntryPanel::tweak()
{
	Palette8bit* pal = new Palette8bit;
	if (pal == NULL) return false;
	pal->copyPalette(palettes[cur_palette]);
	PaletteColourTweakDialog pctd(theMainWindow, pal);
	if (pctd.ShowModal() == wxID_OK)
	{
		palettes[cur_palette]->copyPalette(pctd.getFinalPalette());
		showPalette(cur_palette);
		setModified();
	}
	delete pal;
	return true;
}
Esempio n. 9
0
PaletteBoxButton::PaletteBoxButton(Palette* p, QWidget* parent)
   : QToolButton(parent)
      {
      palette = p;
      editAction = 0;

      setCheckable(true);
      setFocusPolicy(Qt::NoFocus);
      connect(this, SIGNAL(clicked(bool)), this, SLOT(showPalette(bool)));
      setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
      setText(qApp->translate("Palette", palette->name().toUtf8()));
      setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
      setArrowType(Qt::RightArrow);
      showPalette(false);
      }
Esempio n. 10
0
/* PaletteEntryPanel::importFrom
 * Imports the selected file in the current palette
 *******************************************************************/
bool PaletteEntryPanel::importFrom()
{
	bool ret = false;

	// Run open file dialog
	SFileDialog::fd_info_t info;
	string extensions = "Raw Palette (*.pal)|*.pal|PNG File (*.png)|*.png|CSV Palette (*.csv)|*.csv|JASC Palette (*.pal)|*.pal|GIMP Palette (*.gpl)|*.gpl";
	if (SFileDialog::openFile(info, "Import Palette As", extensions, this))
	{
		// Load palette
		ret = palettes[cur_palette]->loadFile(info.filenames[0], info.ext_index);
		if (ret)
		{
			setModified();
			showPalette(cur_palette);
		}
	}
	return ret;
}
Esempio n. 11
0
/* PaletteEntryPanel::clearOne
 * Deletes the current palette from the list
 *******************************************************************/
bool PaletteEntryPanel::clearOne()
{
	// Always keep at least one palette
	if (cur_palette == 0 && palettes.size() == 1)
	{
		wxLogMessage("Palette cannot be removed, no other palette in this entry.");
		return false;
	}

	// Erase palette
	delete palettes[cur_palette];
	palettes.erase(palettes.begin() + cur_palette);

	// Display the next, or previous, palette instead
	if (cur_palette >= palettes.size())
		--cur_palette;
	showPalette(cur_palette);
	setModified();
	return true;
}
Esempio n. 12
0
void PaletteEntryPanel::analysePalettes()
{
	if (palettes.size() < PALETTECHECK + 1)
		return;
#ifdef GPALCOMPANALYSIS
	int devR, devG, devB;
	int minR, minG, minB;
	int maxR, maxG, maxB;
	int wrongcount;
#else
	unsigned int reds[256];
	unsigned int greens[256];
	unsigned int blues[256];
#endif
	string report = "\n";
#ifdef GPALCOMPANALYSIS
	int i = PALETTECHECK;
	if (i)
	{
		report += S_FMT("Deviation between palettes 0 and %i:\n\n", i);
		devR = devG = devB = 0;
		maxR = maxG = maxB = -1;
		minR = minG = minB = 256;
		wrongcount = 0;
#else
	report += S_FMT("Changes between %u palettes compared to the first:\n\n", palettes.size());
	for (size_t i = 1; i < palettes.size(); ++i)
	{
		for (int j = 0; j < 256; ++j)
			reds[j] = blues[j] = greens[j] = 999;
#endif
		report += S_FMT("\n==============\n= Palette %02u =\n==============\n", i);
		for (size_t c = 0; c < 256; ++c)
		{
			rgba_t ref1 = palettes[0]->colour(c);
			rgba_t cmp1 = palettes[i]->colour(c);
			hsl_t  ref2 = Misc::rgbToHsl(ref1);
			hsl_t  cmp2 = Misc::rgbToHsl(cmp1);
#ifdef GPALCOMPANALYSIS
			int r, g, b;
			double h, s, l;
			r = cmp1.r - ref1.r;
			g = cmp1.g - ref1.g;
			b = cmp1.b - ref1.b;
			h = cmp2.h - ref2.h;
			s = cmp2.s - ref2.s;
			l = cmp2.l - ref2.l;
			devR += r;
			devG += g;
			devB += b;
			if (r > maxR) maxR = r; if (r < minR) minR = r;
			if (g > maxG) maxG = g; if (g < minG) minG = g;
			if (b > maxB) maxB = b; if (b < minB) minB = b;
			if (r | g | b)
			{
				++wrongcount;
				report += S_FMT("Index %003u: [%003i %003i %003i | %1.3f %1.3f %1.3f]->[%003i %003i %003i | %1.3f %1.3f %1.3f]\t\tR %+003i\tG %+003i\tB %+003i\t\t\tH %+1.3f\tS %+1.3f\tL %+1.3f\n",
				                c,
				                ref1.r, ref1.g, ref1.b, ref2.h, ref2.s, ref2.l,
				                cmp1.r, cmp1.g, cmp1.b, cmp2.h, cmp2.s, cmp2.l,
				                r, g, b, h, s, l);
			}
#else
			if (reds[ref1.r] != cmp1.r && reds[ref1.r] != 999)
				DPrintf("Discrepency for red channel at index %i, value %i: %d vs. %d set before",
				        c, ref1.r, cmp1.r, reds[ref1.r]);
			if (greens[ref1.g] != cmp1.g && greens[ref1.g] != 999)
				DPrintf("Discrepency for green channel at index %i, value %i: %d vs. %d set before",
				        c, ref1.g, cmp1.g, greens[ref1.g]);
			if (blues[ref1.b] != cmp1.b && blues[ref1.b] != 999)
				DPrintf("Discrepency for blue channel at index %i, value %i: %d vs. %d set before",
				        c, ref1.b, cmp1.b, blues[ref1.b]);
			reds[ref1.r] = cmp1.r;
			greens[ref1.g] = cmp1.g;
			blues[ref1.b] = cmp1.b;
#endif
		}
#ifdef GPALCOMPANALYSIS
		report += S_FMT("Deviation sigma: R %+003i G %+003i B %+003i\t%s\n", devR, devG, devB, entry->getName(true));
		report += S_FMT("Min R %+003i Min G %+003i Min B %+003i Max R %+003i Max G %+003i Max B %+003i \nError count: %i\n",
		                minR, minG, minB, maxR, maxG, maxB, wrongcount);
#else
		report += "Shift table for existing channel values:\n|  I  |  R  |  G  |  B  |\n";
		for (size_t i = 0; i < 256; ++i)
		{
			if (reds[i] < 999 || greens[i] < 999 || blues[i] < 999)
				report += S_FMT("| %003d | %003d | %003d | %003d |\n", i, reds[i], greens[i], blues[i]);
		}
		report.Replace("999", "   ");
#endif
	}

	wxLogMessage(report);

}

/*******************************************************************
 * PALETTEENTRYPANEL CLASS EVENTS
 *******************************************************************/

/* PaletteEntryPanel::onPalCanvasMouseEvent
 * Called when a mouse event happens within the palette canvas (eg.
 * button clicked, pointer moved, etc)
 *******************************************************************/
void PaletteEntryPanel::onPalCanvasMouseEvent(wxMouseEvent& e)
{
	// Update colour info label with selected colour (if any)
	if (e.LeftDown())
	{
		// Send to palette canvas
		pal_canvas->onMouseLeftDown(e);

		// Update status bar
		updateStatus();
	}
	else if (e.RightDown())
	{
		// Would this be better if the colour picking was handled by
		// the canvas' onMouseRightDown() function? The problem here
		// being that the canvas processes its events after the panel.
		// So for the left click we can afford to call it from there
		// first and let it harmlessly process it again, but for the
		// right click it would result in the colour box being shown
		// twice to the user, the second time being ignored. So it is
		// preferrable to handle all this on this side rather than try
		// to make the canvas do the work.
		// Pretend there was a left click to get the selected colour.
		pal_canvas->onMouseLeftDown(e);
		int sel = pal_canvas->getSelectionStart();

		// There actually was a colour selected
		if (sel > -1)
		{
			rgba_t col = pal_canvas->getSelectedColour();
			// Open a colour dialog
			wxColour cd = wxGetColourFromUser(GetParent(), WXCOL(col));

			if (cd.Ok())
			{
				col.r = cd.Red();
				col.g = cd.Green();
				col.b = cd.Blue();

				palettes[cur_palette]->setColour(sel, col);
				setModified();
				showPalette(cur_palette);
			}
		}
	}
}