/*
 * Copyright 2004, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
 * Copyright 2015, Augustin Cavalier <waddlesplash>. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Effect from corTeX / Optimum.
 */


#include <AppKit.h>
#include <Catalog.h>
#include <ColorMenuItem.h>
#include <ControlLook.h>
#include <InterfaceKit.h>
#include <LayoutBuilder.h>
#include <MenuField.h>
#include <ScreenSaver.h>
#include <String.h>
#include <SupportDefs.h>
#include <Window.h>

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "Nebula Screen Saver"


typedef struct
{
	int x, y, z, r;
} p3;

typedef float matrix[3][3];

#define GMAX 5000
p3 gal[GMAX];
float precos[512];
float presin[512];

typedef unsigned short word;

extern "C" {
#include "Draw.h"
#include "DrawStars.h"
}

const uint32 kMsgWidth  = 'widt';
const uint32 kMsgColorScheme = 'cols';
const uint32 kMsgBlankBorders = 'blbr';
const uint32 kMsgMotionBlur = 'blur';
const uint32 kMsgSpeed = 'sped';
const uint32 kMsgFrames = 'mfps';

float	gSpeed;
bool	gMotionBlur;
int32	gSettingsWidth;
int32	gWidth;
int32	gHeight;
float	gMaxFramesPerSecond;
BBitmap* gBitmap;
BScreenSaver* gScreenSaver;
uint32	gPalette[256];
int8	gPaletteScheme;
int8	gBlankBorders;
char*	gBuffer8;   /* working 8bit buffer */


inline float
ocos(float a)
{
	return (precos[(int)(a * 256 / M_PI) & 511]);
}

inline float
osin(float a)
{
	return (presin[(int)(a * 256 / M_PI) & 511]);
}


void
mulmat(matrix* a, matrix* b, matrix* c)
{
	int i, j;

	for (i = 0; i < 3; i++) {
		for (j = 0; j < 3; j++) {
			(*c)[i][j] = (*a)[i][0] * (*b)[0][j] +
						 (*a)[i][1] * (*b)[1][j] +
						 (*a)[i][2] * (*b)[2][j];
		}
	}
}


inline void
mulvec(matrix* a, float* x, float* y, float* z)
{
	float nx = *x, ny = *y, nz = *z;

	*x = nx * (*a)[0][0] + ny * (*a)[0][1] + nz * (*a)[0][2];
	*y = nx * (*a)[1][0] + ny * (*a)[1][1] + nz * (*a)[1][2];
	*z = nx * (*a)[2][0] + ny * (*a)[2][1] + nz * (*a)[2][2];
}


void
setrmat(float a, float b, float c, matrix* m)
{
	int i, j;
	for (i = 0; i < 3; i++)
		for (j = 0; j < 3; j++)
			(*m)[i][j] = (float)(i == j);

	if (a != 0) {
		(*m)[0][0] = cos(a);	(*m)[0][1] = sin(a);
		(*m)[1][0] = sin(a);	(*m)[1][1] = -cos(a);
		return;
	}
	if (b != 0) {
		(*m)[0][0] = cos(b);	(*m)[0][2] = sin(b);
		(*m)[2][0] = sin(b);	(*m)[2][2] = -cos(b);
		return;
	}
	(*m)[1][1] = cos(c);	(*m)[1][2] = sin(c);
	(*m)[2][1] = sin(c);	(*m)[2][2] = -cos(c);
}


void
rotate3d(float* xr, float* yr, float* zr,  /* point to rotate */
	float ax, float ay, float az)     /* the 3 angles (order ?..) */
{
	float xr2, yr2, zr2;

	xr2 = (*xr * ocos(az) + *yr * osin(az));
	yr2 = (*xr * osin(az) - *yr * ocos(az));
	*xr = xr2;
	*yr = yr2;

	xr2 = (*xr * ocos(ay) + *zr * osin(ay));
	zr2 = (*xr * osin(ay) - *zr * ocos(ay));
	*xr = xr2;
	*zr = zr2;

	zr2 = (*zr * ocos(ax) + *yr * osin(ax));
	yr2 = (*zr * osin(ax) - *yr * ocos(ax));
	*zr = zr2;
	*yr = yr2;
}


