Merged changes in the trunk up to revision 47977.
authorTamito Kajiyama <rd6t-kjym@asahi-net.or.jp>
Fri, 15 Jun 2012 22:18:25 +0000 (22:18 +0000)
committerTamito Kajiyama <rd6t-kjym@asahi-net.or.jp>
Fri, 15 Jun 2012 22:18:25 +0000 (22:18 +0000)
771 files changed:
CMakeLists.txt
doc/python_api/rst/bge.types.rst
doc/python_api/sphinx_doc_gen.py
doc/python_api/sphinx_doc_gen.sh
extern/libmv/libmv-capi.cpp
extern/libmv/libmv-capi.h
extern/libmv/libmv/tracking/track_region.cc
extern/libmv/libmv/tracking/track_region.h
extern/libmv/third_party/ceres/CMakeLists.txt
extern/libmv/third_party/ceres/SConscript
extern/libmv/third_party/ceres/bundle.sh [changed mode: 0644->0755]
extern/libmv/third_party/ceres/internal/ceres/collections_port.h
extern/libmv/third_party/ceres/patches/collections_port.h.mingw.patch [new file with mode: 0644]
extern/recastnavigation/Recast/Include/RecastAssert.h
intern/cycles/blender/addon/properties.py
intern/cycles/blender/addon/ui.py
intern/cycles/blender/blender_camera.cpp
intern/cycles/blender/blender_object.cpp
intern/cycles/blender/blender_shader.cpp
intern/cycles/blender/blender_sync.cpp
intern/cycles/kernel/kernel_emission.h
intern/cycles/kernel/kernel_light.h
intern/cycles/kernel/kernel_path.h
intern/cycles/kernel/kernel_shader.h
intern/cycles/kernel/kernel_types.h
intern/cycles/render/integrator.cpp
intern/cycles/render/integrator.h
intern/cycles/render/light.cpp
intern/cycles/render/light.h
intern/cycles/render/object.cpp
intern/cycles/render/scene.cpp
intern/ghost/CMakeLists.txt
intern/itasc/kdl/frames.inl
intern/raskter/raskter.c
intern/raskter/raskter.h
intern/smoke/intern/WTURBULENCE.cpp
release/scripts/presets/interface_theme/back_to_black.xml
release/scripts/presets/interface_theme/blender_24x.xml
release/scripts/presets/interface_theme/elsyiun.xml
release/scripts/presets/interface_theme/hexagon.xml
release/scripts/presets/interface_theme/ubuntu_ambiance.xml
release/scripts/presets/operator/wm.collada_export/second_life.py
release/scripts/startup/bl_ui/properties_object_constraint.py
release/scripts/startup/bl_ui/space_clip.py
release/scripts/startup/bl_ui/space_userpref.py
release/scripts/startup/bl_ui/space_userpref_keymap.py
release/scripts/startup/bl_ui/space_view3d.py
release/scripts/templates/operator_node.py [new file with mode: 0644]
source/blender/blenkernel/BKE_blender.h
source/blender/blenkernel/BKE_colortools.h
source/blender/blenkernel/BKE_mask.h
source/blender/blenkernel/BKE_node.h
source/blender/blenkernel/BKE_object.h
source/blender/blenkernel/BKE_shrinkwrap.h
source/blender/blenkernel/BKE_tracking.h
source/blender/blenkernel/intern/anim_sys.c
source/blender/blenkernel/intern/armature.c
source/blender/blenkernel/intern/colortools.c
source/blender/blenkernel/intern/constraint.c
source/blender/blenkernel/intern/curve.c
source/blender/blenkernel/intern/mask.c
source/blender/blenkernel/intern/movieclip.c
source/blender/blenkernel/intern/multires.c
source/blender/blenkernel/intern/node.c
source/blender/blenkernel/intern/object.c
source/blender/blenkernel/intern/sequencer.c
source/blender/blenkernel/intern/tracking.c
source/blender/blenlib/BLI_math_color.h
source/blender/blenlib/BLI_math_vector.h
source/blender/blenlib/BLI_pbvh.h
source/blender/blenlib/BLI_voronoi.h [new file with mode: 0644]
source/blender/blenlib/CMakeLists.txt
source/blender/blenlib/intern/math_color.c
source/blender/blenlib/intern/math_color_inline.c
source/blender/blenlib/intern/math_vector_inline.c
source/blender/blenlib/intern/pbvh.c
source/blender/blenlib/intern/voronoi.c [new file with mode: 0644]
source/blender/blenloader/intern/readfile.c
source/blender/bmesh/intern/bmesh_marking.c
source/blender/bmesh/intern/bmesh_operators.c
source/blender/bmesh/intern/bmesh_operators.h
source/blender/bmesh/intern/bmesh_queries.c
source/blender/bmesh/operators/bmo_dupe.c
source/blender/bmesh/operators/bmo_utils.c
source/blender/collada/AnimationExporter.cpp
source/blender/collada/AnimationImporter.cpp
source/blender/collada/AnimationImporter.h
source/blender/collada/ArmatureExporter.cpp
source/blender/collada/ArmatureImporter.cpp
source/blender/collada/CameraExporter.cpp
source/blender/collada/CameraExporter.h
source/blender/collada/DocumentExporter.cpp
source/blender/collada/DocumentExporter.h
source/blender/collada/DocumentImporter.cpp
source/blender/collada/EffectExporter.cpp
source/blender/collada/ErrorHandler.cpp
source/blender/collada/ExportSettings.h
source/blender/collada/ExtraHandler.cpp
source/blender/collada/ExtraTags.cpp
source/blender/collada/GeometryExporter.cpp
source/blender/collada/GeometryExporter.h
source/blender/collada/ImageExporter.cpp
source/blender/collada/InstanceWriter.cpp
source/blender/collada/LightExporter.cpp
source/blender/collada/MaterialExporter.cpp
source/blender/collada/MaterialExporter.h
source/blender/collada/MeshImporter.cpp
source/blender/collada/SceneExporter.cpp
source/blender/collada/SkinInfo.cpp
source/blender/collada/TransformReader.cpp
source/blender/collada/TransformWriter.cpp
source/blender/collada/collada.cpp
source/blender/collada/collada.h
source/blender/collada/collada_internal.cpp
source/blender/collada/collada_internal.h
source/blender/collada/collada_utils.cpp
source/blender/collada/collada_utils.h
source/blender/compositor/CMakeLists.txt
source/blender/compositor/COM_compositor.h
source/blender/compositor/COM_defines.h
source/blender/compositor/intern/COM_CPUDevice.cpp
source/blender/compositor/intern/COM_CPUDevice.h
source/blender/compositor/intern/COM_ChannelInfo.cpp
source/blender/compositor/intern/COM_ChannelInfo.h
source/blender/compositor/intern/COM_ChunkOrder.cpp
source/blender/compositor/intern/COM_ChunkOrder.h
source/blender/compositor/intern/COM_ChunkOrderHotspot.cpp
source/blender/compositor/intern/COM_CompositorContext.cpp
source/blender/compositor/intern/COM_CompositorContext.h
source/blender/compositor/intern/COM_Converter.cpp
source/blender/compositor/intern/COM_Converter.h
source/blender/compositor/intern/COM_Device.h
source/blender/compositor/intern/COM_ExecutionGroup.cpp
source/blender/compositor/intern/COM_ExecutionGroup.h
source/blender/compositor/intern/COM_ExecutionSystem.cpp
source/blender/compositor/intern/COM_ExecutionSystem.h
source/blender/compositor/intern/COM_ExecutionSystemHelper.cpp
source/blender/compositor/intern/COM_ExecutionSystemHelper.h
source/blender/compositor/intern/COM_InputSocket.cpp
source/blender/compositor/intern/COM_InputSocket.h
source/blender/compositor/intern/COM_MemoryBuffer.cpp
source/blender/compositor/intern/COM_MemoryBuffer.h
source/blender/compositor/intern/COM_MemoryProxy.h
source/blender/compositor/intern/COM_Node.cpp
source/blender/compositor/intern/COM_Node.h
source/blender/compositor/intern/COM_NodeBase.cpp
source/blender/compositor/intern/COM_NodeBase.h
source/blender/compositor/intern/COM_NodeOperation.cpp
source/blender/compositor/intern/COM_NodeOperation.h
source/blender/compositor/intern/COM_OpenCLDevice.cpp
source/blender/compositor/intern/COM_OpenCLDevice.h
source/blender/compositor/intern/COM_OutputSocket.cpp
source/blender/compositor/intern/COM_OutputSocket.h
source/blender/compositor/intern/COM_SingleThreadedNodeOperation.cpp [new file with mode: 0644]
source/blender/compositor/intern/COM_SingleThreadedNodeOperation.h [new file with mode: 0644]
source/blender/compositor/intern/COM_Socket.cpp
source/blender/compositor/intern/COM_Socket.h
source/blender/compositor/intern/COM_SocketConnection.cpp
source/blender/compositor/intern/COM_SocketConnection.h
source/blender/compositor/intern/COM_SocketReader.h
source/blender/compositor/intern/COM_WorkPackage.h
source/blender/compositor/intern/COM_WorkScheduler.cpp
source/blender/compositor/intern/COM_WorkScheduler.h
source/blender/compositor/intern/COM_compositor.cpp
source/blender/compositor/nodes/COM_AlphaOverNode.cpp
source/blender/compositor/nodes/COM_AlphaOverNode.h
source/blender/compositor/nodes/COM_BilateralBlurNode.cpp
source/blender/compositor/nodes/COM_BilateralBlurNode.h
source/blender/compositor/nodes/COM_BlurNode.cpp
source/blender/compositor/nodes/COM_BlurNode.h
source/blender/compositor/nodes/COM_BokehBlurNode.cpp
source/blender/compositor/nodes/COM_BokehBlurNode.h
source/blender/compositor/nodes/COM_BokehImageNode.cpp
source/blender/compositor/nodes/COM_BokehImageNode.h
source/blender/compositor/nodes/COM_BoxMaskNode.cpp
source/blender/compositor/nodes/COM_BoxMaskNode.h
source/blender/compositor/nodes/COM_BrightnessNode.cpp
source/blender/compositor/nodes/COM_BrightnessNode.h
source/blender/compositor/nodes/COM_ChannelMatteNode.cpp
source/blender/compositor/nodes/COM_ChannelMatteNode.h
source/blender/compositor/nodes/COM_ChromaMatteNode.cpp
source/blender/compositor/nodes/COM_ChromaMatteNode.h
source/blender/compositor/nodes/COM_ColorBalanceNode.cpp
source/blender/compositor/nodes/COM_ColorBalanceNode.h
source/blender/compositor/nodes/COM_ColorCorrectionNode.cpp
source/blender/compositor/nodes/COM_ColorCorrectionNode.h
source/blender/compositor/nodes/COM_ColorCurveNode.cpp
source/blender/compositor/nodes/COM_ColorCurveNode.h
source/blender/compositor/nodes/COM_ColorMatteNode.cpp
source/blender/compositor/nodes/COM_ColorMatteNode.h
source/blender/compositor/nodes/COM_ColorNode.cpp
source/blender/compositor/nodes/COM_ColorNode.h
source/blender/compositor/nodes/COM_ColorRampNode.cpp
source/blender/compositor/nodes/COM_ColorRampNode.h
source/blender/compositor/nodes/COM_ColorSpillNode.cpp
source/blender/compositor/nodes/COM_ColorSpillNode.h
source/blender/compositor/nodes/COM_ColorToBWNode.cpp
source/blender/compositor/nodes/COM_ColorToBWNode.h
source/blender/compositor/nodes/COM_CombineHSVANode.cpp
source/blender/compositor/nodes/COM_CombineHSVANode.h
source/blender/compositor/nodes/COM_CombineRGBANode.cpp
source/blender/compositor/nodes/COM_CombineRGBANode.h
source/blender/compositor/nodes/COM_CombineYCCANode.cpp
source/blender/compositor/nodes/COM_CombineYCCANode.h
source/blender/compositor/nodes/COM_CombineYUVANode.cpp
source/blender/compositor/nodes/COM_CombineYUVANode.h
source/blender/compositor/nodes/COM_CompositorNode.cpp
source/blender/compositor/nodes/COM_CompositorNode.h
source/blender/compositor/nodes/COM_ConvertAlphaNode.cpp
source/blender/compositor/nodes/COM_ConvertAlphaNode.h
source/blender/compositor/nodes/COM_CropNode.cpp
source/blender/compositor/nodes/COM_CropNode.h
source/blender/compositor/nodes/COM_DefocusNode.cpp
source/blender/compositor/nodes/COM_DefocusNode.h
source/blender/compositor/nodes/COM_DifferenceMatteNode.cpp
source/blender/compositor/nodes/COM_DifferenceMatteNode.h
source/blender/compositor/nodes/COM_DilateErodeNode.cpp
source/blender/compositor/nodes/COM_DilateErodeNode.h
source/blender/compositor/nodes/COM_DirectionalBlurNode.cpp
source/blender/compositor/nodes/COM_DirectionalBlurNode.h
source/blender/compositor/nodes/COM_DisplaceNode.cpp
source/blender/compositor/nodes/COM_DisplaceNode.h
source/blender/compositor/nodes/COM_DistanceMatteNode.cpp
source/blender/compositor/nodes/COM_DistanceMatteNode.h
source/blender/compositor/nodes/COM_DoubleEdgeMaskNode.cpp
source/blender/compositor/nodes/COM_DoubleEdgeMaskNode.h
source/blender/compositor/nodes/COM_EllipseMaskNode.cpp
source/blender/compositor/nodes/COM_EllipseMaskNode.h
source/blender/compositor/nodes/COM_FilterNode.cpp
source/blender/compositor/nodes/COM_FilterNode.h
source/blender/compositor/nodes/COM_FlipNode.cpp
source/blender/compositor/nodes/COM_FlipNode.h
source/blender/compositor/nodes/COM_GammaNode.cpp
source/blender/compositor/nodes/COM_GammaNode.h
source/blender/compositor/nodes/COM_GlareNode.cpp
source/blender/compositor/nodes/COM_GlareNode.h
source/blender/compositor/nodes/COM_GroupNode.cpp
source/blender/compositor/nodes/COM_GroupNode.h
source/blender/compositor/nodes/COM_HueSaturationValueCorrectNode.cpp
source/blender/compositor/nodes/COM_HueSaturationValueCorrectNode.h
source/blender/compositor/nodes/COM_HueSaturationValueNode.cpp
source/blender/compositor/nodes/COM_HueSaturationValueNode.h
source/blender/compositor/nodes/COM_IDMaskNode.cpp
source/blender/compositor/nodes/COM_IDMaskNode.h
source/blender/compositor/nodes/COM_ImageNode.cpp
source/blender/compositor/nodes/COM_ImageNode.h
source/blender/compositor/nodes/COM_InvertNode.cpp
source/blender/compositor/nodes/COM_InvertNode.h
source/blender/compositor/nodes/COM_KeyingNode.cpp [new file with mode: 0644]
source/blender/compositor/nodes/COM_KeyingNode.h [new file with mode: 0644]
source/blender/compositor/nodes/COM_KeyingScreenNode.cpp [new file with mode: 0644]
source/blender/compositor/nodes/COM_KeyingScreenNode.h [new file with mode: 0644]
source/blender/compositor/nodes/COM_LensDistortionNode.cpp
source/blender/compositor/nodes/COM_LensDistortionNode.h
source/blender/compositor/nodes/COM_LuminanceMatteNode.cpp
source/blender/compositor/nodes/COM_LuminanceMatteNode.h
source/blender/compositor/nodes/COM_MapUVNode.cpp
source/blender/compositor/nodes/COM_MapUVNode.h
source/blender/compositor/nodes/COM_MapValueNode.cpp
source/blender/compositor/nodes/COM_MapValueNode.h
source/blender/compositor/nodes/COM_MaskNode.cpp
source/blender/compositor/nodes/COM_MaskNode.h
source/blender/compositor/nodes/COM_MathNode.cpp
source/blender/compositor/nodes/COM_MathNode.h
source/blender/compositor/nodes/COM_MixNode.cpp
source/blender/compositor/nodes/COM_MixNode.h
source/blender/compositor/nodes/COM_MovieClipNode.cpp
source/blender/compositor/nodes/COM_MovieClipNode.h
source/blender/compositor/nodes/COM_MovieDistortionNode.cpp
source/blender/compositor/nodes/COM_MovieDistortionNode.h
source/blender/compositor/nodes/COM_MuteNode.cpp
source/blender/compositor/nodes/COM_MuteNode.h
source/blender/compositor/nodes/COM_NormalNode.cpp
source/blender/compositor/nodes/COM_NormalNode.h
source/blender/compositor/nodes/COM_NormalizeNode.cpp
source/blender/compositor/nodes/COM_NormalizeNode.h
source/blender/compositor/nodes/COM_OutputFileNode.cpp
source/blender/compositor/nodes/COM_OutputFileNode.h
source/blender/compositor/nodes/COM_RenderLayersNode.cpp
source/blender/compositor/nodes/COM_RenderLayersNode.h
source/blender/compositor/nodes/COM_RotateNode.cpp
source/blender/compositor/nodes/COM_RotateNode.h
source/blender/compositor/nodes/COM_ScaleNode.cpp
source/blender/compositor/nodes/COM_ScaleNode.h
source/blender/compositor/nodes/COM_SeparateHSVANode.cpp
source/blender/compositor/nodes/COM_SeparateHSVANode.h
source/blender/compositor/nodes/COM_SeparateRGBANode.cpp
source/blender/compositor/nodes/COM_SeparateRGBANode.h
source/blender/compositor/nodes/COM_SeparateYCCANode.cpp
source/blender/compositor/nodes/COM_SeparateYCCANode.h
source/blender/compositor/nodes/COM_SeparateYUVANode.cpp
source/blender/compositor/nodes/COM_SeparateYUVANode.h
source/blender/compositor/nodes/COM_SetAlphaNode.cpp
source/blender/compositor/nodes/COM_SetAlphaNode.h
source/blender/compositor/nodes/COM_SocketProxyNode.cpp
source/blender/compositor/nodes/COM_SocketProxyNode.h
source/blender/compositor/nodes/COM_SplitViewerNode.cpp
source/blender/compositor/nodes/COM_SplitViewerNode.h
source/blender/compositor/nodes/COM_Stabilize2dNode.cpp
source/blender/compositor/nodes/COM_Stabilize2dNode.h
source/blender/compositor/nodes/COM_SwitchNode.cpp
source/blender/compositor/nodes/COM_SwitchNode.h
source/blender/compositor/nodes/COM_TextureNode.cpp
source/blender/compositor/nodes/COM_TextureNode.h
source/blender/compositor/nodes/COM_TimeNode.cpp
source/blender/compositor/nodes/COM_TimeNode.h
source/blender/compositor/nodes/COM_TonemapNode.cpp
source/blender/compositor/nodes/COM_TonemapNode.h
source/blender/compositor/nodes/COM_TransformNode.cpp
source/blender/compositor/nodes/COM_TransformNode.h
source/blender/compositor/nodes/COM_TranslateNode.cpp
source/blender/compositor/nodes/COM_TranslateNode.h
source/blender/compositor/nodes/COM_ValueNode.cpp
source/blender/compositor/nodes/COM_ValueNode.h
source/blender/compositor/nodes/COM_VectorBlurNode.cpp
source/blender/compositor/nodes/COM_VectorBlurNode.h
source/blender/compositor/nodes/COM_VectorCurveNode.cpp
source/blender/compositor/nodes/COM_VectorCurveNode.h
source/blender/compositor/nodes/COM_ViewLevelsNode.cpp
source/blender/compositor/nodes/COM_ViewLevelsNode.h
source/blender/compositor/nodes/COM_ViewerNode.cpp
source/blender/compositor/nodes/COM_ViewerNode.h
source/blender/compositor/nodes/COM_ZCombineNode.cpp
source/blender/compositor/nodes/COM_ZCombineNode.h
source/blender/compositor/operations/COM_AlphaOverKeyOperation.cpp
source/blender/compositor/operations/COM_AlphaOverKeyOperation.h
source/blender/compositor/operations/COM_AlphaOverMixedOperation.cpp
source/blender/compositor/operations/COM_AlphaOverMixedOperation.h
source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.cpp
source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.h
source/blender/compositor/operations/COM_AntiAliasOperation.cpp
source/blender/compositor/operations/COM_AntiAliasOperation.h
source/blender/compositor/operations/COM_BilateralBlurOperation.cpp
source/blender/compositor/operations/COM_BilateralBlurOperation.h
source/blender/compositor/operations/COM_BlurBaseOperation.cpp
source/blender/compositor/operations/COM_BlurBaseOperation.h
source/blender/compositor/operations/COM_BokehBlurOperation.cpp
source/blender/compositor/operations/COM_BokehBlurOperation.h
source/blender/compositor/operations/COM_BokehImageOperation.cpp
source/blender/compositor/operations/COM_BokehImageOperation.h
source/blender/compositor/operations/COM_BoxMaskOperation.cpp
source/blender/compositor/operations/COM_BoxMaskOperation.h
source/blender/compositor/operations/COM_BrightnessOperation.cpp
source/blender/compositor/operations/COM_BrightnessOperation.h
source/blender/compositor/operations/COM_CalculateMeanOperation.cpp
source/blender/compositor/operations/COM_CalculateMeanOperation.h
source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.cpp
source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.h
source/blender/compositor/operations/COM_ChangeHSVOperation.cpp
source/blender/compositor/operations/COM_ChangeHSVOperation.h
source/blender/compositor/operations/COM_ChannelMatteOperation.cpp
source/blender/compositor/operations/COM_ChannelMatteOperation.h
source/blender/compositor/operations/COM_ChromaMatteOperation.cpp
source/blender/compositor/operations/COM_ChromaMatteOperation.h
source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.cpp
source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.h
source/blender/compositor/operations/COM_ColorBalanceLGGOperation.cpp
source/blender/compositor/operations/COM_ColorBalanceLGGOperation.h
source/blender/compositor/operations/COM_ColorCorrectionOperation.cpp
source/blender/compositor/operations/COM_ColorCorrectionOperation.h
source/blender/compositor/operations/COM_ColorCurveOperation.cpp
source/blender/compositor/operations/COM_ColorCurveOperation.h
source/blender/compositor/operations/COM_ColorMatteOperation.cpp
source/blender/compositor/operations/COM_ColorMatteOperation.h
source/blender/compositor/operations/COM_ColorRampOperation.cpp
source/blender/compositor/operations/COM_ColorRampOperation.h
source/blender/compositor/operations/COM_ColorSpillOperation.cpp
source/blender/compositor/operations/COM_ColorSpillOperation.h
source/blender/compositor/operations/COM_CombineChannelsOperation.cpp
source/blender/compositor/operations/COM_CombineChannelsOperation.h
source/blender/compositor/operations/COM_CompositorOperation.cpp
source/blender/compositor/operations/COM_CompositorOperation.h
source/blender/compositor/operations/COM_ConvertColorProfileOperation.cpp
source/blender/compositor/operations/COM_ConvertColorProfileOperation.h
source/blender/compositor/operations/COM_ConvertColorToBWOperation.cpp
source/blender/compositor/operations/COM_ConvertColorToBWOperation.h
source/blender/compositor/operations/COM_ConvertColorToVectorOperation.cpp
source/blender/compositor/operations/COM_ConvertColorToVectorOperation.h
source/blender/compositor/operations/COM_ConvertColourToValueProg.cpp
source/blender/compositor/operations/COM_ConvertColourToValueProg.h
source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.cpp
source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.h
source/blender/compositor/operations/COM_ConvertHSVToRGBOperation.cpp
source/blender/compositor/operations/COM_ConvertHSVToRGBOperation.h
source/blender/compositor/operations/COM_ConvertKeyToPremulOperation.cpp
source/blender/compositor/operations/COM_ConvertKeyToPremulOperation.h
source/blender/compositor/operations/COM_ConvertPremulToKeyOperation.cpp
source/blender/compositor/operations/COM_ConvertPremulToKeyOperation.h
source/blender/compositor/operations/COM_ConvertRGBToHSVOperation.cpp
source/blender/compositor/operations/COM_ConvertRGBToHSVOperation.h
source/blender/compositor/operations/COM_ConvertRGBToYCCOperation.cpp
source/blender/compositor/operations/COM_ConvertRGBToYCCOperation.h
source/blender/compositor/operations/COM_ConvertRGBToYUVOperation.cpp
source/blender/compositor/operations/COM_ConvertRGBToYUVOperation.h
source/blender/compositor/operations/COM_ConvertValueToColourProg.cpp
source/blender/compositor/operations/COM_ConvertValueToColourProg.h
source/blender/compositor/operations/COM_ConvertValueToVectorOperation.cpp
source/blender/compositor/operations/COM_ConvertValueToVectorOperation.h
source/blender/compositor/operations/COM_ConvertVectorToColorOperation.cpp
source/blender/compositor/operations/COM_ConvertVectorToColorOperation.h
source/blender/compositor/operations/COM_ConvertVectorToValueOperation.cpp
source/blender/compositor/operations/COM_ConvertVectorToValueOperation.h
source/blender/compositor/operations/COM_ConvertYCCToRGBOperation.cpp
source/blender/compositor/operations/COM_ConvertYCCToRGBOperation.h
source/blender/compositor/operations/COM_ConvertYUVToRGBOperation.cpp
source/blender/compositor/operations/COM_ConvertYUVToRGBOperation.h
source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.cpp
source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.h
source/blender/compositor/operations/COM_ConvolutionFilterOperation.cpp
source/blender/compositor/operations/COM_ConvolutionFilterOperation.h
source/blender/compositor/operations/COM_CropOperation.cpp
source/blender/compositor/operations/COM_CropOperation.h
source/blender/compositor/operations/COM_CurveBaseOperation.cpp
source/blender/compositor/operations/COM_CurveBaseOperation.h
source/blender/compositor/operations/COM_DifferenceMatteOperation.cpp
source/blender/compositor/operations/COM_DifferenceMatteOperation.h
source/blender/compositor/operations/COM_DilateErodeOperation.cpp
source/blender/compositor/operations/COM_DilateErodeOperation.h
source/blender/compositor/operations/COM_DirectionalBlurOperation.cpp
source/blender/compositor/operations/COM_DirectionalBlurOperation.h
source/blender/compositor/operations/COM_DisplaceOperation.cpp
source/blender/compositor/operations/COM_DisplaceOperation.h
source/blender/compositor/operations/COM_DisplaceSimpleOperation.cpp
source/blender/compositor/operations/COM_DisplaceSimpleOperation.h
source/blender/compositor/operations/COM_DistanceMatteOperation.cpp
source/blender/compositor/operations/COM_DistanceMatteOperation.h
source/blender/compositor/operations/COM_DotproductOperation.cpp
source/blender/compositor/operations/COM_DotproductOperation.h
source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cpp
source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.h
source/blender/compositor/operations/COM_EllipseMaskOperation.cpp
source/blender/compositor/operations/COM_EllipseMaskOperation.h
source/blender/compositor/operations/COM_FastGaussianBlurOperation.cpp
source/blender/compositor/operations/COM_FastGaussianBlurOperation.h
source/blender/compositor/operations/COM_FlipOperation.cpp
source/blender/compositor/operations/COM_FlipOperation.h
source/blender/compositor/operations/COM_FogGlowImageOperation.cpp [deleted file]
source/blender/compositor/operations/COM_GammaCorrectOperation.cpp
source/blender/compositor/operations/COM_GammaCorrectOperation.h
source/blender/compositor/operations/COM_GammaOperation.cpp
source/blender/compositor/operations/COM_GammaOperation.h
source/blender/compositor/operations/COM_GaussianBokehBlurOperation.cpp
source/blender/compositor/operations/COM_GaussianBokehBlurOperation.h
source/blender/compositor/operations/COM_GaussianXBlurOperation.cpp
source/blender/compositor/operations/COM_GaussianXBlurOperation.h
source/blender/compositor/operations/COM_GaussianYBlurOperation.cpp
source/blender/compositor/operations/COM_GaussianYBlurOperation.h
source/blender/compositor/operations/COM_GlareBaseOperation.cpp
source/blender/compositor/operations/COM_GlareBaseOperation.h
source/blender/compositor/operations/COM_GlareFogGlowOperation.cpp [new file with mode: 0644]
source/blender/compositor/operations/COM_GlareFogGlowOperation.h [new file with mode: 0644]
source/blender/compositor/operations/COM_GlareGhostOperation.cpp
source/blender/compositor/operations/COM_GlareGhostOperation.h
source/blender/compositor/operations/COM_GlareSimpleStarOperation.cpp
source/blender/compositor/operations/COM_GlareSimpleStarOperation.h
source/blender/compositor/operations/COM_GlareStreaksOperation.cpp
source/blender/compositor/operations/COM_GlareStreaksOperation.h
source/blender/compositor/operations/COM_GlareThresholdOperation.cpp
source/blender/compositor/operations/COM_GlareThresholdOperation.h
source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.cpp
source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.h
source/blender/compositor/operations/COM_IDMaskOperation.cpp
source/blender/compositor/operations/COM_IDMaskOperation.h
source/blender/compositor/operations/COM_ImageOperation.cpp
source/blender/compositor/operations/COM_ImageOperation.h
source/blender/compositor/operations/COM_InvertOperation.cpp
source/blender/compositor/operations/COM_InvertOperation.h
source/blender/compositor/operations/COM_KeyingBlurOperation.cpp [new file with mode: 0644]
source/blender/compositor/operations/COM_KeyingBlurOperation.h [new file with mode: 0644]
source/blender/compositor/operations/COM_KeyingClipOperation.cpp [new file with mode: 0644]
source/blender/compositor/operations/COM_KeyingClipOperation.h [new file with mode: 0644]
source/blender/compositor/operations/COM_KeyingDespillOperation.cpp [new file with mode: 0644]
source/blender/compositor/operations/COM_KeyingDespillOperation.h [new file with mode: 0644]
source/blender/compositor/operations/COM_KeyingOperation.cpp [new file with mode: 0644]
source/blender/compositor/operations/COM_KeyingOperation.h [new file with mode: 0644]
source/blender/compositor/operations/COM_KeyingScreenOperation.cpp [new file with mode: 0644]
source/blender/compositor/operations/COM_KeyingScreenOperation.h [new file with mode: 0644]
source/blender/compositor/operations/COM_LuminanceMatteOperation.cpp
source/blender/compositor/operations/COM_LuminanceMatteOperation.h
source/blender/compositor/operations/COM_MapUVOperation.cpp
source/blender/compositor/operations/COM_MapUVOperation.h
source/blender/compositor/operations/COM_MapValueOperation.cpp
source/blender/compositor/operations/COM_MapValueOperation.h
source/blender/compositor/operations/COM_MaskOperation.cpp
source/blender/compositor/operations/COM_MaskOperation.h
source/blender/compositor/operations/COM_MathBaseOperation.cpp
source/blender/compositor/operations/COM_MathBaseOperation.h
source/blender/compositor/operations/COM_MixAddOperation.cpp
source/blender/compositor/operations/COM_MixAddOperation.h
source/blender/compositor/operations/COM_MixBaseOperation.cpp
source/blender/compositor/operations/COM_MixBaseOperation.h
source/blender/compositor/operations/COM_MixBlendOperation.cpp
source/blender/compositor/operations/COM_MixBlendOperation.h
source/blender/compositor/operations/COM_MixBurnOperation.cpp
source/blender/compositor/operations/COM_MixBurnOperation.h
source/blender/compositor/operations/COM_MixColorOperation.cpp
source/blender/compositor/operations/COM_MixColorOperation.h
source/blender/compositor/operations/COM_MixDarkenOperation.cpp
source/blender/compositor/operations/COM_MixDarkenOperation.h
source/blender/compositor/operations/COM_MixDifferenceOperation.cpp
source/blender/compositor/operations/COM_MixDifferenceOperation.h
source/blender/compositor/operations/COM_MixDivideOperation.cpp
source/blender/compositor/operations/COM_MixDivideOperation.h
source/blender/compositor/operations/COM_MixDodgeOperation.cpp
source/blender/compositor/operations/COM_MixDodgeOperation.h
source/blender/compositor/operations/COM_MixGlareOperation.cpp [new file with mode: 0644]
source/blender/compositor/operations/COM_MixGlareOperation.h [moved from source/blender/compositor/operations/COM_FogGlowImageOperation.h with 66% similarity]
source/blender/compositor/operations/COM_MixHueOperation.cpp
source/blender/compositor/operations/COM_MixHueOperation.h
source/blender/compositor/operations/COM_MixLightenOperation.cpp
source/blender/compositor/operations/COM_MixLightenOperation.h
source/blender/compositor/operations/COM_MixLinearLightOperation.cpp
source/blender/compositor/operations/COM_MixLinearLightOperation.h
source/blender/compositor/operations/COM_MixMultiplyOperation.cpp
source/blender/compositor/operations/COM_MixMultiplyOperation.h
source/blender/compositor/operations/COM_MixOverlayOperation.cpp
source/blender/compositor/operations/COM_MixOverlayOperation.h
source/blender/compositor/operations/COM_MixSaturationOperation.cpp
source/blender/compositor/operations/COM_MixSaturationOperation.h
source/blender/compositor/operations/COM_MixScreenOperation.cpp
source/blender/compositor/operations/COM_MixScreenOperation.h
source/blender/compositor/operations/COM_MixSoftLightOperation.cpp
source/blender/compositor/operations/COM_MixSoftLightOperation.h
source/blender/compositor/operations/COM_MixSubtractOperation.cpp
source/blender/compositor/operations/COM_MixSubtractOperation.h
source/blender/compositor/operations/COM_MixValueOperation.cpp
source/blender/compositor/operations/COM_MixValueOperation.h
source/blender/compositor/operations/COM_MovieClipAttributeOperation.cpp
source/blender/compositor/operations/COM_MovieClipAttributeOperation.h
source/blender/compositor/operations/COM_MovieClipOperation.cpp
source/blender/compositor/operations/COM_MovieClipOperation.h
source/blender/compositor/operations/COM_MovieDistortionOperation.cpp
source/blender/compositor/operations/COM_MovieDistortionOperation.h
source/blender/compositor/operations/COM_MultilayerImageOperation.cpp
source/blender/compositor/operations/COM_MultilayerImageOperation.h
source/blender/compositor/operations/COM_NormalizeOperation.cpp
source/blender/compositor/operations/COM_NormalizeOperation.h
source/blender/compositor/operations/COM_OpenCLKernels.cl
source/blender/compositor/operations/COM_OpenCLKernels.cl.h
source/blender/compositor/operations/COM_OutputFileOperation.cpp
source/blender/compositor/operations/COM_OutputFileOperation.h
source/blender/compositor/operations/COM_PreviewOperation.cpp
source/blender/compositor/operations/COM_PreviewOperation.h
source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.cpp
source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.h
source/blender/compositor/operations/COM_QualityStepHelper.cpp
source/blender/compositor/operations/COM_QualityStepHelper.h
source/blender/compositor/operations/COM_ReadBufferOperation.cpp
source/blender/compositor/operations/COM_ReadBufferOperation.h
source/blender/compositor/operations/COM_RenderLayersAOOperation.cpp
source/blender/compositor/operations/COM_RenderLayersAlphaProg.cpp
source/blender/compositor/operations/COM_RenderLayersAlphaProg.h
source/blender/compositor/operations/COM_RenderLayersBaseProg.cpp
source/blender/compositor/operations/COM_RenderLayersBaseProg.h
source/blender/compositor/operations/COM_RenderLayersColorOperation.cpp
source/blender/compositor/operations/COM_RenderLayersCyclesOperation.cpp
source/blender/compositor/operations/COM_RenderLayersDepthProg.cpp
source/blender/compositor/operations/COM_RenderLayersDiffuseOperation.cpp
source/blender/compositor/operations/COM_RenderLayersEmitOperation.cpp
source/blender/compositor/operations/COM_RenderLayersEnvironmentOperation.cpp
source/blender/compositor/operations/COM_RenderLayersImageProg.cpp
source/blender/compositor/operations/COM_RenderLayersIndirectOperation.cpp
source/blender/compositor/operations/COM_RenderLayersMaterialIndexOperation.cpp
source/blender/compositor/operations/COM_RenderLayersMistOperation.cpp
source/blender/compositor/operations/COM_RenderLayersNormalOperation.cpp
source/blender/compositor/operations/COM_RenderLayersObjectIndexOperation.cpp
source/blender/compositor/operations/COM_RenderLayersReflectionOperation.cpp
source/blender/compositor/operations/COM_RenderLayersRefractionOperation.cpp
source/blender/compositor/operations/COM_RenderLayersShadowOperation.cpp
source/blender/compositor/operations/COM_RenderLayersSpecularOperation.cpp
source/blender/compositor/operations/COM_RenderLayersSpeedOperation.cpp
source/blender/compositor/operations/COM_RenderLayersUVOperation.cpp
source/blender/compositor/operations/COM_RotateOperation.cpp
source/blender/compositor/operations/COM_RotateOperation.h
source/blender/compositor/operations/COM_ScaleOperation.cpp
source/blender/compositor/operations/COM_ScaleOperation.h
source/blender/compositor/operations/COM_ScreenLensDistortionOperation.cpp
source/blender/compositor/operations/COM_ScreenLensDistortionOperation.h
source/blender/compositor/operations/COM_SeparateChannelOperation.cpp
source/blender/compositor/operations/COM_SeparateChannelOperation.h
source/blender/compositor/operations/COM_SetAlphaOperation.cpp
source/blender/compositor/operations/COM_SetAlphaOperation.h
source/blender/compositor/operations/COM_SetColorOperation.cpp
source/blender/compositor/operations/COM_SetColorOperation.h
source/blender/compositor/operations/COM_SetSamplerOperation.cpp
source/blender/compositor/operations/COM_SetSamplerOperation.h
source/blender/compositor/operations/COM_SetValueOperation.cpp
source/blender/compositor/operations/COM_SetValueOperation.h
source/blender/compositor/operations/COM_SetVectorOperation.cpp
source/blender/compositor/operations/COM_SetVectorOperation.h
source/blender/compositor/operations/COM_SocketProxyOperation.cpp
source/blender/compositor/operations/COM_SocketProxyOperation.h
source/blender/compositor/operations/COM_SplitViewerOperation.cpp
source/blender/compositor/operations/COM_SplitViewerOperation.h
source/blender/compositor/operations/COM_TextureOperation.cpp
source/blender/compositor/operations/COM_TextureOperation.h
source/blender/compositor/operations/COM_TonemapOperation.cpp
source/blender/compositor/operations/COM_TonemapOperation.h
source/blender/compositor/operations/COM_TranslateOperation.cpp
source/blender/compositor/operations/COM_TranslateOperation.h
source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.cpp
source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.h
source/blender/compositor/operations/COM_VectorBlurOperation.cpp
source/blender/compositor/operations/COM_VectorBlurOperation.h
source/blender/compositor/operations/COM_VectorCurveOperation.cpp
source/blender/compositor/operations/COM_VectorCurveOperation.h
source/blender/compositor/operations/COM_ViewerBaseOperation.cpp
source/blender/compositor/operations/COM_ViewerBaseOperation.h
source/blender/compositor/operations/COM_ViewerOperation.cpp
source/blender/compositor/operations/COM_ViewerOperation.h
source/blender/compositor/operations/COM_WriteBufferOperation.cpp
source/blender/compositor/operations/COM_WriteBufferOperation.h
source/blender/compositor/operations/COM_ZCombineOperation.cpp
source/blender/compositor/operations/COM_ZCombineOperation.h
source/blender/editors/animation/keyframes_general.c
source/blender/editors/gpencil/drawgpencil.c
source/blender/editors/gpencil/gpencil_buttons.c
source/blender/editors/gpencil/gpencil_edit.c
source/blender/editors/gpencil/gpencil_paint.c
source/blender/editors/include/ED_clip.h
source/blender/editors/include/ED_gpencil.h
source/blender/editors/include/ED_sequencer.h
source/blender/editors/interface/interface_draw.c
source/blender/editors/interface/interface_handlers.c
source/blender/editors/interface/interface_ops.c
source/blender/editors/interface/interface_utils.c
source/blender/editors/mask/mask_draw.c
source/blender/editors/mask/mask_edit.c
source/blender/editors/mask/mask_intern.h
source/blender/editors/mask/mask_ops.c
source/blender/editors/mask/mask_relationships.c
source/blender/editors/mesh/editmesh_bvh.c
source/blender/editors/mesh/editmesh_bvh.h
source/blender/editors/mesh/editmesh_loopcut.c
source/blender/editors/mesh/editmesh_select.c
source/blender/editors/mesh/meshtools.c
source/blender/editors/object/object_add.c
source/blender/editors/object/object_constraint.c
source/blender/editors/object/object_edit.c
source/blender/editors/sculpt_paint/sculpt.c
source/blender/editors/space_action/space_action.c
source/blender/editors/space_clip/CMakeLists.txt
source/blender/editors/space_clip/clip_buttons.c
source/blender/editors/space_clip/clip_dopesheet_draw.c
source/blender/editors/space_clip/clip_dopesheet_ops.c
source/blender/editors/space_clip/clip_draw.c
source/blender/editors/space_clip/clip_editor.c
source/blender/editors/space_clip/clip_graph_draw.c
source/blender/editors/space_clip/clip_graph_ops.c
source/blender/editors/space_clip/clip_intern.h
source/blender/editors/space_clip/clip_ops.c
source/blender/editors/space_clip/clip_utils.c
source/blender/editors/space_clip/space_clip.c
source/blender/editors/space_clip/tracking_ops.c
source/blender/editors/space_clip/tracking_select.c [new file with mode: 0644]
source/blender/editors/space_image/image_draw.c
source/blender/editors/space_image/image_ops.c
source/blender/editors/space_image/space_image.c
source/blender/editors/space_node/drawnode.c
source/blender/editors/space_node/node_draw.c
source/blender/editors/space_node/node_edit.c
source/blender/editors/space_node/node_intern.h
source/blender/editors/space_node/node_ops.c
source/blender/editors/space_node/space_node.c
source/blender/editors/space_outliner/outliner_edit.c
source/blender/editors/space_outliner/outliner_intern.h
source/blender/editors/space_outliner/outliner_ops.c
source/blender/editors/space_outliner/space_outliner.c
source/blender/editors/space_sequencer/CMakeLists.txt
source/blender/editors/space_sequencer/SConscript
source/blender/editors/space_sequencer/sequencer_buttons.c
source/blender/editors/space_sequencer/sequencer_draw.c
source/blender/editors/space_sequencer/sequencer_intern.h
source/blender/editors/space_sequencer/space_sequencer.c
source/blender/editors/space_view3d/drawobject.c
source/blender/editors/space_view3d/view3d_draw.c
source/blender/editors/space_view3d/view3d_select.c
source/blender/editors/space_view3d/view3d_snap.c
source/blender/editors/transform/transform.c
source/blender/editors/transform/transform_constraints.c
source/blender/editors/transform/transform_conversions.c
source/blender/editors/transform/transform_generics.c
source/blender/editors/transform/transform_input.c
source/blender/editors/transform/transform_manipulator.c
source/blender/editors/transform/transform_ops.c
source/blender/editors/transform/transform_orientations.c
source/blender/editors/transform/transform_snap.c
source/blender/editors/uvedit/uvedit_parametrizer.c
source/blender/gpu/GPU_draw.h
source/blender/gpu/intern/gpu_draw.c
source/blender/imbuf/intern/divers.c
source/blender/imbuf/intern/jp2.c
source/blender/imbuf/intern/openexr/openexr_api.cpp
source/blender/makesdna/DNA_ID.h
source/blender/makesdna/DNA_action_types.h
source/blender/makesdna/DNA_anim_types.h
source/blender/makesdna/DNA_armature_types.h
source/blender/makesdna/DNA_boid_types.h
source/blender/makesdna/DNA_brush_types.h
source/blender/makesdna/DNA_color_types.h
source/blender/makesdna/DNA_constraint_types.h
source/blender/makesdna/DNA_curve_types.h
source/blender/makesdna/DNA_mask_types.h
source/blender/makesdna/DNA_modifier_types.h
source/blender/makesdna/DNA_movieclip_types.h
source/blender/makesdna/DNA_node_types.h
source/blender/makesdna/DNA_object_force.h
source/blender/makesdna/DNA_packedFile_types.h
source/blender/makesdna/DNA_scene_types.h
source/blender/makesdna/DNA_screen_types.h
source/blender/makesdna/DNA_sound_types.h
source/blender/makesdna/DNA_space_types.h
source/blender/makesdna/DNA_tracking_types.h
source/blender/makesdna/DNA_userdef_types.h
source/blender/makesdna/DNA_view3d_types.h
source/blender/makesrna/RNA_access.h
source/blender/makesrna/intern/rna_color.c
source/blender/makesrna/intern/rna_constraint.c
source/blender/makesrna/intern/rna_lamp.c
source/blender/makesrna/intern/rna_mask.c
source/blender/makesrna/intern/rna_modifier.c
source/blender/makesrna/intern/rna_movieclip.c
source/blender/makesrna/intern/rna_nodetree.c
source/blender/makesrna/intern/rna_nodetree_types.h
source/blender/makesrna/intern/rna_pose.c
source/blender/makesrna/intern/rna_scene_api.c
source/blender/makesrna/intern/rna_space.c
source/blender/makesrna/intern/rna_tracking.c
source/blender/makesrna/intern/rna_userdef.c
source/blender/modifiers/intern/MOD_array.c
source/blender/modifiers/intern/MOD_simpledeform.c
source/blender/nodes/CMakeLists.txt
source/blender/nodes/NOD_composite.h
source/blender/nodes/composite/node_composite_tree.c
source/blender/nodes/composite/node_composite_util.c
source/blender/nodes/composite/node_composite_util.h
source/blender/nodes/composite/nodes/node_composite_bilateralblur.c
source/blender/nodes/composite/nodes/node_composite_blur.c
source/blender/nodes/composite/nodes/node_composite_bokehblur.c
source/blender/nodes/composite/nodes/node_composite_dilate.c
source/blender/nodes/composite/nodes/node_composite_directionalblur.c
source/blender/nodes/composite/nodes/node_composite_glare.c
source/blender/nodes/composite/nodes/node_composite_keying.c [new file with mode: 0644]
source/blender/nodes/composite/nodes/node_composite_keyingscreen.c [new file with mode: 0644]
source/blender/nodes/composite/nodes/node_composite_mask.c
source/blender/nodes/composite/nodes/node_composite_movieclip.c
source/blender/nodes/composite/nodes/node_composite_moviedistortion.c
source/blender/nodes/composite/nodes/node_composite_scale.c
source/blender/nodes/composite/nodes/node_composite_stabilize2d.c
source/blender/nodes/composite/nodes/node_composite_tonemap.c
source/blender/nodes/composite/nodes/node_composite_vecBlur.c
source/blender/nodes/composite/nodes/node_composite_viewer.c
source/blender/nodes/intern/node_common.c
source/blender/nodes/intern/node_common.h
source/blender/python/mathutils/mathutils_Vector.c
source/blender/render/intern/source/convertblender.c
source/blender/render/intern/source/occlusion.c
source/blender/render/intern/source/pipeline.c
source/blender/render/intern/source/render_result.c
source/blender/render/intern/source/strand.c
source/blender/render/intern/source/volumetric.c
source/blender/windowmanager/intern/wm_event_system.c
source/blender/windowmanager/intern/wm_init_exit.c
source/blender/windowmanager/intern/wm_operators.c
source/creator/creator.c
source/gameengine/BlenderRoutines/KX_BlenderKeyboardDevice.h
source/gameengine/Ketsji/KX_RadarSensor.cpp
source/gameengine/Ketsji/KX_RadarSensor.h
source/gameengine/Rasterizer/RAS_2DFilterManager.cpp
source/gameengine/Rasterizer/RAS_2DFilterManager.h
source/gameengine/Rasterizer/RAS_MeshObject.h

