1 /* ScummVM - Graphic Adventure Engine
2 *
3 * ScummVM is the legal property of its developers, whose names
4 * are too numerous to list here. Please refer to the COPYRIGHT
5 * file distributed with this source distribution.
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20 *
21 */
22
23 #include "graphics/palette.h"
24
25 #include "toltecs/toltecs.h"
26 #include "toltecs/palette.h"
27 #include "toltecs/resource.h"
28
29 namespace Toltecs {
30
Palette(ToltecsEngine * vm)31 Palette::Palette(ToltecsEngine *vm) : _vm(vm) {
32 clearFragments();
33
34 memset(_mainPalette, 0, sizeof(_mainPalette));
35 memset(_animPalette, 0, sizeof(_animPalette));
36 memset(_colorTransTable, 0, sizeof(_colorTransTable));
37 }
38
~Palette()39 Palette::~Palette() {
40 }
41
setFullPalette(byte * palette)42 void Palette::setFullPalette(byte *palette) {
43 byte colors[768];
44 for (int i = 0; i < 256; i++) {
45 colors[i * 3 + 0] = palette[i * 3 + 0] << 2;
46 colors[i * 3 + 1] = palette[i * 3 + 1] << 2;
47 colors[i * 3 + 2] = palette[i * 3 + 2] << 2;
48 }
49 _vm->_system->getPaletteManager()->setPalette((const byte *)colors, 0, 256);
50 _vm->_system->updateScreen();
51 }
52
getFullPalette(byte * palette)53 void Palette::getFullPalette(byte *palette) {
54 byte colors[768];
55 _vm->_system->getPaletteManager()->grabPalette(colors, 0, 256);
56 for (int i = 0; i < 256; i++) {
57 palette[i * 3 + 0] = colors[i * 3 + 0] >> 2;
58 palette[i * 3 + 1] = colors[i * 3 + 1] >> 2;
59 palette[i * 3 + 2] = colors[i * 3 + 2] >> 2;
60 }
61 }
62
setDeltaPalette(byte * palette,byte mask,int8 deltaValue,int16 count,int16 startIndex)63 void Palette::setDeltaPalette(byte *palette, byte mask, int8 deltaValue, int16 count, int16 startIndex) {
64 byte colors[768];
65
66 byte *palPtr = palette + startIndex * 3;
67 int16 index = startIndex, colorCount = count;
68 byte rgb;
69
70 count++;
71
72 _vm->_system->getPaletteManager()->grabPalette(colors, 0, 256);
73
74 deltaValue *= -1;
75
76 while (count--) {
77 rgb = *palPtr++;
78 if (mask & 1) colors[index * 3 + 0] = CLIP<int>(rgb + deltaValue, 0, 63) << 2;
79 rgb = *palPtr++;
80 if (mask & 2) colors[index * 3 + 1] = CLIP<int>(rgb + deltaValue, 0, 63) << 2;
81 rgb = *palPtr++;
82 if (mask & 4) colors[index * 3 + 2] = CLIP<int>(rgb + deltaValue, 0, 63) << 2;
83 index++;
84 }
85
86 debug(0, "startIndex = %d; colorCount = %d", startIndex, colorCount);
87
88 _vm->_system->getPaletteManager()->setPalette((const byte *)colors, 0, 256);
89 }
90
loadAddPalette(uint resIndex,byte startIndex)91 void Palette::loadAddPalette(uint resIndex, byte startIndex) {
92 Resource *paletteResource = _vm->_res->load(resIndex);
93 memcpy(&_mainPalette[startIndex * 3], paletteResource->data, paletteResource->size);
94 }
95
loadAddPaletteFrom(byte * source,byte startIndex,byte count)96 void Palette::loadAddPaletteFrom(byte *source, byte startIndex, byte count) {
97 memcpy(&_mainPalette[startIndex * 3], source, count * 3);
98 }
99
addFragment(uint resIndex,int16 id)100 void Palette::addFragment(uint resIndex, int16 id) {
101 debug(0, "Palette::addFragment(%d, %d)", resIndex, id);
102
103 Resource *fragmentResource = _vm->_res->load(resIndex);
104 byte count = fragmentResource->size / 3;
105
106 memcpy(&_mainPalette[_fragmentIndex * 3], fragmentResource->data, count * 3);
107
108 PaletteFragment fragment;
109 fragment.id = id;
110 fragment.index = _fragmentIndex;
111 fragment.count = count;
112 _fragments.push_back(fragment);
113
114 debug(0, "Palette::addFragment() index = %02X; count = %02X", fragment.index, fragment.count);
115
116 _fragmentIndex += count;
117 }
118
findFragment(int16 id)119 uint16 Palette::findFragment(int16 id) {
120 debug(0, "Palette::findFragment(%d)", id);
121
122 uint16 result = 0;
123 for (PaletteFragmentArray::iterator iter = _fragments.begin(); iter != _fragments.end(); ++iter) {
124 PaletteFragment fragment = *iter;
125 if (fragment.id == id) {
126 result = (fragment.count << 8) | fragment.index;
127 break;
128 }
129 }
130
131 debug(0, "Palette::findFragment() result = %04X", result);
132
133 return result;
134 }
135
clearFragments()136 void Palette::clearFragments() {
137 debug(0, "Palette::clearFragments()");
138 _fragmentIndex = 128;
139 _fragments.clear();
140 }
141
getMatchingColor(byte r,byte g,byte b)142 byte Palette::getMatchingColor(byte r, byte g, byte b) {
143 int bestIndex = 0;
144 uint16 bestMatch = 0xFFFF;
145
146 for (int j = 0; j < 256; j++) {
147 byte distance = ABS(_mainPalette[j * 3 + 0] - r) + ABS(_mainPalette[j * 3 + 1] - g) + ABS(_mainPalette[j * 3 + 2] - b);
148 byte maxColor = MAX(_mainPalette[j * 3 + 0], MAX(_mainPalette[j * 3 + 1], _mainPalette[j * 3 + 2]));
149 uint16 match = (distance << 8) | maxColor;
150 if (match < bestMatch) {
151 bestMatch = match;
152 bestIndex = j;
153 }
154 }
155
156 return bestIndex;
157 }
158
buildColorTransTable(byte limit,int8 deltaValue,byte mask)159 void Palette::buildColorTransTable(byte limit, int8 deltaValue, byte mask) {
160 byte r = 0, g = 0, b = 0;
161
162 mask &= 7;
163
164 if (deltaValue < 0) // unused
165 error("buildColorTransTable called with a negative delta value(limit %d, delta %d, mask %02X)", limit, deltaValue, mask);
166
167 for (int i = 0; i < 256; i++) {
168 r = _mainPalette[i * 3 + 0];
169 g = _mainPalette[i * 3 + 1];
170 b = _mainPalette[i * 3 + 2];
171 if (MAX(r, MAX(b, g)) >= limit) {
172 if ((mask & 1) && r >= deltaValue)
173 r -= deltaValue;
174 if ((mask & 2) && g >= deltaValue)
175 g -= deltaValue;
176 if ((mask & 4) && b >= deltaValue)
177 b -= deltaValue;
178 }
179
180 _colorTransTable[i] = getMatchingColor(r, g, b);
181 }
182 }
183
saveState(Common::WriteStream * out)184 void Palette::saveState(Common::WriteStream *out) {
185 // Save currently active palette
186 byte palette[768];
187 getFullPalette(palette);
188 out->write(palette, 768);
189
190 out->write(_mainPalette, 768);
191 out->write(_animPalette, 768);
192 out->write(_colorTransTable, 256);
193
194 uint16 fragmentCount = _fragments.size();
195 out->writeUint16LE(fragmentCount);
196 for (PaletteFragmentArray::iterator iter = _fragments.begin(); iter != _fragments.end(); ++iter) {
197 PaletteFragment fragment = *iter;
198 out->writeUint16LE(fragment.id);
199 out->writeByte(fragment.index);
200 out->writeByte(fragment.count);
201 }
202 out->writeByte(_fragmentIndex);
203 }
204
loadState(Common::ReadStream * in)205 void Palette::loadState(Common::ReadStream *in) {
206 // Save currently active palette
207 byte palette[768];
208 in->read(palette, 768);
209 setFullPalette(palette);
210
211 in->read(_mainPalette, 768);
212 in->read(_animPalette, 768);
213 in->read(_colorTransTable, 256);
214
215 uint16 fragmentCount = in->readUint16LE();
216 _fragments.clear();
217 for (uint16 i = 0; i < fragmentCount; i++) {
218 PaletteFragment fragment;
219 fragment.id = in->readUint16LE();
220 fragment.index = in->readByte();
221 fragment.count = in->readByte();
222 _fragments.push_back(fragment);
223 }
224 _fragmentIndex = in->readByte();
225 }
226
227
228 } // End of namespace Toltecs
229