Initial implementation of Cycles materials for Freestyle stroke rendering.

intern/cycles/blender/blender_python.cpp

@@ -84,10 +84,12 @@ static PyObject *create_func(PyObject *self, PyObject *args)
 
 	PointerRNA dataptr;
 	RNA_id_pointer_create((ID*)PyLong_AsVoidPtr(pydata), &dataptr);
+	std::cout << "_cycles.create: dataptr " << PyLong_AsVoidPtr(pydata) << std::endl;
 	BL::BlendData data(dataptr);
 
 	PointerRNA sceneptr;
 	RNA_id_pointer_create((ID*)PyLong_AsVoidPtr(pyscene), &sceneptr);
+	std::cout << "_cycles.create: sceneptr " << PyLong_AsVoidPtr(pyscene) << std::endl;
 	BL::Scene scene(sceneptr);
 
 	PointerRNA regionptr;

source/blender/freestyle/intern/application/Controller.cpp

@@ -210,6 +210,7 @@ void Controller::setContext(bContext *C)
 {
 	PythonInterpreter *py_inter = dynamic_cast<PythonInterpreter*>(_inter);
 	py_inter->setContext(C);
+	_context = C;
 }
 
 int Controller::LoadMesh(Render *re, SceneRenderLayer *srl)
@@ -850,7 +851,7 @@ void Controller::ResetRenderCount()
 Render *Controller::RenderStrokes(Render *re, bool render)
 {
 	_Chrono.start();
-	BlenderStrokeRenderer *blenderRenderer = new BlenderStrokeRenderer(re, ++_render_count);
+	BlenderStrokeRenderer *blenderRenderer = new BlenderStrokeRenderer(_context, re, ++_render_count);
 	if (render)
 		_Canvas->Render(blenderRenderer);
 	real d = _Chrono.stop();

source/blender/freestyle/intern/application/Controller.h

@@ -217,6 +217,7 @@ private:
 	real _EPSILON;
 	real _bboxDiag;
 
+	bContext *_context;
 	int _render_count;
 
 	//AppStyleWindow *_pStyleWindow;

source/blender/freestyle/intern/blender_interface/BlenderStrokeRenderer.cpp

@@ -32,35 +32,43 @@ extern "C" {
 
 #include "DNA_camera_types.h"
 #include "DNA_listBase.h"
+#include "DNA_material_types.h"
 #include "DNA_meshdata_types.h"
 #include "DNA_mesh_types.h"
 #include "DNA_object_types.h"
 #include "DNA_screen_types.h"
+#include "DNA_scene_types.h"
 
 #include "BKE_customdata.h"
 #include "BKE_depsgraph.h"
 #include "BKE_global.h"
 #include "BKE_library.h" /* free_libblock */
-#include "BKE_main.h" /* struct Main */
 #include "BKE_material.h"
 #include "BKE_mesh.h"
+#include "BKE_node.h"
 #include "BKE_object.h"
 #include "BKE_scene.h"
 
 #include "BLI_utildefines.h"
 
 #include "RE_pipeline.h"
+
+#include "C:\bf-blender\blender.git\source\blender\nodes\NOD_shader.h"
+#include "C:\bf-blender\blender.git\source\blender\makesrna\RNA_access.h"
+
+#include "render_types.h"
 }
 
 #include <limits.h>
 
 namespace Freestyle {
 
-BlenderStrokeRenderer::BlenderStrokeRenderer(Render *re, int render_count) : StrokeRenderer()
+BlenderStrokeRenderer::BlenderStrokeRenderer(bContext *C, Render *re, int render_count) : StrokeRenderer()
 {
 	freestyle_bmain = re->freestyle_bmain;
 
 	// for stroke mesh generation
+	_context = C;
 	_width = re->winx;
 	_height = re->winy;
 
@@ -72,6 +80,7 @@ BlenderStrokeRenderer::BlenderStrokeRenderer(Render *re, int render_count) : Str
 	freestyle_scene->r.cfra = old_scene->r.cfra;
 	freestyle_scene->r.mode = old_scene->r.mode &
 	                          ~(R_EDGE_FRS | R_SHADOW | R_SSS | R_PANORAMA | R_ENVMAP | R_MBLUR | R_BORDER);
+	freestyle_scene->r.mode |= R_PERSISTENT_DATA; // for nested Cycles sessions
 	freestyle_scene->r.xsch = re->rectx; // old_scene->r.xsch
 	freestyle_scene->r.ysch = re->recty; // old_scene->r.ysch
 	freestyle_scene->r.xasp = 1.0f; // old_scene->r.xasp;
@@ -98,7 +107,7 @@ BlenderStrokeRenderer::BlenderStrokeRenderer(Render *re, int render_count) : Str
 	freestyle_scene->r.filtertype = old_scene->r.filtertype;
 	freestyle_scene->r.gauss = old_scene->r.gauss;
 	freestyle_scene->r.dither_intensity = old_scene->r.dither_intensity;
-	strcpy(freestyle_scene->r.engine, "BLENDER_RENDER"); // old_scene->r.engine
+	BLI_strncpy(freestyle_scene->r.engine, old_scene->r.engine, sizeof(freestyle_scene->r.engine));
 	freestyle_scene->r.im_format.planes = R_IMF_PLANES_RGBA; 
 	freestyle_scene->r.im_format.imtype = R_IMF_IMTYPE_PNG;
 	BKE_scene_disable_color_management(freestyle_scene);
@@ -254,6 +263,64 @@ void BlenderStrokeRenderer::RenderStrokeRep(StrokeRep *iStrokeRep) const
 			}
 			a++;
 		}
+
+		if (strcmp(freestyle_scene->r.engine, "CYCLES") == 0) {
+			bNodeTree *ntree;
+			bNodeSocket *fromsock, *tosock;
+
+			BLI_assert(BKE_scene_use_new_shading_nodes(freestyle_scene));
+
+			ntree = ntreeAddTree(NULL, "Shader Nodetree", ntreeType_Shader->idname);
+			ma->nodetree = ntree;
+			ma->use_nodes = 1;
+
+			bNode *input_attribute = nodeAddStaticNode(_context, ntree, SH_NODE_ATTRIBUTE);
+			input_attribute->locx = 0.0f;
+			input_attribute->locy = 0.0f;
+			NodeShaderAttribute *storage = (NodeShaderAttribute *)input_attribute->storage;
+			BLI_strncpy(storage->name, "Col", sizeof(storage->name));
+
+			bNode *shader_emission = nodeAddStaticNode(_context, ntree, SH_NODE_EMISSION);
+			shader_emission->locx = 200.0f;
+			shader_emission->locy = 0.0f;
+
+			bNode *input_light_path = nodeAddStaticNode(_context, ntree, SH_NODE_LIGHT_PATH);
+			input_light_path->locx = 200.0f;
+			input_light_path->locy = 300.0f;
+
+			bNode *shader_mix = nodeAddStaticNode(_context, ntree, SH_NODE_MIX_SHADER);
+			shader_mix->locx = 400.0f;
+			shader_mix->locy = 100.0f;
+
+			bNode *output_material = nodeAddStaticNode(_context, ntree, SH_NODE_OUTPUT_MATERIAL);
+			output_material->locx = 600.0f;
+			output_material->locy = 100.0f;
+
+			fromsock = (bNodeSocket *)BLI_findlink(&input_attribute->outputs, 0);
+			tosock = (bNodeSocket *)BLI_findlink(&shader_emission->inputs, 0);
+			nodeAddLink(ntree, input_attribute, fromsock, shader_emission, tosock);
+
+			fromsock = (bNodeSocket *)BLI_findlink(&shader_emission->outputs, 0);
+			tosock = (bNodeSocket *)BLI_findlink(&shader_mix->inputs, 2);
+			nodeAddLink(ntree, shader_emission, fromsock, shader_mix, tosock);
+
+			fromsock = (bNodeSocket *)BLI_findlink(&input_light_path->outputs, 0);
+			tosock = (bNodeSocket *)BLI_findlink(&shader_mix->inputs, 0);
+			nodeAddLink(ntree, input_light_path, fromsock, shader_mix, tosock);
+
+			fromsock = (bNodeSocket *)BLI_findlink(&shader_mix->outputs, 0);
+			tosock = (bNodeSocket *)BLI_findlink(&output_material->inputs, 0);
+			nodeAddLink(ntree, shader_mix, fromsock, output_material, tosock);
+
+			nodeSetActive(ntree, shader_mix);
+			ntreeUpdateTree(freestyle_bmain, ntree);
+
+			PointerRNA scene_ptr;
+			RNA_pointer_create(NULL, &RNA_Scene, freestyle_scene, &scene_ptr);
+			PointerRNA cycles_ptr = RNA_pointer_get(&scene_ptr, "cycles");
+			RNA_boolean_set(&cycles_ptr, "film_transparent", 1);
+		}
+
 		iStrokeRep->setMaterial(ma);
 	}
 