index 191fb61e1b4f593c21f3197f6895ce3aeb6a39dd..5b70110947be116620b116c620a3840baf1c6201 100644 (file)
@@ -1605,6 +1605,20 @@ if(CMAKE_COMPILER_IS_GNUCC)
                ADD_CHECK_C_COMPILER_FLAG(CC_REMOVE_STRICT_FLAGS C_WARN_NO_ERROR_UNUSED_BUT_SET_VARIABLE -Wno-error=unused-but-set-variable)
        endif()
 
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+
+       ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_ALL -Wall)
+       ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_NO_AUTOLOGICAL_COMPARE -Wno-tautological-compare)
+       ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_NO_UNKNOWN_PRAGMAS -Wno-unknown-pragmas)
+       ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_NO_CHAR_SUBSCRIPTS -Wno-char-subscripts)
+
+       ADD_CHECK_C_COMPILER_FLAG(CXX_WARNINGS C_WARN_ALL -Wall)
+       ADD_CHECK_C_COMPILER_FLAG(CXX_WARNINGS CXX_WARN_NO_AUTOLOGICAL_COMPARE -Wno-tautological-compare)
+       ADD_CHECK_C_COMPILER_FLAG(CXX_WARNINGS CXX_WARN_NO_UNKNOWN_PRAGMAS -Wno-unknown-pragmas)
+       ADD_CHECK_C_COMPILER_FLAG(CXX_WARNINGS CXX_WARN_NO_CHAR_SUBSCRIPTS -Wno-char-subscripts)
+       ADD_CHECK_C_COMPILER_FLAG(CXX_WARNINGS CXX_WARN_NO_OVERLOADED_VIRTUAL -Wno-overloaded-virtual)  # we get a lot of these, if its a problem a dev needs to look into it.
+       ADD_CHECK_CXX_COMPILER_FLAG(CXX_WARNINGS CXX_WARN_NO_INVALID_OFFSETOF -Wno-invalid-offsetof)
+
 elseif(CMAKE_C_COMPILER_ID MATCHES "Intel")
 
        ADD_CHECK_C_COMPILER_FLAG(C_WARNINGS C_WARN_ALL -Wall)
