public void InitPlayerTexture()
{
PaletteSwap.InitColorSwapTex(mySpriteRenderer);
// Pull the colors from the GameManager
Color bodyColor = new Color(GameManager.gameData.customPlayerColorBody [0],
GameManager.gameData.customPlayerColorBody [1],
GameManager.gameData.customPlayerColorBody [2], 1f);
float h, s, v; // The Hue, Sat, Value of the bodyColor
Color.RGBToHSV(bodyColor, out h, out s, out v);
v /= 2f; // Divide the value in half
Color bodyColorDark = Color.HSVToRGB(h, s, v); // Create a dark color from the body color
if (bodyColorDark.r < .1f)
{
bodyColorDark.r = .1f;
}
Color trimColor = new Color(GameManager.gameData.customPlayerColorTrim [0],
GameManager.gameData.customPlayerColorTrim [1],
GameManager.gameData.customPlayerColorTrim [2], 1f);
// Swap the colors
PaletteSwap.SwapColor(PaletteSwap.SwapIndex.Body, bodyColor);
PaletteSwap.SwapColor(PaletteSwap.SwapIndex.BodyDark, bodyColorDark);
PaletteSwap.SwapColor(PaletteSwap.SwapIndex.Trim, trimColor);
PaletteSwap.mColorSwapTex.Apply(); // Apply the texture
}
private void Start()
{
++enemyCount;
swapper = GetComponent <PaletteSwap>();
animator = GetComponent <Animator>();
rigidbody = GetComponent <Rigidbody2D>();
renderer = GetComponent <SpriteRenderer>();
swapper.SetColour(1, hairColors[Random.Range(0, hairColors.Length)]);
swapper.SetColour(2, skinColors[Random.Range(0, skinColors.Length)]);
swapper.SetColour(4, clothingColors[Random.Range(0, clothingColors.Length)]);
swapper.SetColour(5, clothingColors[Random.Range(0, clothingColors.Length)]);
hitFadeMaterial = new Material(hitFadeMaterial);
rainbowBlendMaterial = new Material(rainbowBlendMaterial);
// Add a red-fade shader to the materials list.
Material[] materials = renderer.materials;
Material[] moreMaterials = new Material[materials.Length + 1];
for (int i = 0; i < materials.Length; ++i)
{
moreMaterials[i] = materials[i];
}
moreMaterials[materials.Length] = hitFadeMaterial;
hitFadeMaterial.SetFloat("_BlendAmount", 0.0f);
renderer.materials = moreMaterials;
attackTime = Random.value * 5.0f;
}
/// <summary>
/// AnimationState should == animationKey! then we can eliminate the need for manual input of string.
/// </summary>
public void SetAnimatorController(ActorData data)
{
actor = GetComponent <BaseActor>();
spriteRenderer = GetComponent <SpriteRenderer>();
if (data.colorPalette.Length > 0 && GetComponent <PaletteSwap>() != null && data.baseActor != null)
{
PaletteSwap pSwap = GetComponent <PaletteSwap>();
pSwap.enabled = true;
pSwap.swapOutPaletteDefault = data.baseActor.colorPalette;
pSwap.swapInPaletteDefault = data.colorPalette;
}
spriteRenderer.material = new Material(Shader.Find("AtomosZ/NoSwapShader"));
spriteMaterial = spriteRenderer.material;
offsetPropertyId = Shader.PropertyToID("_Offset");
animator = GetComponent <Animator>();
spriteRenderer.sprite = data.sprite;
if (data.animatorController == null)
{
Debug.LogWarning(data.actorName + " data has no animatorController");
}
else
{
animator.runtimeAnimatorController = data.animatorController;
animationPrefix = data.animationPrefix;
if (!animationPrefix.EndsWith("_"))
{
animationPrefix += "_";
}
}
}
private void SpawnPlayer(int playerIndex)
{
GameObject playerObj = Instantiate(PREFAB_PLAYER, spawnPoints[playerIndex].position, Quaternion.identity);
Player player = playerObj.GetComponent <Player>();
player.Initialize(this, playerIndex);
PaletteSwap palette = playerObj.GetComponent <PaletteSwap>();
palette.SetColors(skinColor, playerColors[playerIndex], pantsColor, 0.1f);
}
private void CreateSprite(string fullPath)
{
MemoryStream stream = new MemoryStream();
System.Drawing.Image image = System.Drawing.Bitmap.FromFile(fullPath);
image.Save(stream, image.RawFormat);
byte[] rawBytes = stream.ToArray();
byte[] spriteBytes = File.ReadAllBytes(fullPath);
//Debug.Log("raw bytes: " + rawBytes.Length + " sb: " + spriteBytes.Length);
System.Drawing.Bitmap bitmap = new System.Drawing.Bitmap(fullPath);
bitmap.RotateFlip(System.Drawing.RotateFlipType.RotateNoneFlipY);
byte[] rgbBytes = new byte[bitmap.Width * bitmap.Height * 4];
for (int x = 0; x < bitmap.Width; x += 1)
{
for (int y = 0; y < bitmap.Height; y += 1)
{
System.Drawing.Color pixel = bitmap.GetPixel(x, y);
//Color c = new Color32(pixel.R, pixel.G, pixel.B, pixel.A);
int offset = y * bitmap.Width * 4 + x * 4;
rgbBytes[offset + 0] = pixel.R;
rgbBytes[offset + 1] = pixel.G;
rgbBytes[offset + 2] = pixel.B;
rgbBytes[offset + 3] = pixel.A;
}
}
//Array.Reverse(rgbBytes);
Texture2D temp = new Texture2D(2, 2, TextureFormat.RGBA32, false);
if (!temp.LoadImage(spriteBytes))
{
Debug.LogError("image file:[" + fullPath + "] could not be read.");
return;
}
Texture2D spriteSheetTexture = new Texture2D(temp.width, temp.height, TextureFormat.RGBA32, false, false);
spriteSheetTexture.LoadRawTextureData(rgbBytes);
if (true)
{
//File.WriteAllBytes(Application.streamingAssetsPath + "/output/" + Path.GetFileNameWithoutExtension(fullPath) + ".png", spriteSheetTexture.EncodeToPNG());
string jsonFile = System.IO.Path.Combine(Path.GetDirectoryName(fullPath), Path.GetFileNameWithoutExtension(fullPath) + ".json");
List <SpriteLoader> loaders = new List <SpriteLoader>();
if (File.Exists(jsonFile))
{
JObject json = JObject.Parse(File.ReadAllText(jsonFile));
float ppu = Funcs.jsonGetFloat(json["ppu"], 32f);
int eachWidth = Funcs.jsonGetInt(json["width"], 32);
int eachHeight = Funcs.jsonGetInt(json["height"], 32);
List <PaletteSwap> swaps = new List <PaletteSwap>();
JArray jsonPaletteSwapArray = Funcs.jsonGetArray(json, "paletteSwaps");
if (jsonPaletteSwapArray != null)
{
foreach (JObject swap in jsonPaletteSwapArray)
{
float csInput = (float)(Funcs.jsonGetInt(swap["input"], 0) % 255);
PaletteSwap ps = new PaletteSwap();
ps.input = csInput / 255.0f;
JArray csOutputs = Funcs.jsonGetArray(swap, "output");
if (csOutputs != null)
{
foreach (JToken csOutputColour in csOutputs)
{
int colour = Convert.ToInt32(csOutputColour.ToString(), 16);
byte r = (byte)((colour >> 16) & 255);
byte g = (byte)((colour >> 8) & 255);
byte b = (byte)((colour >> 0) & 255);
//Debug.Log(csOutputColour.ToString() + " r:" + r + " g:" + g + " b:" + b);
Color c = new Color32(r, g, b, 255);
ps.output.Add(c);
}
swaps.Add(ps);
}
}
}
JArray jsonArray = Funcs.jsonGetArray(json, "sprites");
if (jsonArray != null)
{
foreach (JObject jsonSprite in jsonArray)
{
string sName = Funcs.jsonGetString(jsonSprite["name"], null);
if (sName == null)
{
continue;
}
SpriteLoader sl = new SpriteLoader(sName);
if (swaps.Count > 0)
{
sl.paletteSwaps = swaps;
}
sl.x = Funcs.jsonGetInt(jsonSprite["x"], sl.x);
sl.y = Funcs.jsonGetInt(jsonSprite["y"], sl.y);
sl.pivotX = Funcs.jsonGetFloat(jsonSprite["px"], sl.pivotX);
sl.pivotY = Funcs.jsonGetFloat(jsonSprite["px"], sl.pivotY);
sl.flipX = Funcs.jsonGetBool(jsonSprite["flipX"], sl.flipX);
sl.width = eachWidth;
sl.height = eachHeight;
sl.ppu = ppu;
sl.spriteSheetTex = new Texture2D(spriteSheetTexture.width, spriteSheetTexture.height, DEFAULT_TEXTURE_FORMAT, false);
sl.spriteSheetTex.SetPixels(spriteSheetTexture.GetPixels());
sl.spriteSheetTex.Apply();
loaders.Add(sl);
}
}
}
else
{
SpriteLoader sl = new SpriteLoader(Path.GetFileNameWithoutExtension(fullPath));
sl.spriteSheetTex = new Texture2D(spriteSheetTexture.width, spriteSheetTexture.height, DEFAULT_TEXTURE_FORMAT, false);
sl.spriteSheetTex.SetPixels(spriteSheetTexture.GetPixels());
sl.spriteSheetTex.Apply();
sl.width = spriteSheetTexture.width;
sl.height = spriteSheetTexture.height;
loaders.Add(sl);
}
foreach (SpriteLoader loader in loaders)
{
Vector2 pivot = new Vector2(loader.pivotX, loader.pivotY);
////Debug.Log("loading " + loader.ToString());
//Color32[] col32 = loader.spriteSheetTex.GetPixels32();
//int xs = loader.x * loader.width;
//int ys = loader.y * loader.height;
//int xe = xs + loader.width;
//int ye = ys + loader.height;
//Color[] c = new Color32[loader.width * loader.height];
//for (int y = 0; y < loader.height; y += 1) {
// for (int x = 0; x < loader.width; x += 1) {
// int srcIndex = ((ys + y) * loader.spriteSheetTex.width) + (xs + x);
// int dstIndex= y * loader.width + x;
// Color32 ccc = col32[srcIndex];
// c[dstIndex] = ccc;
// }
//}
Color[] c = loader.spriteSheetTex.GetPixels(loader.x * loader.width, loader.y * loader.height, loader.width, loader.height);
loader.spriteTex = new Texture2D(loader.width, loader.height, DEFAULT_TEXTURE_FORMAT, false);
if (loader.flipX)
{
for (int x = 0; x < loader.width; x += 1)
{
int xx = loader.width - 1 - x;
for (int y = 0; y < loader.height; y += 1)
{
loader.spriteTex.SetPixel(x, y, c[y * loader.width + xx]);
}
}
}
else
{
loader.spriteTex.SetPixels(c);
}
loader.spriteTex.filterMode = loader.filter;
loader.spriteTex.Apply();
//Color32[] c32 = tex.GetPixels32();
////for(int ii = 0; ii < c32.Length; ii += 1) {
//// c32[ii] = new Color32(c32[ii].r, c32[ii].g, c32[ii].b, 255);
////}
//tex.SetPixels32(c32);
//tex.Apply();
if (loader.paletteSwaps == null)
{
Rect rect = new Rect(0, 0, loader.width, loader.height);
string properName = Path.GetFileName(Path.GetDirectoryName(fullPath)) + "::" + loader.name;
CreateIcon(loader.spriteTex, properName);
Sprite sprite = Sprite.Create(loader.spriteTex, rect, pivot, loader.ppu);
sprite.name = "sprite::" + properName;
sprites[properName] = sprite;
}
else
{
for (int j = 0; j < 10; j += 1)
{
Texture2D newTex = new Texture2D(loader.spriteTex.width, loader.spriteTex.height, DEFAULT_TEXTURE_FORMAT, false);
newTex.SetPixels(loader.spriteTex.GetPixels());
foreach (PaletteSwap ps in loader.paletteSwaps)
{
Color[] c32 = loader.spriteTex.GetPixels();
Color newColour = ps.output[UnityEngine.Random.Range(0, ps.output.Count)];
for (int y = 0; y < newTex.height; y += 1)
{
for (int x = 0; x < newTex.width; x += 1)
{
Color oc = c32[y * newTex.width + x];
//if (x == y) Debug.Log(loader.name + "(" + x + "," + y + ") oc = " + oc.ToString() + " " + " input=" + ps.input);
if (oc.a > 0 && oc.r == ps.input)
{
newTex.SetPixel(x, y, newColour);
}
else
{
}
}
}
}
newTex.filterMode = FilterMode.Point;
newTex.Apply();
Rect rect = new Rect(0, 0, loader.width, loader.height);
string properName = Path.GetFileName(Path.GetDirectoryName(fullPath)) + "::" + loader.name + "_" + j;
CreateIcon(newTex, properName);
Sprite sprite = Sprite.Create(newTex, rect, pivot, loader.ppu);
sprite.name = "sprite::" + properName;
sprites[properName] = sprite;
}
}
//string output = sprite.name + " [" + properName + "]"+
// "\n(" + sprite.texture.width + "x" + sprite.texture.height + "@"+sprite.pixelsPerUnit+ ") (g:" + sprite.texture.graphicsFormat + ") (format:" + sprite.texture.format + ")";
//Debug.Log("sprite:" + output);
//Debug.Log("loader:" + loader);
}
}
}
private void SetUpCamera()
{
cam = Camera.main;
camController = cam.gameObject.GetComponent <CameraController>(); // sus
palette = cam.gameObject.GetComponent <PaletteSwap>();
}