void
drawshdisk(int x0, int y0, int r)
{
	int x = 0;
	int y;
	int ly;		/* last y */
	int delta;
	int c;		/* color at center */
	int d;		/* delta */

#define SLIMIT 17
#define SRANGE 15

	if (r <= SLIMIT) {
		/* range checking is already (more or less) done... */
		draw_stars(gWidth, &gBuffer8[x0 + gWidth * y0], 10 + r * 5);
		//gBuffer8[x0 + W * y0] = 10 + r * 5;
		return;
	}

	if (r < SLIMIT + SRANGE)
		r = ((r - SLIMIT) * SLIMIT) / SRANGE + 1;

	y = ly = r;     /* AAaargh */
	delta = 3 - 2 * r;

	do {
		if (y != ly) {
			/* dont overlap these lines */
			c = ((r - y + 1) << 13) / r;
			d = -c / (x + 1);

			if (y == x + 1)		/* this would overlap with the next x lines */
				goto TOTO;		/* WHY NOT */

			/*  note : for "normal" numbers (not too big) :
				(unsigned int)(x) < M   <=>  0<=x<H
				(because if x<0, then (unsigned)(x) = 2**32-|x| which is
				BIG and thus >H )

				This is clearly a stupid, unmaintanable, unreadable
				"optimization". But i like it :)
			*/
			if ((uint32)(y0 - y - 1) < gHeight - 3)
				memshset(&gBuffer8[x0 + gWidth * (y0 - y + 1)], c, d, x);

			if ((uint32)(y0 + y - 1) < gHeight - 3)
				memshset(&gBuffer8[x0 + gWidth*(y0 + y)], c, d, x);
		}
		TOTO:
		c = ((r - x + 1) << 13) / r;
		d = -c / (y);

		if ((uint32)(y0 - x - 1) < gHeight - 3)
			memshset(&gBuffer8[x0 + gWidth*(y0 - x)], c, d, y);
		if ((uint32)(y0 + x - 1) < gHeight - 3)
			memshset(&gBuffer8[x0 + gWidth * (y0 + x + 1)], c, d, y);

		ly = y;
		if (delta < 0)
			delta += 4 * x + 6;
		else {
			delta += 4 * (x - y) + 10;
			y--;
		}
		x++;
	} while (x < y);
}


void
drawGalaxy()
{
	int r;
	int x, y;
	float rx, ry, rz;
	int i;
	float oa, ob, oc;
	float t;
	float a, b, c;
	matrix ma, mb, mc, mr;

	/* t is the parametric coordinate for the animation;
	change the scale value to change the speed of anim
	(independant of processor speed)
	*/
	static bigtime_t firstTime = system_time();
	t = ((double)gSpeed * system_time() - firstTime) / 1000000.0;
		//opti_scale_time(0.418, &demo_elapsed_time);

	a = 0.9 * t;
	b = t;
	c = 1.1 * t;

	setrmat(a, 0, 0, &ma);
	setrmat(0, b, 0, &mb);
	mulmat(&ma, &mb, &mc);
	setrmat(0, 0, c, &ma);
	mulmat(&ma, &mc, &mr);

	oa = 140 * osin(a);
	ob = 140 * ocos(b);
	oc = 240 * osin(c);

	if (gMotionBlur) {
		/* mblur does something like that:
		 * (or did, perhaps it's another version!..)

		for (i = 0; i < W * H; i++)
			gBuffer8[i]= (gBuffer8[i] >> 3) + (gBuffer8[i] >> 1);
		*/
		mblur (gBuffer8, gWidth * gHeight);
	} else
		memset(gBuffer8, 0, gWidth * gHeight);

	for (i = 0; i < GMAX; i++) {
		rx = gal[i].x;
		ry = gal[i].y;
		rz = gal[i].z;

		mulvec(&mr, &rx, &ry, &rz);

		rx += oa;
		ry += ob;
		rz += oc;
		rz += 300;

		if (rz > 5) {
			x = (int)(15 * rx / (rz / 5 + 1)) + gWidth / 2;
				/* tain jcomprend plus rien  */
			y = (int)(15 * ry/ (rz / 5 + 1)) + gHeight / 2;
				/* a ces formules de daube !! */
			r = (int)(3 * gal[i].r / (rz / 4 + 3)) + 2;

			if (x > 5 && x < gWidth - 6 && y > 5 && y < gHeight - 6)
//			if ((uint32)x < gWidth - 1 && (uint32)y < gHeight - 1)
				drawshdisk(x, y, r);
		}
	}
}


