private static void Main()
{
int remainingTestCases = int.Parse(Console.ReadLine());
while (remainingTestCases-- > 0)
{
int[] line = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
int rowCount = line[0];
int columnCount = line[1];
string[] zeroOneRows = new string[rowCount];
for (int r = 0; r < rowCount; ++r)
{
zeroOneRows[r] = Console.ReadLine();
}
var output = new StringBuilder();
int?[,] nearestWhitePixelDistances = BITMAP.Solve(rowCount, columnCount, zeroOneRows);
for (int r = 0; r < rowCount; ++r)
{
output.Append(nearestWhitePixelDistances[r, 0]);
for (int c = 1; c < columnCount; ++c)
{
output.Append($" {nearestWhitePixelDistances[r, c]}");
}
output.AppendLine();
}
Console.Write(output);
Console.ReadLine();
}
}
//一定時間ごとにスクショを保存する。
void GetPict()
{
BITMAP bitmap = DisplayCapt.CaptureWindow(_hwnd);
if (bitmap == null)
{
_exception = new InvalidHandleException();
_isRun = false;
return;
}
if (bitmap.Width != _defBitmap.Width || bitmap.Height != _defBitmap.Height)
{
_exception = new ChangeSizeException();
_isRun = false;
return;
}
BitmapData bdata = bitmap.Bitmap.LockBits(new Rectangle(0, 0, _defBitmap.Width, _defBitmap.Height),
ImageLockMode.ReadOnly, _defBitmap.PixelFormat);
byte[] buf = new byte[_defBitmap.Size];
Marshal.Copy(bdata.Scan0, buf, 0, _defBitmap.Size);
bitmap.Bitmap.UnlockBits(bdata);
_pictureBuf.Add(buf);
}
static BitmapSource CreateBitmapSourceFromHandle(IntPtr bitmapHandle, BITMAP bitmap)
{
var bitmapSource = Imaging.CreateBitmapSourceFromHBitmap(bitmapHandle, IntPtr.Zero, new Int32Rect(0, 0, bitmap.Width, bitmap.Height), BitmapSizeOptions.FromWidthAndHeight(bitmap.Width, bitmap.Height));
bitmapSource.Freeze();
return(bitmapSource);
}
/* draw a line (for wireframe display) */
static void wire(BITMAP b, VTX v1, VTX v2)
{
int col = MID(128, 255 - fixtoi(v1.z + v2.z) / 16, 255);
line(b, fixtoi(v1.x), fixtoi(v1.y), fixtoi(v2.x), fixtoi(v2.y),
palette_color[col]);
}
private static void Main(string[] args)
{
//var r = CaptureUtil.DefGetCaptureData(ref offset, ref width, ref height);
IntPtr hwnd = IntPtr.Zero;
IntPtr hdc = IntPtr.Zero;
if (CaptureUtil.GetWindowHDC(ref hwnd, ref hdc))
{
int x = 0;
int y = 0;
CaptureUtil.GetWindowSize(hwnd, ref x, ref y);
// 4k / 4 = 1k
// sqrt(1024) = 32
int num = 0;
const int blockSize = 128;
var bitmap = new BITMAP();
var bitmapSize = CaptureUtil.DefGetCaptureBlockBitmap(hwnd, hdc, 0, 0, blockSize, blockSize, ref bitmap);
int blockSizeW = (x + blockSize - 1) / blockSize;
int blockSizeH = (y + blockSize - 1) / blockSize;
for (int i = 0; i < blockSizeW; ++i)
{
for (int j = 0; j < blockSizeH; ++j)
{
var r = CaptureUtil.DefGetCaptureData(hwnd, hdc, bitmapSize, bitmap, i * blockSize, j * blockSize, blockSize, blockSize);
var result = CaptureUtil.ConvertBmpToJpeg(r);
using (FileStream fs = new FileStream(@"D:\Test\test" + num + @".jpg", FileMode.Create, FileAccess.Write))
{
fs.Write(result, 0, result.Length);
}
++num;
}
}
}
}
/* cull backfaces and draw cubes */
static void draw_cube(BITMAP buffer, V3D_f[] x1, V3D_f[] x2)
{
int i;
for (i = 0; i < 6; i++)
{
V3D_f vtx1, vtx2, vtx3, vtx4;
vtx1 = x1[faces[i].v1];
vtx2 = x1[faces[i].v2];
vtx3 = x1[faces[i].v3];
vtx4 = x1[faces[i].v4];
if (polygon_z_normal_f(ref vtx1, ref vtx2, ref vtx3) > 0)
{
quad3d_f(buffer, POLYTYPE_GCOL | POLYTYPE_ZBUF, NULL,
ref vtx1, ref vtx2, ref vtx3, ref vtx4);
}
vtx1 = x2[faces[i].v1];
vtx2 = x2[faces[i].v2];
vtx3 = x2[faces[i].v3];
vtx4 = x2[faces[i].v4];
if (polygon_z_normal_f(ref vtx1, ref vtx2, ref vtx3) > 0)
{
quad3d_f(buffer, POLYTYPE_GCOL | POLYTYPE_ZBUF, NULL,
ref vtx1, ref vtx2, ref vtx3, ref vtx4);
}
}
}
public void WritePixelsDirect(int[] pixels, int byteOffset = 0)
{
if (m_hBitmap == IntPtr.Zero)
{
throw new ObjectDisposedException(nameof(DibBitmap));
}
if (pixels == null)
{
throw new ArgumentNullException(nameof(pixels));
}
if (byteOffset < 0)
{
throw new ArgumentOutOfRangeException(nameof(byteOffset));
}
BITMAP bitmap = new BITMAP();
int size = Marshal.SizeOf(bitmap);
GetObject(m_hBitmap, size, out bitmap);
if (bitmap.bmBits != IntPtr.Zero)
{
// invert y axis
for (int y = 0; y < m_Height; y++)
{
int srcPos = (byteOffset / 4) + (y * m_Width);
int dstPos = ((m_Height - y) * m_Width * 4);
// dstPos = 0;
Marshal.Copy(pixels, srcPos, bitmap.bmBits + dstPos, m_Width);
}
// Marshal.Copy(pixels, byteOffset / 4, bitmap.bmBits, m_Width * m_Height);
}
}
/* draw the shapes calculated by translate_shapes() */
static void draw_shapes(BITMAP b)
{
int c;
QUAD[] face = output_faces;
VTX v1, v2, v3, v4;
/* depth sort */
Array.Sort(output_faces);
for (c = 0; c < NUM_FACES * NUM_SHAPES; c++)
{
/* find the vertices used by the face */
v1 = face[c].vtxlist[face[c].v1];
v2 = face[c].vtxlist[face[c].v2];
v3 = face[c].vtxlist[face[c].v3];
v4 = face[c].vtxlist[face[c].v4];
/* draw the face */
if (_render_mode == render_mode.wireframe)
{
wire(b, v1, v2);
wire(b, v2, v3);
wire(b, v3, v4);
wire(b, v4, v1);
}
else
{
draw_quad(b, v1, v2, v3, v4, render_type[(int)_render_mode]);
}
}
}
/* main animation control loop */
static void triple_buffer(BITMAP page1, BITMAP page2, BITMAP page3)
{
BITMAP active_page = page1;
int page = 0;
do
{
/* draw a frame */
draw(active_page);
/* make sure the last flip request has actually happened */
do
{
} while (poll_scroll());
/* post a request to display the page we just drew */
request_video_bitmap(active_page);
/* update counters to point to the next page */
switch (page)
{
case 0: page = 1; active_page = page2; break;
case 1: page = 2; active_page = page3; break;
case 2: page = 0; active_page = page1; break;
}
} while (!keypressed());
clear_keybuf();
}
/* draw a quad */
static void draw_quad(BITMAP b, VTX v1, VTX v2, VTX v3, VTX v4, int mode)
{
int col;
/* four vertices */
V3D vtx1 = new V3D(0, 0, 0, 0, 0, 0);
V3D vtx2 = new V3D(0, 0, 0, 32 << 16, 0, 0);
V3D vtx3 = new V3D(0, 0, 0, 32 << 16, 32 << 16, 0);
V3D vtx4 = new V3D(0, 0, 0, 0, 32 << 16, 0);
vtx1.x = v1.x; vtx1.y = v1.y; vtx1.z = v1.z;
vtx2.x = v2.x; vtx2.y = v2.y; vtx2.z = v2.z;
vtx3.x = v3.x; vtx3.y = v3.y; vtx3.z = v3.z;
vtx4.x = v4.x; vtx4.y = v4.y; vtx4.z = v4.z;
/* cull backfaces */
if ((mode != POLYTYPE_ATEX_MASK) && (mode != POLYTYPE_PTEX_MASK) &&
(mode != POLYTYPE_ATEX_MASK_LIT) && (mode != POLYTYPE_PTEX_MASK_LIT) &&
(polygon_z_normal(ref vtx1, ref vtx2, ref vtx3) < 0))
{
return;
}
/* set up the vertex color, differently for each rendering mode */
switch (mode)
{
case POLYTYPE_FLAT:
col = MID(128, 255 - fixtoi(v1.z + v2.z) / 16, 255);
vtx1.c = vtx2.c = vtx3.c = vtx4.c = palette_color[col];
break;
case POLYTYPE_GCOL:
vtx1.c = palette_color[0xD0];
vtx2.c = palette_color[0x80];
vtx3.c = palette_color[0xB0];
vtx4.c = palette_color[0xFF];
break;
case POLYTYPE_GRGB:
vtx1.c = 0x000000;
vtx2.c = 0x7F0000;
vtx3.c = 0xFF0000;
vtx4.c = 0x7F0000;
break;
case POLYTYPE_ATEX_LIT:
case POLYTYPE_PTEX_LIT:
case POLYTYPE_ATEX_MASK_LIT:
case POLYTYPE_PTEX_MASK_LIT:
vtx1.c = MID(0, 255 - fixtoi(v1.z) / 4, 255);
vtx2.c = MID(0, 255 - fixtoi(v2.z) / 4, 255);
vtx3.c = MID(0, 255 - fixtoi(v3.z) / 4, 255);
vtx4.c = MID(0, 255 - fixtoi(v4.z) / 4, 255);
break;
}
/* draw the quad */
quad3d(b, mode, texture, ref vtx1, ref vtx2, ref vtx3, ref vtx4);
}
/* draws a set of objects that demonstrate whats going on. It consists
* of a cube, an arrow showing the 'to' orientation, an another arrow
* showing the 'from' orientation, and another arrow showing the
* interpolated orientation.
*/
static void render_demo_box(BITMAP b, ref MATRIX_f from, ref MATRIX_f _in, ref MATRIX_f to, int col1, int col2, int col3)
{
float[,] tmp_points = new float[8, 3];
render_wireframe_object(ref _in, b, box_points, tmp_points, box_edges, 8, 12, col1);
render_wireframe_object(ref from, b, arrow_points, tmp_points, arrow_edges, 4, 3, col3);
render_wireframe_object(ref to, b, arrow_points, tmp_points, arrow_edges, 4, 3, col3);
render_wireframe_object(ref _in, b, arrow_points, tmp_points, arrow_edges, 4, 3, col2);
}
public Image GetImageFromHBitmap(IntPtr hBitmap)
{
var bitmapStruct = new BITMAP();
GetObjectBitmap(hBitmap, Marshal.SizeOf(bitmapStruct), ref bitmapStruct);
var image = new Bitmap(bitmapStruct.bmWidth, bitmapStruct.bmHeight, bitmapStruct.bmWidth * 4, System.Drawing.Imaging.PixelFormat.Format32bppArgb, bitmapStruct.bmBits);
return(image);
}
/* this merges 'bmp' into 'back'. This is how the trails work */
static void blur_12(BITMAP bmp, BITMAP back)
{
int x, y, r1, g1, b1, r2, g2, b2, c1, c2;
// TODO: check why I had to add "2 *"
for (y = 0; y < 2 * bmp.h; y++)
{
ManagedPointerArray backline = back.line[y];
ManagedPointerArray bmpline = bmp.line[y];
for (x = 0; x < bmp.w / 2; x++)
{
/* first get the pixel from each bitmap, then move the first
* colour value slightly towards the second.
*/
c1 = bmpline[x];
c2 = backline[x];
r1 = c1 & 0xF00;
r2 = c2 & 0xF00;
if (r1 < r2)
{
c1 += 0x100;
}
else if (r1 > r2)
{
c1 -= 0x100;
}
b1 = c1 & 0xF0;
b2 = c2 & 0xF0;
if (b1 < b2)
{
c1 += 0x10;
}
else if (b1 > b2)
{
c1 -= 0x10;
}
g1 = c1 & 0x0F;
g2 = c2 & 0x0F;
if (g1 < g2)
{
c1 += 0x01;
}
else if (g1 > g2)
{
c1 -= 0x01;
}
/* then put it back in the bitmap */
bmpline[x] = (ushort)c1;
}
}
}
/* helper to draw four mirrored versions of a triangle */
static void kalid(BITMAP bmp, int x1, int y1, int x2, int y2, int x3, int y3,
int r, int g, int b)
{
triangle(bmp, SCREEN_W / 2 + x1, SCREEN_H / 2 + y1, SCREEN_W / 2 + x2, SCREEN_H / 2 + y2,
SCREEN_W / 2 + x3, SCREEN_H / 2 + y3, makecol(r, g, b));
triangle(bmp, SCREEN_W / 2 - x1, SCREEN_H / 2 + y1, SCREEN_W / 2 - x2, SCREEN_H / 2 + y2,
SCREEN_W / 2 - x3, SCREEN_H / 2 + y3, makecol(r, g, b));
triangle(bmp, SCREEN_W / 2 - x1, SCREEN_H / 2 - y1, SCREEN_W / 2 - x2, SCREEN_H / 2 - y2,
SCREEN_W / 2 - x3, SCREEN_H / 2 - y3, makecol(r, g, b));
triangle(bmp, SCREEN_W / 2 + x1, SCREEN_H / 2 - y1, SCREEN_W / 2 + x2, SCREEN_H / 2 - y2,
SCREEN_W / 2 + x3, SCREEN_H / 2 - y3, makecol(r, g, b));
}
public BITMAP ProcessStack(BITMAP src)
{
return(src.Clone
(
dc =>
{
foreach (var xform in _Transforms)
{
xform?.Invoke(dc);
}
}
));
}
//-------------------------------------------------------------------
//
// Public Methods
//
//-------------------------------------------------------------------
public void Open()
{
IntPtr hInstance = Marshal.GetHINSTANCE(typeof(SplashScreen).Module);
BITMAP bitmapInfo = new BITMAP();
IntPtr splashScreenBitmap = GetHBitmapFromResource(hInstance, SplashScreenResourceType, SplashScreenResourceId);
GetBitmapInformation(splashScreenBitmap, Marshal.SizeOf(typeof(BITMAP)), ref bitmapInfo);
int top, left;
CreateWindow(hInstance, bitmapInfo.bmWidth, bitmapInfo.bmHeight, out left, out top);
SelectBitmap(splashScreenBitmap, bitmapInfo.bmWidth, bitmapInfo.bmHeight, left, top);
}
public void CreateDIBitmapTest()
{
var bits = new byte[128 * 4];
byte[] rlebits = { 2, 0, 0, 0, 2, 1, 0, 1 };
using SafeHDC hdc = GetDC();
BITMAPINFO bmi = new();
bmi.bmiHeader.biSize = (uint)Marshal.SizeOf <BITMAPINFOHEADER>();
bmi.bmiHeader.biWidth = 2;
bmi.bmiHeader.biHeight = 2;
bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biBitCount = 16;
bmi.bmiHeader.biCompression = BitmapCompressionMode.BI_RGB;
bmi.bmiHeader.biSizeImage = 0;
bmi.bmiHeader.biXPelsPerMeter = 1;
bmi.bmiHeader.biYPelsPerMeter = 1;
bmi.bmiHeader.biClrUsed = 0;
bmi.bmiHeader.biClrImportant = 0;
SafeHBITMAP hbmp = CreateDIBitmap(hdc, bmi.bmiHeader, CBM.CBM_INIT, bits, bmi, DIBColorMode.DIB_RGB_COLORS);
Assert.That(hbmp, ResultIs.ValidHandle);
BITMAP bitmap = GetObject <BITMAP>(hbmp);
Assert.IsTrue(bitmap.bmType == 0);
Assert.IsTrue(bitmap.bmWidth == 2);
Assert.IsTrue(bitmap.bmHeight == 2);
Assert.That(bitmap.bmWidthBytes, Is.EqualTo(8));
Assert.IsTrue(bitmap.bmPlanes == 1);
Assert.IsTrue(bitmap.bmBitsPixel == GetDeviceCaps(hdc, DeviceCap.BITSPIXEL));
Assert.IsTrue(bitmap.bmBits == IntPtr.Zero);
bmi.bmiHeader.biCompression = BitmapCompressionMode.BI_RLE8;
bmi.bmiHeader.biBitCount = 8;
bmi.bmiHeader.biSizeImage = 8;
bmi.bmiHeader.biClrUsed = 1;
Assert.That(hbmp = CreateDIBitmap(hdc, bmi.bmiHeader, CBM.CBM_INIT, rlebits, new SafeBITMAPINFO(bmi), DIBColorMode.DIB_PAL_COLORS), ResultIs.ValidHandle);
bitmap = GetObject <BITMAP>(hbmp);
Assert.IsTrue(bitmap.bmType == 0);
Assert.IsTrue(bitmap.bmWidth == 2);
Assert.IsTrue(bitmap.bmHeight == 2);
Assert.That(bitmap.bmWidthBytes, Is.EqualTo(8));
Assert.IsTrue(bitmap.bmPlanes == 1);
Assert.IsTrue(bitmap.bmBitsPixel == GetDeviceCaps(hdc, DeviceCap.BITSPIXEL));
Assert.IsTrue(bitmap.bmBits == IntPtr.Zero);
}
/* helper function to draw a hand on the clock */
static void draw_hand(BITMAP bmp, int value, int range, int v2, int range2, int length, int color)
{
int angle;
int x, y;
int w, h;
angle = ((itofix(value) * 256) / range) +
((itofix(v2) * 256) / (range * range2)) - itofix(64);
x = fixmul(fixcos(angle), length);
y = fixmul(fixsin(angle), length);
w = bmp.w / 2;
h = bmp.h / 2;
line(bmp, w, h, w + fixtoi(x * w), h + fixtoi(y * h), color);
}
//初期化
void Initialize(PixelFormat pixelFormat)
{
_defBitmap = DisplayCapt.CaptureWindow(_hwnd);
if (_defBitmap == null)
{
throw new InvalidHandleException();
}
_defBitmap.PixelFormat = pixelFormat;
BitmapData bitmapData = _defBitmap.Bitmap.LockBits(new Rectangle(0, 0, _defBitmap.Width, _defBitmap.Height), ImageLockMode.ReadOnly, _defBitmap.PixelFormat);
_defBitmap.Stride = bitmapData.Stride;
_defBitmap.Size = _defBitmap.Stride * _defBitmap.Height;
_defBitmap.Bitmap.UnlockBits(bitmapData);
}
public byte[] GetIcon(string path, bool allowThumbnails, int dimensions = 256)
{
var bitmapHandle = IntPtr.Zero;
var uniqueId = new Guid("43826d1e-e718-42ee-bc55-a1e261c37bfe");
IShellItem rawFactory;
SHCreateItemFromParsingName(path, IntPtr.Zero, uniqueId, out rawFactory);
var factory = (IShellItemImageFactory)rawFactory;
var iconOnlyScope = SIIGBF.SIIGBF_ICONONLY;
var sizeScope = SIIGBF.SIIGBF_BIGGERSIZEOK;
var scope = (allowThumbnails ? SIIGBF.SIIGBF_THUMBNAILONLY : iconOnlyScope) | sizeScope;
try
{
factory.GetImage(new SIZE(dimensions, dimensions), scope, ref bitmapHandle);
}
catch (COMException ex) when (ex.ErrorCode == -2147175936 && allowThumbnails)
{
//no thumbnail available. fetch the icon instead.
factory.GetImage(new SIZE(dimensions, dimensions), iconOnlyScope | sizeScope, ref bitmapHandle);
}
if (bitmapHandle != IntPtr.Zero)
{
var bitmap = new BITMAP();
var bufferSize = Marshal.SizeOf(bitmap);
GetObject(bitmapHandle, bufferSize, out bitmap);
var bytes = new byte[bitmap.WidthBytes * bitmap.Height];
Marshal.Copy(bitmap.Bits, bytes, 0, bytes.Length);
DeleteObject(bitmapHandle);
return bytes;
}
else
{
//the handle is 0, assume that the data comes from Windows itself.
return null;
}
}
public static byte[] DefGetCaptureData(IntPtr hwnd, IntPtr hdc, uint size, BITMAP bmp, int x, int y, int w, int h)
{
uint offset = 0;
byte[] data = new byte[size];
offset = AppendBitmapHeader(ref data[0], ref bmp);
if (offset == 0)
{
return(null);
}
if (GetCaptureData(hwnd, hdc, x, y, w, h, ref data[offset]) == 0)
{
return(null);
}
return(data);
}
public rodent(BITMAP bmp)
{
x = rand.Next() % (SCREEN_W - bmp.w);
y = rand.Next() % (SCREEN_H - bmp.h);
do
{
delta_x = (rand.Next() % 11) - 5;
} while (delta_x == 0);
do
{
delta_y = (rand.Next() % 11) - 5;
} while (delta_y == 0);
sprite = bmp;
}
byte[] GenerateByteArrayFromBitmapHandle(IntPtr bitmapHandle)
{
var bitmap = new BITMAP();
AllocateBitmapSpace(bitmapHandle, ref bitmap);
try
{
FillBitmapBitsIntoHandle(bitmap);
var bitmapSource = CreateBitmapSourceFromHandle(bitmapHandle, bitmap);
return imagePersistenceService.ConvertBitmapSourceToByteArray(bitmapSource);
}
finally
{
DeleteObject(bitmapHandle);
}
}
/* draws a frame of the animation */
static void draw(BITMAP b)
{
int c;
//char message[1024];
string message;
acquire_bitmap(b);
clear_bitmap(b);
for (c = 0; c < NUM_SHAPES; c++)
{
triangle(b,
fixtoi(shapes[c].x + fixmul(shapes[c].dist1,
fixcos(shapes[c].dir1))),
fixtoi(shapes[c].y + fixmul(shapes[c].dist1,
fixsin(shapes[c].dir1))),
fixtoi(shapes[c].x + fixmul(shapes[c].dist2,
fixcos(shapes[c].dir2))),
fixtoi(shapes[c].y + fixmul(shapes[c].dist2,
fixsin(shapes[c].dir2))),
fixtoi(shapes[c].x + fixmul(shapes[c].dist3,
fixcos(shapes[c].dir3))),
fixtoi(shapes[c].y + fixmul(shapes[c].dist3,
fixsin(shapes[c].dir3))),
shapes[c].color);
move_shape(shapes[c]);
}
if (triplebuffer_not_available)
{
//ustrzcpy(message, sizeof message, "Simulated triple buffering");
message = "Simulated triple buffering";
}
else
{
//ustrzcpy(message, sizeof message, "Real triple buffering");
message = "Real triple buffering";
}
textout_ex(b, font, message, 0, 0, 255, -1);
release_bitmap(b);
}
byte[] GenerateByteArrayFromBitmapHandle(IntPtr bitmapHandle)
{
var bitmap = new BITMAP();
AllocateBitmapSpace(bitmapHandle, ref bitmap);
try
{
FillBitmapBitsIntoHandle(bitmap);
var bitmapSource = CreateBitmapSourceFromHandle(bitmapHandle, bitmap);
return(imagePersistenceService.ConvertBitmapSourceToByteArray(bitmapSource));
}
finally
{
DeleteObject(bitmapHandle);
}
}
static void magic_putpix(BITMAP bmp, int x, int y, int r, int g, int b)
{
//bmp.line[y][(x) * 3] &= 0xE0;
//bmp.line[y][(x) * 3 + 1] &= 0xE0;
//bmp.line[y][(x) * 3 + 2] &= 0xE0;
ManagedBytePointerArray line = new ManagedBytePointerArray(bmp.line).Offset(y * 3 * 256 * sizeof(byte));
line[x * 3] &= 0xE0;
line[x * 3 + 1] &= 0xE0;
line[x * 3 + 2] &= 0xE0;
//bmp.line[y][(x) * 3] |= r;
//bmp.line[y][(x) * 3 + 1] |= g;
//bmp.line[y][(x) * 3 + 2] |= b;
line[x * 3] |= (byte)r;
line[x * 3 + 1] |= (byte)g;
line[x * 3 + 2] |= (byte)b;
}
public static void _3D()
{
BITMAP buffer = create_bitmap(SCREEN_W, SCREEN_H);
create_scene(24, 6);
set_projection_viewport(0, 0, SCREEN_W, SCREEN_H);
MATRIX_f matrix = new MATRIX_f(), matrix_r = new MATRIX_f(), matrix_t = new MATRIX_f();
int rx = 0, ry = 0, tz = 40;
int rot = 0, inc = 1;
int k = 1;
while (!key[KEY_ESC])
{
clear_bitmap(buffer);
clear_scene(buffer);
get_rotation_matrix_f(ref matrix_r, rx, ry, 0);
get_translation_matrix_f(ref matrix_t, 0, 0, tz + k * 40);
matrix_mul_f(ref matrix_r, ref matrix_t, out matrix);
matrix = matrix_r;
draw_cube(ref matrix);
render_scene();
tz -= 2;
if (tz == 0)
{
tz = 40;
}
rx += 4;
ry += 4;
rot += inc;
if ((rot >= 25) || (rot <= -25))
{
inc = -inc;
}
}
destroy_bitmap(buffer);
destroy_scene();
}
static void Main()
{
allegro_init();
if (install_keyboard() != 0)
{
return;
}
install_mouse();
install_timer();
int bpp = 32;
set_color_depth(bpp);
if (set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0) != 0)
{
allegro_message("Error: " + allegro_error);
}
//Allegro();
//Gui();
//Menu();
//_3D();
//Direct(bpp);
//Fixed();
BITMAP source = create_bitmap(24, 48);
clear_to_color(source, makecol(0, 0, 255));
RLE_SPRITE sprite = get_rle_sprite(source);
COMPILED_SPRITE compiled = get_compiled_sprite(source, FALSE);
draw_sprite(screen, source, 64, 64);
draw_rle_sprite(screen, sprite, 32, 32);
rectfill(screen, 96, 96, 128, 128, makecol(255, 0, 0));
draw_compiled_sprite(screen, compiled, 160, 160);
readkey();
//world game = new world();
//game.Dispose();
allegro_exit();
}
/* converts a bitmap from the normal Allegro format into our magic layout */
static BITMAP get_magic_bitmap_format(BITMAP orig, PALETTE pal)
{
BITMAP bmp;
int c, r, g, b;
int x, y;
int bpp;
/* create an 8 bpp image, three times as wide as the original */
bmp = create_bitmap_ex(8, orig.w * 3, orig.h);
/* store info about the original bitmap format */
bpp = bitmap_color_depth(orig);
//select_palette(pal);
/* convert the data */
for (y = 0; y < orig.h; y++)
{
for (x = 0; x < orig.w; x++)
{
c = getpixel(orig, x, y);
r = getr_depth(bpp, c);
g = getg_depth(bpp, c);
b = getb_depth(bpp, c);
//bmp->line[y][x*3] = r*31/255 | AMBIENT_LIGHT;
//bmp->line[y][x*3+1] = g*31/255 | AMBIENT_LIGHT;
//bmp->line[y][x*3+2] = b*31/255 | AMBIENT_LIGHT;
r = (r * 31 / 255) | AMBIENT_LIGHT;
g = (g * 31 / 255) | AMBIENT_LIGHT;
b = (b * 31 / 255) | AMBIENT_LIGHT;
ManagedBytePointerArray line = new ManagedBytePointerArray(bmp.line).Offset(y * 3 * orig.w * sizeof(byte));
line[x * 3] = (byte)r;
line[x * 3 + 1] = (byte)g;
line[x * 3 + 2] = (byte)b;
}
}
/* return our new, magic format version of the image */
return(bmp);
}
static void draw_pattern(BITMAP bitmap, string message, int color)
{
BITMAP pattern;
acquire_bitmap(bitmap);
/* create a pattern bitmap */
pattern = create_bitmap(text_length(font, message), text_height(font));
clear_to_color(pattern, bitmap_mask_color(pattern));
textout_ex(pattern, font, message, 0, 0, palette_color[255], bitmap_mask_color(screen));
/* cover the bitmap with the pattern */
drawing_mode(DRAW_MODE_MASKED_PATTERN, pattern, 0, 0);
rectfill(bitmap, 0, 0, bitmap.w, bitmap.h, palette_color[color]);
solid_mode();
/* destroy the pattern bitmap */
destroy_bitmap(pattern);
release_bitmap(bitmap);
}
protected override BITMAP Evaluate()
{
if (Source == null)
{
return(null);
}
var target = new BITMAP(Source.Width, Source.Height);
foreach (var layer in Layers.Where(l => l != null))
{
using (var clone = layer.ProcessStack(Source))
{
target.Mutate(dc => dc.DrawImage(clone, layer.Mode, layer.Opacity));
}
}
Source.Dispose();
return(target);
}
/* generates some nice RGB scales onto the specified bitmap */
static void rgb_scales_12(BITMAP bmp, int ox, int oy, int w, int h)
{
int x, y;
for (y = 0; y < h; y++)
{
for (x = 0; x < w; x++)
{
putpixel(bmp, ox + x, oy + y, makecol12(x * 256 / w, y * 256 / h, 0));
}
}
for (y = 0; y < h; y++)
{
for (x = 0; x < w; x++)
{
putpixel(bmp, ox + x + w, oy + y, makecol12(x * 256 / w, 0, y * 256 / h));
}
}
for (y = 0; y < h; y++)
{
for (x = 0; x < w; x++)
{
putpixel(bmp, ox + x, oy + y + h, makecol12(0, x * 256 / w, y * 256 / h));
}
}
for (y = 0; y < h; y++)
{
for (x = 0; x < w; x++)
{
putpixel(bmp, ox + x + w, oy + y + h, makecol12(x * 128 / w + y * 128 / h,
x * 128 / w + y * 128 / h,
x * 128 / w + y * 128 / h));
}
}
}
private static extern int GetObjectBitmap(IntPtr hObject, int nCount, ref BITMAP lpObject);
static void FillBitmapBitsIntoHandle(BITMAP bitmap)
{
var bytes = new byte[bitmap.WidthBytes * bitmap.Height];
Marshal.Copy(bitmap.Bits, bytes, 0, bytes.Length);
}
public static extern int GetObject(HBITMAP hbmp, int cb, ref BITMAP bm);
static BitmapSource CreateBitmapSourceFromHandle(IntPtr bitmapHandle, BITMAP bitmap)
{
var bitmapSource = Imaging.CreateBitmapSourceFromHBitmap(bitmapHandle, IntPtr.Zero, new Int32Rect(0, 0, bitmap.Width, bitmap.Height), BitmapSizeOptions.FromWidthAndHeight(bitmap.Width, bitmap.Height));
bitmapSource.Freeze();
return bitmapSource;
}
public static extern int GetObject(IntPtr hObj, int cb, ref BITMAP obj);
static void AllocateBitmapSpace(IntPtr bitmapHandle, ref BITMAP bitmap)
{
var bufferSize = Marshal.SizeOf(bitmap);
GetObject(bitmapHandle, bufferSize, out bitmap);
}
public static extern int GetObject(IntPtr hgdiobj, int cbBuffer, ref BITMAP lpvObject);
internal static extern int GetObject(
IntPtr hgdiobj,
int cbBuffer,
out BITMAP lpvObject
);
int IIconNativeApi.GetObject(IntPtr hgdiobj, int cbBuffer, out BITMAP lpvObject)
{
return GetObject(hgdiobj, cbBuffer, out lpvObject);
}
/// <summary>
/// Converts a Windows DIBSection object to a Bitmap.
/// </summary>
/// <param name="hDib">Handle to a Windows DIBSection.</param>
/// <returns>Bitmap containing the DIBSection picture.</returns>
public static Bitmap DibToBitmap(IntPtr hDib) {
BITMAP tBM = new BITMAP();
GetObjectBitmap(hDib, Marshal.SizeOf(tBM), ref tBM);
Bitmap bm = new Bitmap(tBM.bmWidth, tBM.bmHeight);
// set the bitmap's data to the data from
// the DIB:
if (tBM.bmBitsPixel == 32) {
// Bizarre but true: you *must* clone the newly created
// bitmap to get one with the correct pixel format, even
// if you attempted to create the original one with the
// correct format...
bm = bm.Clone(new Rectangle(0, 0, tBM.bmWidth, tBM.bmHeight), PixelFormat.Format32bppArgb);
// Lock the bitmap bits
BitmapData destData = bm.LockBits(new Rectangle(0, 0, bm.Width, bm.Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
int destWidth = destData.Stride;
IntPtr destScan0 = destData.Scan0;
unsafe {
byte* pDest = (byte*)(void*)destScan0;
// The DIB is upside down compared to a GDI+ bitmap
pDest += ((bm.Width * 4) * (bm.Height - 1));
byte* pSrc = (byte*)(void*)tBM.bmBits;
for (int y = 0; y < bm.Height; ++y) {
for (int x = 0; x < bm.Width; ++x) {
pDest[0] = pSrc[0]; // blue
pDest[1] = pSrc[1]; // green
pDest[2] = pSrc[2]; // red
pDest[3] = pSrc[3]; // alpha
// Move to next BGRA
pDest += 4;
pSrc += 4;
}
pDest -= (bm.Width * 8);
}
}
bm.UnlockBits(destData);
}
else {
// Easier to just copy src -> dst using GDI.
// Put the DIB into a DC:
IntPtr hWndDesktop = GetDesktopWindow();
IntPtr hDCComp = GetDC(hWndDesktop);
IntPtr hDCSrc = CreateCompatibleDC(hDCComp);
ReleaseDC(hWndDesktop, hDCComp);
IntPtr hBmpOld = SelectObject(hDCSrc, hDib);
Graphics gfx = Graphics.FromImage(bm);
IntPtr hDCDest = gfx.GetHdc();
BitBlt(hDCDest, 0, 0, tBM.bmWidth, tBM.bmHeight, hDCSrc, 0, 0, SRCCOPY);
gfx.ReleaseHdc(hDCDest);
SelectObject(hDCSrc, hBmpOld);
DeleteDC(hDCSrc);
}
return bm;
}
