/* this file has been autogenerated by vtkNodeJsWrap */
/* editing this might proof futile */

#define VTK_WRAPPING_CXX
#define VTK_STREAMS_FWD_ONLY
#include <nan.h>

#include "vtkVolumeMapperWrap.h"
#include "vtkVolumeRayCastMapperWrap.h"
#include "vtkObjectWrap.h"
#include "vtkVolumeRayCastFunctionWrap.h"
#include "vtkEncodedGradientEstimatorWrap.h"
#include "vtkEncodedGradientShaderWrap.h"
#include "vtkRendererWrap.h"
#include "vtkVolumeWrap.h"
#include "vtkWindowWrap.h"
#include "../../plus/plus.h"

using namespace v8;

extern Nan::Persistent<v8::Object> vtkNodeJsNoWrap;
Nan::Persistent<v8::FunctionTemplate> VtkVolumeRayCastMapperWrap::ptpl;

VtkVolumeRayCastMapperWrap::VtkVolumeRayCastMapperWrap()
{ }

VtkVolumeRayCastMapperWrap::VtkVolumeRayCastMapperWrap(vtkSmartPointer<vtkVolumeRayCastMapper> _native)
{ native = _native; }

VtkVolumeRayCastMapperWrap::~VtkVolumeRayCastMapperWrap()
{ }

void VtkVolumeRayCastMapperWrap::Init(v8::Local<v8::Object> exports)
{
	Nan::SetAccessor(exports, Nan::New("vtkVolumeRayCastMapper").ToLocalChecked(), ConstructorGetter);
	Nan::SetAccessor(exports, Nan::New("VolumeRayCastMapper").ToLocalChecked(), ConstructorGetter);
}

void VtkVolumeRayCastMapperWrap::ConstructorGetter(
	v8::Local<v8::String> property,
	const Nan::PropertyCallbackInfo<v8::Value>& info)
{
	InitPtpl();
	info.GetReturnValue().Set(Nan::New(ptpl)->GetFunction());
}

