bind_render.cpp
No OneTemporary
Actions

Authored By

Unknown

Size

76 KB

Referenced Files

None

Subscribers

None

bind_render.cpp
View Options

	#include "binds.h"
	#include "obj/universe.h"
	#include "render/camera.h"
	#include "render/render_state.h"
	#include "render/vertexBuffer.h"
	#include "render/lighting.h"
	#include "main/references.h"
	#include "main/tick.h"
	#include "main/logging.h"
	#include "files.h"
	#include "processing.h"
	#include "threads.h"
	#include "network/network_manager.h"

	#include "obj/object.h"
	#include "empire.h"

	#include "frustum.h"
	#include "physics/physics_world.h"

	#include "scene/billboard_node.h"
	#include "scene/beam_node.h"
	#include "scene/plane_node.h"
	#include "scene/scripted_node.h"
	#include "scene/billboard_node.h"
	#include "scene/mesh_icon_node.h"
	#include "scene/mesh_node.h"
	#include "scene/animation/anim_linear.h"
	#include "scene/animation/anim_node_sync.h"
	#include "scene/particle_system.h"

	#include "../as_addons/include/scriptarray.h"

	#include "compat/gl.h"

	#include "ISoundDevice.h"

	#include <string>

	//Fix Windows.h being an asshole
	#ifdef min
	#undef min
	#endif

	extern double pixelSizeRatio, scale_3d;
	extern Colorf fallbackNodeColor;
	extern Object* fallbackNodeObject;
	extern void queueDestroyTexture(const render::Texture* tex);
	extern void setShaderLightRadius(unsigned,double);

	namespace scripts {

	template<class From, class To>
	To* dynamicCast(From* f) {
	return dynamic_cast<To*>(f);
	}

	template<class From, class To>
	To* grabbedCast(From* f) {
	To* other = dynamic_cast<To*>(f);
	if(other)
	other->grab();
	return other;
	}

	void takeScreenshot(const std::string& fname, bool increment = true) {
	Image* screen = devices.render->getScreen(0,0,devices.driver->win_width,devices.driver->win_height);

	std::string filename = devices.mods.getGlobalProfile("screenshots") + "/" + fname;
	if(filename.empty())
	filename = "screenshot";
	if(filename.size() > 4 && filename.compare(filename.size() - 4, 4, ".png") == 0)
	filename = filename.substr(0, filename.size() - 4);

	std::string base = filename;
	filename += ".png";

	unsigned number = 2;
	while(fileExists(filename))
	filename = base + toString(number++) + ".png";

	if(!isAccessible(filename)) {
	scripts::throwException("Cannot access file outside game or profile directories.");
	return;
	}

	threads::async([screen,filename]() -> int {
	try {
	if(!saveImage(screen, filename.c_str(), true))
	throw 0;
	print("Wrote screenshot to %s", filename.c_str());
	}
	catch(...) {
	print("Could not write image");
	}

	delete screen;
	return 0;
	});
	}

	extern asITypeInfo* getObjectArrayType();

	asITypeInfo* getNodeArrayType() {
	return (asITypeInfo*)asGetActiveContext()->GetEngine()->GetUserData(EDID_nodeArray);
	}

	static const render::RenderState& getErrorMat() {
	return devices.library.getErrorMaterial();
	}

	static const render::RenderState& getMat(const std::string& name) {
	return devices.library.getMaterial(name);
	}

	static const render::RenderMesh& getErrorModel() {
	return devices.library.getMesh("");
	}

	static const render::RenderMesh& getModel(const std::string& name) {
	return devices.library.getMesh(name);
	}

	static const render::RenderState& getMat_index(unsigned index) {
	if(index >= devices.library.material_names.size()) {
	scripts::throwException("Out of bounds material index");
	return (const render::RenderState)0;
	}
	return devices.library.getMaterial(devices.library.material_names[index]);
	}

	static const std::string& getMat_name(unsigned index) {
	if(index >= devices.library.material_names.size()) {
	scripts::throwException("Out of bounds material index");
	return (const std::string)0;
	}
	return devices.library.material_names[index];
	}

	static unsigned getMatCount() {
	return (unsigned)devices.library.material_names.size();
	}

	static const render::SpriteSheet& getErrorSheet() {
	return devices.library.getSpriteSheet("");
	}

	static const render::SpriteSheet& getSheet(const std::string& name) {
	return devices.library.getSpriteSheet(name);
	}

	static render::Sprite getSprite(const std::string& name) {
	return devices.library.getSprite(name);
	}

	static std::string getSpriteDesc(const render::Sprite& sprt) {
	return devices.library.getSpriteDesc(sprt);
	}

	static const render::SpriteSheet& getSheet_index(unsigned index) {
	if(index >= devices.library.spritesheet_names.size()) {
	scripts::throwException("Out of bounds spritesheet index");
	return (const render::SpriteSheet)0;
	}
	return devices.library.getSpriteSheet(devices.library.spritesheet_names[index]);
	}

	static const std::string& getSheet_name(unsigned index) {
	if(index >= devices.library.spritesheet_names.size()) {
	scripts::throwException("Out of bounds spritesheet index");
	return (const std::string)0;
	}
	return devices.library.spritesheet_names[index];
	}

	static unsigned getSheetCount() {
	return (unsigned)devices.library.spritesheet_names.size();
	}

	static const render::MaterialGroup& getMatGroup(const std::string& id) {
	return devices.library.getMaterialGroup(id);
	}

	static std::string getGroupMatID(render::MaterialGroup& group, unsigned index) {
	if(index < group.names.size())
	return group.names[index];
	else
	return "";
	}

	static const render::RenderState* getGroupMat(render::MaterialGroup& group, unsigned index) {
	if(index < group.materials.size())
	return group.materials[index];
	return nullptr;
	}

	static unsigned getGroupMatCount(render::MaterialGroup& group) {
	return group.materials.size();
	}

	static void setSkybox(const render::RenderState* mat) {
	devices.render->setSkybox(mat);
	}

	static void setSkyboxMesh(const render::RenderMesh* mesh) {
	devices.render->setSkyboxMesh(mesh);
	}

	static void draw_rect(const recti& pos, const Color& color) {
	Color colors[4] = {color, color, color, color};
	devices.render->drawRectangle(pos, 0, 0, colors, getClip());
	}

	static void draw_rect_m(const recti&pos, const render::RenderState* mat, const Color& color) {
	Color colors[4] = {color, color, color, color};
	devices.render->drawRectangle(pos, mat, 0, colors, getClip());
	}

	static void draw_rect_g(const recti& pos, const Color& topleft, const Color& topright, const Color& botright, const Color& botleft) {
	Color colors[4] = {topleft, topright, botright, botleft};
	devices.render->drawRectangle(pos, 0, 0, colors, getClip());
	}

	static void draw_mat(const render::RenderState* mat, const recti& pos) {
	devices.render->drawRectangle(pos, mat, 0, 0, getClip());
	}

	static void draw_mat_c(const render::RenderState* mat, const recti& pos, const Color& color) {
	devices.render->drawRectangle(pos, mat, color, getClip());
	}

	static void draw_mat_csh(const render::RenderState* mat, const recti& pos, const Color& color, const render::Shader* shader) {
	static render::RenderState state;
	state = *mat;
	state.constant = false;
	state.shader = shader;
	devices.render->drawRectangle(pos, &state, color, getClip());
	}

	static void draw_mat_s(const render::RenderState* mat, const recti& pos, const recti* src) {
	devices.render->drawRectangle(pos, mat, src, 0, getClip());
	}

	static void draw_mat_sc(const render::RenderState* mat, const recti& pos, const recti* src, const Color& color) {
	Color colors[4] = {color, color, color, color};
	devices.render->drawRectangle(pos, mat, src, colors, getClip());
	}

	static void draw_mat_scr(const render::RenderState* mat, const recti& pos, const recti* src, const Color& color, double rotation) {
	Color colors[4] = {color, color, color, color};
	devices.render->drawRectangle(pos, mat, src, colors, getClip(), rotation);
	}

	static void draw_mat_scc(const render::RenderState* mat, const recti& pos,
	const recti* src, const Color& topleft, const Color& topright,
	const Color& botright, const Color& botleft) {
	Color colors[4] = {topleft, topright, botright, botleft};
	devices.render->drawRectangle(pos, mat, src, colors, getClip());
	}

	static void draw_fps(const recti& pos) {
	devices.render->drawFPSGraph(pos);
	}

	static vec2i sprite_size(const render::SpriteSheet& sheet) {
	return vec2i(sheet.width, sheet.height);
	}

	static render::Sprite sprite_offset(const render::SpriteSheet& sheet, unsigned number) {
	return render::Sprite(&sheet, number);
	}

	static void sprite_sourceUV(const render::SpriteSheet& sheet, unsigned index, vec4f& output) {
	output = sheet.getSourceUV(index);
	}

	static void draw_sprite(const render::SpriteSheet& sheet, unsigned index, const recti& pos) {
	sheet.render(*devices.render, index, pos, 0, getClip());
	}

	static void draw_sprite_s(const render::SpriteSheet& sheet, unsigned index, const recti& pos, const render::Shader* shader) {
	sheet.render(*devices.render, index, pos, 0, getClip(), shader);
	}

	static void draw_sprite_c(const render::SpriteSheet& sheet, unsigned index, const recti& pos, const Color& color) {
	Color colors[4] = {color, color, color, color};
	sheet.render(*devices.render, index, pos, colors, getClip());
	}

	static void draw_sprite_cr(const render::SpriteSheet& sheet, unsigned index, const recti& pos, const Color& color, double rotation) {
	Color colors[4] = {color, color, color, color};
	sheet.render(*devices.render, index, pos, colors, getClip(), 0, rotation);
	}

	static void draw_sprite_cc(const render::SpriteSheet& sheet, unsigned index,
	const recti& pos, const Color& topleft, const Color& topright, const Color& botright, const Color& botleft) {
	Color colors[4] = {topleft, topright, botright, botleft};
	sheet.render(*devices.render, index, pos, colors, getClip());
	}

	static void draw_sprt(const render::Sprite* sprt, const recti& pos) {
	if(sprt->sheet)
	draw_sprite_c(*sprt->sheet, sprt->index, pos, sprt->color);
	else if(sprt->mat)
	draw_mat_c(sprt->mat, pos, sprt->color);
	}

	static void draw_sprt_c(const render::Sprite* sprt, const recti& pos, const Color& color) {
	if(sprt->sheet)
	draw_sprite_c(sprt->sheet, sprt->index, pos, color sprt->color);
	else if(sprt->mat)
	draw_mat_c(sprt->mat, pos, color * sprt->color);
	}

	static void draw_sprt_csh(const render::Sprite* sprt, const recti& pos, const Color& color, const render::Shader* shader) {
	Color blended = sprt->color * color;
	if(sprt->sheet) {
	Color colors[4] = {blended, blended, blended, blended};
	sprt->sheet->render(*devices.render, sprt->index, pos, colors, getClip(), shader);
	}
	else if(sprt->mat)
	draw_mat_csh(sprt->mat, pos, blended, shader);
	}

	static void draw_sprt_cr(const render::Sprite* sprt, const recti& pos, const Color& color, double rotation) {
	Color blended = sprt->color * color;
	if(sprt->sheet) {
	Color colors[4] = {blended, blended, blended, blended};
	sprt->sheet->render(*devices.render, sprt->index, pos, colors, getClip(), 0, rotation);
	}
	else if(sprt->mat)
	draw_mat_scr(sprt->mat, pos, 0, blended, rotation);
	}

	static vec2i mat_size(const render::RenderState& mat) {
	if(mat.textures[0])
	return mat.textures[0]->size;
	return vec2i();
	}

	static void mat_activate(const render::RenderState& mat) {
	devices.render->switchToRenderState(mat);
	}

	static bool mat_pxactive(const render::RenderState& mat, const vec2i& px) {
	if(mat.textures[0])
	return mat.textures[0]->isPixelActive(px);
	return false;
	}

	static inline void complex_clip_start() {
	if(recti* clip = getClip())
	devices.render->pushScreenClip(*clip);
	}

	static inline void complex_clip_end() {
	if(getClip())
	devices.render->popScreenClip();
	}

	static void getVideoModes(CScriptArray* arr) {
	std::vector<os::OSDriver::VideoMode> modes;
	devices.driver->getVideoModes(modes);

	arr->Resize(modes.size());
	for(unsigned i = 0, cnt = modes.size(); i < cnt; ++i)
	(os::OSDriver::VideoMode)arr->At(i) = modes[i];
	}

	static void getMonitorNames(CScriptArray* arr) {
	std::vector<std::string> names;
	devices.driver->getMonitorNames(names);

	arr->Resize(names.size());
	for(unsigned i = 0, cnt = names.size(); i < cnt; ++i)
	(std::string)arr->At(i) = names[i];
	}

	static void setVsync(int frames) {
	devices.driver->setVerticalSync(frames);
	}

	static void getAudioNames(CScriptArray* arr) {
	std::vector<std::string> names;
	audio::enumerateDevices([&](const char* name) { names.push_back(name); });

	arr->Resize(names.size());
	for(unsigned i = 0, cnt = names.size(); i < cnt; ++i)
	(std::string)arr->At(i) = names[i];
	}

	render::VertexTCV* verts = 0;
	unsigned allocatedVerts = 0;
	unsigned nextIndex = 0;
	Color vertCol;
	bool flushVB = false;

	static inline render::VertexTCV* getNextVertex() {
	if(nextIndex < allocatedVerts)
	return &verts[nextIndex++];
	else
	return 0;
	}

	static void poly_start_c(unsigned polyCount, const render::RenderState* mat, const Color& col) {
	if(polyCount == 0)
	return;

	if(mat == 0) {
	devices.render->set2DRenderState();
	mat = devices.render->getLastRenderState();
	}

	if(getClip()) {
	render::renderVertexBuffers();
	flushVB = true;
	}
	else if(!mat->constant) {
	flushVB = true;
	}

	auto* buffer = render::VertexBufferTCV::fetch(mat);
	verts = buffer->request(polyCount, render::PT_Triangles);
	allocatedVerts = 3 * polyCount;
	vertCol = col;

	complex_clip_start();
	}

	static void poly_start(unsigned polyCount, const render::RenderState* mat) {
	poly_start_c(polyCount, mat, Color());
	}

	static void poly_start_t(render::PrimitiveType type, unsigned polyCount, const render::RenderState* mat) {
	if(polyCount == 0)
	return;

	if(mat == 0) {
	devices.render->set2DRenderState();
	mat = devices.render->getLastRenderState();
	}

	if(getClip()) {
	render::renderVertexBuffers();
	flushVB = true;
	}
	else if(!mat->constant) {
	flushVB = true;
	}

	auto* buffer = render::VertexBufferTCV::fetch(mat);
	verts = buffer->request(polyCount, type);
	vertCol = Color();

	switch(type) {
	case render::PT_Lines:
	allocatedVerts = 2 * polyCount; break;
	case render::PT_LineStrip:
	allocatedVerts = 1 + polyCount; break;
	case render::PT_Triangles:
	allocatedVerts = 3 * polyCount; break;
	case render::PT_Quads:
	allocatedVerts = 4 * polyCount; break;
	}

	complex_clip_start();
	}

	static void poly_end() {
	if(allocatedVerts == 0)
	return;

	if(flushVB) {
	render::renderVertexBuffers();
	complex_clip_end();
	flushVB = false;
	}

	allocatedVerts = 0;
	nextIndex = 0;
	}

	static void poly_coord(const vec2i& pos) {
	if(auto* vert = getNextVertex()) {
	vert->col = vertCol;
	vert->uv = vec2f();
	vert->pos.x = float(pos.x);
	vert->pos.y = float(pos.y);
	vert->pos.z = 0;
	}
	else {
	scripts::throwException("Attempted to write to more vertices than were allocated.");
	}
	}

	static void poly_coord_uv(const vec2i& pos, const vec2f& uv) {
	if(auto* vert = getNextVertex()) {
	vert->col = vertCol;
	vert->uv = uv;
	vert->pos.x = float(pos.x);
	vert->pos.y = float(pos.y);
	vert->pos.z = 0;
	}
	else {
	scripts::throwException("Attempted to write to more vertices than were allocated.");
	}
	}

	static void poly_coord_uvc(const vec2i& pos, const vec2f& uv, const Color& col) {
	if(auto* vert = getNextVertex()) {
	vertCol = col;
	vert->col = col;
	vert->uv = uv;
	vert->pos.x = float(pos.x);
	vert->pos.y = float(pos.y);
	vert->pos.z = 0;
	}
	else {
	scripts::throwException("Attempted to write to more vertices than were allocated.");
	}
	}

	static void poly_coord_c(const vec2i& pos, const Color& col) {
	if(auto* vert = getNextVertex()) {
	vertCol = col;
	vert->col = col;
	vert->uv = vec2f();
	vert->pos.x = float(pos.x);
	vert->pos.y = float(pos.y);
	vert->pos.z = 0;
	}
	else {
	scripts::throwException("Attempted to write to more vertices than were allocated.");
	}
	}

	static void poly_fcoord(const vec2f& pos) {
	if(auto* vert = getNextVertex()) {
	vert->col = vertCol;
	vert->uv = vec2f();
	vert->pos.x = pos.x;
	vert->pos.y = pos.y;
	vert->pos.z = 0;
	}
	else {
	scripts::throwException("Attempted to write to more vertices than were allocated.");
	}
	}

	static void poly_fcoord_uv(const vec2f& pos, const vec2f& uv) {
	if(auto* vert = getNextVertex()) {
	vert->col = vertCol;
	vert->uv = uv;
	vert->pos.x = pos.x;
	vert->pos.y = pos.y;
	vert->pos.z = 0;
	}
	else {
	scripts::throwException("Attempted to write to more vertices than were allocated.");
	}
	}

	static void poly_fcoord_c(const vec2f& pos, const Color& col) {
	if(auto* vert = getNextVertex()) {
	vertCol = col;
	vert->col = col;
	vert->uv = vec2f();
	vert->pos.x = pos.x;
	vert->pos.y = pos.y;
	vert->pos.z = 0;
	}
	else {
	scripts::throwException("Attempted to write to more vertices than were allocated.");
	}
	}

	static void poly3_coord(const vec3d& pos) {
	if(auto* vert = getNextVertex()) {
	vert->col = vertCol;
	vert->uv = vec2f();

	vert->pos = vec3f(pos - devices.render->cam_pos);
	}
	else {
	scripts::throwException("Attempted to write to more vertices than were allocated.");
	}
	}

	static void poly3_coord_uv(const vec3d& pos, const vec2f& uv) {
	if(auto* vert = getNextVertex()) {
	vert->col = vertCol;
	vert->uv = uv;

	vert->pos = vec3f(pos - devices.render->cam_pos);
	}
	else {
	scripts::throwException("Attempted to write to more vertices than were allocated.");
	}
	}

	static void poly3_coord_uvc(const vec3d& pos, const vec2f& uv, const Color& col) {
	if(auto* vert = getNextVertex()) {
	vertCol = col;
	vert->col = col;
	vert->uv = uv;

	vert->pos = vec3f(pos - devices.render->cam_pos);
	}
	else {
	scripts::throwException("Attempted to write to more vertices than were allocated.");
	}
	}

	static void poly3_coord_c(const vec3d& pos, const Color& col) {
	if(auto* vert = getNextVertex()) {
	vertCol = col;
	vert->col = col;
	vert->uv = vec2f();

	vert->pos = vec3f(pos - devices.render->cam_pos);
	}
	else {
	scripts::throwException("Attempted to write to more vertices than were allocated.");
	}
	}

	static void draw_line_c(const vec2i& from, const vec2i& to, const Color& color, int size, const render::RenderState* mat) {
	double angle = (to - from).radians();
	vec2d off(cos(angle-1.5708) * double(size) * 0.5, sin(angle-1.5708) * double(size) * 0.5);

	vec2d fTo(to);
	vec2d fFrom(from);

	poly_start_t(render::PT_Quads, 1, mat);

	poly_coord_uvc(vec2i(fFrom - off), vec2f(0,0), color);
	poly_coord_uv(vec2i(fFrom + off), vec2f(0,1));
	poly_coord_uv(vec2i(fTo + off), vec2f(1,1));
	poly_coord_uv(vec2i(fTo - off), vec2f(1,0));

	poly_end();
	}

	static void draw_line(const vec2i& from, const vec2i& to, int size, const render::RenderState* mat) {
	draw_line_c(from, to, Color(0xffffffff), size, mat);
	}

	static void draw_model(render::RenderMesh* mesh, render::RenderState* mat, recti& pos, quaterniond rotation, double Scale) {
	render::renderVertexBuffers();

	vec2i center = pos.getCenter();
	double scale = (double)std::min(pos.getWidth(), pos.getHeight()) * 0.5 * Scale;

	complex_clip_start();
	Matrix transform;

	rotation.toTransform(transform, vec3d(center.x, center.y, 0), vec3d(scale, -scale, scale));

	devices.render->setTransformationAbs(transform);
	if(mat)
	devices.render->switchToRenderState(*mat);
	else
	devices.render->setDefaultRenderState();
	mesh->render();
	devices.render->resetTransformation();
	complex_clip_end();
	}

	static void drawBuffers() {
	render::renderVertexBuffers();
	}

	static void meshRenderLOD(render::RenderMesh* mesh, double lodDist) {
	mesh->selectLOD(lodDist)->render();
	}

	static render::Camera* cameraFactory() {
	return new render::Camera();
	}

	static void updateCamera(render::Camera& cam) {
	devices.render->setCameraData(cam);
	}

	static void prepareRender(render::Camera& cam) {
	devices.render->prepareRender3D(cam);
	}

	static void prepareRenderClip(render::Camera& cam, const recti& clip) {
	devices.render->prepareRender3D(cam, &clip);
	}

	static void renderWorld() {
	devices.render->renderWorld();
	}

	static Object* objectFromPixel(render::Camera& cam, const vec2i& px) {
	if(devices.universe) {
	Object* obj = devices.universe->getClosestOnLine(
	cam.screenToRay(
	(double)px.x / ((double)devices.driver->win_width / ui_scale),
	(double)px.y / ((double)devices.driver->win_height / ui_scale)
	));
	if(obj)
	obj->grab();
	return obj;
	}
	else {
	return 0;
	}
	}

	static double cam_dist(const vec3d& pos, double scale) {
	auto fromCamera = pos + (devices.render->cam_facing * scale) - devices.render->cam_pos;
	return fromCamera.getLength();
	}

	static vec3d cam_pos() {
	return devices.render->cam_pos;
	}

	static vec3d cam_up() {
	return devices.render->cam_up;
	}

	static vec3d cam_facing() {
	return devices.render->cam_facing;
	}

	static bool isInView(const vec3d& center, double radius) {
	return devices.render->getViewFrustum().overlaps(center, radius);
	}

	static ObjArray* boxSelect(render::Camera& cam, const recti& box) {
	ObjArray* results = new ObjArray();
	results->reserve(100);

	vec2i screenSize = vec2i(devices.driver->win_width, devices.driver->win_height);

	rectd boxd = rectd( double(box.topLeft.x) / double(screenSize.width),
	double(box.topLeft.y) / double(screenSize.height),
	double(box.botRight.x) / double(screenSize.width),
	double(box.botRight.y) / double(screenSize.height));

	frustum ViewFrustum = frustum( cam.screenToRay(boxd.topLeft.x, boxd.topLeft.y),
	cam.screenToRay(boxd.botRight.x, boxd.topLeft.y),
	cam.screenToRay(boxd.topLeft.x, boxd.botRight.y),
	cam.screenToRay(boxd.botRight.x, boxd.botRight.y) );

	Empire* player = Empire::getPlayerEmpire();

	devices.nodePhysics->findInBox(ViewFrustum.bound,
	[&results,&ViewFrustum,player](const PhysicsItem& item) {
	scene::Node* node = item.node;
	if(!node \|\| !node->frameVisible \|\| !node->obj)
	return;
	bool inFrustum;
	inFrustum = ViewFrustum.overlaps(node->position, node->abs_scale);

	if(inFrustum) {
	node->obj->grab();
	results->push_back(node->obj);
	}
	}
	);

	return results;
	}

	static void nodeConeSelect(const line3dd& line, double slope, CScriptArray* results) {
	results->Resize(0);

	if(!devices.nodePhysics)
	return;

	results->Reserve(100);

	AABBoxd bound(line);
	bound.addBox(AABBoxd::fromCircle(line.end, line.getLength() * slope));

	vec3d dir = line.getDirection();
	planed clip(line.start, dir);

	devices.nodePhysics->findInBox(bound,
	[&](const PhysicsItem& item) {
	if(item.type == PIT_Node) {
	auto* node = item.node;
	if(!node->frameVisible)
	return;

	const vec3d& pos = node->abs_position;
	double dist = clip.distanceFromPlane(pos);
	//Only select node after the start of the line
	if(dist < 0.0)
	return;

	//Collide sphere with cone
	vec3d pt = line.start + dir * dist;
	double dSq = pt.distanceToSQ(pos);

	double rad = node->abs_scale;
	if(dSq < rad * rad) {
	results->InsertLast(&node);
	}
	else if(!node->getFlag(scene::NF_FixedSize)) {
	rad += dist * slope;
	if(dSq < rad * rad) {
	results->InsertLast(&node);
	}
	}
	}
	}
	);
	}

	static void renderBillboard(const render::RenderState& mat, const vec3d& pos, double width, double rotation) {
	devices.render->drawBillboard(pos, width, mat, rotation);
	}

	static void renderBillboard_sheet(const render::SpriteSheet& sheet, unsigned index, const vec3d& pos, double width, double rotation) {
	devices.render->drawBillboard(pos, width, sheet.material, sheet.getSource(index), rotation);
	}

	static void renderBillboard_sprite(const render::Sprite& sprite, const vec3d& pos, double width, double rotation) {
	if(sprite.mat)
	renderBillboard(*sprite.mat, pos, width, rotation);
	else if(sprite.sheet)
	renderBillboard_sheet(*sprite.sheet, sprite.index, pos, width, rotation);
	}

	static void renderBillboard_c(const render::RenderState& mat, const vec3d& pos, double width, double rotation, Color& color) {
	devices.render->drawBillboard(pos, width, mat, rotation, &color);
	}

	static void renderBillboard_sheet_c(const render::SpriteSheet& sheet, unsigned index, const vec3d& pos, double width, double rotation, Color& color) {
	devices.render->drawBillboard(pos, width, sheet.material, sheet.getSource(index), rotation, color);
	}

	static void renderBillboard_sprite_c(const render::Sprite& sprite, const vec3d& pos, double width, double rotation, Color& color) {
	if(sprite.mat)
	renderBillboard_c(*sprite.mat, pos, width, rotation, color);
	else if(sprite.sheet)
	renderBillboard_sheet_c(*sprite.sheet, sprite.index, pos, width, rotation, color);
	}

	static void renderPlane(const render::RenderState& mat, const vec3d& pos, double width, Color& color, double angle) {
	vec3d tr;
	vec3d tl;
	if(angle != 0.0) {
	double cn = cos(angle), sn = sin(angle);
	vec3d r = vec3d(cn * width, 0.0, sn * width);
	vec3d u = vec3d(-sn * width, 0.0, cn * width);

	tr = r + u;
	tl = u - r;
	}
	else {
	tr = vec3d(width, 0.0, width);
	tl = vec3d(-width, 0.0, width);
	}

	vec3d verts[] = {
	pos - tr,
	pos - tl,
	pos + tr,
	pos + tl
	};

	vec2f uvs[] = { vec2f(0,0), vec2f(1,0), vec2f(1,1), vec2f(0,1) };
	Color colors[] = { color, color, color, color };

	devices.render->switchToRenderState(mat);
	devices.render->drawQuad(verts, uvs, colors);
	}

	render::Camera& copyCamera(render::Camera& dest, render::Camera& src) {
	dest = src;
	return dest;
	}

	#define decl_access(member, type) \
	void set_##member(type v) {\
	member = v;\
	}\
	type get_##member() {\
	return member;\
	}\

	#define bind_access(member, type) \
	mat.addMethod(#type " get_" #member "() const", asMETHOD(ScriptMaterial, get_##member));\
	mat.addMethod("void set_" #member "(" #type " value)", asMETHOD(ScriptMaterial, set_##member));

	struct ScriptMaterial : public render::RenderState {
	threads::atomic_int refs;

	ScriptMaterial(const ScriptMaterial& other) : refs(1) {
	(render::RenderState)this = (render::RenderState)&other;
	constant = false;
	culling = render::FC_None;
	depthTest = render::DT_Always;
	depthWrite = true;
	lighting = false;
	baseMat = render::MAT_Alpha;
	}

	ScriptMaterial() : RenderState(), refs(1) {
	constant = false;
	culling = render::FC_None;
	depthTest = render::DT_Always;
	depthWrite = true;
	lighting = false;
	baseMat = render::MAT_Alpha;
	}

	decl_access(culling, render::FaceCulling);
	decl_access(depthTest, render::DepthTest);
	decl_access(baseMat, render::BaseMaterial);
	decl_access(drawMode, render::DrawMode);
	decl_access(depthWrite, bool);
	decl_access(constant, bool);
	decl_access(lighting, bool);
	decl_access(normalizeNormals, bool);
	decl_access(wrapHorizontal, render::TextureWrap);
	decl_access(wrapVertical, render::TextureWrap);
	decl_access(filterMin, render::TextureFilter);
	decl_access(filterMag, render::TextureFilter);
	decl_access(mipmap, bool);
	decl_access(cachePixels, bool);

	ScriptMaterial& assign(const render::RenderState& other) {
	(render::RenderState)this = other;
	constant = false;
	return *this;
	}

	void* operator new(size_t size) {
	return ::operator new(size);
	}

	void operator delete(void* address) {
	::operator delete(address);
	}

	void grab() {
	if(!constant) {
	++refs;
	}
	}

	void drop() {
	if(!constant) {
	if(!--refs)
	delete this;
	}
	}
	};

	ScriptMaterial* createMat() {
	return new ScriptMaterial();
	}

	ScriptMaterial* copyMat(const ScriptMaterial& other) {
	return new ScriptMaterial(other);
	}

	static void createSprite_e(void* memory) {
	new(memory) render::Sprite();
	}

	static void createSprite(void* memory, const render::SpriteSheet* sheet, unsigned index) {
	new(memory) render::Sprite(sheet, index);
	}

	static void createSprite_mat(render::Sprite* memory, const render::RenderState* material) {
	new(memory) render::Sprite(material);
	}

	static void createSprite_c(render::Sprite* memory, const render::SpriteSheet* sheet, unsigned index, const Color& color) {
	new(memory) render::Sprite(sheet, index);
	memory->color = color;
	}

	static void createSprite_mat_c(render::Sprite* memory, const render::RenderState* material, const Color& color) {
	new(memory) render::Sprite(material);
	memory->color = color;
	}

	static void delSprite(render::Sprite* sprite) {
	sprite->~Sprite();
	}

	static vec2i spriteSize(render::Sprite& sprite) {
	if(sprite.sheet) {
	return vec2i(sprite.sheet->width, sprite.sheet->height);
	}
	else if(sprite.mat) {
	auto* tex = sprite.mat->textures[0];
	if(tex)
	return tex->size;
	}
	return vec2i(0, 0);
	}

	static double spriteAspect(render::Sprite& sprite) {
	double w = 0.0, h = 0.0;
	if(sprite.sheet) {
	w = sprite.sheet->width;
	h = sprite.sheet->height;
	}
	else if(sprite.mat) {
	auto* tex = sprite.mat->textures[0];
	if(tex) {
	w = tex->size.width;
	h = tex->size.height;
	}
	}
	if(h == 0.0)
	return 1.0;
	return w / h;
	}

	static render::Sprite& copySprite(render::Sprite& into, const render::Sprite& other) {
	into = other;
	return into;
	}

	static bool spriteValid(render::Sprite& sprt) {
	if(sprt.mat == nullptr && sprt.sheet == nullptr)
	return false;
	if(sprt.mat == &devices.library.getErrorMaterial())
	return false;
	if(sprt.sheet == &devices.library.getErrorSpriteSheet())
	return false;
	return true;
	}

	static render::Sprite spriteColorized(render::Sprite& sprt, const Color& color, float blend = 1.f) {
	render::Sprite newsprt = sprt;
	newsprt.color = newsprt.color.getInterpolated(color, blend);
	return newsprt;
	}

	static render::Sprite sprt_color(render::Sprite& sprt, const Color& color) {
	render::Sprite newsprt = sprt;
	newsprt.color = newsprt.color * color;
	return newsprt;
	}

	class CreateNodePhysics : public scene::NodeEvent {
	public:
	CreateNodePhysics(scene::Node* node) : NodeEvent(node) {}

	void process() override {
	if(!node->physics && devices.nodePhysics)
	node->createPhysics();
	}
	};

	void makeNodePhysics(scene::Node* node) {
	scene::queueNodeEvent(new CreateNodePhysics(node));
	}

	class SetNodeObject : public scene::NodeEvent {
	Object* object;
	public:
	SetNodeObject(scene::Node* node, Object* obj) : NodeEvent(node), object(obj) {
	}

	~SetNodeObject() {
	if(object)
	object->drop();
	}

	void process() override {
	node->setObject(object);
	}
	};

	void setNodeObject(scene::Node* node, Object* obj) {
	scene::queueNodeEvent(new SetNodeObject(node, obj));
	}

	template<scene::NodeFlag flag>
	void setNodeFlag(scene::Node& node, bool state) {
	node.setFlag(flag, state);
	}

	template<scene::NodeFlag flag>
	bool getNodeFlag(scene::Node& node) {
	return node.getFlag(flag);
	}

	template<scene::NodeFlag flag>
	void setNodeFlagInv(scene::Node& node, bool state) {
	node.setFlag(flag, !state);
	}

	void pushNodeTransform(scene::Node& node) {
	devices.render->setTransformation(node.transformation);
	}

	void renderNode(scene::Node& node) {
	node.render(*devices.render);
	}

	void animateNode(scene::Node& node, double frameLen) {
	int frameLenMS = (int)(frameLen * 1000.0);
	std::swap(frameLen, frameLen_s);
	std::swap(frameLenMS, frameLen_ms);
	node.animate();
	std::swap(frameLenMS, frameLen_ms);
	std::swap(frameLen, frameLen_s);
	}

	bool isNodeInView(const scene::Node& node) {
	return devices.render->getViewFrustum().overlaps(node.abs_position, node.abs_scale);
	}

	void applyTransform(const vec3d& pos, const vec3d& scale, const quaterniond& rot) {
	Matrix transform;
	rot.toTransform(transform, pos, scale);
	devices.render->setTransformation(transform);
	}

	void applyAbsTransform(const vec3d& pos, const vec3d& scale, const quaterniond& rot) {
	Matrix transform;
	rot.toTransform(transform, pos, scale);
	devices.render->setTransformationAbs(transform);
	}

	void applyBBTransform(const vec3d& pos, double width, double rot) {
	devices.render->setBBTransform(pos, width, rot);
	}

	void popTransform() {
	devices.render->resetTransformation();
	}

	void getBBVecs(vec3d& upLeft, vec3d& upRight, double rot) {
	devices.render->getBillboardVecs(upLeft, upRight, rot);
	}

	void getBBVecsFacing(const vec3d& pos, vec3d& upLeft, vec3d& upRight, double rot) {
	devices.render->getBillboardVecs(pos, upLeft, upRight, rot);
	}

	void nodeSyncObject(scene::Node* node, Object* obj) {
	node->animator = scene::NodeSyncAnimator::getSingleton();
	node->scale = node->abs_scale = obj->radius;
	node->position = node->abs_position = obj->position;
	node->rotation = obj->rotation;
	node->setObject(obj);
	}

	scene::BeamNode* makeBeam(const render::RenderState* mat, float width, const vec3d& startPoint, const vec3d& endPoint, bool staticSize) {
	auto* node = new scene::BeamNode(mat, width, startPoint, endPoint, staticSize);
	if(processing::isRunning())
	node->queueReparent(devices.scene);
	else
	devices.scene->addChild(node);
	return node;
	}

	scene::SpriteNode* makeBillboard(const render::Sprite& sprt, float width) {
	auto* node = new scene::SpriteNode(sprt, width);
	if(processing::isRunning())
	node->queueReparent(devices.scene);
	else
	devices.scene->addChild(node);
	return node;
	}

	scene::PlaneNode* makePlane(const render::RenderState* mat, double size) {
	auto* node = new scene::PlaneNode(mat, size);
	if(processing::isRunning())
	node->queueReparent(devices.scene);
	else
	devices.scene->addChild(node);
	return node;
	}

	scene::MeshNode* makeMesh(const render::RenderMesh* mesh, const render::RenderState* mat) {
	auto* node = new scene::MeshNode(mesh, mat);
	if(processing::isRunning())
	node->queueReparent(devices.scene);
	else
	devices.scene->addChild(node);
	return node;
	}

	template<class T>
	void setShaderValue(asIScriptGeneric* f) {
	auto* shader = (resource::ShaderGlobal*)f->GetFunction()->GetUserData();
	unsigned index = f->GetArgDWord(0);
	T* v = (T*)f->GetArgAddress(1);
	shader->setValue<T>(index, *v);
	}

	const scene::ParticleSystemDesc* getParticleSystem(const std::string& name) {
	return devices.library.getParticleSystem(name);
	}

	scene::ParticleSystem* playParticleSys(const std::string& name, const vec3d& position, float scale, scene::Node* parent) {
	auto* ps = scene::playParticleSystem(devices.library.getParticleSystem(name), parent, position, quaterniond(), vec3d(), scale);
	if(parent)
	parent->drop();
	return ps;
	}

	scene::ParticleSystem* playParticleSys_ps(scene::ParticleSystemDesc* desc, const vec3d& position, float scale, scene::Node* parent) {
	auto* ps = scene::playParticleSystem(desc, parent, position, quaterniond(), vec3d(), scale);
	if(parent)
	parent->drop();
	return ps;
	}

	struct PlayParticles : public scene::NodeEvent {
	heldPointer<Object> parent;
	const scene::ParticleSystemDesc* desc;
	vec3d position;
	quaterniond rotation;
	float scale;

	PlayParticles(const scene::ParticleSystemDesc* sys, const vec3d& pos, const quaterniond& rot, float Scale, Object* Parent = nullptr)
	: scene::NodeEvent(nullptr), desc(sys), position(pos), rotation(rot), scale(Scale), parent(Parent) {}

	void process() override {
	scene::Node* pnode = nullptr;
	vec3d vel;
	quaterniond rot = rotation;
	if(parent) {
	pnode = parent->node;
	vel = parent->velocity;
	}
	auto* ps = scene::playParticleSystem(desc, pnode, position, rotation, vel, scale);
	if(ps)
	ps->drop();
	}
	};

	void playParticleSys_server(const std::string& name, const vec3d& position, const quaterniond& rot, float scale, unsigned mask, bool transmit) {
	if(auto* player = Empire::getPlayerEmpire())
	if(player->visionMask & mask)
	scene::queueNodeEvent(new PlayParticles(devices.library.getParticleSystem(name), position, rot, scale));
	if(transmit && devices.network->isServer)
	devices.network->sendParticleSystem(name, position, vec3d(), rot, scale, mask);
	}

	void playParticleSys_server_o(const std::string& name, const vec3d& position, const quaterniond& rot, float scale, Object* obj, bool transmit) {
	if(auto* player = Empire::getPlayerEmpire())
	if(obj->isVisibleTo(player))
	scene::queueNodeEvent(new PlayParticles(devices.library.getParticleSystem(name), position, rot, scale, obj));
	if(transmit && devices.network->isServer)
	devices.network->sendParticleSystem(name, position, vec3d(), rot, scale, obj);
	}

	class ScriptRenderTarget : public AtomicRefCounted {
	public:
	render::Texture* rt;
	scene::Node* node;
	render::Camera* camera;
	double nextFrame;

	ScriptRenderTarget(const vec2i& size) : nextFrame(0.0) {
	rt = devices.render->createRenderTarget(size);
	node = new scene::Node();
	camera = new render::Camera();
	}

	~ScriptRenderTarget() {
	delete rt;
	if(node)
	node->drop();
	if(camera)
	camera->drop();
	}

	void resize(const vec2i& size) {
	delete rt;
	rt = devices.render->createRenderTarget(size);
	}

	bool isValid() {
	return rt != nullptr;
	}

	void set() {
	devices.render->setRenderTarget(rt);
	}

	void reset() {
	devices.render->setRenderTarget(nullptr);
	}

	void animate(double time) {
	nextFrame += time;
	}

	void draw(const recti& rect) {
	render::renderVertexBuffers();
	set();
	camera->animate(nextFrame);
	devices.render->prepareRender3D(*camera);
	devices.render->setCameraData(*camera);
	camera->setRenderConstraints(1.0, 1000.0, 70.0, (double)rect.getWidth() / (double)rect.getHeight(), rect.getWidth(), rect.getHeight());
	{
	int frameLenMS = (int)(nextFrame * 1000.0);
	std::swap(nextFrame, frameLen_s);
	std::swap(frameLenMS, frameLen_ms);
	node->animate();
	std::swap(frameLenMS, frameLen_ms);
	std::swap(nextFrame, frameLen_s);
	nextFrame = 0.0;
	}

	node->_render(*devices.render);
	render::renderVertexBuffers();
	reset();

	render::RenderState mat;
	mat.textures[0] = rt;
	mat.lighting = false;
	mat.constant = false;
	mat.depthTest = render::DT_Always;
	mat.culling = render::FC_None;

	devices.render->prepareRender2D();
	devices.render->drawRectangle(rect, &mat, Color(), getClip());
	}
	};

	ScriptRenderTarget* makeRenderTarget(const vec2i& size) {
	return new ScriptRenderTarget(size);
	}

	struct ImageLoadData {
	std::string fname;
	Image* img;
	bool loaded;
	bool piped;
	bool owned;

	void prepLoad(const std::string& filename) {
	if(img) {
	delete img;
	img = 0;
	}

	loaded = false;
	piped = false;
	fname = filename;
	}

	ImageLoadData() : img(nullptr), loaded(true), piped(true), owned(false) {
	}

	~ImageLoadData() {
	delete img;
	}
	};

	class DynamicTexture;
	struct ScriptImage;

	extern Image* getInternalImage(ScriptImage* img);

	struct LoadRef {
	DynamicTexture* tex;
	ImageLoadData* dat;
	};

	threads::threadreturn threadcall ImageLoadThread(void* ptr);

	class DynamicTexture : public AtomicRefCounted {
	public:
	ScriptMaterial* state;
	ImageLoadData images[RENDER_MAX_TEXTURES];

	DynamicTexture() {
	state = new ScriptMaterial();
	}

	~DynamicTexture() {
	for(unsigned i = 0; i < RENDER_MAX_TEXTURES; ++i) {
	if(state->textures[i] && images[i].owned)
	queueDestroyTexture(state->textures[i]);
	state->textures[i] = nullptr;
	}
	state->drop();
	}

	bool isLoaded(unsigned index = 0) {
	if(index >= RENDER_MAX_TEXTURES)
	return false;
	return images[index].loaded;
	}

	vec2i getSize(unsigned index = 0) {
	if(index >= RENDER_MAX_TEXTURES \|\| !images[index].loaded \|\| !images[index].img)
	return vec2i();
	return vec2i(images[index].img->width, images[index].img->height);
	}

	void load(const std::string& filename, unsigned index = 0) {
	if(index >= RENDER_MAX_TEXTURES)
	return;
	if(!images[index].loaded) {
	error("Attempting to load an image before previous completed.");
	return;
	}

	images[index].prepLoad(filename);
	if(!state->textures[index])
	state->textures[index] = (render::Texture*)devices.library.getErrorTexture();

	LoadRef* ref = new LoadRef();
	ref->dat = &images[index];
	ref->tex = this;
	grab();
	threads::createThread(ImageLoadThread, ref);
	}

	void set(unsigned index, const ScriptImage* img) {
	if(!img)
	return;
	//TODO: Setting an image to overlap an existing texture will break things
	if(index < RENDER_MAX_TEXTURES) {
	auto& load = images[index];
	if(load.loaded) {
	load.prepLoad("");
	load.img = new Image(getInternalImage((ScriptImage)img));
	load.loaded = true;
	load.piped = false;
	}
	}
	}

	bool stream() {
	//Load images into the GPU
	bool loaded = true;
	for(unsigned i = 0; i < RENDER_MAX_TEXTURES; ++i) {
	auto& img = images[i];
	if(!img.piped) {
	if(img.loaded) {
	if(img.img) {
	auto*& tex = state->textures[i];
	if(!tex \|\| !img.owned) {
	tex = devices.render->createTexture();
	img.owned = true;
	}
	tex->load(*img.img, state->mipmap, state->cachePixels);
	}
	img.piped = true;
	}
	else {
	loaded = false;
	}
	}
	}
	return loaded;
	}

	void draw(const recti& pos, const Color& color) {
	//Draw the full material
	if(stream()) {
	Color colors[4] = {color, color, color, color};
	devices.render->drawRectangle(pos, state, 0, colors, getClip());
	}
	}
	};

	DynamicTexture* makeDynamicTexture() {
	return new DynamicTexture();
	}

	threads::threadreturn threadcall ImageLoadThread(void* ptr) {
	LoadRef* ref = (LoadRef*)ptr;
	ImageLoadData* dat = ref->dat;

	dat->img = loadImage(dat->fname.c_str());
	dat->loaded = true;

	ref->tex->drop();
	delete ref;

	return 0;
	}

	const unsigned MAX_LIGHTS = 8;
	unsigned activeLights = 0;
	render::light::PointLight lights[MAX_LIGHTS];

	void lightEnable(render::light::PointLight* light) {
	if(activeLights < MAX_LIGHTS) {
	vec3f nullOffset;
	setShaderLightRadius(activeLights,light->getRadius());
	light->enable(activeLights, nullOffset);
	}
	}

	void resetLights() {
	activeLights = 0;
	render::light::resetLights();
	}

	render::light::PointLight* getLight(unsigned i) {
	if(i < MAX_LIGHTS)
	return &lights[i];
	else
	return 0;
	}

	template<class T>
	void bindNode(ClassBind& bind) {
	bind.setReferenceFuncs(asMETHOD(T,grab),asMETHOD(T,drop));
	bind.addMethod("Object@ get_object() const", asMETHOD(T,getObject));
	bind.addExternMethod("void set_object(Object@)", asFUNCTION(setNodeObject))
	doc("Changes the node's associated object. This is an asynchronous call.", "");
	bind.addMethod("void markForDeletion()", asMETHOD(T,markForDeletion))
	doc("Flags the node for destruction, removing it from the node tree and destroying it some time in the future.");

	bind.addExternMethod("void createPhysics()", asFUNCTION(makeNodePhysics))
	doc("Gives the node a physics representation in the node physics world.");
	bind.addMethod("void rebuildTransform()", asMETHOD(T,rebuildTransformation))
	doc("Recalculates the node's absolute position, scale, and rotation.");
	bind.addExternMethod("void set_transparent(bool)", asFUNCTION(setNodeFlag<scene::NF_Transparent>))
	doc("Sets whether the node should be treated as transparent.", "");
	bind.addExternMethod("void set_memorable(bool)", asFUNCTION(setNodeFlag<scene::NF_Memorable>))
	doc("Sets whether the node should be visible when the associated object is only remembered.", "");
	bind.addExternMethod("bool get_memorable()", asFUNCTION(getNodeFlag<scene::NF_Memorable>));
	bind.addExternMethod("void set_animInvis(bool)", asFUNCTION(setNodeFlagInv<scene::NF_AnimOnlyVisible>))
	doc("Sets whether the node should call preRender when invisible.", "");
	bind.addExternMethod("void set_autoCull(bool)", asFUNCTION(setNodeFlagInv<scene::NF_NoCulling>))
	doc("Sets whether the node should be automatically culled based on the camera view frustum.", "");
	bind.addExternMethod("void set_fixedSize(bool)", asFUNCTION(setNodeFlag<scene::NF_FixedSize>))
	doc("Sets whether the node is a fixed apparent size. Disables cone behavior in node searches.", "");
	bind.addExternMethod("void set_customColor(bool)", asFUNCTION(setNodeFlag<scene::NF_CustomColor>))
	doc("Sets whether this node should not receive its object's empire's color.", "");
	bind.addExternMethod("void set_needsTransform(bool)", asFUNCTION(setNodeFlagInv<scene::NF_NoMatrix>))
	doc("Sets whether the node should build its matrix when the transform is updated (e.g. for applyTransform).", "");
	bind.addExternMethod("void applyTransform()", asFUNCTION(pushNodeTransform))
	doc("Applies the node's position, scale, and rotation to the model transform.");
	bind.addExternMethod("void render()", asFUNCTION(renderNode))
	doc("Renders the node and its children.");
	bind.addExternMethod("void animate(double seconds)", asFUNCTION(animateNode))
	doc("Animates the node and its children.", "Amount of time to animate by.");
	bind.addExternMethod("bool isInView() const", asFUNCTION(isNodeInView))
	doc("Returns true if the node's bounding sphere is within the camera's view frustum.", "");
	bind.addMethod("void hintParentObject(Object@ obj, bool checkDistance = true)", asMETHOD(T,hintParentObject))
	doc("Hint that this node should be parented to an object's node.",
	"Whether to check whether the node is fully contained or assume it is.",
	"Object to hint for.");
	bind.addMethod("void reparent(Node@+ parent)", asMETHOD(T, queueReparent));

	bind.addMember("Colorf color", offsetof(T, color))
	doc("Color of the node (Owner color for bound nodes).");
	bind.addMember("vec3d position", offsetof(T, position))
	doc("Position relative to the parent.");
	bind.addMember("double scale", offsetof(T, scale))
	doc("Scale relative to the parent.");
	bind.addMember("double sortDistance", offsetof(T, sortDistance))
	doc("Distance to the camera for sorting.");
	bind.addMember("quaterniond rotation", offsetof(T, rotation))
	doc("Rotationg relative to the parent.");
	bind.addMember("vec3d abs_position", offsetof(T, abs_position))
	doc("Absolute position.");
	bind.addMember("double abs_scale", offsetof(T, abs_scale))
	doc("Absolute scale.");
	bind.addMember("quaterniond abs_rotation", offsetof(T, abs_rotation))
	doc("Absolute rotation.");
	bind.addMember("double distanceCutoff", offsetof(T, distanceCutoff))
	doc("Squared distance at which nodes synced to objects will not be rendered for any reason.");
	bind.addMember("bool visible", offsetof(T, visible))
	doc("Determines if the node is rendered when otherwise visible.");
	bind.addMember("bool remembered", offsetof(T, remembered))
	doc("For memorable nodes, tracks whether the associated objects is remembered.");
	bind.addMember("Node@ parent", offsetof(T, parent))
	doc("Parent node in the node tree.");
	}

	void bindScriptNode(ClassBind& bind) {
	bindNode<scene::ScriptedNode>(bind);
	}

	void reloadSettingsShaders() {
	foreach(it, devices.library.settingsShaders) {
	if((*it)->program) {
	(*it)->program->compile();
	(*it)->compile();
	}
	}
	}

	scene::Node* getRenderingNode() {
	auto* n = scene::renderingNode;
	if(n)
	n->grab();
	return n;
	}

	void setRenderingNode(scene::Node* newNode) {
	auto* n = scene::renderingNode;
	if(n)
	n->drop();
	scene::renderingNode = newNode; //reference moved from argument
	}

	void RegisterRenderBinds(bool decl, bool isMenu, bool server) {
	if(decl) {
	ClassBind tex("Texture", asOBJ_REF \| asOBJ_NOCOUNT, 0);
	ClassBind shd("Shader", asOBJ_REF \| asOBJ_NOCOUNT, 0);
	ClassBind light("Light", asOBJ_REF \| asOBJ_NOCOUNT, 0);
	ClassBind group("MatGroup", asOBJ_REF \| asOBJ_NOCOUNT, 0);
	ClassBind mat("Material", asOBJ_REF, 0);
	ClassBind sheet("SpriteSheet", asOBJ_REF \| asOBJ_NOCOUNT, 0);
	ClassBind sprt("Sprite", asOBJ_VALUE \| asOBJ_POD \| asOBJ_APP_CLASS_CDA, sizeof(render::Sprite));
	return;
	}

	ClassBind tex("Texture");
	ClassBind shd("Shader");
	ClassBind light("Light");
	ClassBind mat("Material");
	ClassBind sheet("SpriteSheet");
	ClassBind sprt("Sprite");
	ClassBind group("MatGroup");

	//Library access
	mat.addBehaviour(asBEHAVE_ADDREF, "void f()", asMETHOD(ScriptMaterial, grab));
	mat.addBehaviour(asBEHAVE_RELEASE, "void f()", asMETHOD(ScriptMaterial, drop));
	mat.addFactory("Material@ f()", asFUNCTION(createMat));
	mat.addFactory("Material@ f(const Material&)", asFUNCTION(copyMat));

	mat.addMethod("Material& opAssign(const Material&)", asMETHOD(ScriptMaterial, assign));
	mat.addMember("Colorf diffuse", offsetof(render::RenderState, diffuse));
	mat.addMember("float shininess", offsetof(render::RenderState, shininess));
	mat.addMember("const Shader@ shader", offsetof(render::RenderState, shader));

	for(unsigned i = 0; i < RENDER_MAX_TEXTURES; ++i)
	mat.addMember(format("const Texture@ texture$1", toString(i)).c_str(),
	offsetof(render::RenderState, textures)+(isizeof(render::Texture)));

	light.addMember("vec3f position", offsetof(render::light::PointLight,position));
	light.addMember("float att_constant", offsetof(render::light::PointLight,att_constant));
	light.addMember("float att_linear", offsetof(render::light::PointLight,att_linear));
	light.addMember("float radius", offsetof(render::light::PointLight,radius));
	light.addMember("float att_quadratic", offsetof(render::light::PointLight,att_quadratic));
	light.addMember("Colorf diffuse", offsetof(render::light::PointLight,diffuse));
	light.addMember("Colorf specular", offsetof(render::light::PointLight,specular));
	light.addExternMethod("void enable()", asFUNCTION(lightEnable));

	bind("void resetLights()", asFUNCTION(resetLights))
	doc("Resets to default lighting. State of input lights is unchanged.");
	bind("Light@ get_light(uint index)", asFUNCTION(getLight));
	bindGlobal("const uint MAX_LIGHTS", (void*)&MAX_LIGHTS);
	bindGlobal("Colorf NODE_COLOR", (void*)&fallbackNodeColor);
	bindGlobal("Object@ NODE_OBJECT", (void*)&fallbackNodeObject);

	EnumBind fc("FaceCulling");
	fc["FC_None"] = render::FC_None;
	fc["FC_Front"] = render::FC_Front;
	fc["FC_Back"] = render::FC_Back;
	fc["FC_Both"] = render::FC_Both;

	EnumBind dt("DepthTest");
	dt["DT_Never"] = render::DT_Never;
	dt["DT_Less"] = render::DT_Less;
	dt["DT_Equal"] = render::DT_Equal;
	dt["DT_LessEqual"] = render::DT_LessEqual;
	dt["DT_Greater"] = render::DT_Greater;
	dt["DT_NotEqual"] = render::DT_NotEqual;
	dt["DT_GreaterEqual"] = render::DT_GreaterEqual;
	dt["DT_Always"] = render::DT_Always;
	dt["DT_NoDepthTest"] = render::DT_NoDepthTest;

	EnumBind tw("TextureWrap");
	tw["TW_Repeat"] = render::TW_Repeat;
	tw["TW_Clamp"] = render::TW_Clamp;
	tw["TW_ClampEdge"] = render::TW_ClampEdge;
	tw["TW_Mirror"] = render::TW_Mirror;

	EnumBind tf("TextureFilter");
	tf["TF_Nearest"] = render::TF_Nearest;
	tf["TF_Linear"] = render::TF_Linear;

	EnumBind bm("BaseMaterial");
	bm["MAT_Solid"] = render::MAT_Solid;
	bm["MAT_Alpha"] = render::MAT_Alpha;
	bm["MAT_Font"] = render::MAT_Font;
	bm["MAT_Overlay"] = render::MAT_Overlay;

	EnumBind dm("DrawMode");
	dm["DM_Fill"] = render::DM_Fill;
	dm["DM_Line"] = render::DM_Line;

	bind_access(culling, FaceCulling);
	bind_access(depthTest, DepthTest);
	bind_access(baseMat, BaseMaterial);
	bind_access(drawMode, DrawMode);
	bind_access(depthWrite, bool);
	bind_access(lighting, bool);
	bind_access(normalizeNormals, bool);
	bind_access(wrapHorizontal, TextureWrap);
	bind_access(wrapVertical, TextureWrap);
	bind_access(filterMin, TextureFilter);
	bind_access(filterMag, TextureFilter);
	bind_access(mipmap, bool);
	bind_access(cachePixels, bool);
	bind_access(constant, bool);

	bind("void drawBuffers()", asFUNCTION(drawBuffers));

	bind("const MatGroup& getMatGroup(const string& id)", asFUNCTION(getMatGroup));
	group.addExternMethod("string getMaterialName(uint index) const", asFUNCTION(getGroupMatID));
	group.addExternMethod("const Material@ getMaterial(uint index) const", asFUNCTION(getGroupMat));
	group.addExternMethod("uint get_materialCount() const", asFUNCTION(getGroupMatCount));

	bind("const Material@ getMaterial(const string &in)", asFUNCTION(getMat));
	bind("const Material@ getMaterial(uint)", asFUNCTION(getMat_index));
	bind("const string& getMaterialName(uint)", asFUNCTION(getMat_name));
	bind("uint getMaterialCount()", asFUNCTION(getMatCount));

	ClassBind mod("Model", asOBJ_REF \| asOBJ_NOCOUNT, 0);
	bind("const Model@ getModel(const string &in)", asFUNCTION(getModel));

	bind("const SpriteSheet@ getSpriteSheet(const string &in)", asFUNCTION(getSheet));
	bind("const SpriteSheet@ getSpriteSheet(uint)", asFUNCTION(getSheet_index));
	bind("const string& getSpriteSheetName(uint)", asFUNCTION(getSheet_name));
	bind("uint getSpriteSheetCount()", asFUNCTION(getSheetCount));

	sprt.addConstructor("void f()", asFUNCTION(createSprite_e));
	sprt.addConstructor("void f(const SpriteSheet@ sheet, uint index)", asFUNCTION(createSprite));
	sprt.addConstructor("void f(const Material@ mat)", asFUNCTION(createSprite_mat));
	sprt.addConstructor("void f(const SpriteSheet@ sheet, uint index, const Color& color)", asFUNCTION(createSprite_c));
	sprt.addConstructor("void f(const Material@ mat, const Color& color)", asFUNCTION(createSprite_mat_c));
	sprt.addDestructor("void f()", asFUNCTION(delSprite));
	sprt.addMember("const Material@ mat", offsetof(render::Sprite, mat));
	sprt.addMember("const SpriteSheet@ sheet", offsetof(render::Sprite, sheet));
	sprt.addMember("uint index", offsetof(render::Sprite, index));
	sprt.addMember("Color color", offsetof(render::Sprite, color));
	sprt.addExternMethod("vec2i get_size() const", asFUNCTION(spriteSize));
	sprt.addExternMethod("double get_aspect() const", asFUNCTION(spriteAspect));
	sprt.addExternMethod("Sprite& opAssign(const Sprite&in other)", asFUNCTION(copySprite));
	sprt.addExternMethod("bool get_valid() const", asFUNCTION(spriteValid));
	sprt.addExternMethod("Sprite colorized(const Color& color, float blend = 1.f) const", asFUNCTION(spriteColorized));
	sprt.addExternMethod("Sprite opMul(const Color& color) const", asFUNCTION(sprt_color));
	bind("Sprite getSprite(const string &in)", asFUNCTION(getSprite));
	bind("string getSpriteDesc(const Sprite&in)", asFUNCTION(getSpriteDesc));
	bind("void takeScreenshot(const string& filename, bool increment = true)", asFUNCTION(takeScreenshot));


	{
	Namespace ns("material");
	bind("const Material@ get_error()", asFUNCTION(getErrorMat));
	foreach(it, devices.library.materials)
	bindGlobal(format("const Material $1", it->first).c_str(), it->second);
	}

	{
	Namespace ns("model");
	bind("const Model@ get_error()", asFUNCTION(getErrorModel));
	foreach(it, devices.library.meshes)
	bindGlobal(format("const Model $1", it->first).c_str(), it->second);
	}

	{
	Namespace ns("spritesheet");
	bind("const SpriteSheet@ get_error()", asFUNCTION(getErrorSheet));
	foreach(it, devices.library.spritesheets)
	bindGlobal(format("const SpriteSheet $1", it->first).c_str(), it->second);
	}

	if(!isMenu) {
	ClassBind node("Node", asOBJ_REF);
	bindNode<scene::Node>(node);

	bind("Node@ get_renderingNode()", asFUNCTION(getRenderingNode));
	bind("void set_renderingNode(Node@ node)", asFUNCTION(setRenderingNode));

	asIScriptEngine* engine = getEngine();
	asITypeInfo* nodeArrayType = engine->GetTypeInfoById(engine->GetTypeIdByDecl("array<Node@>"));
	engine->SetUserData(nodeArrayType, EDID_nodeArray);

	bind("void nodeConeSelect(const line3dd &in line, double slope, array<Node@>&)", asFUNCTION(nodeConeSelect));
	bind("void nodeSyncObject(Node& node, Object& obj)", asFUNCTION(nodeSyncObject));

	ClassBind bb("BillboardNode", asOBJ_REF);
	bb.addFactory("BillboardNode@ f(const Sprite& sprt, float width)",
	asFUNCTION(makeBillboard));
	bb.addMember("Sprite sprite", offsetof(scene::SpriteNode, sprite));
	bb.addMember("float width", offsetof(scene::SpriteNode, width));
	bindNode<scene::SpriteNode>(bb);


	node.addExternMethod("BillboardNode@ opCast() const", asFUNCTION((grabbedCast<scene::Node,scene::SpriteNode>)));
	bb.addExternMethod("Node@ opImplCast() const", asFUNCTION((grabbedCast<scene::SpriteNode,scene::Node>)));

	ClassBind beam("BeamNode", asOBJ_REF);
	beam.addFactory("BeamNode@ f(const Material& mat, float width, const vec3d&in startPoint, const vec3d&in endPoint, bool staticSize = false)",
	asFUNCTION(makeBeam));
	beam.addMember("bool staticSize", offsetof(scene::BeamNode, staticSize));
	beam.addMember("float width", offsetof(scene::BeamNode, width));
	beam.addMember("vec3d endPosition", offsetof(scene::BeamNode, endPosition));
	bindNode<scene::BeamNode>(beam);

	node.addExternMethod("BeamNode@ opCast() const", asFUNCTION((grabbedCast<scene::Node,scene::BeamNode>)));
	beam.addExternMethod("Node@ opImplCast() const", asFUNCTION((grabbedCast<scene::BeamNode,scene::Node>)));

	ClassBind plane("PlaneNode", asOBJ_REF);
	plane.addMember("const Material@ material", offsetof(scene::PlaneNode, material));
	plane.addMember("float minRad", offsetof(scene::PlaneNode, minRad));
	plane.addMember("float maxRad", offsetof(scene::PlaneNode, maxRad));
	plane.addFactory("PlaneNode@ f(const Material& mat, double size)",
	asFUNCTION(makePlane));
	bindNode<scene::PlaneNode>(plane);

	node.addExternMethod("PlaneNode@ opCast() const", asFUNCTION((grabbedCast<scene::Node,scene::PlaneNode>)));
	plane.addExternMethod("Node@ opImplCast() const", asFUNCTION((grabbedCast<scene::PlaneNode,scene::Node>)));

	ClassBind mesh("MeshNode", asOBJ_REF);
	mesh.addMember("const Model@ model", offsetof(scene::MeshNode, mesh));
	mesh.addMember("const Material@ material", offsetof(scene::MeshNode, material));

	node.addExternMethod("MeshNode@ opCast() const", asFUNCTION((grabbedCast<scene::Node,scene::MeshNode>)));
	mesh.addExternMethod("Node@ opImplCast() const", asFUNCTION((grabbedCast<scene::MeshNode,scene::Node>)));

	mesh.addFactory("MeshNode@ f(const Model& model, const Material& mat)",
	asFUNCTION(makeMesh));
	bindNode<scene::MeshNode>(mesh);
	}

	if(server) {
	bind("void playParticleSystem(const string& name, const vec3d& position, const quaterniond& rot, float scale = 1, uint mask = 4294967295, bool networked = true)", asFUNCTION(playParticleSys_server));
	bind("void playParticleSystem(const string& name, const vec3d& position, const quaterniond& rot, float scale, Object& parent, bool networked = true)", asFUNCTION(playParticleSys_server_o));
	return;
	}

	{
	Namespace ns("shader");
	bind("void reloadSettingsShaders()", asFUNCTION(reloadSettingsShaders));
	foreach(it, devices.library.shaders)
	bindGlobal(format("const ::Shader $1", it->first).c_str(), it->second);

	devices.library.iterateShaderGlobals([&](std::string& name, resource::ShaderGlobal* shader) {
	if(shader->arraySize == 1) {
	void* ptr = shader->ptr;
	switch(shader->type) {
	case render::Shader::VT_int:
	bindGlobal(format("int $1", name).c_str(), ptr);
	break;
	case render::Shader::VT_int2:
	bindGlobal(format("::vec2i $1", name).c_str(), ptr);
	break;
	case render::Shader::VT_int3:
	bindGlobal(format("::vec3i $1", name).c_str(), ptr);
	break;
	case render::Shader::VT_int4:
	bindGlobal(format("::vec4i $1", name).c_str(), ptr);
	break;
	case render::Shader::VT_float:
	bindGlobal(format("float $1", name).c_str(), ptr);
	break;
	case render::Shader::VT_float2:
	bindGlobal(format("::vec2f $1", name).c_str(), ptr);
	break;
	case render::Shader::VT_float3:
	bindGlobal(format("::vec3f $1", name).c_str(), ptr);
	break;
	case render::Shader::VT_float4:
	bindGlobal(format("::vec4f $1", name).c_str(), ptr);
	break;
	}
	}
	else {
	int fid = -1;
	auto* engine = getEngine();

	switch(shader->type) {
	case render::Shader::VT_int:
	fid = engine->RegisterGlobalFunction(format("void set_$1(uint,const int &in)", name).c_str(),
	asFUNCTION(setShaderValue<int>), asCALL_GENERIC);
	break;
	case render::Shader::VT_int2:
	fid = engine->RegisterGlobalFunction(format("void set_$1(uint,const ::vec2i &in)", name).c_str(),
	asFUNCTION(setShaderValue<vec2i>), asCALL_GENERIC);
	break;
	case render::Shader::VT_int3:
	fid = engine->RegisterGlobalFunction(format("void set_$1(uint,const ::vec3i &in)", name).c_str(),
	asFUNCTION(setShaderValue<vec3i>), asCALL_GENERIC);
	break;
	case render::Shader::VT_int4:
	fid = engine->RegisterGlobalFunction(format("void set_$1(uint,const ::vec4i &in)", name).c_str(),
	asFUNCTION(setShaderValue<vec4i>), asCALL_GENERIC);
	break;
	case render::Shader::VT_float:
	fid = engine->RegisterGlobalFunction(format("void set_$1(uint,const float &in)", name).c_str(),
	asFUNCTION(setShaderValue<float>), asCALL_GENERIC);
	break;
	case render::Shader::VT_float2:
	fid = engine->RegisterGlobalFunction(format("void set_$1(uint,const ::vec2f &in)", name).c_str(),
	asFUNCTION(setShaderValue<vec2f>), asCALL_GENERIC);
	break;
	case render::Shader::VT_float3:
	fid = engine->RegisterGlobalFunction(format("void set_$1(uint,const ::vec3f &in)", name).c_str(),
	asFUNCTION(setShaderValue<vec3f>), asCALL_GENERIC);
	break;
	case render::Shader::VT_float4:
	fid = engine->RegisterGlobalFunction(format("void set_$1(uint,const ::vec4f &in)", name).c_str(),
	asFUNCTION(setShaderValue<vec4f>), asCALL_GENERIC);
	break;
	}

	if(auto* func = engine->GetFunctionById(fid))
	func->SetUserData(shader);
	}
	});
	}

	//Sprite draw shortcuts
	sprt.addExternMethod("void draw(const recti &in pos) const", asFUNCTION(draw_sprt));
	sprt.addExternMethod("void draw(const recti &in pos, const Color&in color) const", asFUNCTION(draw_sprt_c));
	sprt.addExternMethod("void draw(const recti &in pos, const Color&in color, const Shader@ shader) const", asFUNCTION(draw_sprt_csh));
	sprt.addExternMethod("void draw(const recti &in pos, const Color&in color, double rotation) const", asFUNCTION(draw_sprt_cr));

	//Material definitions
	mat.addExternMethod("vec2i get_size() const", asFUNCTION(mat_size));
	mat.addExternMethod("void switchTo() const", asFUNCTION(mat_activate));

	mat.addExternMethod("bool isPixelActive(const vec2i&in px) const", asFUNCTION(mat_pxactive));
	mat.addExternMethod("void draw(const recti &in pos) const", asFUNCTION(draw_mat));
	mat.addExternMethod("void draw(const recti &in pos, const Color&in color) const", asFUNCTION(draw_mat_c));
	mat.addExternMethod("void draw(const recti &in pos, const Color&in color, const Shader@ shader) const", asFUNCTION(draw_mat_csh));
	mat.addExternMethod("void draw(const recti &in pos, const recti &in src) const", asFUNCTION(draw_mat_s));
	mat.addExternMethod("void draw(const recti &in pos, const recti &in src, const Color&in color) const", asFUNCTION(draw_mat_sc));
	mat.addExternMethod("void draw(const recti &in pos, const recti &in src, const Color&in color, double rotation) const", asFUNCTION(draw_mat_scr));
	mat.addExternMethod("void draw(const recti &in pos, const recti &in src, const Color&in topleft, const Color&in topright, const Color&in botright, const Color&in botleft) const", asFUNCTION(draw_mat_scc));

	//Spritesheet definitions
	sheet.addMember("const Material material", offsetof(render::SpriteSheet, material));
	sheet.addMember("int width", offsetof(render::SpriteSheet, width));
	sheet.addMember("int height", offsetof(render::SpriteSheet, height));
	sheet.addMethod("uint get_count() const", asMETHOD(render::SpriteSheet, getCount));
	sheet.addExternMethod("void getSourceUV(uint index, vec4f&out value) const", asFUNCTION(sprite_sourceUV));
	sheet.addExternMethod("vec2i get_size() const", asFUNCTION(sprite_size));
	sheet.addExternMethod("Sprite opAdd(uint num) const", asFUNCTION(sprite_offset));

	sheet.addMethod("bool isPixelActive(uint index, const vec2i&in px) const", asMETHOD(render::SpriteSheet, isPixelActive));
	sheet.addMethod("recti getSource(uint index) const", asMETHODPR(render::SpriteSheet, getSource, (unsigned) const, recti));
	sheet.addExternMethod("void draw(uint index, const recti &in pos) const", asFUNCTION(draw_sprite));
	sheet.addExternMethod("void draw(uint index, const recti &in pos, const Shader@ shader) const", asFUNCTION(draw_sprite_s));
	sheet.addExternMethod("void draw(uint index, const recti &in pos, const Color&in color) const", asFUNCTION(draw_sprite_c));
	sheet.addExternMethod("void draw(uint index, const recti &in pos, const Color&in color, double rotation) const", asFUNCTION(draw_sprite_cr));
	sheet.addExternMethod("void draw(uint index, const recti &in pos, const Color&in topleft, const Color&in topright, const Color&in botright, const Color&in botleft) const", asFUNCTION(draw_sprite_cc));

	//Model definitions
	mod.addExternMethod("void draw(const Material& mat, const recti&in pos, quaterniond rotation = quaterniond(), double scale = 1.0) const", asFUNCTION(draw_model));
	mod.addMethod("void draw() const", asMETHOD(render::RenderMesh,render));
	mod.addExternMethod("void draw(double lodDist) const", asFUNCTION(meshRenderLOD));

	//Global functions
	bind("void setSkybox(const Material@)", asFUNCTION(setSkybox));
	bind("void setSkyboxMesh(const Model@)", asFUNCTION(setSkyboxMesh));
	bindGlobal("const Shader@ fullscreenShader", &fsShader);
	bind("void applyTransform(const vec3d &in pos, const vec3d &in scale, const quaterniond &in rot)", asFUNCTION(applyTransform))
	doc("Applies a transformation to the modelview matrix. Also applies the camera's position as an offset. Call undoTransform() afterwards.", "", "", "");
	bind("void applyAbsTransform(const vec3d &in pos, const vec3d &in scale, const quaterniond &in rot)", asFUNCTION(applyAbsTransform))
	doc("Applies a transformation to the modelview matrix. Call undoTransform() afterwards.", "", "", "");
	bind("void applyBBTransform(const vec3d &in pos, double width, double rot)", asFUNCTION(applyBBTransform))
	doc("Applies a transformation that rotates a model in the same way a billboard would rotate. Call undoTransform() afterwards.", "", "", "");
	bind("void undoTransform()", asFUNCTION(popTransform))
	doc("Undoes a modelview transform.");
	bind("void getBillboardVecs(vec3d &out upLeft, vec3d &out upRight, double rot = 0)", asFUNCTION(getBBVecs))
	doc("Fetches the two cached vectors necessary to build a billboard.", "Top left corner offset.", "Top right corner offset.", "Optional rotation to apply to the billboard.");
	bind("void getBillboardVecs(const vec3d &in from, vec3d &out upLeft, vec3d &out upRight, double rot = 0)", asFUNCTION(getBBVecsFacing))
	doc("Fetches the two cached vectors necessary to build a billboard that faces the camera.", "Position to face the billboard from.", "Top left corner offset.", "Top right corner offset.", "Optional rotation to apply to the billboard.");
	bind("const ParticleSystem@ getParticleSystem(const string& name)", asFUNCTION(getParticleSystem));
	if(!server) {
	ClassBind psn("ParticleSystemNode", asOBJ_REF);
	bindNode<scene::ParticleSystem>(psn);
	psn.addMember("vec3d velocity", offsetof(scene::ParticleSystem,vel));
	psn.addMember("quaterniond emitRot", offsetof(scene::ParticleSystem,rot));
	psn.addMethod("void stop()", asMETHOD(scene::ParticleSystem,end));

	ClassBind node("Node");

	node.addExternMethod("ParticleSystemNode@ opCast() const", asFUNCTION((grabbedCast<scene::Node,scene::ParticleSystem>)));
	psn.addExternMethod("Node@ opImplCast() const", asFUNCTION((grabbedCast<scene::ParticleSystem,scene::Node>)));

	bind("ParticleSystemNode@ playParticleSystem(const string& name, const vec3d& position, float scale = 1, Node@ parent = null)", asFUNCTION(playParticleSys));
	bind("ParticleSystemNode@ playParticleSystem(const ParticleSystem& system, const vec3d& position, float scale = 1, Node@ parent = null)", asFUNCTION(playParticleSys_ps));
	}

	//Camera
	ClassBind cam("Camera", asOBJ_REF);
	cam.addFactory("Camera@ f()", asFUNCTION(cameraFactory));
	cam.setReferenceFuncs(asMETHOD(render::Camera, grab), asMETHOD(render::Camera, drop));
	cam.addMethod("void animate(double time)", asMETHOD(render::Camera, animate));
	cam.addExternMethod("Camera& opAssign(const Camera&in other)", asFUNCTION(copyCamera));

	cam.addMethod("void yaw(double rad, bool snap = false)", asMETHOD(render::Camera, yaw));
	cam.addMethod("void pitch(double rad, bool snap = false)", asMETHOD(render::Camera, pitch));
	cam.addMethod("void roll(double rad, bool snap = false)", asMETHOD(render::Camera, roll));
	cam.addMethod("void zoom(double)", asMETHOD(render::Camera, zoom));
	cam.addMethod("void zoomTo(double, const vec3d &in, double minDistance = 0.0)", asMETHOD(render::Camera, zoomTo));
	cam.addMethod("void zoomAlong(double, const vec3d &in)", asMETHOD(render::Camera, zoomAlong));
	cam.addMethod("void resetRotation()", asMETHOD(render::Camera, resetRotation));
	cam.addMethod("void resetZoom()", asMETHOD(render::Camera, resetZoom));
	cam.addMethod("void snap()", asMETHOD(render::Camera, snap));
	cam.addMethod("void snapTranslation()", asMETHOD(render::Camera, snapTranslation));

	cam.addMethod("double get_radius()", asMETHOD(render::Camera, getRadius));
	cam.addMethod("void set_radius(double value)", asMETHOD(render::Camera, setRadius));

	cam.addMethod("void set_linearZoom(bool) const", asMETHOD(render::Camera, setLinearZoom));
	cam.addMethod("void set_lockedRotation(bool) const", asMETHOD(render::Camera, setLockedRotation))
	doc("Sets whether the camera is allowed to rotate to be upside down.", "");

	cam.addMethod("void setPositionBound(const vec3d &in minimum, const vec3d &in maximum)", asMETHOD(render::Camera, setPositionBound));
	cam.addMethod("void set_maxDistance(double dist)", asMETHOD(render::Camera, setMaxDistance));

	cam.addMethod("void abs_yaw(double rad, bool snap = false)", asMETHOD(render::Camera, abs_yaw));
	cam.addMethod("void abs_pitch(double rad, bool snap = false)", asMETHOD(render::Camera, abs_pitch));

	cam.addMethod("void abs_yaw_to(double rad, bool snap = false)", asMETHOD(render::Camera, abs_yaw_to));
	cam.addMethod("void abs_pitch_to(double rad, bool snap = false)", asMETHOD(render::Camera, abs_pitch_to));

	cam.addMethod("void move_abs(const vec3d &in)", asMETHOD(render::Camera, move_abs));
	cam.addMethod("void move_world_abs(const vec3d &in)", asMETHOD(render::Camera, move_world_abs));
	cam.addMethod("void move_world(const vec3d &in)", asMETHOD(render::Camera, move_world));
	cam.addMethod("void move_cam(const vec3d &in)", asMETHOD(render::Camera, move_cam));
	cam.addMethod("void move_cam_abs(const vec3d &in)", asMETHOD(render::Camera, move_cam_abs));

	cam.addMethod("vec3d get_position() const", asMETHOD(render::Camera, getPosition));
	cam.addMethod("vec3d get_finalPosition() const", asMETHOD(render::Camera, getFinalPosition));
	cam.addMethod("vec3d get_facing() const", asMETHOD(render::Camera, getFacing));
	cam.addMethod("vec3d get_right() const", asMETHOD(render::Camera, getRight));
	cam.addMethod("vec3d get_lookAt() const", asMETHOD(render::Camera, getLookAt));
	cam.addMethod("vec3d get_finalLookAt() const", asMETHOD(render::Camera, getFinalLookAt));
	cam.addMethod("vec3d get_up() const", asMETHOD(render::Camera, getUp));
	cam.addMethod("double get_distance() const", asMETHOD(render::Camera, getDistance));
	cam.addMethod("bool get_inverted()", asMETHOD(render::Camera, inverted));

	cam.addMethod("double get_yaw() const", asMETHOD(render::Camera, getYaw));
	cam.addMethod("double get_pitch() const", asMETHOD(render::Camera, getPitch));
	cam.addMethod("double get_roll() const", asMETHOD(render::Camera, getRoll));

	cam.addMethod("double screenAngle(const vec3d&in pos) const", asMETHOD(render::Camera, screenAngle));
	cam.addMethod("vec2i screenPos(const vec3d&in pos) const", asMETHOD(render::Camera, screenPos));
	cam.addMethod("line3dd screenToRay(double, double) const", asMETHOD(render::Camera, screenToRay));

	cam.addMethod("void toLookAt(vec3d &out, vec3d &out, vec3d &out) const", asMETHOD(render::Camera, toLookAt));
	cam.addMethod("void setRenderConstraints(double, double, double, double, double, double)", asMETHOD(render::Camera, setRenderConstraints));

	if(!isMenu) {
	cam.addExternMethod("Object@ getObject(const vec2i& line) const", asFUNCTION(objectFromPixel));
	cam.addExternMethod("array<Object@>@ boxSelect(const recti& box)", asFUNCTION(boxSelect));
	}

	bind("double getCameraDistance(const vec3d&in pos, double scale = 0)", asFUNCTION(cam_dist));
	bind("vec3d get_cameraPos()", asFUNCTION(cam_pos));
	bind("vec3d get_cameraUp()", asFUNCTION(cam_up));
	bind("vec3d get_cameraFacing()", asFUNCTION(cam_facing));
	bind("bool isSphereVisible(const vec3d& center, double radius)", asFUNCTION(isInView));

	bindGlobal("double pixelSizeRatio", &pixelSizeRatio);
	bindGlobal("bool render3DIcons", &scene::MeshIconNode::render3DIcons);

	ClassBind rt("RenderTarget", asOBJ_REF);
	rt.addFactory("RenderTarget@ f(const vec2i &in size)", asFUNCTION(makeRenderTarget));
	rt.setReferenceFuncs(asMETHOD(ScriptRenderTarget, grab), asMETHOD(ScriptRenderTarget, drop));
	rt.addMethod("bool get_valid() const", asMETHOD(ScriptRenderTarget, isValid));
	rt.addMethod("void set() const", asMETHOD(ScriptRenderTarget, set));
	rt.addMethod("void reset() const", asMETHOD(ScriptRenderTarget, reset));
	rt.addMethod("void animate(double time)", asMETHOD(ScriptRenderTarget, animate));
	rt.addMethod("void draw(const recti& in)", asMETHOD(ScriptRenderTarget, draw));
	rt.addMethod("void set_size(const vec2i& in)", asMETHOD(ScriptRenderTarget, resize));
	rt.addMember("Node@ node", offsetof(ScriptRenderTarget, node));
	rt.addMember("Camera@ camera", offsetof(ScriptRenderTarget, camera));

	//-- Dynamic texture loading
	ClassBind dtex("DynamicTexture", asOBJ_REF);
	dtex.addFactory("DynamicTexture@ f()", asFUNCTION(makeDynamicTexture));
	dtex.setReferenceFuncs(asMETHOD(DynamicTexture, grab), asMETHOD(DynamicTexture, drop));

	dtex.addMember("Material@ material", offsetof(DynamicTexture, state));
	dtex.addMethod("bool isLoaded(uint index = 0)", asMETHOD(DynamicTexture, isLoaded));
	dtex.addMethod("vec2i get_size(uint index = 0)", asMETHOD(DynamicTexture, getSize));
	dtex.addMethod("void load(const string&in filename, uint index = 0)", asMETHOD(DynamicTexture, load));
	dtex.addMethod("void set_image(uint index, const Image@+ img)", asMETHOD(DynamicTexture, set));
	dtex.addMethod("void draw(const recti&in pos, const Color& color)", asMETHOD(DynamicTexture, draw));
	dtex.addMethod("bool stream()", asMETHOD(DynamicTexture, stream));

	//-- Render functions
	bind("void drawRectangle(const recti &in pos, const Color&in color)", asFUNCTION(draw_rect));
	bind("void drawRectangle(const recti &in pos, const Material@ mat, const Color&in color)", asFUNCTION(draw_rect_m));
	bind("void drawRectangle(const recti &in pos, const Color&in topleft, const Color&in topright, const Color&in botright, const Color&in botleft)", asFUNCTION(draw_rect_g));

	//TODO: Figure out why the JIT doesn't supoprt asCALL_THISCALL_ASGLOBAL
	//bind("void updateRenderCamera(Camera& cam)", asMETHOD(render::RenderDriver,setCameraData), devices.render);
	//bind("void prepareRender(Camera& cam)", asMETHOD(render::RenderDriver,prepareRender3D), devices.render);
	bind("void updateRenderCamera(Camera& cam)", asFUNCTION(updateCamera));
	bind("void prepareRender(Camera& cam)", asFUNCTION(prepareRender));
	bind("void prepareRender(Camera& cam, const recti&)", asFUNCTION(prepareRenderClip));
	bind("void renderWorld()", asFUNCTION(renderWorld));
	bind("void renderBillboard(const Material& mat, const vec3d &in pos, double width, double rotation = 0)", asFUNCTION(renderBillboard));
	bind("void renderBillboard(const SpriteSheet& sheet, uint index, const vec3d &in pos, double width, double rotation = 0)", asFUNCTION(renderBillboard_sheet));
	bind("void renderBillboard(const Sprite& spr, const vec3d &in pos, double width, double rotation = 0)", asFUNCTION(renderBillboard_sprite));
	bind("void renderBillboard(const Material& mat, const vec3d &in pos, double width, double rotation, const Color&in)", asFUNCTION(renderBillboard_c));
	bind("void renderBillboard(const SpriteSheet& sheet, uint index, const vec3d &in pos, double width, double rotation, const Color&in)", asFUNCTION(renderBillboard_sheet_c));
	bind("void renderBillboard(const Sprite& spr, const vec3d &in pos, double width, double rotation, const Color&in)", asFUNCTION(renderBillboard_sprite_c));
	bind("void renderPlane(const Material& mat, const vec3d &in pos, double width, const Color&in, double rotation = 0)", asFUNCTION(renderPlane));
	bind("void drawFPSGraph(const recti &in pos)", asFUNCTION(draw_fps));

	EnumBind pt("PolygonType");
	pt["PT_Lines"] = render::PT_Lines;
	pt["PT_LineStrip"] = render::PT_LineStrip;
	pt["PT_Triangles"] = render::PT_Triangles;
	pt["PT_Quads"] = render::PT_Quads;

	bind("void drawPolygonStart(uint triangles, const Material@ mat = null)", asFUNCTION(poly_start));
	bind("void drawPolygonStart(uint triangles, const Material@ mat, const Color&in)", asFUNCTION(poly_start_c));
	bind("void drawPolygonStart(PolygonType type, uint polyCount, const Material@ mat = null)", asFUNCTION(poly_start_t));
	bind("void drawPolygonEnd()", asFUNCTION(poly_end));

	bind("void drawPolygonPoint(const vec2i &in)", asFUNCTION(poly_coord));
	bind("void drawPolygonPoint(const vec2i &in, const vec2f& in)", asFUNCTION(poly_coord_uv));
	bind("void drawPolygonPoint(const vec2i &in, const vec2f& in, const Color& in)", asFUNCTION(poly_coord_uvc));
	bind("void drawPolygonPoint(const vec2i &in, const Color&in)", asFUNCTION(poly_coord_c));

	bind("void drawPolygonPoint(const vec2f &in)", asFUNCTION(poly_fcoord));
	bind("void drawPolygonPoint(const vec2f &in, const vec2f& in)", asFUNCTION(poly_fcoord_uv));
	bind("void drawPolygonPoint(const vec2f &in, const Color&in)", asFUNCTION(poly_fcoord_c));

	bind("void drawPolygonPoint(const vec3d &in)", asFUNCTION(poly3_coord));
	bind("void drawPolygonPoint(const vec3d &in, const vec2f& in)", asFUNCTION(poly3_coord_uv));
	bind("void drawPolygonPoint(const vec3d &in, const Color&in)", asFUNCTION(poly3_coord_c));
	bind("void drawPolygonPoint(const vec3d &in, const vec2f& in, const Color&in)", asFUNCTION(poly3_coord_uvc));

	bind("void drawLine(const vec2i&in from, const vec2i& to, int size = 1, const Material@ mat = null)", asFUNCTION(draw_line));
	bind("void drawLine(const vec2i&in from, const vec2i& to, const Color&in color, int size = 1, const Material@ mat = null)", asFUNCTION(draw_line_c));

	//-- Video modes
	ClassBind vm("VideoMode", asOBJ_POD \| asOBJ_VALUE, sizeof(os::OSDriver::VideoMode));
	vm.addMember("uint width", offsetof(os::OSDriver::VideoMode, width));
	vm.addMember("uint height", offsetof(os::OSDriver::VideoMode, height));
	vm.addMember("uint refresh", offsetof(os::OSDriver::VideoMode, refresh));
	bind("void getVideoModes(array<VideoMode>& output)", asFUNCTION(getVideoModes));
	bind("void getMonitorNames(array<string>& output)", asFUNCTION(getMonitorNames));

	bind("void set_vsync(int blanks)", asFUNCTION(setVsync))
	doc("Sets vsync mode (applied immediately if possible)", "Number of frames to wait for. -1 for adaptive vsync where available.");
	bindGlobal("double scale_3d", &scale_3d)
	doc("Linear factor by which to scale the 3D render for supersampling.");

	//-- Sound
	bind("void getAudioDeviceNames(array<string>& output)", asFUNCTION(getAudioNames));
	}

	};

File Metadata

Mime Type: text/x-c++
Expires: Sun, Nov 15, 2:53 PM (18 h, 48 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 130834
Default Alt Text: bind_render.cpp (76 KB)

bind_render.cppNo OneTemporaryActions

bind_render.cppView Options

File Metadata

Event Timeline

bind_render.cpp
No OneTemporary
Actions

bind_render.cpp
View Options