index bcef816dc9d2a577b188ad7cefc4290f701f8f1e..ff85df1f68b4d2143e5b952017e9279f3140f93a 100644 (file)
@@ -2692,7 +2692,7 @@ Game Types (bge.types)
 
       The angle of the cone (in degrees) with which to test.
 
-      :type: float from 0 to 360
+      :type: float
 
    .. attribute:: axis
 
@@ -2703,11 +2703,6 @@ Game Types (bge.types)
       KX_RADAR_AXIS_POS_X, KX_RADAR_AXIS_POS_Y, KX_RADAR_AXIS_POS_Z, 
       KX_RADAR_AXIS_NEG_X, KX_RADAR_AXIS_NEG_Y, KX_RADAR_AXIS_NEG_Z
 
-   .. method:: getConeHeight()
-
-      :return: The height of the cone with which to test.
-      :rtype: float
-
 .. class:: KX_RaySensor(SCA_ISensor)
 
    A ray sensor detects the first object in a given direction.
index 5408c479b7caa92f22914471e7627b56a72752bf..57dec830c7479500913515dd3ba93555a8750fbc 100644 (file)
@@ -942,6 +942,8 @@ def pycontext2sphinx(basepath):
         "image_context_dir",
         "node_context_dir",
         "text_context_dir",
+        "clip_context_dir",
+        "sequencer_context_dir",
     )
 
     # Changes in blender will force errors here
@@ -951,6 +953,7 @@ def pycontext2sphinx(basepath):
         "active_object": ("Object", False),
         "active_operator": ("Operator", False),
         "active_pose_bone": ("PoseBone", False),
+        "active_node": ("Node", False),
         "armature": ("Armature", False),
         "bone": ("Bone", False),
         "brush": ("Brush", False),
@@ -961,6 +964,8 @@ def pycontext2sphinx(basepath):
         "dynamic_paint": ("DynamicPaintModifier", False),
         "edit_bone": ("EditBone", False),
         "edit_image": ("Image", False),
+        "edit_mask": ("Mask", False),
+        "edit_movieclip": ("MovieClip", False),
         "edit_object": ("Object", False),
         "edit_text": ("Text", False),
         "editable_bones": ("EditBone", True),
index ccb293d7a0e287de42d12a5ba5fd34d7c6b99f4a..924619619204b7eafff675c46a670e4e9c052fd8 100755 (executable)
@@ -61,7 +61,7 @@ if $DO_OUT_HTML ; then
 
        # annoying bug in sphinx makes it very slow unless we do this. should report.
        cd $SPHINXBASE
-       sphinx-build -n -b html sphinx-in sphinx-out
+       sphinx-build -b html sphinx-in sphinx-out
 
        # XXX, saves space on upload and zip, should move HTML outside
        # and zip up there, for now this is OK
index ffa065f08fe372efcfabd1a89ff5c463e405483d..3d3b7398c9bc23aedf766ee168c63b22dc11820c 100644 (file)
@@ -243,7 +243,7 @@ void savePNGImage(png_bytep *row_pointers, int width, int height, int depth, int
        fclose(fp);
 }
 
-static void saveImage(char *prefix, libmv::FloatImage image, int x0, int y0)
+static void saveImage(const char *prefix, libmv::FloatImage image, int x0, int y0)
 {
        int x, y;
        png_bytep *row_pointers;
@@ -283,7 +283,7 @@ static void saveImage(char *prefix, libmv::FloatImage image, int x0, int y0)
        free(row_pointers);
 }
 