void
setPalette()
{
	int i;

	switch (gPaletteScheme) {
		case 0:		// yellow
		default:
			for (i = 0; i < 30; i++)
				gPalette[i] = (uint8)(i * 8 / 10) << 16
					| (uint8)(i * 6 / 10) << 8;
					// | (uint8)(i*3/10);

			for (i = 30; i < 256; i++) {
				uint8 r = (i);
				uint8 g = (i * i >> 8); //(i*8/10);
				uint8 b = i >= 240 ? (i - 240) << 3 : 0; //(i * 2 / 10);

				gPalette[i] = ((r << 16) | (g << 8) | (b));
			}
			break;

		case 1:		// blue
			for (i = 0; i < 30; i++)
				gPalette[i] = (uint8)(i * 8 / 10);
					// << 16 | (uint8)(i * 6 / 10) << 8;
					// | (uint8)(i * 3 / 10);

			for (i = 30; i < 256; i++) {
				uint8 b = (i);
				uint8 g = (i * i >> 8); //(i * 8 / 10);
				uint8 r = i >= 240 ? (i - 240) << 3 : 0; //(i * 2 / 10);

				gPalette[i] = ((r << 16) | (g << 8) | (b));
			}
			break;

		case 2:		// red
			for (i = 0; i < 128; i++)
				gPalette[i] = (uint8)i << 16;
					// << 16 | (uint8)(i * 6/10) << 8;
					// | (uint8)(i * 3 / 10);

			for (i = 128;i < 256; i++) {
				uint8 r = i;
				uint8 c = (uint8)((cos((i - 256) / 42.0) * 0.5 + 0.5) * 225);

				gPalette[i] = ((r << 16) | (c << 8) | c);
			}
/*			for (i = 192; i < 224; i++) {
				uint8 c = (i - 192);
				gPalette[i] = gPalette[i] & 0xff0000 | c << 8 | c;
			}
			for (i = 224; i < 256; i++) {
				uint8 c = (i-224) / 2;
				c = 32 + c * c * 6 / 10;
				gPalette[i] = gPalette[i] & 0xff0000 | c << 8 | c;
			}
*/			break;

		case 3:		// green
			for (i = 0; i < 30; i++)
				gPalette[i] = (uint8)(i * 8 / 10) << 8;
					// << 16 | (uint8)(i * 6 / 10) << 8;
					// | (uint8)(i * 3 / 10);

			for (i = 30; i < 256; i++) {
				uint8 g = (i);
				uint8 r = (i * i >> 8); //(i * 8 / 10);
				uint8 b = i >= 240 ? (i-240) << 3 : 0; //(i * 2 / 10);

				gPalette[i] = ((r << 16) | (g << 8) | (b));
			}
			break;

		case 4:		// grey
			for (i = 0; i < 256; i++) {
				uint8 c = i * 15 / 16 + 10;
				gPalette[i] = c << 16 | c << 8 | c;
			}
			break;
		case 5:		// cold
			for (i = 0; i < 30; i++)
				gPalette[i] = (uint8)(i * 8 / 10) << 16;
					// << 16 | (uint8)(i * 6 / 10) << 8;
					// | (uint8)(i * 3 / 10);

			for (i = 30; i < 256; i++) {
				uint8 r = i;
				uint8 c = (uint8)((cos((i - 255) / 82.0) * 0.5 + 0.5) * 255);

				gPalette[i] = ((r << 16) | (c << 8) | c);
			}
			break;

		case 6:		// original
			for (i = 0; i < 256; i++) {
				uint32 c = *(char *)&i;
				gPalette[i] = c << 16 | c << 8;
			}
			break;
	}
/*	for (i = 0;i < 256; i++) {
		uint8 r = (i);
		uint8 g = (i * i >> 8); //(i * 8 / 10);
		uint8 b = 0; //(i * 2 / 10);

		gPalette[i] = ((r << 16) | (g << 8) | (b));
	}
*/
/*	for (i = 240; i < 256; i++)
		gPalette[i] = (uint8)i << 16 | (uint8)i << 8 | (uint8)(i * 6 / 10);
*/
}


// #pragma mark - SimpleSlider


class SimpleSlider : public BSlider {
public:
	SimpleSlider(const char* label, BMessage* message)
	:
	BSlider(B_EMPTY_STRING, B_EMPTY_STRING, message, 1, 100, B_HORIZONTAL)
	{
		SetLimitLabels("1", "100");
		SetHashMarks(B_HASH_MARKS_BOTTOM);
		SetHashMarkCount(11);
		fLabel = label;
	};