void VtkVolumeRayCastMapperWrap::InitPtpl()
{
	if (!ptpl.IsEmpty()) return;
	v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
	VtkVolumeMapperWrap::InitPtpl( );
	tpl->Inherit(Nan::New<FunctionTemplate>(VtkVolumeMapperWrap::ptpl));
	tpl->SetClassName(Nan::New("VtkVolumeRayCastMapperWrap").ToLocalChecked());
	tpl->InstanceTemplate()->SetInternalFieldCount(1);

	Nan::SetPrototypeMethod(tpl, "AutoAdjustSampleDistancesOff", AutoAdjustSampleDistancesOff);
	Nan::SetPrototypeMethod(tpl, "autoAdjustSampleDistancesOff", AutoAdjustSampleDistancesOff);

	Nan::SetPrototypeMethod(tpl, "AutoAdjustSampleDistancesOn", AutoAdjustSampleDistancesOn);
	Nan::SetPrototypeMethod(tpl, "autoAdjustSampleDistancesOn", AutoAdjustSampleDistancesOn);

	Nan::SetPrototypeMethod(tpl, "GetAutoAdjustSampleDistances", GetAutoAdjustSampleDistances);
	Nan::SetPrototypeMethod(tpl, "getAutoAdjustSampleDistances", GetAutoAdjustSampleDistances);

	Nan::SetPrototypeMethod(tpl, "GetAutoAdjustSampleDistancesMaxValue", GetAutoAdjustSampleDistancesMaxValue);
	Nan::SetPrototypeMethod(tpl, "getAutoAdjustSampleDistancesMaxValue", GetAutoAdjustSampleDistancesMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetAutoAdjustSampleDistancesMinValue", GetAutoAdjustSampleDistancesMinValue);
	Nan::SetPrototypeMethod(tpl, "getAutoAdjustSampleDistancesMinValue", GetAutoAdjustSampleDistancesMinValue);

	Nan::SetPrototypeMethod(tpl, "GetClassName", GetClassName);
	Nan::SetPrototypeMethod(tpl, "getClassName", GetClassName);

	Nan::SetPrototypeMethod(tpl, "GetGradientEstimator", GetGradientEstimator);
	Nan::SetPrototypeMethod(tpl, "getGradientEstimator", GetGradientEstimator);

	Nan::SetPrototypeMethod(tpl, "GetGradientMagnitudeBias", GetGradientMagnitudeBias);
	Nan::SetPrototypeMethod(tpl, "getGradientMagnitudeBias", GetGradientMagnitudeBias);

	Nan::SetPrototypeMethod(tpl, "GetGradientMagnitudeScale", GetGradientMagnitudeScale);
	Nan::SetPrototypeMethod(tpl, "getGradientMagnitudeScale", GetGradientMagnitudeScale);

	Nan::SetPrototypeMethod(tpl, "GetGradientShader", GetGradientShader);
	Nan::SetPrototypeMethod(tpl, "getGradientShader", GetGradientShader);

	Nan::SetPrototypeMethod(tpl, "GetImageSampleDistance", GetImageSampleDistance);
	Nan::SetPrototypeMethod(tpl, "getImageSampleDistance", GetImageSampleDistance);

	Nan::SetPrototypeMethod(tpl, "GetImageSampleDistanceMaxValue", GetImageSampleDistanceMaxValue);
	Nan::SetPrototypeMethod(tpl, "getImageSampleDistanceMaxValue", GetImageSampleDistanceMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetImageSampleDistanceMinValue", GetImageSampleDistanceMinValue);
	Nan::SetPrototypeMethod(tpl, "getImageSampleDistanceMinValue", GetImageSampleDistanceMinValue);

	Nan::SetPrototypeMethod(tpl, "GetIntermixIntersectingGeometry", GetIntermixIntersectingGeometry);
	Nan::SetPrototypeMethod(tpl, "getIntermixIntersectingGeometry", GetIntermixIntersectingGeometry);

	Nan::SetPrototypeMethod(tpl, "GetIntermixIntersectingGeometryMaxValue", GetIntermixIntersectingGeometryMaxValue);
	Nan::SetPrototypeMethod(tpl, "getIntermixIntersectingGeometryMaxValue", GetIntermixIntersectingGeometryMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetIntermixIntersectingGeometryMinValue", GetIntermixIntersectingGeometryMinValue);
	Nan::SetPrototypeMethod(tpl, "getIntermixIntersectingGeometryMinValue", GetIntermixIntersectingGeometryMinValue);

	Nan::SetPrototypeMethod(tpl, "GetMaximumImageSampleDistance", GetMaximumImageSampleDistance);
	Nan::SetPrototypeMethod(tpl, "getMaximumImageSampleDistance", GetMaximumImageSampleDistance);

	Nan::SetPrototypeMethod(tpl, "GetMaximumImageSampleDistanceMaxValue", GetMaximumImageSampleDistanceMaxValue);
	Nan::SetPrototypeMethod(tpl, "getMaximumImageSampleDistanceMaxValue", GetMaximumImageSampleDistanceMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetMaximumImageSampleDistanceMinValue", GetMaximumImageSampleDistanceMinValue);
	Nan::SetPrototypeMethod(tpl, "getMaximumImageSampleDistanceMinValue", GetMaximumImageSampleDistanceMinValue);

	Nan::SetPrototypeMethod(tpl, "GetMinimumImageSampleDistance", GetMinimumImageSampleDistance);
	Nan::SetPrototypeMethod(tpl, "getMinimumImageSampleDistance", GetMinimumImageSampleDistance);

	Nan::SetPrototypeMethod(tpl, "GetMinimumImageSampleDistanceMaxValue", GetMinimumImageSampleDistanceMaxValue);
	Nan::SetPrototypeMethod(tpl, "getMinimumImageSampleDistanceMaxValue", GetMinimumImageSampleDistanceMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetMinimumImageSampleDistanceMinValue", GetMinimumImageSampleDistanceMinValue);
	Nan::SetPrototypeMethod(tpl, "getMinimumImageSampleDistanceMinValue", GetMinimumImageSampleDistanceMinValue);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfThreads", GetNumberOfThreads);
	Nan::SetPrototypeMethod(tpl, "getNumberOfThreads", GetNumberOfThreads);

	Nan::SetPrototypeMethod(tpl, "GetSampleDistance", GetSampleDistance);
	Nan::SetPrototypeMethod(tpl, "getSampleDistance", GetSampleDistance);

	Nan::SetPrototypeMethod(tpl, "GetVolumeRayCastFunction", GetVolumeRayCastFunction);
	Nan::SetPrototypeMethod(tpl, "getVolumeRayCastFunction", GetVolumeRayCastFunction);

	Nan::SetPrototypeMethod(tpl, "GetZeroOpacityThreshold", GetZeroOpacityThreshold);
	Nan::SetPrototypeMethod(tpl, "getZeroOpacityThreshold", GetZeroOpacityThreshold);

	Nan::SetPrototypeMethod(tpl, "IntermixIntersectingGeometryOff", IntermixIntersectingGeometryOff);
	Nan::SetPrototypeMethod(tpl, "intermixIntersectingGeometryOff", IntermixIntersectingGeometryOff);

	Nan::SetPrototypeMethod(tpl, "IntermixIntersectingGeometryOn", IntermixIntersectingGeometryOn);
	Nan::SetPrototypeMethod(tpl, "intermixIntersectingGeometryOn", IntermixIntersectingGeometryOn);

	Nan::SetPrototypeMethod(tpl, "IsA", IsA);
	Nan::SetPrototypeMethod(tpl, "isA", IsA);

	Nan::SetPrototypeMethod(tpl, "NewInstance", NewInstance);
	Nan::SetPrototypeMethod(tpl, "newInstance", NewInstance);

	Nan::SetPrototypeMethod(tpl, "ReleaseGraphicsResources", ReleaseGraphicsResources);
	Nan::SetPrototypeMethod(tpl, "releaseGraphicsResources", ReleaseGraphicsResources);

	Nan::SetPrototypeMethod(tpl, "Render", Render);
	Nan::SetPrototypeMethod(tpl, "render", Render);

	Nan::SetPrototypeMethod(tpl, "SafeDownCast", SafeDownCast);
	Nan::SetPrototypeMethod(tpl, "safeDownCast", SafeDownCast);

	Nan::SetPrototypeMethod(tpl, "SetAutoAdjustSampleDistances", SetAutoAdjustSampleDistances);
	Nan::SetPrototypeMethod(tpl, "setAutoAdjustSampleDistances", SetAutoAdjustSampleDistances);

	Nan::SetPrototypeMethod(tpl, "SetGradientEstimator", SetGradientEstimator);
	Nan::SetPrototypeMethod(tpl, "setGradientEstimator", SetGradientEstimator);

	Nan::SetPrototypeMethod(tpl, "SetImageSampleDistance", SetImageSampleDistance);
	Nan::SetPrototypeMethod(tpl, "setImageSampleDistance", SetImageSampleDistance);

	Nan::SetPrototypeMethod(tpl, "SetIntermixIntersectingGeometry", SetIntermixIntersectingGeometry);
	Nan::SetPrototypeMethod(tpl, "setIntermixIntersectingGeometry", SetIntermixIntersectingGeometry);

	Nan::SetPrototypeMethod(tpl, "SetMaximumImageSampleDistance", SetMaximumImageSampleDistance);
	Nan::SetPrototypeMethod(tpl, "setMaximumImageSampleDistance", SetMaximumImageSampleDistance);

	Nan::SetPrototypeMethod(tpl, "SetMinimumImageSampleDistance", SetMinimumImageSampleDistance);
	Nan::SetPrototypeMethod(tpl, "setMinimumImageSampleDistance", SetMinimumImageSampleDistance);

	Nan::SetPrototypeMethod(tpl, "SetNumberOfThreads", SetNumberOfThreads);
	Nan::SetPrototypeMethod(tpl, "setNumberOfThreads", SetNumberOfThreads);

	Nan::SetPrototypeMethod(tpl, "SetSampleDistance", SetSampleDistance);
	Nan::SetPrototypeMethod(tpl, "setSampleDistance", SetSampleDistance);

	Nan::SetPrototypeMethod(tpl, "SetVolumeRayCastFunction", SetVolumeRayCastFunction);
	Nan::SetPrototypeMethod(tpl, "setVolumeRayCastFunction", SetVolumeRayCastFunction);

#ifdef VTK_NODE_PLUS_VTKVOLUMERAYCASTMAPPERWRAP_INITPTPL
	VTK_NODE_PLUS_VTKVOLUMERAYCASTMAPPERWRAP_INITPTPL
#endif
	ptpl.Reset( tpl );
}

void VtkVolumeRayCastMapperWrap::New(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	if(!info.IsConstructCall())
	{
		Nan::ThrowError("Constructor not called in a construct call.");
		return;
	}

	if(info.Length() == 0)
	{
		vtkSmartPointer<vtkVolumeRayCastMapper> native = vtkSmartPointer<vtkVolumeRayCastMapper>::New();
		VtkVolumeRayCastMapperWrap* obj = new VtkVolumeRayCastMapperWrap(native);
		obj->Wrap(info.This());
	}
	else
	{
		if(info[0]->ToObject() != vtkNodeJsNoWrap )
		{
			Nan::ThrowError("Parameter Error");
			return;
		}
	}

	info.GetReturnValue().Set(info.This());
}

void VtkVolumeRayCastMapperWrap::AutoAdjustSampleDistancesOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->AutoAdjustSampleDistancesOff();
}

void VtkVolumeRayCastMapperWrap::AutoAdjustSampleDistancesOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->AutoAdjustSampleDistancesOn();
}

void VtkVolumeRayCastMapperWrap::GetAutoAdjustSampleDistances(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetAutoAdjustSampleDistances();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkVolumeRayCastMapperWrap::GetAutoAdjustSampleDistancesMaxValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetAutoAdjustSampleDistancesMaxValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkVolumeRayCastMapperWrap::GetAutoAdjustSampleDistancesMinValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetAutoAdjustSampleDistancesMinValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkVolumeRayCastMapperWrap::GetClassName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetClassName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkVolumeRayCastMapperWrap::GetGradientEstimator(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	vtkEncodedGradientEstimator * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetGradientEstimator();
	VtkEncodedGradientEstimatorWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkEncodedGradientEstimatorWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkEncodedGradientEstimatorWrap *w = new VtkEncodedGradientEstimatorWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkVolumeRayCastMapperWrap::GetGradientMagnitudeBias(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		float r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetGradientMagnitudeBias(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	float r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetGradientMagnitudeBias();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkVolumeRayCastMapperWrap::GetGradientMagnitudeScale(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		float r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetGradientMagnitudeScale(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	float r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetGradientMagnitudeScale();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkVolumeRayCastMapperWrap::GetGradientShader(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	vtkEncodedGradientShader * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetGradientShader();
	VtkEncodedGradientShaderWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkEncodedGradientShaderWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkEncodedGradientShaderWrap *w = new VtkEncodedGradientShaderWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkVolumeRayCastMapperWrap::GetImageSampleDistance(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetImageSampleDistance();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkVolumeRayCastMapperWrap::GetImageSampleDistanceMaxValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetImageSampleDistanceMaxValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkVolumeRayCastMapperWrap::GetImageSampleDistanceMinValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetImageSampleDistanceMinValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkVolumeRayCastMapperWrap::GetIntermixIntersectingGeometry(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetIntermixIntersectingGeometry();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkVolumeRayCastMapperWrap::GetIntermixIntersectingGeometryMaxValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetIntermixIntersectingGeometryMaxValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkVolumeRayCastMapperWrap::GetIntermixIntersectingGeometryMinValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetIntermixIntersectingGeometryMinValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkVolumeRayCastMapperWrap::GetMaximumImageSampleDistance(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMaximumImageSampleDistance();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkVolumeRayCastMapperWrap::GetMaximumImageSampleDistanceMaxValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMaximumImageSampleDistanceMaxValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkVolumeRayCastMapperWrap::GetMaximumImageSampleDistanceMinValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMaximumImageSampleDistanceMinValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkVolumeRayCastMapperWrap::GetMinimumImageSampleDistance(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMinimumImageSampleDistance();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkVolumeRayCastMapperWrap::GetMinimumImageSampleDistanceMaxValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMinimumImageSampleDistanceMaxValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkVolumeRayCastMapperWrap::GetMinimumImageSampleDistanceMinValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMinimumImageSampleDistanceMinValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkVolumeRayCastMapperWrap::GetNumberOfThreads(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfThreads();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkVolumeRayCastMapperWrap::GetSampleDistance(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetSampleDistance();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkVolumeRayCastMapperWrap::GetVolumeRayCastFunction(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	vtkVolumeRayCastFunction * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetVolumeRayCastFunction();
	VtkVolumeRayCastFunctionWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkVolumeRayCastFunctionWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkVolumeRayCastFunctionWrap *w = new VtkVolumeRayCastFunctionWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkVolumeRayCastMapperWrap::GetZeroOpacityThreshold(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkVolumeWrap::ptpl))->HasInstance(info[0]))
	{
		VtkVolumeWrap *a0 = ObjectWrap::Unwrap<VtkVolumeWrap>(info[0]->ToObject());
		float r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetZeroOpacityThreshold(
			(vtkVolume *) a0->native.GetPointer()
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkVolumeRayCastMapperWrap::IntermixIntersectingGeometryOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->IntermixIntersectingGeometryOff();
}

void VtkVolumeRayCastMapperWrap::IntermixIntersectingGeometryOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->IntermixIntersectingGeometryOn();
}

void VtkVolumeRayCastMapperWrap::IsA(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->IsA(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkVolumeRayCastMapperWrap::NewInstance(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	vtkVolumeRayCastMapper * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->NewInstance();
	VtkVolumeRayCastMapperWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkVolumeRayCastMapperWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkVolumeRayCastMapperWrap *w = new VtkVolumeRayCastMapperWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkVolumeRayCastMapperWrap::ReleaseGraphicsResources(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkWindowWrap::ptpl))->HasInstance(info[0]))
	{
		VtkWindowWrap *a0 = ObjectWrap::Unwrap<VtkWindowWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->ReleaseGraphicsResources(
			(vtkWindow *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkVolumeRayCastMapperWrap::Render(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkRendererWrap::ptpl))->HasInstance(info[0]))
	{
		VtkRendererWrap *a0 = ObjectWrap::Unwrap<VtkRendererWrap>(info[0]->ToObject());
		if(info.Length() > 1 && info[1]->IsObject() && (Nan::New(VtkVolumeWrap::ptpl))->HasInstance(info[1]))
		{
			VtkVolumeWrap *a1 = ObjectWrap::Unwrap<VtkVolumeWrap>(info[1]->ToObject());
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->Render(
				(vtkRenderer *) a0->native.GetPointer(),
				(vtkVolume *) a1->native.GetPointer()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkVolumeRayCastMapperWrap::SafeDownCast(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkObjectWrap::ptpl))->HasInstance(info[0]))
	{
		VtkObjectWrap *a0 = ObjectWrap::Unwrap<VtkObjectWrap>(info[0]->ToObject());
		vtkVolumeRayCastMapper * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->SafeDownCast(
			(vtkObject *) a0->native.GetPointer()
		);
		VtkVolumeRayCastMapperWrap::InitPtpl();
		v8::Local<v8::Value> argv[1] =
			{ Nan::New(vtkNodeJsNoWrap) };
		v8::Local<v8::Function> cons =
			Nan::New<v8::FunctionTemplate>(VtkVolumeRayCastMapperWrap::ptpl)->GetFunction();
		v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
		VtkVolumeRayCastMapperWrap *w = new VtkVolumeRayCastMapperWrap();
		w->native = r;
		w->Wrap(wo);
		info.GetReturnValue().Set(wo);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkVolumeRayCastMapperWrap::SetAutoAdjustSampleDistances(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetAutoAdjustSampleDistances(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkVolumeRayCastMapperWrap::SetGradientEstimator(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkEncodedGradientEstimatorWrap::ptpl))->HasInstance(info[0]))
	{
		VtkEncodedGradientEstimatorWrap *a0 = ObjectWrap::Unwrap<VtkEncodedGradientEstimatorWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetGradientEstimator(
			(vtkEncodedGradientEstimator *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkVolumeRayCastMapperWrap::SetImageSampleDistance(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetImageSampleDistance(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkVolumeRayCastMapperWrap::SetIntermixIntersectingGeometry(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetIntermixIntersectingGeometry(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkVolumeRayCastMapperWrap::SetMaximumImageSampleDistance(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetMaximumImageSampleDistance(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkVolumeRayCastMapperWrap::SetMinimumImageSampleDistance(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetMinimumImageSampleDistance(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkVolumeRayCastMapperWrap::SetNumberOfThreads(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetNumberOfThreads(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkVolumeRayCastMapperWrap::SetSampleDistance(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetSampleDistance(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkVolumeRayCastMapperWrap::SetVolumeRayCastFunction(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkVolumeRayCastMapperWrap *wrapper = ObjectWrap::Unwrap<VtkVolumeRayCastMapperWrap>(info.Holder());
	vtkVolumeRayCastMapper *native = (vtkVolumeRayCastMapper *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkVolumeRayCastFunctionWrap::ptpl))->HasInstance(info[0]))
	{
		VtkVolumeRayCastFunctionWrap *a0 = ObjectWrap::Unwrap<VtkVolumeRayCastFunctionWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetVolumeRayCastFunction(
			(vtkVolumeRayCastFunction *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}