-static void saveBytesImage(char *prefix, unsigned char *data, int width, int height)
+static void saveBytesImage(const char *prefix, unsigned char *data, int width, int height)
 {
        int x, y;
        png_bytep *row_pointers;
@@ -357,8 +357,8 @@ void libmv_regionTrackerDestroy(libmv_RegionTracker *libmv_tracker)
 
 /* TrackRegion (new planar tracker) */
 int libmv_trackRegion(const struct libmv_trackRegionOptions *options,
-                      const float *image1, const float *image2,
-                      int width, int height, 
+                      const float *image1, int image1_width, int image1_height,
+                      const float *image2, int image2_width, int image2_height,
                       const double *x1, const double *y1,
                       struct libmv_trackRegionResult *result,
                       double *x2, double *y2)
@@ -376,6 +376,8 @@ int libmv_trackRegion(const struct libmv_trackRegionOptions *options,
        }
 
        libmv::TrackRegionOptions track_region_options;
+       libmv::FloatImage image1_mask;
+
        switch (options->motion_model) {
 #define LIBMV_CONVERT(the_model) \
     case libmv::TrackRegionOptions::the_model: \
@@ -398,10 +400,16 @@ int libmv_trackRegion(const struct libmv_trackRegionOptions *options,
        track_region_options.use_brute_initialization = options->use_brute;
        track_region_options.use_normalized_intensities = options->use_normalization;
 
+       if (options->image1_mask) {
+               floatBufToImage(options->image1_mask, image1_width, image1_height, 1, &image1_mask);
+
+               track_region_options.image1_mask = &image1_mask;
+       }
+
        /* Convert from raw float buffers to libmv's FloatImage. */
        libmv::FloatImage old_patch, new_patch;
-       floatBufToImage(image1, width, height, 1, &old_patch);
-       floatBufToImage(image2, width, height, 1, &new_patch);
+       floatBufToImage(image1, image1_width, image1_height, 1, &old_patch);
+       floatBufToImage(image2, image2_width, image2_height, 1, &new_patch);
 
        libmv::TrackRegionResult track_region_result;
        libmv::TrackRegion(old_patch, new_patch, xx1, yy1, track_region_options, xx2, yy2, &track_region_result);
@@ -437,15 +445,24 @@ int libmv_trackRegion(const struct libmv_trackRegionOptions *options,
 
 void libmv_samplePlanarPatch(const float *image, int width, int height,
                              int channels, const double *xs, const double *ys,
-                             int num_samples_x, int num_samples_y, float *patch,
+                             int num_samples_x, int num_samples_y,
+                             const float *mask, float *patch,
                              double *warped_position_x, double *warped_position_y)
 {
-       libmv::FloatImage libmv_image, libmv_patch;
+       libmv::FloatImage libmv_image, libmv_patch, libmv_mask;
+       libmv::FloatImage *libmv_mask_for_sample = NULL;
 
        floatBufToImage(image, width, height, channels, &libmv_image);
 
+       if (mask) {
+               floatBufToImage(mask, width, height, 1, &libmv_mask);
+
+               libmv_mask_for_sample = &libmv_mask;
+       }
+
        libmv::SamplePlanarPatch(libmv_image, xs, ys, num_samples_x, num_samples_y,
-                                &libmv_patch, warped_position_x, warped_position_y);
+                                libmv_mask_for_sample, &libmv_patch,
+                                warped_position_x, warped_position_y);
 
        imageToFloatBuf(&libmv_patch, channels, patch);
 }
index 6f4b5dea3849cd6bf33a104c4ba86902b0311ba8..fc3b6f94f62de582332ee3c2fe49707930c59809 100644 (file)
@@ -52,28 +52,32 @@ void libmv_regionTrackerDestroy(struct libmv_RegionTracker *libmv_tracker);
 
 /* TrackRegion (new planar tracker) */
 struct libmv_trackRegionOptions {
-  int motion_model;
-  int num_iterations;
-  int use_brute;
-  int use_normalization;
-  double minimum_correlation;
-  double sigma;
+       int motion_model;
+       int num_iterations;
+       int use_brute;
+       int use_normalization;
+       double minimum_correlation;
+       double sigma;
+       float *image1_mask;
 };
+
 struct libmv_trackRegionResult {
-  int termination;
-  const char *termination_reason;
-  double correlation;
+       int termination;
+       const char *termination_reason;
+       double correlation;
 };
+
 int libmv_trackRegion(const struct libmv_trackRegionOptions *options,
-                      const float *image1, const float *image2,
-                      int width, int height, 
+                      const float *image1, int image1_width, int image1_height,
+                      const float *image2, int image2_width, int image2_height,
                       const double *x1, const double *y1,
                       struct libmv_trackRegionResult *result,
                       double *x2, double *y2);
 
 void libmv_samplePlanarPatch(const float *image, int width, int height,
                              int channels, const double *xs, const double *ys,
-                             int num_samples_x, int num_samples_y, float *patch,
+                             int num_samples_x, int num_samples_y,
+                             const float *mask, float *patch,
                              double *warped_position_x, double *warped_position_y);
 
 /* Tracks */
index e65ead50c80bac0140feeb71f170bd6fd6918030..f52919b2a616a5debfa876bd4be1b70dded5d5cf 100644 (file)
@@ -1351,7 +1351,7 @@ void TrackRegion(const FloatImage &image1,
 bool SamplePlanarPatch(const FloatImage &image,
                        const double *xs, const double *ys,
                        int num_samples_x, int num_samples_y,
-                       FloatImage *patch,
+                       FloatImage *mask, FloatImage *patch,
                        double *warped_position_x, double *warped_position_y) {
   // Bail early if the points are outside the image.
   if (!AllInBounds(image, xs, ys)) {
@@ -1376,6 +1376,13 @@ bool SamplePlanarPatch(const FloatImage &image,
       SampleLinear(image, image_position(1),
                    image_position(0),
                    &(*patch)(r, c, 0));
+      if (mask) {
+        float maskValue = SampleLinear(*mask, image_position(1),
+                                       image_position(0), 0);
+
+        for (int d = 0; d < image.Depth(); d++)
+          (*patch)(r, c, d) *= maskValue;
+      }
     }
   }
 
index 0de11239da69b382d8b081a5326d9753e7c35262..22ecfc54a15ba9de1293711d60e7eedf761df2b7 100644 (file)
@@ -135,10 +135,14 @@ void TrackRegion(const FloatImage &image1,
 // pixels of border around them. (so e.g. a corner of the patch cannot lie
 // directly on the edge of the image). Four corners are always required. All
 // channels are interpolated.
+// When mask is not null it'll be used as a pattern mask. Ot should match
+// the size of image.
+// Warped coordinates of marker's position would be returned in
+// warped_position_x and warped_position_y
 bool SamplePlanarPatch(const FloatImage &image,
                        const double *xs, const double *ys,
                        int num_samples_x, int num_samples_y,
-                       FloatImage *patch,
+                       FloatImage *mask, FloatImage *patch,
                        double *warped_position_x, double *warped_position_y);
 
 }  // namespace libmv
index 5207bddec12558f3e0d4e368661365556db86186..e6a9e430c47420035d5419fc5d2bd6509840fd2a 100644 (file)
@@ -58,21 +58,6 @@ set(SRC
        internal/ceres/detect_structure.cc
        internal/ceres/evaluator.cc
        internal/ceres/file.cc
-       internal/ceres/generated/schur_eliminator_2_2_2.cc
-       internal/ceres/generated/schur_eliminator_2_2_3.cc
-       internal/ceres/generated/schur_eliminator_2_2_4.cc
-       internal/ceres/generated/schur_eliminator_2_2_d.cc
-       internal/ceres/generated/schur_eliminator_2_3_3.cc
-       internal/ceres/generated/schur_eliminator_2_3_4.cc
-       internal/ceres/generated/schur_eliminator_2_3_9.cc
-       internal/ceres/generated/schur_eliminator_2_3_d.cc
-       internal/ceres/generated/schur_eliminator_2_4_3.cc
-       internal/ceres/generated/schur_eliminator_2_4_4.cc
-       internal/ceres/generated/schur_eliminator_2_4_d.cc
-       internal/ceres/generated/schur_eliminator_4_4_2.cc
-       internal/ceres/generated/schur_eliminator_4_4_3.cc
-       internal/ceres/generated/schur_eliminator_4_4_4.cc
-       internal/ceres/generated/schur_eliminator_4_4_d.cc
        internal/ceres/generated/schur_eliminator_d_d_d.cc
        internal/ceres/gradient_checking_cost_function.cc
        internal/ceres/implicit_schur_complement.cc
@@ -191,6 +176,26 @@ set(SRC
        internal/ceres/visibility.h
 )
 
+#if(FALSE)
+#      list(APPEND SRC
+#              internal/ceres/generated/schur_eliminator_2_2_2.cc
+#              internal/ceres/generated/schur_eliminator_2_2_3.cc
+#              internal/ceres/generated/schur_eliminator_2_2_4.cc
+#              internal/ceres/generated/schur_eliminator_2_2_d.cc
+#              internal/ceres/generated/schur_eliminator_2_3_3.cc
+#              internal/ceres/generated/schur_eliminator_2_3_4.cc
+#              internal/ceres/generated/schur_eliminator_2_3_9.cc
+#              internal/ceres/generated/schur_eliminator_2_3_d.cc
+#              internal/ceres/generated/schur_eliminator_2_4_3.cc
+#              internal/ceres/generated/schur_eliminator_2_4_4.cc
+#              internal/ceres/generated/schur_eliminator_2_4_d.cc
+#              internal/ceres/generated/schur_eliminator_4_4_2.cc
+#              internal/ceres/generated/schur_eliminator_4_4_3.cc
+#              internal/ceres/generated/schur_eliminator_4_4_4.cc
+#              internal/ceres/generated/schur_eliminator_4_4_d.cc
+#      )
+#endif()
+
 if(WIN32)
        list(APPEND INC
                ../glog/src/windows
@@ -213,6 +218,7 @@ add_definitions(
        -D"CERES_HASH_NAMESPACE_END=}}"
        -DCERES_NO_SUITESPARSE
        -DCERES_DONT_HAVE_PROTOCOL_BUFFERS
+       -DCERES_RESTRICT_SCHUR_SPECIALIZATION
 )
 
 blender_add_lib(extern_ceres "${SRC}" "${INC}" "${INC_SYS}")
index d8b2b8520d75665757240f867443f655352566ec..6b5f1b8d64d8ae4a47ee7aefdb0019188c492e35 100644 (file)
@@ -13,13 +13,15 @@ src = []
 defs = []
 
 src += env.Glob('internal/ceres/*.cc')
-src += env.Glob('internal/ceres/generated/*.cc')
+src += env.Glob('internal/ceres/generated/schur_eliminator_d_d_d.cc')
+#src += env.Glob('internal/ceres/generated/*.cc')
 
 defs.append('CERES_HAVE_PTHREAD')
 defs.append('CERES_HASH_NAMESPACE_START=namespace std { namespace tr1 {')
 defs.append('CERES_HASH_NAMESPACE_END=}}')
 defs.append('CERES_NO_SUITESPARSE')
 defs.append('CERES_DONT_HAVE_PROTOCOL_BUFFERS')
+defs.append('CERES_RESTRICT_SCHUR_SPECIALIZATION')
 
 incs = '. ../../ ../../../Eigen3 ./include ./internal ../gflags'
 
old mode 100644 (file)
new mode 100755 (executable)
index f543421..99aaadd
@@ -1,5 +1,6 @@
 #!/bin/sh
 
+if false; then
 if [ "x$1" = "x--i-really-know-what-im-doing" ] ; then
   echo Proceeding as requested by command line ...
 else
@@ -36,7 +37,10 @@ done
 
 rm -rf $tmp
 
-sources=`find ./include ./internal -type f -iname '*.cc' -or -iname '*.cpp' -or -iname '*.c' | sed -r 's/^\.\//\t/' | sort -d`
+fi
+
+sources=`find ./include ./internal -type f -iname '*.cc' -or -iname '*.cpp' -or -iname '*.c' | sed -r 's/^\.\//\t/' | grep -v -E 'schur_eliminator_[0-9]_[0-9]_[0-9d].cc' | sort -d`
+generated_sources=`find ./include ./internal -type f -iname '*.cc' -or -iname '*.cpp' -or -iname '*.c' | sed -r 's/^\.\//#\t\t/' | grep -E 'schur_eliminator_[0-9]_[0-9]_[0-9d].cc' | sort -d`
 headers=`find ./include ./internal -type f -iname '*.h' | sed -r 's/^\.\//\t/' | sort -d`
 
 src_dir=`find ./internal -type f -iname '*.cc' -exec dirname {} \; -or -iname '*.cpp' -exec dirname {} \; -or -iname '*.c' -exec dirname {} \; | sed -r 's/^\.\//\t/' | sort -d | uniq`
@@ -48,6 +52,10 @@ for x in $src_dir $src_third_dir; do
     continue;
   fi
 
+  if test  `echo "$x" | grep -c generated` -eq 1; then
+    continue;
+  fi
+
   if stat $x/*.cpp > /dev/null 2>&1; then
     t="src += env.Glob('`echo $x'/*.cpp'`')"
   fi
@@ -121,6 +129,12 @@ ${sources}
 ${headers}
 )
 
+#if(FALSE)
+#      list(APPEND SRC
+${generated_sources}
+#      )
+#endif()
+
 if(WIN32)
        list(APPEND INC
                ../glog/src/windows
@@ -143,6 +157,7 @@ add_definitions(
        -D"CERES_HASH_NAMESPACE_END=}}"
        -DCERES_NO_SUITESPARSE
        -DCERES_DONT_HAVE_PROTOCOL_BUFFERS
+       -DCERES_RESTRICT_SCHUR_SPECIALIZATION
 )
 
 blender_add_lib(extern_ceres "\${SRC}" "\${INC}" "\${INC_SYS}")
@@ -164,12 +179,15 @@ src = []
 defs = []
 
 $src
+src += env.Glob('internal/ceres/generated/schur_eliminator_d_d_d.cc')
+#src += env.Glob('internal/ceres/generated/*.cc')
 
 defs.append('CERES_HAVE_PTHREAD')
 defs.append('CERES_HASH_NAMESPACE_START=namespace std { namespace tr1 {')
 defs.append('CERES_HASH_NAMESPACE_END=}}')
 defs.append('CERES_NO_SUITESPARSE')
 defs.append('CERES_DONT_HAVE_PROTOCOL_BUFFERS')
+defs.append('CERES_RESTRICT_SCHUR_SPECIALIZATION')
 
 incs = '. ../../ ../../../Eigen3 ./include ./internal ../gflags'
 
index e125f3fffcd2fb0f3be17e6ed94649f80bcdb42b..55f725390237726d0e9ed8f32c3c872796d34543 100644 (file)
@@ -53,7 +53,7 @@ struct HashMap : tr1::unordered_map<K, V> {};
 template<typename K>
 struct HashSet : tr1::unordered_set<K> {};
 
-#ifdef _WIN32
+#if defined(_WIN32) && !defined(__MINGW64__) && !defined(__MINGW32__)
 #define GG_LONGLONG(x) x##I64
 #define GG_ULONGLONG(x) x##UI64
 #else
diff --git a/extern/libmv/third_party/ceres/patches/collections_port.h.mingw.patch b/extern/libmv/third_party/ceres/patches/collections_port.h.mingw.patch
new file mode 100644 (file)
index 0000000..bbb366e
--- /dev/null
@@ -0,0 +1,13 @@
+Index: internal/ceres/collections_port.h
+===================================================================
+--- internal/ceres/collections_port.h  (revision 47730)
++++ internal/ceres/collections_port.h  (working copy)
+@@ -53,7 +53,7 @@
+ template<typename K>
+ struct HashSet : tr1::unordered_set<K> {};
+-#ifdef _WIN32
++#if defined(_WIN32) && !defined(__MINGW64__) && !defined(__MINGW32__)
+ #define GG_LONGLONG(x) x##I64
+ #define GG_ULONGLONG(x) x##UI64
+ #else
index b58b8fcd286946a984cecf1da1f252a0d053dab7..45cb01fb595d39852e3ed2af0ad49a328c8bc46f 100644 (file)
@@ -24,7 +24,7 @@
 
 #ifdef NDEBUG
 // From http://cnicholson.net/2009/02/stupid-c-tricks-adventures-in-assert/
-#      define rcAssert(x) do { (void)sizeof(x); } while(__LINE__==-1,false)  
+#      define rcAssert(x) do { (void)sizeof(x); } while((void)(__LINE__ == -1), false)
 #else
 #      include <assert.h> 
 #      define rcAssert assert
index 3ade04c4658c61e7d197431fffae7a6d699b0b9f..b4673ec620643c147d7e430fca5f1964fcb2d087 100644 (file)
@@ -57,6 +57,12 @@ class CyclesRenderSettings(bpy.types.PropertyGroup):
                 default='GPU_COMPATIBLE',
                 )
 
+        cls.progressive = BoolProperty(
+                name="Progressive",
+                description="Use progressive sampling of lighting",
+                default=True,
+                )
+
         cls.samples = IntProperty(
                 name="Samples",
                 description="Number of samples to render for each pixel",
@@ -80,6 +86,49 @@ class CyclesRenderSettings(bpy.types.PropertyGroup):
                 default=False,
                 )
 
+        cls.aa_samples = IntProperty(
+                name="AA Samples",
+                description="Number of antialiasing samples to render for each pixel",
+                min=1, max=10000,
+                default=4,
+                )
+        cls.preview_aa_samples = IntProperty(
+                name="AA Samples",
+                description="Number of antialiasing samples to render in the viewport, unlimited if 0",
+                min=0, max=10000,
+                default=4,
+                )
+        cls.diffuse_samples = IntProperty(
+                name="Diffuse Samples",
+                description="Number of diffuse bounce samples to render for each AA sample",
+                min=1, max=10000,
+                default=1,
+                )
+        cls.glossy_samples = IntProperty(
+                name="Glossy Samples",
+                description="Number of glossy bounce samples to render for each AA sample",
+                min=1, max=10000,
+                default=1,
+                )
+        cls.transmission_samples = IntProperty(
+                name="Transmission Samples",
+                description="Number of transmission bounce samples to render for each AA sample",
+                min=1, max=10000,
+                default=1,
+                )
+        cls.ao_samples = IntProperty(
+                name="Ambient Occlusion Samples",
+                description="Number of ambient occlusion samples to render for each AA sample",
+                min=1, max=10000,
+                default=1,
+                )
+        cls.mesh_light_samples = IntProperty(
+                name="Mesh Light Samples",
+                description="Number of mesh emission light samples to render for each AA sample",
+                min=1, max=10000,
+                default=1,
+                )
+
         cls.no_caustics = BoolProperty(
                 name="No Caustics",
                 description="Leave out caustics, resulting in a darker image with less noise",
@@ -340,6 +389,12 @@ class CyclesLampSettings(bpy.types.PropertyGroup):
                 description="Lamp casts shadows",
                 default=True,
                 )
+        cls.samples = IntProperty(
+                name="Samples",
+                description="Number of light samples to render for each AA sample",
+                min=1, max=10000,
+                default=1,
+                )
 
     @classmethod
     def unregister(cls):
@@ -365,6 +420,12 @@ class CyclesWorldSettings(bpy.types.PropertyGroup):
                 min=4, max=8096,
                 default=256,
                 )
+        cls.samples = IntProperty(
+                name="Samples",
+                description="Number of light samples to render for each AA sample",
+                min=1, max=10000,
+                default=4,
+                )
 
     @classmethod
     def unregister(cls):
index 3b906bb4bdf0327c53225ccab8cae2c676171535..bda8249c17e943b51ed75b4886f50888be4077bb 100644 (file)
@@ -44,8 +44,49 @@ class CyclesButtonsPanel():
         return rd.engine == 'CYCLES'
 
 
-class CyclesRender_PT_integrator(CyclesButtonsPanel, Panel):
-    bl_label = "Integrator"
+class CyclesRender_PT_sampling(CyclesButtonsPanel, Panel):
+    bl_label = "Sampling"
+    bl_options = {'DEFAULT_CLOSED'}
+
+    def draw(self, context):
+        layout = self.layout
+
+        scene = context.scene
+        cscene = scene.cycles
+
+        split = layout.split()
+
+        col = split.column()
+        sub = col.column()
+        sub.active = cscene.device == 'CPU'
+        sub.prop(cscene, "progressive")
+
+        sub = col.column(align=True)
+        sub.prop(cscene, "seed")
+        sub.prop(cscene, "sample_clamp")
+
+        if cscene.progressive or cscene.device != 'CPU':
+            col = split.column()
+            col.label(text="Samples:")
+            sub = col.column(align=True)
+            sub.prop(cscene, "samples", text="Render")
+            sub.prop(cscene, "preview_samples", text="Preview")
+        else:
+            sub.label(text="AA Samples:")
+            sub.prop(cscene, "aa_samples", text="Render")
+            sub.prop(cscene, "preview_aa_samples", text="Preview")
+
+            col = split.column()
+            col.label(text="Samples:")
+            sub = col.column(align=True)
+            sub.prop(cscene, "diffuse_samples", text="Diffuse")
+            sub.prop(cscene, "glossy_samples", text="Glossy")
+            sub.prop(cscene, "transmission_samples", text="Transmission")
+            sub.prop(cscene, "ao_samples", text="AO")
+            sub.prop(cscene, "mesh_light_samples", text="Mesh Light")
+
+class CyclesRender_PT_light_paths(CyclesButtonsPanel, Panel):
+    bl_label = "Light Paths"
     bl_options = {'DEFAULT_CLOSED'}
 
     def draw(self, context):
@@ -62,12 +103,6 @@ class CyclesRender_PT_integrator(CyclesButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        sub = col.column(align=True)
-        sub.label(text="Samples:")
-        sub.prop(cscene, "samples", text="Render")
-        sub.prop(cscene, "preview_samples", text="Preview")
-        sub.prop(cscene, "seed")
-        sub.prop(cscene, "sample_clamp")
 
         sub = col.column(align=True)
         sub.label("Transparency:")
@@ -75,6 +110,11 @@ class CyclesRender_PT_integrator(CyclesButtonsPanel, Panel):
         sub.prop(cscene, "transparent_min_bounces", text="Min")
         sub.prop(cscene, "use_transparent_shadows", text="Shadows")
 
+        col.separator()
+
+        col.prop(cscene, "no_caustics")
+        col.prop(cscene, "blur_glossy")
+
         col = split.column()
 
         sub = col.column(align=True)
@@ -83,16 +123,10 @@ class CyclesRender_PT_integrator(CyclesButtonsPanel, Panel):
         sub.prop(cscene, "min_bounces", text="Min")
 
         sub = col.column(align=True)
-        sub.label(text="Light Paths:")
         sub.prop(cscene, "diffuse_bounces", text="Diffuse")
         sub.prop(cscene, "glossy_bounces", text="Glossy")
         sub.prop(cscene, "transmission_bounces", text="Transmission")
 
-        col.separator()
-
-        col.prop(cscene, "no_caustics")
-        col.prop(cscene, "blur_glossy")
-
 
 class CyclesRender_PT_motion_blur(CyclesButtonsPanel, Panel):
     bl_label = "Motion Blur"
@@ -467,6 +501,7 @@ class CyclesLamp_PT_lamp(CyclesButtonsPanel, Panel):
 
         lamp = context.lamp
         clamp = lamp.cycles
+        cscene = context.scene.cycles
 
         layout.prop(lamp, "type", expand=True)
 
@@ -485,6 +520,9 @@ class CyclesLamp_PT_lamp(CyclesButtonsPanel, Panel):
                 sub.prop(lamp, "size", text="Size X")
                 sub.prop(lamp, "size_y", text="Size Y")
 
+        if not cscene.progressive and cscene.device == 'CPU':
+            col.prop(clamp, "samples")
+
         col = split.column()
         col.prop(clamp, "cast_shadow")
 
@@ -604,13 +642,16 @@ class CyclesWorld_PT_settings(CyclesButtonsPanel, Panel):
 
         world = context.world
         cworld = world.cycles
+        cscene = context.scene.cycles
 
         col = layout.column()
 
         col.prop(cworld, "sample_as_light")
-        row = col.row()
-        row.active = cworld.sample_as_light
-        row.prop(cworld, "sample_map_resolution")
+        sub = col.row(align=True)
+        sub.active = cworld.sample_as_light
+        sub.prop(cworld, "sample_map_resolution")
+        if not cscene.progressive and cscene.device == 'CPU':
+            sub.prop(cworld, "samples")
 
 
 class CyclesMaterial_PT_surface(CyclesButtonsPanel, Panel):
index 122d0bd7c17c08e2d4ac8af9f40e636eaa8bf2b6..46d5fefd4dcad7140cad2e6ae6dd21ea4c12b55b 100644 (file)
@@ -485,10 +485,10 @@ static void blender_camera_border(BlenderCamera *bcam, BL::Scene b_scene, BL::Sp
        bcam->border_top = tmp_bottom + bcam->border_top*(tmp_top - tmp_bottom);
 
        /* clamp */
-       bcam->border_left = max(bcam->border_left, 0.0f);
-       bcam->border_right = min(bcam->border_right, 1.0f);
-       bcam->border_bottom = max(bcam->border_bottom, 0.0f);
-       bcam->border_top = min(bcam->border_top, 1.0f);
+       bcam->border_left = clamp(bcam->border_left, 0.0f, 1.0f);
+       bcam->border_right = clamp(bcam->border_right, 0.0f, 1.0f);
+       bcam->border_bottom = clamp(bcam->border_bottom, 0.0f, 1.0f);
+       bcam->border_top = clamp(bcam->border_top, 0.0f, 1.0f);
 }
 
 void BlenderSync::sync_view(BL::SpaceView3D b_v3d, BL::RegionView3D b_rv3d, int width, int height)
@@ -514,6 +514,10 @@ BufferParams BlenderSync::get_buffer_params(BL::Scene b_scene, Camera *cam, int
                params.full_y = cam->border_bottom*height;
                params.width = (int)(cam->border_right*width) - params.full_x;
                params.height = (int)(cam->border_top*height) - params.full_y;
+
+               /* survive in case border goes out of view or becomes too small */
+               params.width = max(params.width, 1);
+               params.height = max(params.height, 1);
        }
        else {
                params.width = width;
index c4b58d6fa761c5ffa6642a01397d70b45366d2a8..d5b884cfccd46ca822c8f607fcb0bc1368e2e2b2 100644 (file)
@@ -154,6 +154,7 @@ void BlenderSync::sync_light(BL::Object b_parent, int b_index, BL::Object b_ob,
        /* shadow */
        PointerRNA clamp = RNA_pointer_get(&b_lamp.ptr, "cycles");
        light->cast_shadow = get_boolean(clamp, "cast_shadow");
+       light->samples = get_int(clamp, "samples");
 
        /* tag */
        light->tag_update(scene);
@@ -178,6 +179,7 @@ void BlenderSync::sync_background_light()
                        {
                                light->type = LIGHT_BACKGROUND;
                                light->map_resolution  = get_int(cworld, "sample_map_resolution");
+                               light->samples  = get_int(cworld, "samples");
                                light->shader = scene->default_background;
 
                                light->tag_update(scene);
@@ -317,14 +319,18 @@ void BlenderSync::sync_objects(BL::SpaceView3D b_v3d, int motion)
                                        object_create_duplilist(*b_ob, b_scene);
 
                                        BL::Object::dupli_list_iterator b_dup;
+                                       int b_index = 0;
+
                                        for(b_ob->dupli_list.begin(b_dup); b_dup != b_ob->dupli_list.end(); ++b_dup) {
                                                Transform tfm = get_transform(b_dup->matrix());
                                                BL::Object b_dup_ob = b_dup->object();
                                                bool dup_hide = (b_v3d)? b_dup_ob.hide(): b_dup_ob.hide_render();
 
                                                if(!(b_dup->hide() || dup_hide)) {
-                                                       sync_object(*b_ob, b_dup->index(), b_dup_ob, tfm, ob_layer, motion, b_dup->particle_index() + particle_offset);
+                                                       sync_object(*b_ob, b_index, b_dup_ob, tfm, ob_layer, motion, b_dup->particle_index() + particle_offset);
                                                }
+                                               
+                                               ++b_index;
                                        }
 
                                        object_free_duplilist(*b_ob);
index 35fe4c67673dbafc03801ef10943965045a49122..2c15a60dab61fa2685f5356d63b9c6f3ace3639c 100644 (file)
@@ -75,6 +75,52 @@ static float get_node_output_value(BL::Node b_node, const string& name)
        return sock.default_value();
 }
 
+static ShaderSocketType convert_socket_type(BL::NodeSocket::type_enum b_type)
+{
+       switch (b_type) {
+       case BL::NodeSocket::type_VALUE:
+               return SHADER_SOCKET_FLOAT;
+       case BL::NodeSocket::type_VECTOR:
+               return SHADER_SOCKET_VECTOR;
+       case BL::NodeSocket::type_RGBA:
+               return SHADER_SOCKET_COLOR;
+       case BL::NodeSocket::type_SHADER:
+               return SHADER_SOCKET_CLOSURE;
+       
+       case BL::NodeSocket::type_BOOLEAN:
+       case BL::NodeSocket::type_MESH:
+       case BL::NodeSocket::type_INT:
+       default:
+               return SHADER_SOCKET_FLOAT;
+       }
+}
+
+static void set_default_value(ShaderInput *input, BL::NodeSocket sock)
+{
+       /* copy values for non linked inputs */
+       switch(input->type) {
+       case SHADER_SOCKET_FLOAT: {
+               BL::NodeSocketFloatNone value_sock(sock);
+               input->set(value_sock.default_value());
+               break;
+       }
+       case SHADER_SOCKET_COLOR: {
+               BL::NodeSocketRGBA rgba_sock(sock);
+               input->set(get_float3(rgba_sock.default_value()));
+               break;
+       }
+       case SHADER_SOCKET_NORMAL:
+       case SHADER_SOCKET_POINT:
+       case SHADER_SOCKET_VECTOR: {
+               BL::NodeSocketVectorNone vec_sock(sock);
+               input->set(get_float3(vec_sock.default_value()));
+               break;
+       }
+       case SHADER_SOCKET_CLOSURE:
+               break;
+       }
+}
+
 static void get_tex_mapping(TextureMapping *mapping, BL::TexMapping b_mapping)
 {
        if(!b_mapping)
@@ -122,6 +168,15 @@ static ShaderNode *add_node(BL::BlendData b_data, BL::Scene b_scene, ShaderGraph
                /* handled outside this function */
                case BL::ShaderNode::type_GROUP: break;
                /* existing blender nodes */
+               case BL::ShaderNode::type_REROUTE: {
+                       BL::Node::inputs_iterator b_input;
+                       b_node.inputs.begin(b_input);
+                       BL::Node::outputs_iterator b_output;
+                       b_node.outputs.begin(b_output);
+                       ProxyNode *proxy = new ProxyNode(convert_socket_type(b_input->type()), convert_socket_type(b_output->type()));
+                       node = proxy;
+                       break;
+               }
                case BL::ShaderNode::type_CURVE_RGB: {
                        RGBCurvesNode *ramp = new RGBCurvesNode();
                        node = ramp;
@@ -488,52 +543,6 @@ static SocketPair node_socket_map_pair(PtrNodeMap& node_map, BL::Node b_node, BL
        return SocketPair(node_map[b_node.ptr.data], name);
 }
 
-static ShaderSocketType convert_socket_type(BL::NodeSocket::type_enum b_type)
-{
-       switch (b_type) {
-       case BL::NodeSocket::type_VALUE:
-               return SHADER_SOCKET_FLOAT;
-       case BL::NodeSocket::type_VECTOR:
-               return SHADER_SOCKET_VECTOR;
-       case BL::NodeSocket::type_RGBA:
-               return SHADER_SOCKET_COLOR;
-       case BL::NodeSocket::type_SHADER:
-               return SHADER_SOCKET_CLOSURE;
-       
-       case BL::NodeSocket::type_BOOLEAN:
-       case BL::NodeSocket::type_MESH:
-       case BL::NodeSocket::type_INT:
-       default:
-               return SHADER_SOCKET_FLOAT;
-       }
-}
-
-static void set_default_value(ShaderInput *input, BL::NodeSocket sock)
-{
-       /* copy values for non linked inputs */
-       switch(input->type) {
-       case SHADER_SOCKET_FLOAT: {
-               BL::NodeSocketFloatNone value_sock(sock);
-               input->set(value_sock.default_value());
-               break;
-       }
-       case SHADER_SOCKET_COLOR: {
-               BL::NodeSocketRGBA rgba_sock(sock);
-               input->set(get_float3(rgba_sock.default_value()));
-               break;
-       }
-       case SHADER_SOCKET_NORMAL:
-       case SHADER_SOCKET_POINT:
-       case SHADER_SOCKET_VECTOR: {
-               BL::NodeSocketVectorNone vec_sock(sock);
-               input->set(get_float3(vec_sock.default_value()));
-               break;
-       }
-       case SHADER_SOCKET_CLOSURE:
-               break;
-       }
-}
-
 static void add_nodes(BL::BlendData b_data, BL::Scene b_scene, ShaderGraph *graph, BL::ShaderNodeTree b_ntree, PtrSockMap& sockets_map)
 {
        /* add nodes */
index 13040e551bdcd9e46dacdec1fdf7777cf511dcce..5640a411fd71243f600086eb4931bab2bdfa42e4 100644 (file)
@@ -168,6 +168,13 @@ void BlenderSync::sync_integrator()
        integrator->motion_blur = (!preview && r.use_motion_blur());
 #endif
 
+       integrator->diffuse_samples = get_int(cscene, "diffuse_samples");
+       integrator->glossy_samples = get_int(cscene, "glossy_samples");
+       integrator->transmission_samples = get_int(cscene, "transmission_samples");
+       integrator->ao_samples = get_int(cscene, "ao_samples");
+       integrator->mesh_light_samples = get_int(cscene, "mesh_light_samples");
+       integrator->progressive = get_boolean(cscene, "progressive");
+
        if(integrator->modified(previntegrator))
                integrator->tag_update(scene);
 }
@@ -308,15 +315,27 @@ SessionParams BlenderSync::get_session_params(BL::UserPreferences b_userpref, BL
 
        /* Background */
        params.background = background;
-                       
+
        /* samples */
-       if(background) {
-               params.samples = get_int(cscene, "samples");
+       if(get_boolean(cscene, "progressive")) {
+               if(background) {
+                       params.samples = get_int(cscene, "samples");
+               }
+               else {
+                       params.samples = get_int(cscene, "preview_samples");
+                       if(params.samples == 0)
+                               params.samples = INT_MAX;
+               }
        }
        else {
-               params.samples = get_int(cscene, "preview_samples");
-               if(params.samples == 0)
-                       params.samples = INT_MAX;
+               if(background) {
+                       params.samples = get_int(cscene, "aa_samples");
+               }
+               else {
+                       params.samples = get_int(cscene, "preview_aa_samples");
+                       if(params.samples == 0)
+                               params.samples = INT_MAX;
+               }
        }
 
        /* other parameters */
index f582ace69f0a2b1424cbaaf02b7e5fb7e948de35..53d53b4bedd498b71aed4e21aaa56dec566fca45 100644 (file)
@@ -67,7 +67,7 @@ __device bool direct_emission(KernelGlobals *kg, ShaderData *sd, int lindex,
 
        float pdf = -1.0f;
 
-#ifdef __MULTI_LIGHT__
+#ifdef __NON_PROGRESSIVE__
        if(lindex != -1) {
                /* sample position on a specified light */
                light_select(kg, lindex, randu, randv, sd->P, &ls, &pdf);
index edc302cd6e38f3a42f2eeaee3a8597463ac973b5..1084415d0cf73e30a11e62126fa4e7f33e245e6d 100644 (file)
@@ -388,6 +388,12 @@ __device float light_sample_pdf(KernelGlobals *kg, LightSample *ls, float3 I, fl
        return pdf;
 }
 
+__device int light_select_num_samples(KernelGlobals *kg, int index)
+{
+       float4 data3 = kernel_tex_fetch(__light_data, index*LIGHT_SIZE + 3);
+       return __float_as_int(data3.x);
+}
+
 __device void light_select(KernelGlobals *kg, int index, float randu, float randv, float3 P, LightSample *ls, float *pdf)
 {
        regular_light_sample(kg, index, randu, randv, P, ls, pdf);
index 8dbf66c108c08ced5d1d0fca3b71b80d6203f6ed..98ab9169c21351a4602db1dabab1fe5556446ab9 100644 (file)
@@ -218,7 +218,7 @@ __device_inline bool shadow_blocked(KernelGlobals *kg, PathState *state, Ray *ra
        return result;
 }
 
-__device float4 kernel_path_integrate(KernelGlobals *kg, RNG *rng, int sample, Ray ray, __global float *buffer)
+__device float4 kernel_path_progressive(KernelGlobals *kg, RNG *rng, int sample, Ray ray, __global float *buffer)
 {
        /* initialize */
        PathRadiance L;
@@ -366,26 +366,189 @@ __device float4 kernel_path_integrate(KernelGlobals *kg, RNG *rng, int sample, R
                                light_ray.time = sd.time;
 #endif
 
-#ifdef __MULTI_LIGHT__
-                               /* index -1 means randomly sample from distribution */
-                               int i = (kernel_data.integrator.num_all_lights)? 0: -1;
+                               if(direct_emission(kg, &sd, -1, light_t, light_o, light_u, light_v, &light_ray, &L_light, &is_lamp)) {
+                                       /* trace shadow ray */
+                                       float3 shadow;
 
-                               for(; i < kernel_data.integrator.num_all_lights; i++) {
-#else
-                               const int i = -1;
+                                       if(!shadow_blocked(kg, &state, &light_ray, &shadow)) {
+                                               /* accumulate */
+                                               path_radiance_accum_light(&L, throughput, &L_light, shadow, state.bounce, is_lamp);
+                                       }
+                               }
+                       }
+               }
 #endif
-                                       if(direct_emission(kg, &sd, i, light_t, light_o, light_u, light_v, &light_ray, &L_light, &is_lamp)) {
-                                               /* trace shadow ray */
-                                               float3 shadow;
 
-                                               if(!shadow_blocked(kg, &state, &light_ray, &shadow)) {
-                                                       /* accumulate */
-                                                       path_radiance_accum_light(&L, throughput, &L_light, shadow, state.bounce, is_lamp);
-                                               }
-                                       }
-#ifdef __MULTI_LIGHT__
+               /* no BSDF? we can stop here */
+               if(!(sd.flag & SD_BSDF))
+                       break;
+
+               /* sample BSDF */
+               float bsdf_pdf;
+               BsdfEval bsdf_eval;
+               float3 bsdf_omega_in;
+               differential3 bsdf_domega_in;
+               float bsdf_u = path_rng(kg, rng, sample, rng_offset + PRNG_BSDF_U);
+               float bsdf_v = path_rng(kg, rng, sample, rng_offset + PRNG_BSDF_V);
+               int label;
+
+               label = shader_bsdf_sample(kg, &sd, bsdf_u, bsdf_v, &bsdf_eval,
+                       &bsdf_omega_in, &bsdf_domega_in, &bsdf_pdf);
+
+               shader_release(kg, &sd);
+
+               if(bsdf_pdf == 0.0f || bsdf_eval_is_zero(&bsdf_eval))
+                       break;
+
+               /* modify throughput */
+               path_radiance_bsdf_bounce(&L, &throughput, &bsdf_eval, bsdf_pdf, state.bounce, label);
+
+               /* set labels */
+               if(!(label & LABEL_TRANSPARENT)) {
+                       ray_pdf = bsdf_pdf;
+                       min_ray_pdf = fminf(bsdf_pdf, min_ray_pdf);
+               }
+
+               /* update path state */
+               path_state_next(kg, &state, label);
+
+               /* setup ray */
+               ray.P = ray_offset(sd.P, (label & LABEL_TRANSMIT)? -sd.Ng: sd.Ng);
+               ray.D = bsdf_omega_in;
+               ray.t = FLT_MAX;
+#ifdef __RAY_DIFFERENTIALS__
+               ray.dP = sd.dP;
+               ray.dD = bsdf_domega_in;
+#endif
+       }
+
+       float3 L_sum = path_radiance_sum(kg, &L);
+
+#ifdef __CLAMP_SAMPLE__
+       path_radiance_clamp(&L, &L_sum, kernel_data.integrator.sample_clamp);
+#endif
+
+       kernel_write_light_passes(kg, buffer, &L, sample);
+
+       return make_float4(L_sum.x, L_sum.y, L_sum.z, 1.0f - L_transparent);
+}
+
+#ifdef __NON_PROGRESSIVE__
+
+__device void kernel_path_indirect(KernelGlobals *kg, RNG *rng, int sample, Ray ray, __global float *buffer,
+       float3 throughput, float min_ray_pdf, float ray_pdf, PathState state, int rng_offset, PathRadiance *L)
+{
+       /* path iteration */
+       for(;; rng_offset += PRNG_BOUNCE_NUM) {
+               /* intersect scene */
+               Intersection isect;
+               uint visibility = path_state_ray_visibility(kg, &state);
+
+               if(!scene_intersect(kg, &ray, visibility, &isect)) {
+#ifdef __BACKGROUND__
+                       /* sample background shader */
+                       float3 L_background = indirect_background(kg, &ray, state.flag, ray_pdf);
+                       path_radiance_accum_background(L, throughput, L_background, state.bounce);
+#endif
+
+                       break;
+               }
+
+               /* setup shading */
+               ShaderData sd;
+               shader_setup_from_ray(kg, &sd, &isect, &ray);
+               float rbsdf = path_rng(kg, rng, sample, rng_offset + PRNG_BSDF);
+               shader_eval_surface(kg, &sd, rbsdf, state.flag);
+               shader_merge_closures(kg, &sd);
+
+               /* blurring of bsdf after bounces, for rays that have a small likelihood
+                * of following this particular path (diffuse, rough glossy) */
+               if(kernel_data.integrator.filter_glossy != FLT_MAX) {
+                       float blur_pdf = kernel_data.integrator.filter_glossy*min_ray_pdf;
+
+                       if(blur_pdf < 1.0f) {
+                               float blur_roughness = sqrtf(1.0f - blur_pdf)*0.5f;
+                               shader_bsdf_blur(kg, &sd, blur_roughness);
+                       }
+               }
+
+#ifdef __EMISSION__
+               /* emission */
+               if(sd.flag & SD_EMISSION) {
+                       float3 emission = indirect_emission(kg, &sd, isect.t, state.flag, ray_pdf);
+                       path_radiance_accum_emission(L, throughput, emission, state.bounce);
+               }
+#endif
+
+               /* path termination. this is a strange place to put the termination, it's
+                * mainly due to the mixed in MIS that we use. gives too many unneeded
+                * shader evaluations, only need emission if we are going to terminate */
+               float probability = path_state_terminate_probability(kg, &state, throughput);
+               float terminate = path_rng(kg, rng, sample, rng_offset + PRNG_TERMINATE);
+
+               if(terminate >= probability)
+                       break;
+
+               throughput /= probability;
+
+#ifdef __AO__
+               /* ambient occlusion */
+               if(kernel_data.integrator.use_ambient_occlusion) {
+                       /* todo: solve correlation */
+                       float bsdf_u = path_rng(kg, rng, sample, rng_offset + PRNG_BSDF_U);
+                       float bsdf_v = path_rng(kg, rng, sample, rng_offset + PRNG_BSDF_V);
+
+                       float3 ao_D;
+                       float ao_pdf;
+
+                       sample_cos_hemisphere(sd.N, bsdf_u, bsdf_v, &ao_D, &ao_pdf);
+
+                       if(dot(sd.Ng, ao_D) > 0.0f && ao_pdf != 0.0f) {
+                               Ray light_ray;
+                               float3 ao_shadow;
+
+                               light_ray.P = ray_offset(sd.P, sd.Ng);
+                               light_ray.D = ao_D;
+                               light_ray.t = kernel_data.background.ao_distance;
+#ifdef __MOTION__
+                               light_ray.time = sd.time;
+#endif
+
+                               if(!shadow_blocked(kg, &state, &light_ray, &ao_shadow)) {
+                                       float3 ao_bsdf = shader_bsdf_diffuse(kg, &sd)*kernel_data.background.ao_factor;
+                                       path_radiance_accum_ao(L, throughput, ao_bsdf, ao_shadow, state.bounce);
                                }
+                       }
+               }
 #endif
+
+#ifdef __EMISSION__
+               if(kernel_data.integrator.use_direct_light) {
+                       /* sample illumination from lights to find path contribution */
+                       if(sd.flag & SD_BSDF_HAS_EVAL) {
+                               float light_t = path_rng(kg, rng, sample, rng_offset + PRNG_LIGHT);
+                               float light_o = path_rng(kg, rng, sample, rng_offset + PRNG_LIGHT_F);
+                               float light_u = path_rng(kg, rng, sample, rng_offset + PRNG_LIGHT_U);
+                               float light_v = path_rng(kg, rng, sample, rng_offset + PRNG_LIGHT_V);
+
+                               Ray light_ray;
+                               BsdfEval L_light;
+                               bool is_lamp;
+
+#ifdef __MOTION__
+                               light_ray.time = sd.time;
+#endif
+
+                               /* sample random light */
+                               if(direct_emission(kg, &sd, -1, light_t, light_o, light_u, light_v, &light_ray, &L_light, &is_lamp)) {
+                                       /* trace shadow ray */
+                                       float3 shadow;
+
+                                       if(!shadow_blocked(kg, &state, &light_ray, &shadow)) {
+                                               /* accumulate */
+                                               path_radiance_accum_light(L, throughput, &L_light, shadow, state.bounce, is_lamp);
+                                       }
+                               }
                        }
                }
 #endif
@@ -412,7 +575,7 @@ __device float4 kernel_path_integrate(KernelGlobals *kg, RNG *rng, int sample, R
                        break;
 
                /* modify throughput */
-               path_radiance_bsdf_bounce(&L, &throughput, &bsdf_eval, bsdf_pdf, state.bounce, label);
+               path_radiance_bsdf_bounce(L, &throughput, &bsdf_eval, bsdf_pdf, state.bounce, label);
 
                /* set labels */
                if(!(label & LABEL_TRANSPARENT)) {
@@ -432,6 +595,276 @@ __device float4 kernel_path_integrate(KernelGlobals *kg, RNG *rng, int sample, R
                ray.dD = bsdf_domega_in;
 #endif
        }
+}
+
+__device float4 kernel_path_non_progressive(KernelGlobals *kg, RNG *rng, int sample, Ray ray, __global float *buffer)
+{
+       /* initialize */
+       PathRadiance L;
+       float3 throughput = make_float3(1.0f, 1.0f, 1.0f);
+       float L_transparent = 0.0f;
+
+       path_radiance_init(&L, kernel_data.film.use_light_pass);
+
+       float ray_pdf = 0.0f;
+       PathState state;
+       int rng_offset = PRNG_BASE_NUM;
+
+       path_state_init(&state);
+
+       for(;; rng_offset += PRNG_BOUNCE_NUM) {
+               /* intersect scene */
+               Intersection isect;
+               uint visibility = path_state_ray_visibility(kg, &state);
+
+               if(!scene_intersect(kg, &ray, visibility, &isect)) {
+                       /* eval background shader if nothing hit */
+                       if(kernel_data.background.transparent) {
+                               L_transparent += average(throughput);
+
+#ifdef __PASSES__
+                               if(!(kernel_data.film.pass_flag & PASS_BACKGROUND))
+#endif
+                                       break;
+                       }
+
+#ifdef __BACKGROUND__
+                       /* sample background shader */
+                       float3 L_background = indirect_background(kg, &ray, state.flag, ray_pdf);
+                       path_radiance_accum_background(&L, throughput, L_background, state.bounce);
+#endif
+
+                       break;
+               }
+
+               /* setup shading */
+               ShaderData sd;
+               shader_setup_from_ray(kg, &sd, &isect, &ray);
+               float rbsdf = path_rng(kg, rng, sample, rng_offset + PRNG_BSDF);
+               shader_eval_surface(kg, &sd, rbsdf, state.flag);
+               shader_merge_closures(kg, &sd);
+
+               kernel_write_data_passes(kg, buffer, &L, &sd, sample, state.flag, throughput);
+
+               /* holdout */
+#ifdef __HOLDOUT__
+               if((sd.flag & (SD_HOLDOUT|SD_HOLDOUT_MASK))) {
+                       if(kernel_data.background.transparent) {
+                               float3 holdout_weight;
+                               
+                               if(sd.flag & SD_HOLDOUT_MASK)
+                                       holdout_weight = make_float3(1.0f, 1.0f, 1.0f);
+                               else
+                                       shader_holdout_eval(kg, &sd);
+
+                               /* any throughput is ok, should all be identical here */
+                               L_transparent += average(holdout_weight*throughput);
+                       }
+
+                       if(sd.flag & SD_HOLDOUT_MASK)
+                               break;
+               }
+#endif
+
+#ifdef __EMISSION__
+               /* emission */
+               if(sd.flag & SD_EMISSION) {
+                       float3 emission = indirect_emission(kg, &sd, isect.t, state.flag, ray_pdf);
+                       path_radiance_accum_emission(&L, throughput, emission, state.bounce);
+               }
+#endif
+
+               /* transparency termination */
+               if(state.flag & PATH_RAY_TRANSPARENT) {
+                       /* path termination. this is a strange place to put the termination, it's
+                        * mainly due to the mixed in MIS that we use. gives too many unneeded
+                        * shader evaluations, only need emission if we are going to terminate */
+                       float probability = path_state_terminate_probability(kg, &state, throughput);
+                       float terminate = path_rng(kg, rng, sample, rng_offset + PRNG_TERMINATE);
+
+                       if(terminate >= probability)
+                               break;
+
+                       throughput /= probability;
+               }
+
+#ifdef __AO__
+               /* ambient occlusion */
+               if(kernel_data.integrator.use_ambient_occlusion) {
+                       int num_samples = kernel_data.integrator.ao_samples;
+                       float num_samples_inv = 1.0f/num_samples;
+                       float ao_factor = kernel_data.background.ao_factor/num_samples;
+
+                       for(int j = 0; j < num_samples; j++) {
+                               /* todo: solve correlation */
+                               float bsdf_u = path_rng(kg, rng, sample*num_samples + j, rng_offset + PRNG_BSDF_U);
+                               float bsdf_v = path_rng(kg, rng, sample*num_samples + j, rng_offset + PRNG_BSDF_V);
+
+                               float3 ao_D;
+                               float ao_pdf;
+
+                               sample_cos_hemisphere(sd.N, bsdf_u, bsdf_v, &ao_D, &ao_pdf);
+
+                               if(dot(sd.Ng, ao_D) > 0.0f && ao_pdf != 0.0f) {
+                                       Ray light_ray;
+                                       float3 ao_shadow;
+
+                                       light_ray.P = ray_offset(sd.P, sd.Ng);
+                                       light_ray.D = ao_D;
+                                       light_ray.t = kernel_data.background.ao_distance;
+#ifdef __MOTION__
+                                       light_ray.time = sd.time;
+#endif
+
+                                       if(!shadow_blocked(kg, &state, &light_ray, &ao_shadow)) {
+                                               float3 ao_bsdf = shader_bsdf_diffuse(kg, &sd)*ao_factor;
+                                               path_radiance_accum_ao(&L, throughput*num_samples_inv, ao_bsdf, ao_shadow, state.bounce);
+                                       }
+                               }
+                       }
+               }
+#endif
+
+#ifdef __EMISSION__
+               /* sample illumination from lights to find path contribution */
+               if(sd.flag & SD_BSDF_HAS_EVAL) {
+                       Ray light_ray;
+                       BsdfEval L_light;
+                       bool is_lamp;
+
+#ifdef __MOTION__
+                       light_ray.time = sd.time;
+#endif
+
+                       /* lamp sampling */
+                       for(int i = 0; i < kernel_data.integrator.num_all_lights; i++) {
+                               int num_samples = light_select_num_samples(kg, i);
+                               float num_samples_inv = 1.0f/(num_samples*kernel_data.integrator.num_all_lights);
+
+                               if(kernel_data.integrator.pdf_triangles != 0.0f)
+                                       num_samples_inv *= 0.5f;
+
+                               for(int j = 0; j < num_samples; j++) {
+                                       float light_u = path_rng(kg, rng, sample*num_samples + j, rng_offset + PRNG_LIGHT_U);
+                                       float light_v = path_rng(kg, rng, sample*num_samples + j, rng_offset + PRNG_LIGHT_V);
+
+                                       if(direct_emission(kg, &sd, i, 0.0f, 0.0f, light_u, light_v, &light_ray, &L_light, &is_lamp)) {
+                                               /* trace shadow ray */
+                                               float3 shadow;
+
+                                               if(!shadow_blocked(kg, &state, &light_ray, &shadow)) {
+                                                       /* accumulate */
+                                                       path_radiance_accum_light(&L, throughput*num_samples_inv, &L_light, shadow, state.bounce, is_lamp);
+                                               }
+                                       }
+                               }
+                       }
+
+                       /* mesh light sampling */
+                       if(kernel_data.integrator.pdf_triangles != 0.0f) {
+                               int num_samples = kernel_data.integrator.mesh_light_samples;
+                               float num_samples_inv = 1.0f/num_samples;
+
+                               if(kernel_data.integrator.num_all_lights)
+                                       num_samples_inv *= 0.5f;
+
+                               for(int j = 0; j < num_samples; j++) {
+                                       float light_t = path_rng(kg, rng, sample*num_samples + j, rng_offset + PRNG_LIGHT);
+                                       float light_u = path_rng(kg, rng, sample*num_samples + j, rng_offset + PRNG_LIGHT_U);
+                                       float light_v = path_rng(kg, rng, sample*num_samples + j, rng_offset + PRNG_LIGHT_V);
+
+                                       /* only sample triangle lights */
+                                       if(kernel_data.integrator.num_all_lights)
+                                               light_t = 0.5f*light_t;
+
+                                       if(direct_emission(kg, &sd, -1, light_t, 0.0f, light_u, light_v, &light_ray, &L_light, &is_lamp)) {
+                                               /* trace shadow ray */
+                                               float3 shadow;
+
+                                               if(!shadow_blocked(kg, &state, &light_ray, &shadow)) {
+                                                       /* accumulate */
+                                                       path_radiance_accum_light(&L, throughput*num_samples_inv, &L_light, shadow, state.bounce, is_lamp);
+                                               }
+                                       }
+                               }
+                       }
+               }
+#endif
+
+               for(int i = 0; i< sd.num_closure; i++) {
+                       const ShaderClosure *sc = &sd.closure[i];
+
+                       if(!CLOSURE_IS_BSDF(sc->type))
+                               continue;
+                       /* transparency is not handled here, but in outer loop */
+                       if(sc->type == CLOSURE_BSDF_TRANSPARENT_ID)
+                               continue;
+
+                       int num_samples;
+
+                       if(CLOSURE_IS_BSDF_DIFFUSE(sc->type))
+                               num_samples = kernel_data.integrator.diffuse_samples;
+                       else if(CLOSURE_IS_BSDF_GLOSSY(sc->type))
+                               num_samples = kernel_data.integrator.glossy_samples;
+                       else
+                               num_samples = kernel_data.integrator.transmission_samples;
+
+                       float num_samples_inv = 1.0f/num_samples;
+
+                       for(int j = 0; j < num_samples; j++) {
+                               /* sample BSDF */
+                               float bsdf_pdf;
+                               BsdfEval bsdf_eval;
+                               float3 bsdf_omega_in;
+                               differential3 bsdf_domega_in;
+                               float bsdf_u = path_rng(kg, rng, sample*num_samples + j, rng_offset + PRNG_BSDF_U);
+                               float bsdf_v = path_rng(kg, rng, sample*num_samples + j, rng_offset + PRNG_BSDF_V);
+                               int label;
+
+                               label = shader_bsdf_sample_closure(kg, &sd, sc, bsdf_u, bsdf_v, &bsdf_eval,
+                                       &bsdf_omega_in, &bsdf_domega_in, &bsdf_pdf);
+
+                               if(bsdf_pdf == 0.0f || bsdf_eval_is_zero(&bsdf_eval))
+                                       continue;
+
+                               /* modify throughput */
+                               float3 tp = throughput;
+                               path_radiance_bsdf_bounce(&L, &tp, &bsdf_eval, bsdf_pdf, state.bounce, label);
+
+                               /* set labels */
+                               float min_ray_pdf = FLT_MAX;
+
+                               if(!(label & LABEL_TRANSPARENT))
+                                       min_ray_pdf = fminf(bsdf_pdf, min_ray_pdf);
+
+                               /* modify path state */
+                               PathState ps = state;
+                               path_state_next(kg, &ps, label);
+
+                               /* setup ray */
+                               ray.P = ray_offset(sd.P, (label & LABEL_TRANSMIT)? -sd.Ng: sd.Ng);
+                               ray.D = bsdf_omega_in;
+                               ray.t = FLT_MAX;
+#ifdef __RAY_DIFFERENTIALS__
+                               ray.dP = sd.dP;
+                               ray.dD = bsdf_domega_in;
+#endif
+
+                               kernel_path_indirect(kg, rng, sample*num_samples, ray, buffer,
+                                       tp*num_samples_inv, min_ray_pdf, bsdf_pdf, ps, rng_offset+PRNG_BOUNCE_NUM, &L);
+                       }
+               }
+
+               /* continue in case of transparency */
+               throughput *= shader_bsdf_transparency(kg, &sd);
+               shader_release(kg, &sd);
+
+               if(is_zero(throughput))
+                       break;
+
+               path_state_next(kg, &state, LABEL_TRANSPARENT);
+               ray.P = ray_offset(sd.P, -sd.Ng);
+       }
 
        float3 L_sum = path_radiance_sum(kg, &L);
 
@@ -444,6 +877,8 @@ __device float4 kernel_path_integrate(KernelGlobals *kg, RNG *rng, int sample, R
        return make_float4(L_sum.x, L_sum.y, L_sum.z, 1.0f - L_transparent);
 }
 
+#endif
+
 __device void kernel_path_trace(KernelGlobals *kg,
        __global float *buffer, __global uint *rng_state,
        int sample, int x, int y, int offset, int stride)
@@ -480,8 +915,16 @@ __device void kernel_path_trace(KernelGlobals *kg,
        /* integrate */
        float4 L;
 
-       if (ray.t != 0.f)
-               L = kernel_path_integrate(kg, &rng, sample, ray, buffer);
+       if (ray.t != 0.0f) {
+#ifdef __NON_PROGRESSIVE__
+               if(kernel_data.integrator.progressive)
+#endif
+                       L = kernel_path_progressive(kg, &rng, sample, ray, buffer);
+#ifdef __NON_PROGRESSIVE__
+               else
+                       L = kernel_path_non_progressive(kg, &rng, sample, ray, buffer);
+#endif
+       }
        else
                L = make_float4(0.f, 0.f, 0.f, 0.f);
 
index 53a41d58e200b8e327d764f743e840c1c4142486..bc873f4e112306d4ab6a7f54290c538790a730b3 100644 (file)
@@ -407,6 +407,25 @@ __device int shader_bsdf_sample(KernelGlobals *kg, const ShaderData *sd,
 #endif
 }
 
+__device int shader_bsdf_sample_closure(KernelGlobals *kg, const ShaderData *sd,
+       const ShaderClosure *sc, float randu, float randv, BsdfEval *bsdf_eval,
+       float3 *omega_in, differential3 *domega_in, float *pdf)
+{
+       int label;
+       float3 eval;
+
+       *pdf = 0.0f;
+#ifdef __OSL__
+       label = OSLShader::bsdf_sample(sd, sc, randu, randv, eval, *omega_in, *domega_in, *pdf);
+#else
+       label = svm_bsdf_sample(sd, sc, randu, randv, &eval, omega_in, domega_in, pdf);
+#endif
+       if(*pdf != 0.0f)
+               bsdf_eval_init(bsdf_eval, sc->type, eval*sc->weight, kernel_data.film.use_light_pass);
+
+       return label;
+}
+
 __device void shader_bsdf_blur(KernelGlobals *kg, ShaderData *sd, float roughness)
 {
 #ifndef __OSL__
@@ -679,6 +698,35 @@ __device bool shader_transparent_shadow(KernelGlobals *kg, Intersection *isect)
 }
 #endif
 
+/* Merging */
+
+#ifdef __NON_PROGRESSIVE__
+__device void shader_merge_closures(KernelGlobals *kg, ShaderData *sd)
+{
+#ifndef __OSL__
+       /* merge identical closures, better when we sample a single closure at a time */
+       for(int i = 0; i < sd->num_closure; i++) {
+               ShaderClosure *sci = &sd->closure[i];
+
+               for(int j = i + 1; j < sd->num_closure; j++) {
+                       ShaderClosure *scj = &sd->closure[j];
+
+                       if(sci->type == scj->type && sci->data0 == scj->data0 && sci->data1 == scj->data1) {
+                               sci->weight += scj->weight;
+                               sci->sample_weight += scj->sample_weight;
+
+                               int size = sd->num_closure - (j+1);
+                               if(size > 0)
+                                       memmove(scj, scj+1, size*sizeof(ShaderClosure));
+
+                               sd->num_closure--;
+                       }
+               }
+       }
+#endif
+}
+#endif
+
 /* Free ShaderData */
 
 __device void shader_release(KernelGlobals *kg, ShaderData *sd)
index 77a800b0e674731775ec9d1729f2a2137f48a716..d204b114b8e5a5e51370f9a4804956e5ebc32f48 100644 (file)
@@ -43,6 +43,7 @@ CCL_NAMESPACE_BEGIN
 #ifdef WITH_OSL
 #define __OSL__
 #endif
+#define __NON_PROGRESSIVE__
 #endif
 
 #ifdef __KERNEL_CUDA__
@@ -110,7 +111,6 @@ CCL_NAMESPACE_BEGIN
 //#define __MOTION__
 #endif
 
-//#define __MULTI_LIGHT__
 //#define __SOBOL_FULL_SCREEN__
 //#define __QBVH__
 
@@ -627,6 +627,15 @@ typedef struct KernelIntegrator {
 
        /* clamp */
        float sample_clamp;
+
+       /* non-progressive */
+       int progressive;
+       int diffuse_samples;
+       int glossy_samples;
+       int transmission_samples;
+       int ao_samples;
+       int mesh_light_samples;
+       int pad1, pad2;
 } KernelIntegrator;
 
 typedef struct KernelBVH {
index b26ebfd91e178733c82773d724a1f4b8f152bded..da563c9c4ec7469857c9236ccef9417947882654 100644 (file)
 
 #include "device.h"
 #include "integrator.h"
+#include "light.h"
 #include "scene.h"
 #include "sobol.h"
 
+#include "util_foreach.h"
 #include "util_hash.h"
 
 CCL_NAMESPACE_BEGIN
@@ -47,6 +49,13 @@ Integrator::Integrator()
        sample_clamp = 0.0f;
        motion_blur = false;
 
+       diffuse_samples = 1;
+       glossy_samples = 1;
+       transmission_samples = 1;
+       ao_samples = 1;
+       mesh_light_samples = 1;
+       progressive = true;
+
        need_update = true;
 }
 
@@ -54,7 +63,7 @@ Integrator::~Integrator()
 {
 }
 
-void Integrator::device_update(Device *device, DeviceScene *dscene)
+void Integrator::device_update(Device *device, DeviceScene *dscene, Scene *scene)
 {
        if(!need_update)
                return;
@@ -93,8 +102,27 @@ void Integrator::device_update(Device *device, DeviceScene *dscene)
        
        kintegrator->sample_clamp = (sample_clamp == 0.0f)? FLT_MAX: sample_clamp*3.0f;
 
+       kintegrator->progressive = progressive;
+       kintegrator->diffuse_samples = diffuse_samples;
+       kintegrator->glossy_samples = glossy_samples;
+       kintegrator->transmission_samples = transmission_samples;
+       kintegrator->ao_samples = ao_samples;
+       kintegrator->mesh_light_samples = mesh_light_samples;
+
        /* sobol directions table */
-       int dimensions = PRNG_BASE_NUM + (max_bounce + transparent_max_bounce + 2)*PRNG_BOUNCE_NUM;
+       int max_samples = 1;
+
+       if(!progressive) {
+               foreach(Light *light, scene->lights)
+                       max_samples = max(max_samples, light->samples);
+
+               max_samples = max(max_samples, max(diffuse_samples, max(glossy_samples, transmission_samples)));
+               max_samples = max(max_samples, max(ao_samples, mesh_light_samples));
+       }
+
+       max_samples *= (max_bounce + transparent_max_bounce + 2);
+
+       int dimensions = PRNG_BASE_NUM + max_samples*PRNG_BOUNCE_NUM;
        uint *directions = dscene->sobol_directions.resize(SOBOL_BITS*dimensions);
 
        sobol_generate_direction_vectors((uint(*)[SOBOL_BITS])directions, dimensions);
@@ -127,6 +155,12 @@ bool Integrator::modified(const Integrator& integrator)
                layer_flag == integrator.layer_flag &&
                seed == integrator.seed &&
                sample_clamp == integrator.sample_clamp &&
+               progressive == integrator.progressive &&
+               diffuse_samples == integrator.diffuse_samples &&
+               glossy_samples == integrator.glossy_samples &&
+               transmission_samples == integrator.transmission_samples &&
+               ao_samples == integrator.ao_samples &&
+               mesh_light_samples == integrator.mesh_light_samples &&
                motion_blur == integrator.motion_blur);
 }
 
index afda41a857ddc022412ed8fcad9e6ad851e93b8c..8fb341182b74ccd882c1801b7a1f114c11b197f9 100644 (file)
@@ -49,12 +49,20 @@ public:
        float sample_clamp;
        bool motion_blur;
 
+       int diffuse_samples;
+       int glossy_samples;
+       int transmission_samples;
+       int ao_samples;
+       int mesh_light_samples;
+
+       bool progressive;
+
        bool need_update;
 
        Integrator();
        ~Integrator();
 
-       void device_update(Device *device, DeviceScene *dscene);
+       void device_update(Device *device, DeviceScene *dscene, Scene *scene);
        void device_free(Device *device, DeviceScene *dscene);
 
        bool modified(const Integrator& integrator);
index e918de990c212ea17a5c1d0620dc19e785c58075..6c03d0859a75caafd93f00f23e0e017979d8fd44 100644 (file)
@@ -17,6 +17,7 @@
  */
 
 #include "device.h"
+#include "integrator.h"
 #include "light.h"
 #include "mesh.h"
 #include "object.h"
@@ -114,6 +115,7 @@ Light::Light()
 
        cast_shadow = true;
        shader = 0;
+       samples = 1;
 }
 
 void Light::tag_update(Scene *scene)
@@ -136,9 +138,6 @@ void LightManager::device_update_distribution(Device *device, DeviceScene *dscen
 {
        progress.set_status("Updating Lights", "Computing distribution");
 
-       /* option to always sample all point lights */
-       bool multi_light = false;
-
        /* count */
        size_t num_lights = scene->lights.size();
        size_t num_triangles = 0;
@@ -169,9 +168,7 @@ void LightManager::device_update_distribution(Device *device, DeviceScene *dscen
        }
 
        size_t num_distribution = num_triangles;
-
-       if(!multi_light)
-               num_distribution += num_lights;
+       num_distribution += num_lights;
 
        /* emission area */
        float4 *distribution = dscene->light_distribution.resize(num_distribution + 1);
@@ -231,16 +228,14 @@ void LightManager::device_update_distribution(Device *device, DeviceScene *dscen
        float trianglearea = totarea;
 
        /* point lights */
-       if(!multi_light) {
-               float lightarea = (totarea > 0.0f)? totarea/scene->lights.size(): 1.0f;
-
-               for(int i = 0; i < scene->lights.size(); i++, offset++) {
-                       distribution[offset].x = totarea;
-                       distribution[offset].y = __int_as_float(~(int)i);
-                       distribution[offset].z = 1.0f;
-                       distribution[offset].w = scene->lights[i]->size;
-                       totarea += lightarea;
-               }
+       float lightarea = (totarea > 0.0f)? totarea/scene->lights.size(): 1.0f;
+
+       for(int i = 0; i < scene->lights.size(); i++, offset++) {
+               distribution[offset].x = totarea;
+               distribution[offset].y = __int_as_float(~(int)i);
+               distribution[offset].z = 1.0f;
+               distribution[offset].w = scene->lights[i]->size;
+               totarea += lightarea;
        }
 
        /* normalize cumulative distribution functions */
@@ -259,7 +254,7 @@ void LightManager::device_update_distribution(Device *device, DeviceScene *dscen
 
        /* update device */
        KernelIntegrator *kintegrator = &dscene->data.integrator;
-       kintegrator->use_direct_light = (totarea > 0.0f) || (multi_light && num_lights);
+       kintegrator->use_direct_light = (totarea > 0.0f);
 
        if(kintegrator->use_direct_light) {
                /* number of emissives */
@@ -269,30 +264,19 @@ void LightManager::device_update_distribution(Device *device, DeviceScene *dscen
                kintegrator->pdf_triangles = 0.0f;
                kintegrator->pdf_lights = 0.0f;
 
-               if(multi_light) {
-                       /* sample one of all triangles and all lights */
-                       kintegrator->num_all_lights = num_lights;
+               /* sample one, with 0.5 probability of light or triangle */
+               kintegrator->num_all_lights = num_lights;
 
-                       if(trianglearea > 0.0f)
-                               kintegrator->pdf_triangles = 1.0f/trianglearea;
+               if(trianglearea > 0.0f) {
+                       kintegrator->pdf_triangles = 1.0f/trianglearea;
                        if(num_lights)
-                               kintegrator->pdf_lights = 1.0f;
+                               kintegrator->pdf_triangles *= 0.5f;
                }
-               else {
-                       /* sample one, with 0.5 probability of light or triangle */
-                       kintegrator->num_all_lights = 0;
-
-                       if(trianglearea > 0.0f) {
-                               kintegrator->pdf_triangles = 1.0f/trianglearea;
-                               if(num_lights)
-                                       kintegrator->pdf_triangles *= 0.5f;
-                       }
 
-                       if(num_lights) {
-                               kintegrator->pdf_lights = 1.0f/num_lights;
-                               if(trianglearea > 0.0f)
-                                       kintegrator->pdf_lights *= 0.5f;
-                       }
+               if(num_lights) {
+                       kintegrator->pdf_lights = 1.0f/num_lights;
+                       if(trianglearea > 0.0f)
+                               kintegrator->pdf_lights *= 0.5f;
                }
 
                /* CDF */
@@ -417,6 +401,7 @@ void LightManager::device_update_points(Device *device, DeviceScene *dscene, Sce
                float3 co = light->co;
                float3 dir = normalize(light->dir);
                int shader_id = scene->shader_manager->get_shader_id(scene->lights[i]->shader);
+               float samples = __int_as_float(light->samples);
 
                if(!light->cast_shadow)
                        shader_id &= ~SHADER_CAST_SHADOW;
@@ -427,7 +412,7 @@ void LightManager::device_update_points(Device *device, DeviceScene *dscene, Sce
                        light_data[i*LIGHT_SIZE + 0] = make_float4(__int_as_float(light->type), co.x, co.y, co.z);
                        light_data[i*LIGHT_SIZE + 1] = make_float4(__int_as_float(shader_id), light->size, 0.0f, 0.0f);
                        light_data[i*LIGHT_SIZE + 2] = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
-                       light_data[i*LIGHT_SIZE + 3] = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+                       light_data[i*LIGHT_SIZE + 3] = make_float4(samples, 0.0f, 0.0f, 0.0f);
                }
                else if(light->type == LIGHT_DISTANT) {
                        shader_id &= ~SHADER_AREA_LIGHT;
@@ -435,7 +420,7 @@ void LightManager::device_update_points(Device *device, DeviceScene *dscene, Sce
                        light_data[i*LIGHT_SIZE + 0] = make_float4(__int_as_float(light->type), dir.x, dir.y, dir.z);
                        light_data[i*LIGHT_SIZE + 1] = make_float4(__int_as_float(shader_id), light->size, 0.0f, 0.0f);
                        light_data[i*LIGHT_SIZE + 2] = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
-                       light_data[i*LIGHT_SIZE + 3] = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+                       light_data[i*LIGHT_SIZE + 3] = make_float4(samples, 0.0f, 0.0f, 0.0f);
                }
                else if(light->type == LIGHT_BACKGROUND) {
                        shader_id &= ~SHADER_AREA_LIGHT;
@@ -443,7 +428,7 @@ void LightManager::device_update_points(Device *device, DeviceScene *dscene, Sce
                        light_data[i*LIGHT_SIZE + 0] = make_float4(__int_as_float(light->type), 0.0f, 0.0f, 0.0f);
                        light_data[i*LIGHT_SIZE + 1] = make_float4(__int_as_float(shader_id), 0.0f, 0.0f, 0.0f);
                        light_data[i*LIGHT_SIZE + 2] = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
-                       light_data[i*LIGHT_SIZE + 3] = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+                       light_data[i*LIGHT_SIZE + 3] = make_float4(samples, 0.0f, 0.0f, 0.0f);
                }
                else if(light->type == LIGHT_AREA) {
                        float3 axisu = light->axisu*(light->sizeu*light->size);
@@ -452,7 +437,7 @@ void LightManager::device_update_points(Device *device, DeviceScene *dscene, Sce
                        light_data[i*LIGHT_SIZE + 0] = make_float4(__int_as_float(light->type), co.x, co.y, co.z);
                        light_data[i*LIGHT_SIZE + 1] = make_float4(__int_as_float(shader_id), axisu.x, axisu.y, axisu.z);
                        light_data[i*LIGHT_SIZE + 2] = make_float4(0.0f, axisv.x, axisv.y, axisv.z);
-                       light_data[i*LIGHT_SIZE + 3] = make_float4(0.0f, dir.x, dir.y, dir.z);
+                       light_data[i*LIGHT_SIZE + 3] = make_float4(samples, dir.x, dir.y, dir.z);
                }
                else if(light->type == LIGHT_SPOT) {
                        shader_id &= ~SHADER_AREA_LIGHT;
@@ -463,7 +448,7 @@ void LightManager::device_update_points(Device *device, DeviceScene *dscene, Sce
                        light_data[i*LIGHT_SIZE + 0] = make_float4(__int_as_float(light->type), co.x, co.y, co.z);
                        light_data[i*LIGHT_SIZE + 1] = make_float4(__int_as_float(shader_id), light->size, dir.x, dir.y);
                        light_data[i*LIGHT_SIZE + 2] = make_float4(dir.z, spot_angle, spot_smooth, 0.0f);
-                       light_data[i*LIGHT_SIZE + 3] = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+                       light_data[i*LIGHT_SIZE + 3] = make_float4(samples, 0.0f, 0.0f, 0.0f);
                }
        }
        
index fb8684fa59b57cf029d3187abbc869723379b059..3cedde2596e270cd7ce6856dfce4bc6c43195c85 100644 (file)
@@ -54,6 +54,7 @@ public:
        bool cast_shadow;
 
        int shader;
+       int samples;
 
        void tag_update(Scene *scene);
 };
index 376a7911fc909a0fdbf361738f389d23f12af5a7..6de7eaea343bab71eb32acfcbd53072b91e37601 100644 (file)
@@ -147,7 +147,7 @@ ObjectManager::~ObjectManager()
 void ObjectManager::device_update_transforms(Device *device, DeviceScene *dscene, Scene *scene, Progress& progress)
 {
        float4 *objects = dscene->objects.resize(OBJECT_SIZE*scene->objects.size());
-       uint *object_flag = dscene->object_flag.resize(OBJECT_SIZE*scene->objects.size());
+       uint *object_flag = dscene->object_flag.resize(scene->objects.size());
        int i = 0;
        map<Mesh*, float> surface_area_map;
        Scene::MotionType need_motion = scene->need_motion();
index a5f90bfe34b4ed1d261b95745e8dbdb431b2e6a4..45c8a05c27df501b32fc48e8ad5c7027086b3c02 100644 (file)
@@ -160,7 +160,7 @@ void Scene::device_update(Device *device_, Progress& progress)
        if(progress.get_cancel()) return;
 
        progress.set_status("Updating Integrator");
-       integrator->device_update(device, &dscene);
+       integrator->device_update(device, &dscene, this);
 
        if(progress.get_cancel()) return;
 
index 277b14e2c66b8a695520991cc2b34ff73862581c..e52ac0af2eda1c22ffa20f59189d9c496dab9996 100644 (file)
@@ -143,6 +143,7 @@ if(WITH_HEADLESS OR WITH_GHOST_SDL)
                                intern/GHOST_SystemPathsCarbon.h
                        )
                endif()
+
        elseif(UNIX)
                list(APPEND SRC
                        intern/GHOST_SystemPathsX11.cpp
@@ -152,13 +153,17 @@ if(WITH_HEADLESS OR WITH_GHOST_SDL)
                if(NOT WITH_INSTALL_PORTABLE)
                        add_definitions(-DPREFIX="${CMAKE_INSTALL_PREFIX}")
                endif()
-       elseif(WIN32)
 
+       elseif(WIN32)
                list(APPEND SRC
                        intern/GHOST_SystemPathsWin32.cpp
 
                        intern/GHOST_SystemPathsWin32.h
                )
+
+               list(APPEND INC
+                       ../utfconv
+               )
        endif()
 
        if(NOT WITH_HEADLESS)
index 65c6148cd8ed23b265dd73d7bf6493e87a283225..a09b532762b149cdef14ee9d1342c6e2ece23909 100644 (file)
@@ -20,8 +20,8 @@
  *                                                                         *
  *   You should have received a copy of the GNU Lesser General Public      *
  *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street,                                    *
- *   Fifth Floor, Boston, MA 02110-1301, USA.                               *
+ *   Foundation, Inc., 51 Franklin Street,                                 *
+ *   Fifth Floor, Boston, MA 02110-1301, USA.                              *
  *                                                                         *
  ***************************************************************************/
 
index 081a7c6bdbd825bf57cd269d25cb466d2e6009ea..910cd4c6a3dc7ad2297cfe0d50cb14a34b8d87c6 100644 (file)
@@ -34,7 +34,7 @@
 /* from BLI_utildefines.h */
 #define MIN2(x, y)               ( (x) < (y) ? (x) : (y) )
 #define MAX2(x, y)               ( (x) > (y) ? (x) : (y) )
-
+#define ABS(a)          ( (a) < 0 ? (-(a)) : (a) )
 
 struct e_status {
        int x;
@@ -67,8 +67,7 @@ struct r_fill_context {
  * just the poly. Since the DEM code could end up being coupled with this, we'll keep it separate
  * for now.
  */
-static void preprocess_all_edges(struct r_fill_context *ctx, struct poly_vert *verts, int num_verts, struct e_status *open_edge)
-{
+static void preprocess_all_edges(struct r_fill_context *ctx, struct poly_vert *verts, int num_verts, struct e_status *open_edge) {
        int i;
        int xbeg;
        int ybeg;
@@ -94,8 +93,7 @@ static void preprocess_all_edges(struct r_fill_context *ctx, struct poly_vert *v
                        /* we're not at the last vert, so end of the edge is the previous vertex */
                        xend = v[i - 1].x;
                        yend = v[i - 1].y;
-               }
-               else {
+               } else {
                        /* we're at the first vertex, so the "end" of this edge is the last vertex */
                        xend = v[num_verts - 1].x;
                        yend = v[num_verts - 1].y;
@@ -124,8 +122,7 @@ static void preprocess_all_edges(struct r_fill_context *ctx, struct poly_vert *v
                        if (dx > 0) {
                                e_new->xdir = 1;
                                xdist = dx;
-                       }
-                       else {
+                       } else {
                                e_new->xdir = -1;
                                xdist = -dx;
                        }
@@ -138,15 +135,13 @@ static void preprocess_all_edges(struct r_fill_context *ctx, struct poly_vert *v
                        /* calculate deltas for incremental drawing */
                        if (dx >= 0) {
                                e_new->drift = 0;
-                       }
-                       else {
+                       } else {
                                e_new->drift = -dy + 1;
                        }
                        if (dy >= xdist) {
                                e_new->drift_inc = xdist;
                                e_new->xshift = 0;
-                       }
-                       else {
+                       } else {
                                e_new->drift_inc = xdist % dy;
                                e_new->xshift = (xdist / dy) * e_new->xdir;
                        }
@@ -170,8 +165,7 @@ static void preprocess_all_edges(struct r_fill_context *ctx, struct poly_vert *v
  * for speed, but waiting on final design choices for curve-data before eliminating data the DEM code will need
  * if it ends up being coupled with this function.
  */
-static int rast_scan_fill(struct r_fill_context *ctx, struct poly_vert *verts, int num_verts)
-{
+static int rast_scan_fill(struct r_fill_context *ctx, struct poly_vert *verts, int num_verts, float intensity) {
        int x_curr;                 /* current pixel position in X */
        int y_curr;                 /* current scan line being drawn */
        int yp;                     /* y-pixel's position in frame buffer */
@@ -260,8 +254,7 @@ static int rast_scan_fill(struct r_fill_context *ctx, struct poly_vert *verts, i
                                        edgec = &ctx->all_edges->e_next;     /* Set our list to the next edge's location in memory. */
                                        ctx->all_edges = e_temp;             /* Skip the NULL or bad X edge, set pointer to next edge. */
                                        break;                               /* Stop looping edges (since we ran out or hit empty X span. */
-                               }
-                               else {
+                               } else {
                                        edgec = &e_curr->e_next;             /* Set the pointer to the edge list the "next" edge. */
                                }
                        }
@@ -307,7 +300,7 @@ static int rast_scan_fill(struct r_fill_context *ctx, struct poly_vert *verts, i
 
                        if ((y_curr >= 0) && (y_curr < ctx->rb.sizey)) {
                                /* draw the pixels. */
-                               for (; cpxl <= mpxl; *cpxl++ = 1.0f);
+                               for(; cpxl <= mpxl; *cpxl++ += intensity);
                        }
                }
 
@@ -323,8 +316,7 @@ static int rast_scan_fill(struct r_fill_context *ctx, struct poly_vert *verts, i
                for (edgec = &ctx->possible_edges; (e_curr = *edgec); ) {
                        if (!(--(e_curr->num))) {
                                *edgec = e_curr->e_next;
-                       }
-                       else {
+                       } else {
                                e_curr->x += e_curr->xshift;
                                if ((e_curr->drift += e_curr->drift_inc) > 0) {
                                        e_curr->x += e_curr->xdir;
@@ -383,12 +375,17 @@ static int rast_scan_fill(struct r_fill_context *ctx, struct poly_vert *verts, i
 }
 
 int PLX_raskterize(float (*base_verts)[2], int num_base_verts,
-                   float *buf, int buf_x, int buf_y)
-{
+                                  float *buf, int buf_x, int buf_y, int do_mask_AA) {
+       int subdiv_AA = (do_mask_AA != 0)? 8:0;
        int i;                                   /* i: Loop counter. */
+       int sAx;
+       int sAy;
        struct poly_vert *ply;                   /* ply: Pointer to a list of integer buffer-space vertex coordinates. */
        struct r_fill_context ctx = {0};
-
+       const float buf_x_f = (float)(buf_x);
+       const float buf_y_f = (float)(buf_y);
+       float div_offset=(1.0f / (float)(subdiv_AA));
+       float div_offset_static = 0.5f * (float)(subdiv_AA) * div_offset;
        /*
         * Allocate enough memory for our poly_vert list. It'll be the size of the poly_vert
         * data structure multiplied by the number of base_verts.
@@ -400,6 +397,9 @@ int PLX_raskterize(float (*base_verts)[2], int num_base_verts,
                return(0);
        }
 
+       ctx.rb.buf = buf;                            /* Set the output buffer pointer. */
+       ctx.rb.sizex = buf_x;                        /* Set the output buffer size in X. (width) */
+       ctx.rb.sizey = buf_y;                        /* Set the output buffer size in Y. (height) */
        /*
         * Loop over all verts passed in to be rasterized. Each vertex's X and Y coordinates are
         * then converted from normalized screen space (0.0 <= POS <= 1.0) to integer coordinates
@@ -408,16 +408,25 @@ int PLX_raskterize(float (*base_verts)[2], int num_base_verts,
         * It's worth noting that this function ONLY outputs fully white pixels in a mask. Every pixel
         * drawn will be 1.0f in value, there is no anti-aliasing.
         */
+
+       if(!subdiv_AA) {
        for (i = 0; i < num_base_verts; i++) {                          /* Loop over all base_verts. */
-               ply[i].x = (base_verts[i][0] * buf_x) + 0.5f;       /* Range expand normalized X to integer buffer-space X. */
-               ply[i].y = (base_verts[i][1] * buf_y) + 0.5f; /* Range expand normalized Y to integer buffer-space Y. */
+                       ply[i].x = (int)((base_verts[i][0] * buf_x_f) + 0.5f);       /* Range expand normalized X to integer buffer-space X. */
+                       ply[i].y = (int)((base_verts[i][1] * buf_y_f) + 0.5f); /* Range expand normalized Y to integer buffer-space Y. */
        }
 
-       ctx.rb.buf = buf;                            /* Set the output buffer pointer. */
-       ctx.rb.sizex = buf_x;                        /* Set the output buffer size in X. (width) */
-       ctx.rb.sizey = buf_y;                        /* Set the output buffer size in Y. (height) */
-
-       i = rast_scan_fill(&ctx, ply, num_base_verts);  /* Call our rasterizer, passing in the integer coords for each vert. */
+               i = rast_scan_fill(&ctx, ply, num_base_verts,1.0f);  /* Call our rasterizer, passing in the integer coords for each vert. */
+       } else {
+               for(sAx=0; sAx < subdiv_AA; sAx++) {
+                       for(sAy=0; sAy < subdiv_AA; sAy++) {
+                               for(i=0; i < num_base_verts; i++) {
+                                       ply[i].x = (int)((base_verts[i][0]*buf_x_f)+0.5f - div_offset_static + (div_offset*(float)(sAx)));
+                                       ply[i].y = (int)((base_verts[i][1]*buf_y_f)+0.5f - div_offset_static + (div_offset*(float)(sAy)));
+                               }
+                               i = rast_scan_fill(&ctx, ply, num_base_verts,(1.0f / (float)(subdiv_AA*subdiv_AA)));
+                       }
+               }
+       }
        free(ply);                                      /* Free the memory allocated for the integer coordinate table. */
        return(i);                                      /* Return the value returned by the rasterizer. */
 }
@@ -429,8 +438,7 @@ int PLX_raskterize(float (*base_verts)[2], int num_base_verts,
  */
 static int rast_scan_feather(struct r_fill_context *ctx,
                              float (*base_verts_f)[2], int num_base_verts,
-                             struct poly_vert *feather_verts, float (*feather_verts_f)[2], int num_feather_verts)
-{
+                                                        struct poly_vert *feather_verts, float(*feather_verts_f)[2], int num_feather_verts) {
        int x_curr;                 /* current pixel position in X */
        int y_curr;                 /* current scan line being drawn */
        int yp;                     /* y-pixel's position in frame buffer */
@@ -536,8 +544,7 @@ static int rast_scan_feather(struct r_fill_context *ctx,
                                        edgec = &ctx->all_edges->e_next;     /* Set our list to the next edge's location in memory. */
                                        ctx->all_edges = e_temp;             /* Skip the NULL or bad X edge, set pointer to next edge. */
                                        break;                               /* Stop looping edges (since we ran out or hit empty X span. */
-                               }
-                               else {
+                               } else {
                                        edgec = &e_curr->e_next;             /* Set the pointer to the edge list the "next" edge. */
                                }
                        }
@@ -647,8 +654,7 @@ static int rast_scan_feather(struct r_fill_context *ctx,
                for (edgec = &ctx->possible_edges; (e_curr = *edgec); ) {
                        if (!(--(e_curr->num))) {
                                *edgec = e_curr->e_next;
-                       }
-                       else {
+                       } else {
                                e_curr->x += e_curr->xshift;
                                if ((e_curr->drift += e_curr->drift_inc) > 0) {
                                        e_curr->x += e_curr->xdir;
@@ -708,8 +714,7 @@ static int rast_scan_feather(struct r_fill_context *ctx,
 }
 
 int PLX_raskterize_feather(float (*base_verts)[2], int num_base_verts, float (*feather_verts)[2], int num_feather_verts,
-                           float *buf, int buf_x, int buf_y)
-{
+                                                  float *buf, int buf_x, int buf_y) {
        int i;                            /* i: Loop counter. */
        struct poly_vert *fe;             /* fe: Pointer to a list of integer buffer-space feather vertex coords. */
        struct r_fill_context ctx = {0};
@@ -751,3 +756,572 @@ int PLX_raskterize_feather(float (*base_verts)[2], int num_base_verts, float (*f
        free(fe);
        return i;                                   /* Return the value returned by the rasterizer. */
 }
+
+int get_range_expanded_pixel_coord(float normalized_value, int max_value) {
+       return (int)((normalized_value * (float)(max_value)) + 0.5f);
+}
+
+float get_pixel_intensity(float *buf, int buf_x, int buf_y, int pos_x, int pos_y) {
+       if(pos_x < 0 || pos_x >= buf_x || pos_y < 0 || pos_y >= buf_y) {
+               return 0.0f;
+       }
+       return buf[(pos_y * buf_y) + buf_x];
+}
+
+float get_pixel_intensity_bilinear(float *buf, int buf_x, int buf_y, float u, float v) {
+       int a;
+       int b;
+       int a_plus_1;
+       int b_plus_1;
+       float prop_u;
+       float prop_v;
+       float inv_prop_u;
+       float inv_prop_v;
+       if(u<0.0f || u>1.0f || v<0.0f || v>1.0f) {
+               return 0.0f;
+       }
+       u = u * (float)(buf_x) - 0.5f;
+       v = v * (float)(buf_y) - 0.5f;
+       a = (int)(u);
+       b = (int)(v);
+       prop_u = u - (float)(a);
+       prop_v = v - (float)(b);
+       inv_prop_u = 1.0f - prop_u;
+       inv_prop_v = 1.0f - prop_v;
+       a_plus_1 = MIN2((buf_x-1),a+1);
+       b_plus_1 = MIN2((buf_y-1),b+1);
+       return (buf[(b * buf_y) + a] * inv_prop_u + buf[(b*buf_y)+(a_plus_1)] * prop_u)*inv_prop_v+(buf[((b_plus_1) * buf_y)+a] * inv_prop_u + buf[((b_plus_1)*buf_y)+(a_plus_1)] * prop_u) * prop_v;
+
+}
+
+void set_pixel_intensity(float *buf, int buf_x, int buf_y, int pos_x, int pos_y, float intensity) {
+       if(pos_x < 0 || pos_x >= buf_x || pos_y < 0 || pos_y >= buf_y) {
+               return;
+       }
+       buf[(pos_y * buf_y) + buf_x] = intensity;
+}
+#define __PLX__FAKE_AA__
+int PLX_antialias_buffer(float *buf, int buf_x, int buf_y) {
+#ifdef __PLX__FAKE_AA__
+#ifdef __PLX_GREY_AA__
+       int i=0;
+       int sz = buf_x * buf_y;
+       for(i=0; i<sz; i++) {
+               buf[i] *= 0.5f;
+       }
+#endif
+       (void)buf_x;
+       (void)buf_y;
+       (void)buf;
+       return 1;
+#else
+       /*XXX - TODO: THIS IS NOT FINAL CODE - IT DOES NOT WORK - DO NOT ENABLE IT */
+       const float p0 = 1.0f;
+       const float p1 = 1.0f;
+       const float p2 = 1.0f;
+       const float p3 = 1.0f;
+       const float p4 = 1.0f;
+       const float p5 = 1.5f;
+       const float p6 = 2.0f;
+       const float p7 = 2.0f;
+       const float p8 = 2.0f;
+       const float p9 = 2.0f;
+       const float p10 = 4.0f;
+       const float p11 = 8.0f;
+
+       const float edge_threshold = 0.063f;
+       const float edge_threshold_min = 0.0312f;
+       const float quality_subpix = 1.0f;
+//     int px_x;
+//     int px_y;
+
+       float posM_x,posM_y;
+       float posB_x,posB_y;
+       float posN_x,posN_y;
+       float posP_x,posP_y;
+       float offNP_x,offNP_y;
+       float lumaM;
+       float lumaS;
+       float lumaE;
+       float lumaN;
+       float lumaW;
+       float lumaNW;
+       float lumaSE;
+       float lumaNE;
+       float lumaSW;
+       float lumaNS;
+       float lumaWE;
+       float lumaNESE;
+       float lumaNWNE;
+       float lumaNWSW;
+       float lumaSWSE;
+       float lumaNN;
+       float lumaSS;
+       float lumaEndN;
+       float lumaEndP;
+       float lumaMM;
+       float lumaMLTZero;
+       float subpixNWSWNESE;
+       float subpixRcpRange;
+       float subpixNSWE;
+       float maxSM;
+       float minSM;
+       float maxESM;
+       float minESM;
+       float maxWN;
+       float minWN;
+       float rangeMax;
+       float rangeMin;
+       float rangeMaxScaled;
+       float range;
+       float rangeMaxClamped;
+       float edgeHorz;
+       float edgeVert;
+       float edgeHorz1;
+       float edgeVert1;
+       float edgeHorz2;
+       float edgeVert2;
+       float edgeHorz3;
+       float edgeVert3;
+       float edgeHorz4;
+       float edgeVert4;
+       float lengthSign;
+       float subpixA;
+       float subpixB;
+       float subpixC;
+       float subpixD;
+       float subpixE;
+       float subpixF;
+       float subpixG;
+       float subpixH;
+       float gradientN;
+       float gradientS;
+       float gradient;
+       float gradientScaled;
+       float dstN;
+       float dstP;
+       float dst;
+       float spanLength;
+       float spanLengthRcp;
+       float pixelOff