	const char* UpdateText() const
	{
		fText.SetToFormat("%s: %d", fLabel, Value());
		return fText.String();
	};

private:
	mutable BString fText;
	const char* fLabel;
};


// #pragma mark - SettingsView


class SettingsView : public BView {
public:
								SettingsView(BRect frame);

	virtual	void				AttachedToWindow();
	virtual	void				MessageReceived(BMessage* message);

	private:
			BMenuField*			fWidthMenuField;
			BMenuField*			fColorMenuField;
			BMenuField*			fBorderMenuField;
			BCheckBox*			fMotionCheck;
			BSlider*			fSpeedSlider;
			BSlider*			fFramesSlider;
};


SettingsView::SettingsView(BRect frame)
	:
	BView(frame, "", B_FOLLOW_ALL, B_WILL_DRAW)
{
	SetViewUIColor(B_PANEL_BACKGROUND_COLOR);

	BStringView* titleString = new BStringView(B_EMPTY_STRING,
		B_TRANSLATE("Nebula"));
	titleString->SetFont(be_bold_font);

	BStringView* copyrightString = new BStringView(B_EMPTY_STRING,
		B_TRANSLATE("© 2001-2004 Axel Dörfler."));

	BPopUpMenu* popUpMenu;

	int32 widths[] = {
		0,
		320,
		512,
		576,
		640,
		800,
		1024,
		1152,
		1280,
		1400,
		1600
	};

	size_t widthsLength = sizeof(widths) / sizeof(widths[0]);

	popUpMenu = new BPopUpMenu("");
	for (size_t i = 0; i < widthsLength; i++) {
		BString label;
		if (widths[i] == 0)
			label.SetTo(B_TRANSLATE("screen resolution"));
		else
			label.SetToFormat(B_TRANSLATE("%" B_PRId32 " pixels"), widths[i]);

		BMessage* message = new BMessage(kMsgWidth);
		message->AddInt32("width", widths[i]);

		BMenuItem* item = new BMenuItem(label.String(), message);
		popUpMenu->AddItem(item);
		item->SetMarked(gSettingsWidth == widths[i]);
	}

	fWidthMenuField = new BMenuField("res", B_TRANSLATE("Internal width:"),
		popUpMenu);

	const char* colorSchemeLabels[] = {
		B_TRANSLATE("yellow"),
		B_TRANSLATE("cyan"),
		B_TRANSLATE("red"),
		B_TRANSLATE("green"),
		B_TRANSLATE("grey"),
		B_TRANSLATE("cold"),
		B_TRANSLATE("orange (original)")
	};

	rgb_color colorSchemeColors[] = {
		(rgb_color){ 255, 220, 0   },
		(rgb_color){ 127, 219, 255 },
		(rgb_color){ 255, 65,  54  },
		(rgb_color){ 46,  204, 64  },
		(rgb_color){ 170, 170, 170 },
		(rgb_color){ 234, 234, 234 },
		(rgb_color){ 255, 133, 27  }
	};

	popUpMenu = new BPopUpMenu("");
	for (int i = 0; i < 7; i++) {
		BMessage* message = new BMessage(kMsgColorScheme);
		message->AddInt8("scheme", (int8)i);
		BColorMenuItem* item = new BColorMenuItem(colorSchemeLabels[i],
			message, colorSchemeColors[i]);
		popUpMenu->AddItem(item);
		item->SetMarked(gPaletteScheme == i);
	}

	fColorMenuField = new BMenuField("col", B_TRANSLATE("Color:"), popUpMenu);

	const char* blankBorderFormats[] = {
		B_TRANSLATE("fullscreen, no borders"),
		B_TRANSLATE("16:9, wide-screen"),
		B_TRANSLATE("2:3.5, cinemascope"),
		B_TRANSLATE("only a slit")
	};

	popUpMenu = new BPopUpMenu("");
	for (int8 i = 0; i < 4; i++) {
		BMessage* message = new BMessage(kMsgBlankBorders);
		message->AddInt8("border", i);
		BMenuItem* item = new BMenuItem(blankBorderFormats[i], message);
		popUpMenu->AddItem(item);
		item->SetMarked(gBlankBorders == i);
	}

	fBorderMenuField = new BMenuField("cinema", B_TRANSLATE("Format:"),
		popUpMenu);

	fMotionCheck = new BCheckBox(B_EMPTY_STRING,
		B_TRANSLATE("Enable motion blur"), new BMessage(kMsgMotionBlur));
	fMotionCheck->SetValue((int)gMotionBlur);

	fSpeedSlider = new SimpleSlider(B_TRANSLATE("Speed"),
		new BMessage(kMsgSpeed));
	fSpeedSlider->SetValue((gSpeed - 0.002) / 0.05);

	fFramesSlider = new SimpleSlider(B_TRANSLATE("Maximum Frames Per Second"),
		new BMessage(kMsgFrames));
	fFramesSlider->SetValue(gMaxFramesPerSecond);

	BLayoutBuilder::Group<>(this, B_VERTICAL, B_USE_HALF_ITEM_SPACING)
		.SetInsets(B_USE_DEFAULT_SPACING)
		.Add(titleString)
		.Add(copyrightString)
		.AddStrut(roundf(be_control_look->DefaultItemSpacing() / 2))
		.AddGlue()
		.AddGrid(B_USE_DEFAULT_SPACING, B_USE_SMALL_SPACING)
			.Add(fColorMenuField->CreateLabelLayoutItem(), 0, 0)
			.AddGroup(B_HORIZONTAL, 0.0f, 1, 0)
				.Add(fColorMenuField->CreateMenuBarLayoutItem(), 0.0f)
				.AddGlue()
				.End()
			.Add(fWidthMenuField->CreateLabelLayoutItem(), 0, 1)
			.AddGroup(B_HORIZONTAL, 0.0f, 1, 1)
				.Add(fWidthMenuField->CreateMenuBarLayoutItem(), 0.0f)
				.AddGlue()
				.End()
			.Add(fBorderMenuField->CreateLabelLayoutItem(), 0, 2)
			.AddGroup(B_HORIZONTAL, 0.0f, 1, 2)
				.Add(fBorderMenuField->CreateMenuBarLayoutItem(), 0.0f)
				.AddGlue()
				.End()
			.Add(fMotionCheck, 1, 3)
			.End()
		.Add(fSpeedSlider)
		.Add(fFramesSlider)
	.End();
}