source/blender/freestyle/intern/blender_interface/BlenderStrokeRenderer.h

@@ -29,12 +29,11 @@
 #include "../system/FreestyleConfig.h"
 
 extern "C" {
-#include "DNA_material_types.h"
-#include "DNA_scene_types.h"
-
-#include "BKE_main.h"
-
-#include "render_types.h"
+struct Main;
+struct Object;
+struct Render;
+struct Scene;
+struct bContext;
 }
 
 namespace Freestyle {
@@ -42,7 +41,7 @@ namespace Freestyle {
 class BlenderStrokeRenderer : public StrokeRenderer
 {
 public:
-	BlenderStrokeRenderer(Render *re, int render_count);
+	BlenderStrokeRenderer(bContext *C, Render *re, int render_count);
 	virtual ~BlenderStrokeRenderer();
 
 	/*! Renders a stroke rep */
@@ -57,6 +56,7 @@ protected:
 	Main *freestyle_bmain;
 	Scene *old_scene;
 	Scene *freestyle_scene;
+	bContext *_context;
 	float _width, _height;
 	float _z, _z_delta;
 	unsigned int _mesh_id;

source/blender/render/intern/source/pipeline.c

@@ -2769,6 +2769,7 @@ void RE_BlenderFrame(Render *re, Main *bmain, Scene *scene, SceneRenderLayer *sr
 	
 	scene->r.cfra = frame;
 	
+	printf("%s: bmain %p scene %p\n", __func__, bmain, scene);
 	if (render_initialize_from_main(re, &scene->r, bmain, scene, srl, camera_override, lay_override, 0, 0)) {
 		MEM_reset_peak_memory();
 
@@ -2803,6 +2804,7 @@ void RE_BlenderFrame(Render *re, Main *bmain, Scene *scene, SceneRenderLayer *sr
 #ifdef WITH_FREESTYLE
 void RE_RenderFreestyleStrokes(Render *re, Main *bmain, Scene *scene, int render)
 {
+	printf("%s: bmain %p scene %p\n", __func__, bmain, scene);
 	re->result_ok= 0;
 	if (render_initialize_from_main(re, &scene->r, bmain, scene, NULL, NULL, scene->lay, 0, 0)) {
 		if (render)