/* 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 "vtkViewportWrap.h"
#include "vtkRendererWrap.h"
#include "vtkObjectBaseWrap.h"
#include "vtkPropWrap.h"
#include "vtkLightWrap.h"
#include "vtkLightCollectionWrap.h"
#include "vtkVolumeCollectionWrap.h"
#include "vtkActorCollectionWrap.h"
#include "vtkCameraWrap.h"
#include "vtkPropCollectionWrap.h"
#include "vtkCullerWrap.h"
#include "vtkCullerCollectionWrap.h"
#include "vtkRenderWindowWrap.h"
#include "vtkWindowWrap.h"
#include "vtkAssemblyPathWrap.h"
#include "vtkRendererDelegateWrap.h"
#include "vtkHardwareSelectorWrap.h"
#include "vtkTextureWrap.h"
#include "vtkFXAAOptionsWrap.h"
#include "vtkRenderPassWrap.h"
#include "vtkInformationWrap.h"
#include "../../plus/plus.h"

using namespace v8;

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

VtkRendererWrap::VtkRendererWrap()
{ }

VtkRendererWrap::VtkRendererWrap(vtkSmartPointer<vtkRenderer> _native)
{ native = _native; }

VtkRendererWrap::~VtkRendererWrap()
{ }

void VtkRendererWrap::Init(v8::Local<v8::Object> exports)
{
	Nan::SetAccessor(exports, Nan::New("vtkRenderer").ToLocalChecked(), ConstructorGetter);
	Nan::SetAccessor(exports, Nan::New("Renderer").ToLocalChecked(), ConstructorGetter);
}

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

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

	Nan::SetPrototypeMethod(tpl, "AddActor", AddActor);
	Nan::SetPrototypeMethod(tpl, "addActor", AddActor);

	Nan::SetPrototypeMethod(tpl, "AddCuller", AddCuller);
	Nan::SetPrototypeMethod(tpl, "addCuller", AddCuller);

	Nan::SetPrototypeMethod(tpl, "AddLight", AddLight);
	Nan::SetPrototypeMethod(tpl, "addLight", AddLight);

	Nan::SetPrototypeMethod(tpl, "AddVolume", AddVolume);
	Nan::SetPrototypeMethod(tpl, "addVolume", AddVolume);

	Nan::SetPrototypeMethod(tpl, "AutomaticLightCreationOff", AutomaticLightCreationOff);
	Nan::SetPrototypeMethod(tpl, "automaticLightCreationOff", AutomaticLightCreationOff);

	Nan::SetPrototypeMethod(tpl, "AutomaticLightCreationOn", AutomaticLightCreationOn);
	Nan::SetPrototypeMethod(tpl, "automaticLightCreationOn", AutomaticLightCreationOn);

	Nan::SetPrototypeMethod(tpl, "BackingStoreOff", BackingStoreOff);
	Nan::SetPrototypeMethod(tpl, "backingStoreOff", BackingStoreOff);

	Nan::SetPrototypeMethod(tpl, "BackingStoreOn", BackingStoreOn);
	Nan::SetPrototypeMethod(tpl, "backingStoreOn", BackingStoreOn);

	Nan::SetPrototypeMethod(tpl, "CaptureGL2PSSpecialProp", CaptureGL2PSSpecialProp);
	Nan::SetPrototypeMethod(tpl, "captureGL2PSSpecialProp", CaptureGL2PSSpecialProp);

	Nan::SetPrototypeMethod(tpl, "Clear", Clear);
	Nan::SetPrototypeMethod(tpl, "clear", Clear);

	Nan::SetPrototypeMethod(tpl, "ClearLights", ClearLights);
	Nan::SetPrototypeMethod(tpl, "clearLights", ClearLights);

	Nan::SetPrototypeMethod(tpl, "ComputeVisiblePropBounds", ComputeVisiblePropBounds);
	Nan::SetPrototypeMethod(tpl, "computeVisiblePropBounds", ComputeVisiblePropBounds);

	Nan::SetPrototypeMethod(tpl, "CreateLight", CreateLight);
	Nan::SetPrototypeMethod(tpl, "createLight", CreateLight);

	Nan::SetPrototypeMethod(tpl, "DeviceRenderOpaqueGeometry", DeviceRenderOpaqueGeometry);
	Nan::SetPrototypeMethod(tpl, "deviceRenderOpaqueGeometry", DeviceRenderOpaqueGeometry);

	Nan::SetPrototypeMethod(tpl, "DeviceRenderTranslucentPolygonalGeometry", DeviceRenderTranslucentPolygonalGeometry);
	Nan::SetPrototypeMethod(tpl, "deviceRenderTranslucentPolygonalGeometry", DeviceRenderTranslucentPolygonalGeometry);

	Nan::SetPrototypeMethod(tpl, "DrawOff", DrawOff);
	Nan::SetPrototypeMethod(tpl, "drawOff", DrawOff);

	Nan::SetPrototypeMethod(tpl, "DrawOn", DrawOn);
	Nan::SetPrototypeMethod(tpl, "drawOn", DrawOn);

	Nan::SetPrototypeMethod(tpl, "EraseOff", EraseOff);
	Nan::SetPrototypeMethod(tpl, "eraseOff", EraseOff);

	Nan::SetPrototypeMethod(tpl, "EraseOn", EraseOn);
	Nan::SetPrototypeMethod(tpl, "eraseOn", EraseOn);

	Nan::SetPrototypeMethod(tpl, "GetActiveCamera", GetActiveCamera);
	Nan::SetPrototypeMethod(tpl, "getActiveCamera", GetActiveCamera);

	Nan::SetPrototypeMethod(tpl, "GetActors", GetActors);
	Nan::SetPrototypeMethod(tpl, "getActors", GetActors);

	Nan::SetPrototypeMethod(tpl, "GetAllocatedRenderTime", GetAllocatedRenderTime);
	Nan::SetPrototypeMethod(tpl, "getAllocatedRenderTime", GetAllocatedRenderTime);

	Nan::SetPrototypeMethod(tpl, "GetAmbient", GetAmbient);
	Nan::SetPrototypeMethod(tpl, "getAmbient", GetAmbient);

	Nan::SetPrototypeMethod(tpl, "GetAutomaticLightCreation", GetAutomaticLightCreation);
	Nan::SetPrototypeMethod(tpl, "getAutomaticLightCreation", GetAutomaticLightCreation);

	Nan::SetPrototypeMethod(tpl, "GetBackgroundTexture", GetBackgroundTexture);
	Nan::SetPrototypeMethod(tpl, "getBackgroundTexture", GetBackgroundTexture);

	Nan::SetPrototypeMethod(tpl, "GetBackingStore", GetBackingStore);
	Nan::SetPrototypeMethod(tpl, "getBackingStore", GetBackingStore);

	Nan::SetPrototypeMethod(tpl, "GetClippingRangeExpansion", GetClippingRangeExpansion);
	Nan::SetPrototypeMethod(tpl, "getClippingRangeExpansion", GetClippingRangeExpansion);

	Nan::SetPrototypeMethod(tpl, "GetClippingRangeExpansionMaxValue", GetClippingRangeExpansionMaxValue);
	Nan::SetPrototypeMethod(tpl, "getClippingRangeExpansionMaxValue", GetClippingRangeExpansionMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetClippingRangeExpansionMinValue", GetClippingRangeExpansionMinValue);
	Nan::SetPrototypeMethod(tpl, "getClippingRangeExpansionMinValue", GetClippingRangeExpansionMinValue);

	Nan::SetPrototypeMethod(tpl, "GetCullers", GetCullers);
	Nan::SetPrototypeMethod(tpl, "getCullers", GetCullers);

	Nan::SetPrototypeMethod(tpl, "GetDelegate", GetDelegate);
	Nan::SetPrototypeMethod(tpl, "getDelegate", GetDelegate);

	Nan::SetPrototypeMethod(tpl, "GetDraw", GetDraw);
	Nan::SetPrototypeMethod(tpl, "getDraw", GetDraw);

	Nan::SetPrototypeMethod(tpl, "GetErase", GetErase);
	Nan::SetPrototypeMethod(tpl, "getErase", GetErase);

	Nan::SetPrototypeMethod(tpl, "GetFXAAOptions", GetFXAAOptions);
	Nan::SetPrototypeMethod(tpl, "getFXAAOptions", GetFXAAOptions);

	Nan::SetPrototypeMethod(tpl, "GetInformation", GetInformation);
	Nan::SetPrototypeMethod(tpl, "getInformation", GetInformation);

	Nan::SetPrototypeMethod(tpl, "GetInteractive", GetInteractive);
	Nan::SetPrototypeMethod(tpl, "getInteractive", GetInteractive);

	Nan::SetPrototypeMethod(tpl, "GetLastRenderTimeInSeconds", GetLastRenderTimeInSeconds);
	Nan::SetPrototypeMethod(tpl, "getLastRenderTimeInSeconds", GetLastRenderTimeInSeconds);

	Nan::SetPrototypeMethod(tpl, "GetLastRenderingUsedDepthPeeling", GetLastRenderingUsedDepthPeeling);
	Nan::SetPrototypeMethod(tpl, "getLastRenderingUsedDepthPeeling", GetLastRenderingUsedDepthPeeling);

	Nan::SetPrototypeMethod(tpl, "GetLayer", GetLayer);
	Nan::SetPrototypeMethod(tpl, "getLayer", GetLayer);

	Nan::SetPrototypeMethod(tpl, "GetLightFollowCamera", GetLightFollowCamera);
	Nan::SetPrototypeMethod(tpl, "getLightFollowCamera", GetLightFollowCamera);

	Nan::SetPrototypeMethod(tpl, "GetLights", GetLights);
	Nan::SetPrototypeMethod(tpl, "getLights", GetLights);

	Nan::SetPrototypeMethod(tpl, "GetMaximumNumberOfPeels", GetMaximumNumberOfPeels);
	Nan::SetPrototypeMethod(tpl, "getMaximumNumberOfPeels", GetMaximumNumberOfPeels);

	Nan::SetPrototypeMethod(tpl, "GetNearClippingPlaneTolerance", GetNearClippingPlaneTolerance);
	Nan::SetPrototypeMethod(tpl, "getNearClippingPlaneTolerance", GetNearClippingPlaneTolerance);

	Nan::SetPrototypeMethod(tpl, "GetNearClippingPlaneToleranceMaxValue", GetNearClippingPlaneToleranceMaxValue);
	Nan::SetPrototypeMethod(tpl, "getNearClippingPlaneToleranceMaxValue", GetNearClippingPlaneToleranceMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetNearClippingPlaneToleranceMinValue", GetNearClippingPlaneToleranceMinValue);
	Nan::SetPrototypeMethod(tpl, "getNearClippingPlaneToleranceMinValue", GetNearClippingPlaneToleranceMinValue);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfPropsRendered", GetNumberOfPropsRendered);
	Nan::SetPrototypeMethod(tpl, "getNumberOfPropsRendered", GetNumberOfPropsRendered);

	Nan::SetPrototypeMethod(tpl, "GetOcclusionRatio", GetOcclusionRatio);
	Nan::SetPrototypeMethod(tpl, "getOcclusionRatio", GetOcclusionRatio);

	Nan::SetPrototypeMethod(tpl, "GetOcclusionRatioMaxValue", GetOcclusionRatioMaxValue);
	Nan::SetPrototypeMethod(tpl, "getOcclusionRatioMaxValue", GetOcclusionRatioMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetOcclusionRatioMinValue", GetOcclusionRatioMinValue);
	Nan::SetPrototypeMethod(tpl, "getOcclusionRatioMinValue", GetOcclusionRatioMinValue);

	Nan::SetPrototypeMethod(tpl, "GetPass", GetPass);
	Nan::SetPrototypeMethod(tpl, "getPass", GetPass);

	Nan::SetPrototypeMethod(tpl, "GetPreserveColorBuffer", GetPreserveColorBuffer);
	Nan::SetPrototypeMethod(tpl, "getPreserveColorBuffer", GetPreserveColorBuffer);

	Nan::SetPrototypeMethod(tpl, "GetPreserveDepthBuffer", GetPreserveDepthBuffer);
	Nan::SetPrototypeMethod(tpl, "getPreserveDepthBuffer", GetPreserveDepthBuffer);

	Nan::SetPrototypeMethod(tpl, "GetRenderWindow", GetRenderWindow);
	Nan::SetPrototypeMethod(tpl, "getRenderWindow", GetRenderWindow);

	Nan::SetPrototypeMethod(tpl, "GetSelector", GetSelector);
	Nan::SetPrototypeMethod(tpl, "getSelector", GetSelector);

	Nan::SetPrototypeMethod(tpl, "GetTexturedBackground", GetTexturedBackground);
	Nan::SetPrototypeMethod(tpl, "getTexturedBackground", GetTexturedBackground);

	Nan::SetPrototypeMethod(tpl, "GetTiledAspectRatio", GetTiledAspectRatio);
	Nan::SetPrototypeMethod(tpl, "getTiledAspectRatio", GetTiledAspectRatio);

	Nan::SetPrototypeMethod(tpl, "GetTimeFactor", GetTimeFactor);
	Nan::SetPrototypeMethod(tpl, "getTimeFactor", GetTimeFactor);

	Nan::SetPrototypeMethod(tpl, "GetTwoSidedLighting", GetTwoSidedLighting);
	Nan::SetPrototypeMethod(tpl, "getTwoSidedLighting", GetTwoSidedLighting);

	Nan::SetPrototypeMethod(tpl, "GetUseDepthPeeling", GetUseDepthPeeling);
	Nan::SetPrototypeMethod(tpl, "getUseDepthPeeling", GetUseDepthPeeling);

	Nan::SetPrototypeMethod(tpl, "GetUseDepthPeelingForVolumes", GetUseDepthPeelingForVolumes);
	Nan::SetPrototypeMethod(tpl, "getUseDepthPeelingForVolumes", GetUseDepthPeelingForVolumes);

	Nan::SetPrototypeMethod(tpl, "GetUseFXAA", GetUseFXAA);
	Nan::SetPrototypeMethod(tpl, "getUseFXAA", GetUseFXAA);

	Nan::SetPrototypeMethod(tpl, "GetUseHiddenLineRemoval", GetUseHiddenLineRemoval);
	Nan::SetPrototypeMethod(tpl, "getUseHiddenLineRemoval", GetUseHiddenLineRemoval);

	Nan::SetPrototypeMethod(tpl, "GetUseShadows", GetUseShadows);
	Nan::SetPrototypeMethod(tpl, "getUseShadows", GetUseShadows);

	Nan::SetPrototypeMethod(tpl, "GetVTKWindow", GetVTKWindow);
	Nan::SetPrototypeMethod(tpl, "getVTKWindow", GetVTKWindow);

	Nan::SetPrototypeMethod(tpl, "GetVolumes", GetVolumes);
	Nan::SetPrototypeMethod(tpl, "getVolumes", GetVolumes);

	Nan::SetPrototypeMethod(tpl, "GetZ", GetZ);
	Nan::SetPrototypeMethod(tpl, "getZ", GetZ);

	Nan::SetPrototypeMethod(tpl, "InteractiveOff", InteractiveOff);
	Nan::SetPrototypeMethod(tpl, "interactiveOff", InteractiveOff);

	Nan::SetPrototypeMethod(tpl, "InteractiveOn", InteractiveOn);
	Nan::SetPrototypeMethod(tpl, "interactiveOn", InteractiveOn);

	Nan::SetPrototypeMethod(tpl, "IsActiveCameraCreated", IsActiveCameraCreated);
	Nan::SetPrototypeMethod(tpl, "isActiveCameraCreated", IsActiveCameraCreated);

	Nan::SetPrototypeMethod(tpl, "LightFollowCameraOff", LightFollowCameraOff);
	Nan::SetPrototypeMethod(tpl, "lightFollowCameraOff", LightFollowCameraOff);

	Nan::SetPrototypeMethod(tpl, "LightFollowCameraOn", LightFollowCameraOn);
	Nan::SetPrototypeMethod(tpl, "lightFollowCameraOn", LightFollowCameraOn);

	Nan::SetPrototypeMethod(tpl, "MakeCamera", MakeCamera);
	Nan::SetPrototypeMethod(tpl, "makeCamera", MakeCamera);

	Nan::SetPrototypeMethod(tpl, "MakeLight", MakeLight);
	Nan::SetPrototypeMethod(tpl, "makeLight", MakeLight);

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

	Nan::SetPrototypeMethod(tpl, "PickProp", PickProp);
	Nan::SetPrototypeMethod(tpl, "pickProp", PickProp);

	Nan::SetPrototypeMethod(tpl, "PreserveColorBufferOff", PreserveColorBufferOff);
	Nan::SetPrototypeMethod(tpl, "preserveColorBufferOff", PreserveColorBufferOff);

	Nan::SetPrototypeMethod(tpl, "PreserveColorBufferOn", PreserveColorBufferOn);
	Nan::SetPrototypeMethod(tpl, "preserveColorBufferOn", PreserveColorBufferOn);

	Nan::SetPrototypeMethod(tpl, "PreserveDepthBufferOff", PreserveDepthBufferOff);
	Nan::SetPrototypeMethod(tpl, "preserveDepthBufferOff", PreserveDepthBufferOff);

	Nan::SetPrototypeMethod(tpl, "PreserveDepthBufferOn", PreserveDepthBufferOn);
	Nan::SetPrototypeMethod(tpl, "preserveDepthBufferOn", PreserveDepthBufferOn);

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

	Nan::SetPrototypeMethod(tpl, "RemoveActor", RemoveActor);
	Nan::SetPrototypeMethod(tpl, "removeActor", RemoveActor);

	Nan::SetPrototypeMethod(tpl, "RemoveAllLights", RemoveAllLights);
	Nan::SetPrototypeMethod(tpl, "removeAllLights", RemoveAllLights);

	Nan::SetPrototypeMethod(tpl, "RemoveCuller", RemoveCuller);
	Nan::SetPrototypeMethod(tpl, "removeCuller", RemoveCuller);

	Nan::SetPrototypeMethod(tpl, "RemoveLight", RemoveLight);
	Nan::SetPrototypeMethod(tpl, "removeLight", RemoveLight);

	Nan::SetPrototypeMethod(tpl, "RemoveVolume", RemoveVolume);
	Nan::SetPrototypeMethod(tpl, "removeVolume", RemoveVolume);

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

	Nan::SetPrototypeMethod(tpl, "ResetCamera", ResetCamera);
	Nan::SetPrototypeMethod(tpl, "resetCamera", ResetCamera);

	Nan::SetPrototypeMethod(tpl, "ResetCameraClippingRange", ResetCameraClippingRange);
	Nan::SetPrototypeMethod(tpl, "resetCameraClippingRange", ResetCameraClippingRange);

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

	Nan::SetPrototypeMethod(tpl, "SetActiveCamera", SetActiveCamera);
	Nan::SetPrototypeMethod(tpl, "setActiveCamera", SetActiveCamera);

	Nan::SetPrototypeMethod(tpl, "SetAllocatedRenderTime", SetAllocatedRenderTime);
	Nan::SetPrototypeMethod(tpl, "setAllocatedRenderTime", SetAllocatedRenderTime);

	Nan::SetPrototypeMethod(tpl, "SetAmbient", SetAmbient);
	Nan::SetPrototypeMethod(tpl, "setAmbient", SetAmbient);

	Nan::SetPrototypeMethod(tpl, "SetAutomaticLightCreation", SetAutomaticLightCreation);
	Nan::SetPrototypeMethod(tpl, "setAutomaticLightCreation", SetAutomaticLightCreation);

	Nan::SetPrototypeMethod(tpl, "SetBackgroundTexture", SetBackgroundTexture);
	Nan::SetPrototypeMethod(tpl, "setBackgroundTexture", SetBackgroundTexture);

	Nan::SetPrototypeMethod(tpl, "SetBackingStore", SetBackingStore);
	Nan::SetPrototypeMethod(tpl, "setBackingStore", SetBackingStore);

	Nan::SetPrototypeMethod(tpl, "SetClippingRangeExpansion", SetClippingRangeExpansion);
	Nan::SetPrototypeMethod(tpl, "setClippingRangeExpansion", SetClippingRangeExpansion);

	Nan::SetPrototypeMethod(tpl, "SetDelegate", SetDelegate);
	Nan::SetPrototypeMethod(tpl, "setDelegate", SetDelegate);

	Nan::SetPrototypeMethod(tpl, "SetDraw", SetDraw);
	Nan::SetPrototypeMethod(tpl, "setDraw", SetDraw);

	Nan::SetPrototypeMethod(tpl, "SetErase", SetErase);
	Nan::SetPrototypeMethod(tpl, "setErase", SetErase);

	Nan::SetPrototypeMethod(tpl, "SetFXAAOptions", SetFXAAOptions);
	Nan::SetPrototypeMethod(tpl, "setFXAAOptions", SetFXAAOptions);

	Nan::SetPrototypeMethod(tpl, "SetGL2PSSpecialPropCollection", SetGL2PSSpecialPropCollection);
	Nan::SetPrototypeMethod(tpl, "setGL2PSSpecialPropCollection", SetGL2PSSpecialPropCollection);

	Nan::SetPrototypeMethod(tpl, "SetInformation", SetInformation);
	Nan::SetPrototypeMethod(tpl, "setInformation", SetInformation);

	Nan::SetPrototypeMethod(tpl, "SetInteractive", SetInteractive);
	Nan::SetPrototypeMethod(tpl, "setInteractive", SetInteractive);

	Nan::SetPrototypeMethod(tpl, "SetLayer", SetLayer);
	Nan::SetPrototypeMethod(tpl, "setLayer", SetLayer);

	Nan::SetPrototypeMethod(tpl, "SetLightCollection", SetLightCollection);
	Nan::SetPrototypeMethod(tpl, "setLightCollection", SetLightCollection);

	Nan::SetPrototypeMethod(tpl, "SetLightFollowCamera", SetLightFollowCamera);
	Nan::SetPrototypeMethod(tpl, "setLightFollowCamera", SetLightFollowCamera);

	Nan::SetPrototypeMethod(tpl, "SetMaximumNumberOfPeels", SetMaximumNumberOfPeels);
	Nan::SetPrototypeMethod(tpl, "setMaximumNumberOfPeels", SetMaximumNumberOfPeels);

	Nan::SetPrototypeMethod(tpl, "SetNearClippingPlaneTolerance", SetNearClippingPlaneTolerance);
	Nan::SetPrototypeMethod(tpl, "setNearClippingPlaneTolerance", SetNearClippingPlaneTolerance);

	Nan::SetPrototypeMethod(tpl, "SetOcclusionRatio", SetOcclusionRatio);
	Nan::SetPrototypeMethod(tpl, "setOcclusionRatio", SetOcclusionRatio);

	Nan::SetPrototypeMethod(tpl, "SetPass", SetPass);
	Nan::SetPrototypeMethod(tpl, "setPass", SetPass);

	Nan::SetPrototypeMethod(tpl, "SetPreserveColorBuffer", SetPreserveColorBuffer);
	Nan::SetPrototypeMethod(tpl, "setPreserveColorBuffer", SetPreserveColorBuffer);

	Nan::SetPrototypeMethod(tpl, "SetPreserveDepthBuffer", SetPreserveDepthBuffer);
	Nan::SetPrototypeMethod(tpl, "setPreserveDepthBuffer", SetPreserveDepthBuffer);

	Nan::SetPrototypeMethod(tpl, "SetRenderWindow", SetRenderWindow);
	Nan::SetPrototypeMethod(tpl, "setRenderWindow", SetRenderWindow);

	Nan::SetPrototypeMethod(tpl, "SetTexturedBackground", SetTexturedBackground);
	Nan::SetPrototypeMethod(tpl, "setTexturedBackground", SetTexturedBackground);

	Nan::SetPrototypeMethod(tpl, "SetTwoSidedLighting", SetTwoSidedLighting);
	Nan::SetPrototypeMethod(tpl, "setTwoSidedLighting", SetTwoSidedLighting);

	Nan::SetPrototypeMethod(tpl, "SetUseDepthPeeling", SetUseDepthPeeling);
	Nan::SetPrototypeMethod(tpl, "setUseDepthPeeling", SetUseDepthPeeling);

	Nan::SetPrototypeMethod(tpl, "SetUseDepthPeelingForVolumes", SetUseDepthPeelingForVolumes);
	Nan::SetPrototypeMethod(tpl, "setUseDepthPeelingForVolumes", SetUseDepthPeelingForVolumes);

	Nan::SetPrototypeMethod(tpl, "SetUseFXAA", SetUseFXAA);
	Nan::SetPrototypeMethod(tpl, "setUseFXAA", SetUseFXAA);

	Nan::SetPrototypeMethod(tpl, "SetUseHiddenLineRemoval", SetUseHiddenLineRemoval);
	Nan::SetPrototypeMethod(tpl, "setUseHiddenLineRemoval", SetUseHiddenLineRemoval);

	Nan::SetPrototypeMethod(tpl, "SetUseShadows", SetUseShadows);
	Nan::SetPrototypeMethod(tpl, "setUseShadows", SetUseShadows);

	Nan::SetPrototypeMethod(tpl, "StereoMidpoint", StereoMidpoint);
	Nan::SetPrototypeMethod(tpl, "stereoMidpoint", StereoMidpoint);

	Nan::SetPrototypeMethod(tpl, "TexturedBackgroundOff", TexturedBackgroundOff);
	Nan::SetPrototypeMethod(tpl, "texturedBackgroundOff", TexturedBackgroundOff);

	Nan::SetPrototypeMethod(tpl, "TexturedBackgroundOn", TexturedBackgroundOn);
	Nan::SetPrototypeMethod(tpl, "texturedBackgroundOn", TexturedBackgroundOn);

	Nan::SetPrototypeMethod(tpl, "Transparent", Transparent);
	Nan::SetPrototypeMethod(tpl, "transparent", Transparent);

	Nan::SetPrototypeMethod(tpl, "TwoSidedLightingOff", TwoSidedLightingOff);
	Nan::SetPrototypeMethod(tpl, "twoSidedLightingOff", TwoSidedLightingOff);

	Nan::SetPrototypeMethod(tpl, "TwoSidedLightingOn", TwoSidedLightingOn);
	Nan::SetPrototypeMethod(tpl, "twoSidedLightingOn", TwoSidedLightingOn);

	Nan::SetPrototypeMethod(tpl, "UpdateLightsGeometryToFollowCamera", UpdateLightsGeometryToFollowCamera);
	Nan::SetPrototypeMethod(tpl, "updateLightsGeometryToFollowCamera", UpdateLightsGeometryToFollowCamera);

	Nan::SetPrototypeMethod(tpl, "UseDepthPeelingForVolumesOff", UseDepthPeelingForVolumesOff);
	Nan::SetPrototypeMethod(tpl, "useDepthPeelingForVolumesOff", UseDepthPeelingForVolumesOff);

	Nan::SetPrototypeMethod(tpl, "UseDepthPeelingForVolumesOn", UseDepthPeelingForVolumesOn);
	Nan::SetPrototypeMethod(tpl, "useDepthPeelingForVolumesOn", UseDepthPeelingForVolumesOn);

	Nan::SetPrototypeMethod(tpl, "UseDepthPeelingOff", UseDepthPeelingOff);
	Nan::SetPrototypeMethod(tpl, "useDepthPeelingOff", UseDepthPeelingOff);

	Nan::SetPrototypeMethod(tpl, "UseDepthPeelingOn", UseDepthPeelingOn);
	Nan::SetPrototypeMethod(tpl, "useDepthPeelingOn", UseDepthPeelingOn);

	Nan::SetPrototypeMethod(tpl, "UseFXAAOff", UseFXAAOff);
	Nan::SetPrototypeMethod(tpl, "useFXAAOff", UseFXAAOff);

	Nan::SetPrototypeMethod(tpl, "UseFXAAOn", UseFXAAOn);
	Nan::SetPrototypeMethod(tpl, "useFXAAOn", UseFXAAOn);

	Nan::SetPrototypeMethod(tpl, "UseHiddenLineRemovalOff", UseHiddenLineRemovalOff);
	Nan::SetPrototypeMethod(tpl, "useHiddenLineRemovalOff", UseHiddenLineRemovalOff);

	Nan::SetPrototypeMethod(tpl, "UseHiddenLineRemovalOn", UseHiddenLineRemovalOn);
	Nan::SetPrototypeMethod(tpl, "useHiddenLineRemovalOn", UseHiddenLineRemovalOn);

	Nan::SetPrototypeMethod(tpl, "UseShadowsOff", UseShadowsOff);
	Nan::SetPrototypeMethod(tpl, "useShadowsOff", UseShadowsOff);

	Nan::SetPrototypeMethod(tpl, "UseShadowsOn", UseShadowsOn);
	Nan::SetPrototypeMethod(tpl, "useShadowsOn", UseShadowsOn);

	Nan::SetPrototypeMethod(tpl, "ViewToWorld", ViewToWorld);
	Nan::SetPrototypeMethod(tpl, "viewToWorld", ViewToWorld);

	Nan::SetPrototypeMethod(tpl, "VisibleActorCount", VisibleActorCount);
	Nan::SetPrototypeMethod(tpl, "visibleActorCount", VisibleActorCount);

	Nan::SetPrototypeMethod(tpl, "VisibleVolumeCount", VisibleVolumeCount);
	Nan::SetPrototypeMethod(tpl, "visibleVolumeCount", VisibleVolumeCount);

	Nan::SetPrototypeMethod(tpl, "WorldToView", WorldToView);
	Nan::SetPrototypeMethod(tpl, "worldToView", WorldToView);

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

void VtkRendererWrap::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<vtkRenderer> native = vtkSmartPointer<vtkRenderer>::New();
		VtkRendererWrap* obj = new VtkRendererWrap(native);
		obj->Wrap(info.This());
	}
	else
	{
		if(info[0]->ToObject() != vtkNodeJsNoWrap )
		{
			Nan::ThrowError("Parameter Error");
			return;
		}
	}

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

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

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

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

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

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

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

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

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

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

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

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

void VtkRendererWrap::ComputeVisiblePropBounds(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRendererWrap *wrapper = ObjectWrap::Unwrap<VtkRendererWrap>(info.Holder());
	vtkRenderer *native = (vtkRenderer *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsFloat64Array())
	{
		v8::Local<v8::Float64Array>a0(v8::Local<v8::Float64Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 6 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->ComputeVisiblePropBounds(
			(double *)(a0->Buffer()->GetContents().Data())
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsArray())
	{
		v8::Local<v8::Array>a0(v8::Local<v8::Array>::Cast(info[0]->ToObject()));
		double b0[6];
		if( a0->Length() < 6 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 6; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->ComputeVisiblePropBounds(
			b0
		);
		return;
	}
	double const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->ComputeVisiblePropBounds();
	Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), 6 * sizeof(double));
	Local<v8::Float64Array> at = v8::Float64Array::New(ab, 0, 6);
	memcpy(ab->GetContents().Data(), r, 6 * sizeof(double));
	info.GetReturnValue().Set(at);
}

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

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

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

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

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

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

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

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

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

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

void VtkRendererWrap::GetAmbient(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRendererWrap *wrapper = ObjectWrap::Unwrap<VtkRendererWrap>(info.Holder());
	vtkRenderer *native = (vtkRenderer *)wrapper->native.GetPointer();
	double const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetAmbient();
	Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), 3 * sizeof(double));
	Local<v8::Float64Array> at = v8::Float64Array::New(ab, 0, 3);
	memcpy(ab->GetContents().Data(), r, 3 * sizeof(double));
	info.GetReturnValue().Set(at);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkRendererWrap::GetZ(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRendererWrap *wrapper = ObjectWrap::Unwrap<VtkRendererWrap>(info.Holder());
	vtkRenderer *native = (vtkRenderer *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		if(info.Length() > 1 && info[1]->IsInt32())
		{
			double r;
			if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			r = native->GetZ(
				info[0]->Int32Value(),
				info[1]->Int32Value()
			);
			info.GetReturnValue().Set(Nan::New(r));
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

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

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

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

void VtkRendererWrap::ReleaseGraphicsResources(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRendererWrap *wrapper = ObjectWrap::Unwrap<VtkRendererWrap>(info.Holder());
	vtkRenderer *native = (vtkRenderer *)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 VtkRendererWrap::RemoveActor(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRendererWrap *wrapper = ObjectWrap::Unwrap<VtkRendererWrap>(info.Holder());
	vtkRenderer *native = (vtkRenderer *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkPropWrap::ptpl))->HasInstance(info[0]))
	{
		VtkPropWrap *a0 = ObjectWrap::Unwrap<VtkPropWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->RemoveActor(
			(vtkProp *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

void VtkRendererWrap::ResetCamera(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRendererWrap *wrapper = ObjectWrap::Unwrap<VtkRendererWrap>(info.Holder());
	vtkRenderer *native = (vtkRenderer *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsFloat64Array())
	{
		v8::Local<v8::Float64Array>a0(v8::Local<v8::Float64Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 6 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->ResetCamera(
			(double *)(a0->Buffer()->GetContents().Data())
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsArray())
	{
		v8::Local<v8::Array>a0(v8::Local<v8::Array>::Cast(info[0]->ToObject()));
		double b0[6];
		if( a0->Length() < 6 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 6; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->ResetCamera(
			b0
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsNumber())
	{
		if(info.Length() > 1 && info[1]->IsNumber())
		{
			if(info.Length() > 2 && info[2]->IsNumber())
			{
				if(info.Length() > 3 && info[3]->IsNumber())
				{
					if(info.Length() > 4 && info[4]->IsNumber())
					{
						if(info.Length() > 5 && info[5]->IsNumber())
						{
														if(info.Length() != 6)
							{
								Nan::ThrowError("Too many parameters.");
								return;
							}
							native->ResetCamera(
								info[0]->NumberValue(),
								info[1]->NumberValue(),
								info[2]->NumberValue(),
								info[3]->NumberValue(),
								info[4]->NumberValue(),
								info[5]->NumberValue()
							);
							return;
						}
					}
				}
			}
		}
	}
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->ResetCamera();
}

void VtkRendererWrap::ResetCameraClippingRange(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRendererWrap *wrapper = ObjectWrap::Unwrap<VtkRendererWrap>(info.Holder());
	vtkRenderer *native = (vtkRenderer *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsFloat64Array())
	{
		v8::Local<v8::Float64Array>a0(v8::Local<v8::Float64Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 6 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->ResetCameraClippingRange(
			(double *)(a0->Buffer()->GetContents().Data())
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsArray())
	{
		v8::Local<v8::Array>a0(v8::Local<v8::Array>::Cast(info[0]->ToObject()));
		double b0[6];
		if( a0->Length() < 6 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 6; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->ResetCameraClippingRange(
			b0
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsNumber())
	{
		if(info.Length() > 1 && info[1]->IsNumber())
		{
			if(info.Length() > 2 && info[2]->IsNumber())
			{
				if(info.Length() > 3 && info[3]->IsNumber())
				{
					if(info.Length() > 4 && info[4]->IsNumber())
					{
						if(info.Length() > 5 && info[5]->IsNumber())
						{
														if(info.Length() != 6)
							{
								Nan::ThrowError("Too many parameters.");
								return;
							}
							native->ResetCameraClippingRange(
								info[0]->NumberValue(),
								info[1]->NumberValue(),
								info[2]->NumberValue(),
								info[3]->NumberValue(),
								info[4]->NumberValue(),
								info[5]->NumberValue()
							);
							return;
						}
					}
				}
			}
		}
	}
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->ResetCameraClippingRange();
}

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

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

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

void VtkRendererWrap::SetAmbient(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkRendererWrap *wrapper = ObjectWrap::Unwrap<VtkRendererWrap>(info.Holder());
	vtkRenderer *native = (vtkRenderer *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsFloat64Array())
	{
		v8::Local<v8::Float64Array>a0(v8::Local<v8::Float64Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 3 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetAmbient(
			(double *)(a0->Buffer()->GetContents().Data())
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsArray())
	{
		v8::Local<v8::Array>a0(v8::Local<v8::Array>::Cast(info[0]->ToObject()));
		double b0[3];
		if( a0->Length() < 3 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 3; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetAmbient(
			b0
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsNumber())
	{
		if(info.Length() > 1 && info[1]->IsNumber())
		{
			if(info.Length() > 2 && info[2]->IsNumber())
			{
								if(info.Length() != 3)
				{
					Nan::ThrowError("Too many parameters.");
					return;
				}
				native->SetAmbient(
					info[0]->NumberValue(),
					info[1]->NumberValue(),
					info[2]->NumberValue()
				);
				return;
			}
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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