void
SettingsView::AttachedToWindow()
{
	fWidthMenuField->Menu()->SetTargetForItems(this);
	fColorMenuField->Menu()->SetTargetForItems(this);
	fBorderMenuField->Menu()->SetTargetForItems(this);
	fMotionCheck->SetTarget(this);
	fSpeedSlider->SetTarget(this);
	fFramesSlider->SetTarget(this);
}


void
SettingsView::MessageReceived(BMessage* message)
{
	switch(message->what) {
		case kMsgWidth:
			message->FindInt32("width", &gSettingsWidth);
			break;

		case kMsgColorScheme:
			if (message->FindInt8("scheme", &gPaletteScheme) == B_OK)
				setPalette();
			break;

		case kMsgBlankBorders:
			message->FindInt8("border", &gBlankBorders);
			break;

		case kMsgMotionBlur:
			gMotionBlur = fMotionCheck->Value() > 0;
			break;

		case kMsgSpeed:
			gSpeed = 0.002 + 0.05 * fSpeedSlider->Value();
			break;

		case kMsgFrames:
			gMaxFramesPerSecond = fFramesSlider->Value();
			gScreenSaver->SetTickSize(
				(bigtime_t)(1000000LL / gMaxFramesPerSecond));
			break;
	}
}



// #pragma mark - Nebula


class Nebula : public BScreenSaver {
public:
								Nebula(BMessage* message, image_id id);

	virtual	void				StartConfig(BView* view);
	virtual	status_t			SaveState(BMessage* state) const;

	virtual	status_t			StartSaver(BView* view, bool preview);
	virtual	void				StopSaver();
	virtual	void				Draw(BView* view, int32 frame);

private:
			float				fFactor;
			bool				fStarted;
};


Nebula::Nebula(BMessage* message, image_id id)
	:
	BScreenSaver(message, id),
	fStarted(false)
{
	message->FindFloat("speed", 0, &gSpeed);
	message->FindInt32("width", 0, &gSettingsWidth);
	message->FindBool("motionblur", 0, &gMotionBlur);
	message->FindFloat("max_fps", 0, &gMaxFramesPerSecond);
	message->FindInt8("scheme", 0, &gPaletteScheme);
	message->FindInt8("border", 0, &gBlankBorders);

	if (gSpeed < 0.01f)
		gSpeed = 0.4f;

	if (gMaxFramesPerSecond < 1.f)
		gMaxFramesPerSecond = 40.0f;

	gScreenSaver = this;
}


