| public Generate ( byte data, int width, int height, TextureFilter filter, bool allowDownSize, TextureRepeat repeat, TextureDepth depth ) : void | ||
| data | byte | |
| width | int | |
| height | int | |
| filter | TextureFilter | |
| allowDownSize | bool | |
| repeat | TextureRepeat | |
| depth | TextureDepth | |
| Résultat | void | |
/// <summary>
/// Create a 2D table that calculates (reflection dot , specularity).
/// </summary>
/// <param name="image"></param>
public static void GenerateSpecular2DTableImage(idImage image)
{
byte[, ,] data = new byte[256, 256, 4];
for(int x = 0; x < 256; x++)
{
float f = x / 255.0f;
for(int y = 0; y < 256; y++)
{
int b = (int) (idMath.Pow(f, y) * 255.0f);
if(b == 0)
{
// as soon as b equals zero all remaining values in this column are going to be zero
// we early out to avoid pow() underflows
break;
}
data[y, x, 0] =
data[y, x, 1] =
data[y, x, 2] =
data[y, x, 3] = (byte) b;
}
}
image.Generate(idHelper.Flatten<byte>(data), 256, 256, TextureFilter.Linear, false, TextureRepeat.Clamp, TextureDepth.HighQuality);
}
/// <summary>
/// Creates a 0-255 ramp image.
/// </summary>
/// <param name="image"></param>
public static void GenerateAlphaRampImage(idImage image)
{
byte[,] data = new byte[256, 4];
for(int x = 0; x < 256; x++)
{
data[x, 0] =
data[x, 1] =
data[x, 2] = 255;
data[x, 3] = (byte) x;
}
image.Generate(idHelper.Flatten<byte>(data), 256, 1, TextureFilter.Nearest, false, TextureRepeat.Clamp, TextureDepth.HighQuality);
}
public static void GenerateAlphaNotchImage(idImage image)
{
byte[,] data = new byte[2, 4];
// this is used for alpha test clip planes
data[0, 0] = data[0, 1] = data[0, 2] = 255;
data[0, 3] = 0;
data[1, 0] = data[1, 1] = data[1, 2] = 255;
data[1, 3] = 255;
image.Generate(idHelper.Flatten<byte>(data), 2, 1, TextureFilter.Nearest, false, TextureRepeat.Clamp, TextureDepth.HighQuality);
}
/// <summary>
/// Creates a ramp that matches our fudged specular calculation.
/// </summary>
/// <param name="image"></param>
public static void GenerateSpecularTableImage(idImage image)
{
byte[,] data = new byte[256, 4];
for(int x = 0; x < 256; x++)
{
float f = x / 255.0f;
// this is the behavior of the hacked up fragment programs that can't really do a power function
f = (f - 0.75f) * 4;
if(f < 0)
{
f = 0;
}
f = f * f;
int b = (int) (f * 255);
data[x, 0] =
data[x, 1] =
data[x, 2] =
data[x, 3] = (byte) b;
}
image.Generate(idHelper.Flatten<byte>(data), 256, 1, TextureFilter.Linear, false, TextureRepeat.Clamp, TextureDepth.HighQuality);
}
public static void GenerateWhiteImage(idImage image)
{
// solid white texture
byte[] data = new byte[DefaultImageSize * DefaultImageSize * 4];
int count = data.Length;
for(int i = 0; i < count; i++)
{
data[i] = 255;
}
image.Generate(data, DefaultImageSize, DefaultImageSize, TextureFilter.Default, false, TextureRepeat.Repeat, TextureDepth.Default);
}
public static void GenerateRGB8Image(idImage image)
{
byte[, ,] data = new byte[DefaultImageSize, DefaultImageSize, 4];
data[0, 0, 0] = 16;
data[0, 0, 1] = 32;
data[0, 0, 2] = 48;
data[0, 0, 3] = 255;
image.Generate(idHelper.Flatten<byte>(data), DefaultImageSize, DefaultImageSize, TextureFilter.Default, false, TextureRepeat.Repeat, TextureDepth.HighQuality);
}
public static void GenerateFlatNormalImage(idImage image)
{
byte[, ,] data = new byte[DefaultImageSize, DefaultImageSize, 4];
int red = (idE.CvarSystem.GetInteger("image_useNormalCompression") == 1) ? 0 : 3;
int alpha = (red == 0) ? 3 : 0;
// flat normal map for default bunp mapping
for(int i = 0; i < 4; i++)
{
data[0, i, red] = 128;
data[0, i, 1] = 128;
data[0, i, 2] = 255;
data[0, i, alpha] = 255;
}
image.Generate(idHelper.Flatten<byte>(data), 2, 2, TextureFilter.Default, true, TextureRepeat.Repeat, TextureDepth.HighQuality);
}
public static void GenerateBorderClampImage(idImage image)
{
// the size determines how far away from the edge the blocks start fading
int borderClampSize = 32;
byte[, ,] data = new byte[borderClampSize, borderClampSize, 4];
// solid white texture with a single pixel black border
for(int y = 0; y < borderClampSize; y++)
{
for(int x = 0; x < borderClampSize; x++)
{
data[y, x, 0] = 255;
data[y, x, 1] = 255;
data[y, x, 2] = 255;
data[y, x, 3] = 255;
}
}
for(int i = 0; i < borderClampSize; i++)
{
data[i, 0, 0] =
data[i, 0, 1] =
data[i, 0, 2] =
data[i, 0, 3] =
data[i, borderClampSize - 1, 0] =
data[i, borderClampSize - 1, 1] =
data[i, borderClampSize - 1, 2] =
data[i, borderClampSize - 1, 3] =
data[0, i, 0] =
data[0, i, 1] =
data[0, i, 2] =
data[0, i, 3] =
data[borderClampSize - 1, i, 0] =
data[borderClampSize - 1, i, 1] =
data[borderClampSize - 1, i, 2] =
data[borderClampSize - 1, i, 3] = 0;
}
image.Generate(idHelper.Flatten<byte>(data), borderClampSize, borderClampSize, TextureFilter.Linear, false, TextureRepeat.ClampToBorder, TextureDepth.Default);
if(idE.RenderSystem.IsRunning == false)
{
// can't call qglTexParameterfv yet
return;
}
// explicit zero border
float[] color = new float[4];
//Gl.glTexParameterfv(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_BORDER_COLOR, color);
}
/// <summary>
/// This is a solid white texture that is zero clamped.
/// </summary>
/// <param name="image"></param>
public static void GenerateNoFalloffImage(idImage image)
{
byte[, ,] data = new byte[16, FalloffTextureSize, 4];
for(int x = 1; x < (FalloffTextureSize - 1); x++)
{
for(int y = 1; y < 15; y++)
{
data[y, x, 0] = 255;
data[y, x, 1] = 255;
data[y, x, 2] = 255;
data[y, x, 3] = 255;
}
}
image.Generate(idHelper.Flatten<byte>(data), FalloffTextureSize, 16, TextureFilter.Default, false, TextureRepeat.ClampToZero, TextureDepth.HighQuality);
}
public static void GenerateQuadraticImage(idImage image)
{
byte[, ,] data = new byte[QuadraticHeight, QuadraticWidth, 4];
for(int x = 0; x < QuadraticWidth; x++)
{
for(int y = 0; y < QuadraticHeight; y++)
{
float d = x - ((QuadraticWidth / 2) - 0.5f);
d = idMath.Abs(d);
d -= 0.5f;
d /= QuadraticWidth / 2;
d = 1.0f - d;
d = d * d;
int b = (byte) (d * 255);
if(b <= 0)
{
b = 0;
}
else if(b > 255)
{
b = 255;
}
data[y, x, 0] =
data[y, x, 1] =
data[y, x, 2] = (byte) b;
data[y, x, 3] = 255;
}
}
image.Generate(idHelper.Flatten<byte>(data), QuadraticWidth, QuadraticHeight, TextureFilter.Default, false, TextureRepeat.Clamp, TextureDepth.HighQuality);
}
/// <summary>
/// We calculate distance correctly in two planes, but the third will still be projection based.
/// </summary>
/// <param name="image"></param>
public static void GenerateFogImage(idImage image)
{
byte[, ,] data = new byte[FogSize, FogSize, 4];
float[] step = new float[256];
float remaining = 1.0f;
for(int i = 0; i < 256; i++)
{
step[i] = remaining;
remaining *= 0.982f;
}
for(int x = 0; x < FogSize; x++)
{
for(int y = 0; y < FogSize; y++)
{
float d = (float) idMath.Sqrt((x - (FogSize / 2)) * (x - (FogSize / 2))
+ (y - (FogSize / 2)) * (y - (FogSize / 2)));
d /= FogSize / 2 - 1;
int b = (byte) (d * 255);
if(b <= 0)
{
b = 0;
}
else if(b > 255)
{
b = 255;
}
b = (byte) (255 * (1.0f - step[b]));
if((x == 0) || (x == (FogSize - 1)) || (y == 0) || (y == (FogSize - 1)))
{
b = 255; // avoid clamping issues
}
data[y, x, 0] =
data[y, x, 1] =
data[y, x, 2] = 255;
data[y, x, 3] = (byte) b;
}
}
image.Generate(idHelper.Flatten<byte>(data), FogSize, FogSize, TextureFilter.Linear, false, TextureRepeat.Clamp, TextureDepth.HighQuality);
}