void
Nebula::StartConfig(BView* view)
{
	view->AddChild(new SettingsView(view->Bounds()));
}


status_t
Nebula::SaveState(BMessage* state) const
{
	state->AddFloat("speed", gSpeed);
	state->AddInt32("width", gSettingsWidth);
	state->AddBool("motionblur", gMotionBlur);
	state->AddFloat("max_fps", gMaxFramesPerSecond);
	state->AddInt8("scheme", gPaletteScheme);
	state->AddInt8("border", gBlankBorders);

	return B_OK;
}


status_t
Nebula::StartSaver(BView* view, bool preview)
{
	// initialize palette
	setPalette();

	int i;
	for (i = 0; i < 512; i++) {
		precos[i]=cos(i * M_PI / 256);
		presin[i]=sin(i * M_PI / 256);
	}

	// uniforme cubique
/*	for (i = 0;i < GMAX; i++) {
		gal[i].x = 1 * ((rand()&1023) - 512);
		gal[i].y = 1 * ((rand()&1023) - 512);
		gal[i].z = 1 * ((rand()&1023) - 512);
		gal[i].r = rand() & 63;
	}
*/

	for (i = 0; i < GMAX; i++) {
		float r, th, h, dth;

		r = rand() * 1.0 / RAND_MAX;
		r = (1 - r) * (1 - r) + 0.05;

		if (r < 0.12)
			th = rand() * M_PI * 2 / RAND_MAX;
		else {
			th = (rand() & 3) * M_PI_2 + r * r * 2;
			dth = rand() * 1.0 / RAND_MAX;
			dth = dth * dth * 2;
			th += dth;
		}
		gal[i].x = (int)(512 * r * cos(th));
		gal[i].z = (int)(512 * r * sin(th));
		h = (1 + cos(r * M_PI)) * 150;
		dth = rand() * 1.0 / RAND_MAX;
		gal[i].y = (int)(h * (dth - 0.5));
		gal[i].r = (int)((2 - r) * 60 + 31);
	}
	gal[0].x = gal[0].y = gal[0].z = 0;
	gal[0].r = 320;

	if (gSettingsWidth == 0)
		gWidth = view->Bounds().Width();
	else
		gWidth = gSettingsWidth;

	fFactor = (view->Bounds().Width()+1) / gWidth;
	if ((int)fFactor != fFactor)
		fFactor += 0.01;

	// 4:3
	gHeight = (int32)((view->Bounds().Height()+1)/fFactor + 0.5f);
	// calculate blank border format (if not in preview)
	if (!preview) switch (gBlankBorders) {
		case 1:		// 16:9
			gHeight = (int32)(gHeight * 0.703125 + 0.5);
			break;
		case 2:		// 2:3.5
			gHeight = (int32)(gHeight * 0.534 + 0.5);
			break;
		case 3:
			gHeight /= 5;
			break;
	}
	view->SetScale(fFactor);

	gBitmap = new BBitmap(BRect(0, 0, gWidth - 1, gHeight - 1), B_RGB32);
	gBuffer8 = (char*)malloc(gWidth * gHeight);

	SetTickSize((bigtime_t)(1000000LL / gMaxFramesPerSecond));
	fStarted = true;

	return B_OK;
}


void
Nebula::StopSaver()
{
	free(gBuffer8);
	gBuffer8 = NULL;

	delete gBitmap;
	gBitmap = NULL;
}


void
Nebula::Draw(BView* view, int32)
{
	if (fStarted) {
		view->SetHighColor(0, 0, 0, 0);
		view->FillRect(view->Frame());
		view->MovePenTo(0,
			(view->Bounds().Height() / fFactor - 1 - gHeight) / 2);

		fStarted = false;
	}
	uint32* buffer32 = (uint32*)gBitmap->Bits();

	drawGalaxy();

	for (int x = 0, end = gWidth * gHeight; x < end; x++)
		buffer32[x] = gPalette[(uint8)gBuffer8[x]];

	view->DrawBitmap(gBitmap);
}


// #pragma mark - instantiate_screen_saver


extern "C" _EXPORT BScreenSaver*
instantiate_screen_saver(BMessage* message, image_id image)
{
	return new Nebula(message, image);
}