rename remaining class members with m_ prefix.

84 files changed, 583 insertions, 586 deletions

diff --git a/source/blender/compositor/intern/COM_ChannelInfo.cpp b/source/blender/compositor/intern/COM_ChannelInfo.cpp
index f2fa62006d5..557075cdc80 100644
--- a/source/blender/compositor/intern/COM_ChannelInfo.cpp
+++ b/source/blender/compositor/intern/COM_ChannelInfo.cpp
@@ -29,7 +29,7 @@
  */
 ChannelInfo::ChannelInfo()
 {
-	this->number = 0;
-	this->premultiplied = true;
-	this->type = COM_CT_UNUSED;
+	this->m_number = 0;
+	this->m_premultiplied = true;
+	this->m_type = COM_CT_UNUSED;
 }
diff --git a/source/blender/compositor/intern/COM_ChannelInfo.h b/source/blender/compositor/intern/COM_ChannelInfo.h
index 399fdc62fa2..44664442359 100644
--- a/source/blender/compositor/intern/COM_ChannelInfo.h
+++ b/source/blender/compositor/intern/COM_ChannelInfo.h
@@ -61,23 +61,23 @@ private:
 	/**
 	 * @brief the channel number, in the connection. [0-3]
 	 */
-	int number;
+	int m_number;
 
 	/**
 	 * @brief type of channel
 	 */
-	ChannelType type;
+	ChannelType m_type;
 
 	/**
 	 * @brieg Is this value in this channel premultiplied with its alpha
 	 * @note only valid if type = ColorComponent;
 	 */
-	bool premultiplied;
+	bool m_premultiplied;
 
 //	/**
-//	  * Color space of this value.
-//	  * only valid when type = ColorComponent;
-//	  */
+//	 * Color space of this value.
+//	 * only valid when type = ColorComponent;
+//	 */
 //	string colorspacename;
 
 public:
@@ -89,32 +89,32 @@ public:
 	/**
 	 * @brief set the index of this channel in the SocketConnection
 	 */
-	void setNumber(const int number) { this->number = number; }
+	void setNumber(const int number) { this->m_number = number; }
 
 	/**
 	 * @brief get the index of this channel in the SocketConnection
 	 */
-	const int getNumber() const { return this->number; }
+	const int getNumber() const { return this->m_number; }
 
 	/**
 	 * @brief set the type of channel
 	 */
-	void setType(const ChannelType type) { this->type = type; }
+	void setType(const ChannelType type) { this->m_type = type; }
 
 	/**
 	 * @brief get the type of channel
 	 */
-	const ChannelType getType() const { return this->type; }
+	const ChannelType getType() const { return this->m_type; }
 
 	/**
 	 * @brief set the premultiplicatioin of this channel
 	 */
-	void setPremultiplied(const bool premultiplied) { this->premultiplied = premultiplied; }
+	void setPremultiplied(const bool premultiplied) { this->m_premultiplied = premultiplied; }
 
 	/**
 	 * @brief is this channel premultiplied
 	 */
-	const bool isPremultiplied() const { return this->premultiplied; }
+	const bool isPremultiplied() const { return this->m_premultiplied; }
 };
 
 
diff --git a/source/blender/compositor/intern/COM_ChunkOrder.cpp b/source/blender/compositor/intern/COM_ChunkOrder.cpp
index 02c28a1997a..38a3350c263 100644
--- a/source/blender/compositor/intern/COM_ChunkOrder.cpp
+++ b/source/blender/compositor/intern/COM_ChunkOrder.cpp
@@ -25,10 +25,10 @@
 
 ChunkOrder::ChunkOrder()
 {
-	this->distance = 0.0;
-	this->number = 0;
-	this->x = 0;
-	this->y = 0;
+	this->m_distance = 0.0;
+	this->m_number = 0;
+	this->m_x = 0;
+	this->m_y = 0;
 }
 
 void ChunkOrder::determineDistance(ChunkOrderHotspot **hotspots, unsigned int numberOfHotspots)
@@ -37,15 +37,15 @@ void ChunkOrder::determineDistance(ChunkOrderHotspot **hotspots, unsigned int nu
 	double distance = MAXFLOAT;
 	for (index = 0; index < numberOfHotspots; index++) {
 		ChunkOrderHotspot *hotspot = hotspots[index];
-		double ndistance = hotspot->determineDistance(this->x, this->y);
+		double ndistance = hotspot->determineDistance(this->m_x, this->m_y);
 		if (ndistance < distance) {
 			distance = ndistance;
 		}
 	}
-	this->distance = distance;
+	this->m_distance = distance;
 }
 
 bool operator<(const ChunkOrder& a, const ChunkOrder& b)
 {
-	return a.distance < b.distance;
+	return a.m_distance < b.m_distance;
 }
diff --git a/source/blender/compositor/intern/COM_ChunkOrder.h b/source/blender/compositor/intern/COM_ChunkOrder.h
index f096ebeebfe..190ecb9c380 100644
--- a/source/blender/compositor/intern/COM_ChunkOrder.h
+++ b/source/blender/compositor/intern/COM_ChunkOrder.h
@@ -26,20 +26,20 @@
 #include "COM_ChunkOrderHotspot.h"
 class ChunkOrder {
 private:
-	unsigned int number;
-	int x;
-	int y;
-	double distance;
+	unsigned int m_number;
+	int m_x;
+	int m_y;
+	double m_distance;
 public:
 	ChunkOrder();
 	void determineDistance(ChunkOrderHotspot **hotspots, unsigned int numberOfHotspots);
 	friend bool operator<(const ChunkOrder& a, const ChunkOrder& b);
 	
-	void setChunkNumber(unsigned int chunknumber) { this->number = chunknumber; }
-	void setX(int x) { this->x = x; }
-	void setY(int y) { this->y = y; }
-	unsigned int getChunkNumber() { return this->number; }
-	double getDistance() { return this->distance; }
+	void setChunkNumber(unsigned int chunknumber) { this->m_number = chunknumber; }
+	void setX(int x) { this->m_x = x; }
+	void setY(int y) { this->m_y = y; }
+	unsigned int getChunkNumber() { return this->m_number; }
+	double getDistance() { return this->m_distance; }
 };
 
 #endif
diff --git a/source/blender/compositor/intern/COM_ChunkOrderHotspot.cpp b/source/blender/compositor/intern/COM_ChunkOrderHotspot.cpp
index 96568092b72..1e64e0b9ea0 100644
--- a/source/blender/compositor/intern/COM_ChunkOrderHotspot.cpp
+++ b/source/blender/compositor/intern/COM_ChunkOrderHotspot.cpp
@@ -25,16 +25,16 @@
 
 ChunkOrderHotspot::ChunkOrderHotspot(int x, int y, float addition)
 {
-	this->x = x;
-	this->y = y;
-	this->addition = addition;
+	this->m_x = x;
+	this->m_y = y;
+	this->m_addition = addition;
 }
 
 double ChunkOrderHotspot::determineDistance(int x, int y)
 {
-	int dx = x - this->x;
-	int dy = y - this->y;
+	int dx = x - this->m_x;
+	int dy = y - this->m_y;
 	double result = sqrt((double)(dx * dx + dy * dy));
-	result += (double)this->addition;
+	result += (double)this->m_addition;
 	return result;
 }
diff --git a/source/blender/compositor/intern/COM_ChunkOrderHotspot.h b/source/blender/compositor/intern/COM_ChunkOrderHotspot.h
index 68140745f8b..b166a7af57f 100644
--- a/source/blender/compositor/intern/COM_ChunkOrderHotspot.h
+++ b/source/blender/compositor/intern/COM_ChunkOrderHotspot.h
@@ -29,9 +29,9 @@
 
 class ChunkOrderHotspot {
 private:
-	int x;
-	int y;
-	float addition;
+	int m_x;
+	int m_y;
+	float m_addition;
 
 public:
 	ChunkOrderHotspot(int x, int y, float addition);
diff --git a/source/blender/compositor/intern/COM_CompositorContext.cpp b/source/blender/compositor/intern/COM_CompositorContext.cpp
index c3470f0a16e..56335630b80 100644
--- a/source/blender/compositor/intern/COM_CompositorContext.cpp
+++ b/source/blender/compositor/intern/COM_CompositorContext.cpp
@@ -26,16 +26,16 @@
 
 CompositorContext::CompositorContext()
 {
-	this->rd = NULL;
-	this->quality = COM_QUALITY_HIGH;
-	this->hasActiveOpenCLDevices = false;
-	this->activegNode = NULL;
+	this->m_rd = NULL;
+	this->m_quality = COM_QUALITY_HIGH;
+	this->m_hasActiveOpenCLDevices = false;
+	this->m_activegNode = NULL;
 }
 
 const int CompositorContext::getFramenumber() const
 {
-	if (this->rd) {
-		return this->rd->cfra;
+	if (this->m_rd) {
+		return this->m_rd->cfra;
 	}
 	else {
 		return -1; /* this should never happen */
@@ -44,8 +44,8 @@ const int CompositorContext::getFramenumber() const
 
 const int CompositorContext::isColorManaged() const
 {
-	if (this->rd) {
-		return this->rd->color_mgt_flag & R_COLOR_MANAGEMENT;
+	if (this->m_rd) {
+		return this->m_rd->color_mgt_flag & R_COLOR_MANAGEMENT;
 	}
 	else {
 		return 0; /* this should never happen */
diff --git a/source/blender/compositor/intern/COM_CompositorContext.h b/source/blender/compositor/intern/COM_CompositorContext.h
index 81fd81b4117..49acda811f1 100644
--- a/source/blender/compositor/intern/COM_CompositorContext.h
+++ b/source/blender/compositor/intern/COM_CompositorContext.h
@@ -41,38 +41,38 @@ private:
 	 * This field is initialized in ExecutionSystem and must only be read from that point on.
 	 * @see ExecutionSystem
 	 */
-	bool rendering;
+	bool m_rendering;
 
 	/**
 	 * @brief The quality of the composite.
 	 * This field is initialized in ExecutionSystem and must only be read from that point on.
 	 * @see ExecutionSystem
 	 */
-	CompositorQuality quality;
+	CompositorQuality m_quality;
 
 	/**
 	 * @brief Reference to the render data that is being composited.
 	 * This field is initialized in ExecutionSystem and must only be read from that point on.
 	 * @see ExecutionSystem
 	 */
-	RenderData *rd;
+	RenderData *m_rd;
 
 	/**
 	 * @brief reference to the bNodeTree
 	 * This field is initialized in ExecutionSystem and must only be read from that point on.
 	 * @see ExecutionSystem
 	 */
-	bNodeTree *bnodetree;
+	bNodeTree *m_bnodetree;
 	
 	/**
 	 * @brief activegNode the group node that is currently being edited.
 	 */
-	bNode *activegNode;
+	bNode *m_activegNode;
 
 	/**
 	 * @brief does this system have active opencl devices?
 	 */
-	bool hasActiveOpenCLDevices;
+	bool m_hasActiveOpenCLDevices;
 
 public:
 	/**
@@ -83,56 +83,52 @@ public:
 	/**
 	 * @brief set the rendering field of the context
 	 */
-	void setRendering(bool rendering) { this->rendering = rendering; }
+	void setRendering(bool rendering) { this->m_rendering = rendering; }
 
 	/**
 	 * @brief get the rendering field of the context
 	 */
-	bool isRendering() const { return this->rendering; }
+	bool isRendering() const { return this->m_rendering; }
 
 	/**
 	 * @brief set the scene of the context
 	 */
-	void setRenderData(RenderData *rd) { this->rd = rd; }
+	void setRenderData(RenderData *rd) { this->m_rd = rd; }
 
 	/**
 	 * @brief set the bnodetree of the context
 	 */
-	void setbNodeTree(bNodeTree *bnodetree) { this->bnodetree = bnodetree; }
+	void setbNodeTree(bNodeTree *bnodetree) { this->m_bnodetree = bnodetree; }
 
 	/**
 	 * @brief get the bnodetree of the context
 	 */
-	const bNodeTree *getbNodeTree() const { return this->bnodetree; }
+	const bNodeTree *getbNodeTree() const { return this->m_bnodetree; }
 
 	/**
 	 * @brief set the active groupnode of the context
 	 */
-	void setActivegNode(bNode *gnode) { this->activegNode = gnode; }
+	void setActivegNode(bNode *gnode) { this->m_activegNode = gnode; }
 
 	/**
 	 * @brief get the active groupnode of the context
 	 */
-	const bNode *getActivegNode() const { return this->activegNode; }
+	const bNode *getActivegNode() const { return this->m_activegNode; }
 
 	/**
 	 * @brief get the scene of the context
 	 */
-	const RenderData *getRenderData() const { return this->rd; }
+	const RenderData *getRenderData() const { return this->m_rd; }
 
 	/**
 	 * @brief set the quality
 	 */
-	void setQuality(CompositorQuality quality) {
-		this->quality = quality;
-	}
+	void setQuality(CompositorQuality quality) { this->m_quality = quality; }
 
 	/**
 	 * @brief get the quality
 	 */
-	const CompositorQuality getQuality() const {
-		return quality;
-	}
+	const CompositorQuality getQuality() const { return this->m_quality; }
 
 	/**
 	 * @brief get the current framenumber of the scene in this context
@@ -142,16 +138,12 @@ public:
 	/**
 	 * @brief has this system active openclDevices?
 	 */
-	const bool getHasActiveOpenCLDevices() const {
-		return this->hasActiveOpenCLDevices;
-	}
+	const bool getHasActiveOpenCLDevices() const { return this->m_hasActiveOpenCLDevices; }
 
 	/**
 	 * @brief set has this system active openclDevices?
 	 */
-	void setHasActiveOpenCLDevices(bool hasAvtiveOpenCLDevices) {
-		this->hasActiveOpenCLDevices = hasAvtiveOpenCLDevices;
-	}
+	void setHasActiveOpenCLDevices(bool hasAvtiveOpenCLDevices) { this->m_hasActiveOpenCLDevices = hasAvtiveOpenCLDevices; }
 	
 	int getChunksize() { return this->getbNodeTree()->chunksize; }
 	
diff --git a/source/blender/compositor/intern/COM_ExecutionGroup.cpp b/source/blender/compositor/intern/COM_ExecutionGroup.cpp
index 4dfb9c7d26c..5aa9ff21070 100644
--- a/source/blender/compositor/intern/COM_ExecutionGroup.cpp
+++ b/source/blender/compositor/intern/COM_ExecutionGroup.cpp
@@ -43,20 +43,20 @@
 
 ExecutionGroup::ExecutionGroup()
 {
-	this->isOutput = false;
-	this->complex = false;
-	this->chunkExecutionStates = NULL;
-	this->bTree = NULL;
-	this->height = 0;
-	this->width = 0;
-	this->cachedMaxReadBufferOffset = 0;
-	this->numberOfXChunks = 0;
-	this->numberOfYChunks = 0;
-	this->numberOfChunks = 0;
-	this->initialized = false;
-	this->openCL = false;
-	this->singleThreaded = false;
-	this->chunksFinished = 0;
+	this->m_isOutput = false;
+	this->m_complex = false;
+	this->m_chunkExecutionStates = NULL;
+	this->m_bTree = NULL;
+	this->m_height = 0;
+	this->m_width = 0;
+	this->m_cachedMaxReadBufferOffset = 0;
+	this->m_numberOfXChunks = 0;
+	this->m_numberOfYChunks = 0;
+	this->m_numberOfChunks = 0;
+	this->m_initialized = false;
+	this->m_openCL = false;
+	this->m_singleThreaded = false;
+	this->m_chunksFinished = 0;
 }
 
 CompositorPriority ExecutionGroup::getRenderPriotrity()
@@ -66,7 +66,7 @@ CompositorPriority ExecutionGroup::getRenderPriotrity()
 
 bool ExecutionGroup::containsOperation(NodeOperation *operation)
 {
-	for (vector<NodeOperation *>::const_iterator iterator = this->operations.begin(); iterator != this->operations.end(); ++iterator) {
+	for (vector<NodeOperation *>::const_iterator iterator = this->m_operations.begin(); iterator != this->m_operations.end(); ++iterator) {
 		NodeOperation *inListOperation = *iterator;
 		if (inListOperation == operation) {
 			return true;
@@ -77,12 +77,12 @@ bool ExecutionGroup::containsOperation(NodeOperation *operation)
 
 const bool ExecutionGroup::isComplex() const
 {
-	return this->complex;
+	return this->m_complex;
 }
 
 bool ExecutionGroup::canContainOperation(NodeOperation *operation)
 {
-	if (!this->initialized) { return true; }
+	if (!this->m_initialized) { return true; }
 	if (operation->isReadBufferOperation()) { return true; }
 	if (operation->isWriteBufferOperation()) { return false; }
 	if (operation->isSetOperation()) { return true; }
@@ -100,12 +100,12 @@ void ExecutionGroup::addOperation(ExecutionSystem *system, NodeOperation *operat
 	if (containsOperation(operation)) return;
 	if (canContainOperation(operation)) {
 		if (!operation->isBufferOperation()) {
-			this->complex = operation->isComplex();
-			this->openCL = operation->isOpenCL();
-			this->singleThreaded = operation->isSingleThreaded();
-			this->initialized = true;
+			this->m_complex = operation->isComplex();
+			this->m_openCL = operation->isOpenCL();
+			this->m_singleThreaded = operation->isSingleThreaded();
+			this->m_initialized = true;
 		}
-		this->operations.push_back(operation);
+		this->m_operations.push_back(operation);
 		if (operation->isReadBufferOperation()) {
 			ReadBufferOperation *readOperation = (ReadBufferOperation *)operation;
 			WriteBufferOperation *writeOperation = readOperation->getMemoryProxy()->getWriteBufferOperation();
@@ -137,52 +137,52 @@ void ExecutionGroup::addOperation(ExecutionSystem *system, NodeOperation *operat
 
 NodeOperation *ExecutionGroup::getOutputNodeOperation() const
 {
-	return this->operations[0]; // the first operation of the group is always the output operation.
+	return this->m_operations[0]; // the first operation of the group is always the output operation.
 }
 
 void ExecutionGroup::initExecution()
 {
-	if (this->chunkExecutionStates != NULL) {
-		delete[] this->chunkExecutionStates;
+	if (this->m_chunkExecutionStates != NULL) {
+		delete[] this->m_chunkExecutionStates;
 	}
 	unsigned int index;
 	determineNumberOfChunks();
 
-	this->chunkExecutionStates = NULL;
-	if (this->numberOfChunks != 0) {
-		this->chunkExecutionStates = new ChunkExecutionState[numberOfChunks];
-		for (index = 0; index < numberOfChunks; index++) {
-			this->chunkExecutionStates[index] = COM_ES_NOT_SCHEDULED;
+	this->m_chunkExecutionStates = NULL;
+	if (this->m_numberOfChunks != 0) {
+		this->m_chunkExecutionStates = new ChunkExecutionState[this->m_numberOfChunks];
+		for (index = 0; index < this->m_numberOfChunks; index++) {
+			this->m_chunkExecutionStates[index] = COM_ES_NOT_SCHEDULED;
 		}
 	}
 
 
 	unsigned int maxNumber = 0;
 
-	for (index = 0; index < this->operations.size(); index++) {
-		NodeOperation *operation = this->operations[index];
+	for (index = 0; index < this->m_operations.size(); index++) {
+		NodeOperation *operation = this->m_operations[index];
 		if (operation->isReadBufferOperation()) {
 			ReadBufferOperation *readOperation = (ReadBufferOperation *)operation;
-			this->cachedReadOperations.push_back(readOperation);
+			this->m_cachedReadOperations.push_back(readOperation);
 			maxNumber = max(maxNumber, readOperation->getOffset());
 		}
 	}
 	maxNumber++;
-	this->cachedMaxReadBufferOffset = maxNumber;
+	this->m_cachedMaxReadBufferOffset = maxNumber;
 
 }
 
 void ExecutionGroup::deinitExecution()
 {
-	if (this->chunkExecutionStates != NULL) {
-		delete[] this->chunkExecutionStates;
-		this->chunkExecutionStates = NULL;
-	}
-	this->numberOfChunks = 0;
-	this->numberOfXChunks = 0;
-	this->numberOfYChunks = 0;
-	this->cachedReadOperations.clear();
-	this->bTree = NULL;
+	if (this->m_chunkExecutionStates != NULL) {
+		delete[] this->m_chunkExecutionStates;
+		this->m_chunkExecutionStates = NULL;
+	}
+	this->m_numberOfChunks = 0;
+	this->m_numberOfXChunks = 0;
+	this->m_numberOfYChunks = 0;
+	this->m_cachedReadOperations.clear();
+	this->m_bTree = NULL;
 }
 void ExecutionGroup::determineResolution(unsigned int resolution[])
 {
@@ -194,16 +194,16 @@ void ExecutionGroup::determineResolution(unsigned int resolution[])
 
 void ExecutionGroup::determineNumberOfChunks()
 {
-	if (singleThreaded) {
-		this->numberOfXChunks = 1;
-		this->numberOfYChunks = 1;
-		this->numberOfChunks = 1;
+	if (this->m_singleThreaded) {
+		this->m_numberOfXChunks = 1;
+		this->m_numberOfYChunks = 1;
+		this->m_numberOfChunks = 1;
 	} 
 	else {
-		const float chunkSizef = this->chunkSize;
-		this->numberOfXChunks = ceil(this->width / chunkSizef);
-		this->numberOfYChunks = ceil(this->height / chunkSizef);
-		this->numberOfChunks = this->numberOfXChunks * this->numberOfYChunks;
+		const float chunkSizef = this->m_chunkSize;
+		this->m_numberOfXChunks = ceil(this->m_width / chunkSizef);
+		this->m_numberOfYChunks = ceil(this->m_height / chunkSizef);
+		this->m_numberOfChunks = this->m_numberOfXChunks * this->m_numberOfYChunks;
 	}
 }
 
@@ -214,17 +214,17 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
 {
 	CompositorContext& context = graph->getContext();
 	const bNodeTree *bTree = context.getbNodeTree();
-	if (this->width == 0 || this->height == 0) {return; } /// @note: break out... no pixels to calculate.
+	if (this->m_width == 0 || this->m_height == 0) {return; } /// @note: break out... no pixels to calculate.
 	if (bTree->test_break && bTree->test_break(bTree->tbh)) {return; } /// @note: early break out for blur and preview nodes
-	if (this->numberOfChunks == 0) {return; } /// @note: early break out
+	if (this->m_numberOfChunks == 0) {return; } /// @note: early break out
 	unsigned int chunkNumber;
 
-	this->chunksFinished = 0;
-	this->bTree = bTree;
+	this->m_chunksFinished = 0;
+	this->m_bTree = bTree;
 	unsigned int index;
-	unsigned int *chunkOrder = new unsigned int[this->numberOfChunks];
+	unsigned int *chunkOrder = new unsigned int[this->m_numberOfChunks];
 
-	for (chunkNumber = 0; chunkNumber < this->numberOfChunks; chunkNumber++) {
+	for (chunkNumber = 0; chunkNumber < this->m_numberOfChunks; chunkNumber++) {
 		chunkOrder[chunkNumber] = chunkNumber;
 	}
 	NodeOperation *operation = this->getOutputNodeOperation();
@@ -241,9 +241,9 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
 
 	switch (chunkorder) {
 		case COM_TO_RANDOM:
-			for (index = 0; index < 2 * numberOfChunks; index++) {
-				int index1 = rand() % numberOfChunks;
-				int index2 = rand() % numberOfChunks;
+			for (index = 0; index < 2 * this->m_numberOfChunks; index++) {
+				int index1 = rand() % this->m_numberOfChunks;
+				int index2 = rand() % this->m_numberOfChunks;
 				int s = chunkOrder[index1];
 				chunkOrder[index1] = chunkOrder[index2];
 				chunkOrder[index2] = s;
@@ -252,10 +252,10 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
 		case COM_TO_CENTER_OUT:
 		{
 			ChunkOrderHotspot **hotspots = new ChunkOrderHotspot *[1];
-			hotspots[0] = new ChunkOrderHotspot(this->width * centerX, this->height * centerY, 0.0f);
+			hotspots[0] = new ChunkOrderHotspot(this->m_width * centerX, this->m_height * centerY, 0.0f);
 			rcti rect;
-			ChunkOrder *chunkOrders = new ChunkOrder[this->numberOfChunks];
-			for (index = 0; index < this->numberOfChunks; index++) {
+			ChunkOrder *chunkOrders = new ChunkOrder[this->m_numberOfChunks];
+			for (index = 0; index < this->m_numberOfChunks; index++) {
 				determineChunkRect(&rect, index);
 				chunkOrders[index].setChunkNumber(index);
 				chunkOrders[index].setX(rect.xmin);
@@ -263,8 +263,8 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
 				chunkOrders[index].determineDistance(hotspots, 1);
 			}
 
-			sort(&chunkOrders[0], &chunkOrders[numberOfChunks - 1]);
-			for (index = 0; index < numberOfChunks; index++) {
+			sort(&chunkOrders[0], &chunkOrders[this->m_numberOfChunks - 1]);
+			for (index = 0; index < this->m_numberOfChunks; index++) {
 				chunkOrder[index] = chunkOrders[index].getChunkNumber();
 			}
 
@@ -276,14 +276,14 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
 		case COM_TO_RULE_OF_THIRDS:
 		{
 			ChunkOrderHotspot **hotspots = new ChunkOrderHotspot *[9];
-			unsigned int tx = this->width / 6;
-			unsigned int ty = this->height / 6;
-			unsigned int mx = this->width / 2;
-			unsigned int my = this->height / 2;
+			unsigned int tx = this->m_width / 6;
+			unsigned int ty = this->m_height / 6;
+			unsigned int mx = this->m_width / 2;
+			unsigned int my = this->m_height / 2;
 			unsigned int bx = mx + 2 * tx;
 			unsigned int by = my + 2 * ty;
 
-			float addition = numberOfChunks / COM_RULE_OF_THIRDS_DIVIDER;
+			float addition = this->m_numberOfChunks / COM_RULE_OF_THIRDS_DIVIDER;
 			hotspots[0] = new ChunkOrderHotspot(mx, my, addition * 0);
 			hotspots[1] = new ChunkOrderHotspot(tx, my, addition * 1);
 			hotspots[2] = new ChunkOrderHotspot(bx, my, addition * 2);
@@ -294,8 +294,8 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
 			hotspots[7] = new ChunkOrderHotspot(mx, ty, addition * 7);
 			hotspots[8] = new ChunkOrderHotspot(mx, by, addition * 8);
 			rcti rect;
-			ChunkOrder *chunkOrders = new ChunkOrder[this->numberOfChunks];
-			for (index = 0; index < this->numberOfChunks; index++) {
+			ChunkOrder *chunkOrders = new ChunkOrder[this->m_numberOfChunks];
+			for (index = 0; index < this->m_numberOfChunks; index++) {
 				determineChunkRect(&rect, index);
 				chunkOrders[index].setChunkNumber(index);
 				chunkOrders[index].setX(rect.xmin);
@@ -303,9 +303,9 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
 				chunkOrders[index].determineDistance(hotspots, 9);
 			}
 
-			sort(&chunkOrders[0], &chunkOrders[numberOfChunks]);
+			sort(&chunkOrders[0], &chunkOrders[this->m_numberOfChunks]);
 
-			for (index = 0; index < numberOfChunks; index++) {
+			for (index = 0; index < this->m_numberOfChunks; index++) {
 				chunkOrder[index] = chunkOrders[index].getChunkNumber();
 			}
 
@@ -338,11 +338,11 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
 		finished = true;
 		int numberEvaluated = 0;
 
-		for (index = startIndex; index < numberOfChunks && numberEvaluated < maxNumberEvaluated; index++) {
+		for (index = startIndex; index < this->m_numberOfChunks && numberEvaluated < maxNumberEvaluated; index++) {
 			int chunkNumber = chunkOrder[index];
-			int yChunk = chunkNumber / this->numberOfXChunks;
-			int xChunk = chunkNumber - (yChunk * this->numberOfXChunks);
-			const ChunkExecutionState state = this->chunkExecutionStates[chunkNumber];
+			int yChunk = chunkNumber / this->m_numberOfXChunks;
+			int xChunk = chunkNumber - (yChunk * this->m_numberOfXChunks);
+			const ChunkExecutionState state = this->m_chunkExecutionStates[chunkNumber];
 			if (state == COM_ES_NOT_SCHEDULED) {
 				scheduleChunkWhenPossible(graph, xChunk, yChunk);
 				finished = false;
@@ -375,12 +375,12 @@ MemoryBuffer **ExecutionGroup::getInputBuffersCPU()
 	unsigned int index;
 
 	this->determineDependingMemoryProxies(&memoryproxies);
-	MemoryBuffer **memoryBuffers = new MemoryBuffer *[this->cachedMaxReadBufferOffset];
-	for (index = 0; index < this->cachedMaxReadBufferOffset; index++) {
+	MemoryBuffer **memoryBuffers = new MemoryBuffer *[this->m_cachedMaxReadBufferOffset];
+	for (index = 0; index < this->m_cachedMaxReadBufferOffset; index++) {
 		memoryBuffers[index] = NULL;
 	}
-	for (index = 0; index < this->cachedReadOperations.size(); index++) {
-		ReadBufferOperation *readOperation = (ReadBufferOperation *)this->cachedReadOperations[index];
+	for (index = 0; index < this->m_cachedReadOperations.size(); index++) {
+		ReadBufferOperation *readOperation = (ReadBufferOperation *)this->m_cachedReadOperations[index];
 		memoryBuffers[readOperation->getOffset()] = readOperation->getMemoryProxy()->getBuffer();
 	}
 	return memoryBuffers;
@@ -394,13 +394,13 @@ MemoryBuffer **ExecutionGroup::getInputBuffersOpenCL(int chunkNumber)
 	determineChunkRect(&rect, chunkNumber);
 
 	this->determineDependingMemoryProxies(&memoryproxies);
-	MemoryBuffer **memoryBuffers = new MemoryBuffer *[this->cachedMaxReadBufferOffset];
-	for (index = 0; index < this->cachedMaxReadBufferOffset; index++) {
+	MemoryBuffer **memoryBuffers = new MemoryBuffer *[this->m_cachedMaxReadBufferOffset];
+	for (index = 0; index < this->m_cachedMaxReadBufferOffset; index++) {
 		memoryBuffers[index] = NULL;
 	}
 	rcti output;
-	for (index = 0; index < this->cachedReadOperations.size(); index++) {
-		ReadBufferOperation *readOperation = (ReadBufferOperation *)this->cachedReadOperations[index];
+	for (index = 0; index < this->m_cachedReadOperations.size(); index++) {
+		ReadBufferOperation *readOperation = (ReadBufferOperation *)this->m_cachedReadOperations[index];
 		MemoryProxy *memoryProxy = readOperation->getMemoryProxy();
 		this->determineDependingAreaOfInterest(&rect, readOperation, &output);
 		MemoryBuffer *memoryBuffer = memoryProxy->getExecutor()->constructConsolidatedMemoryBuffer(memoryProxy, &output);
@@ -419,12 +419,12 @@ MemoryBuffer *ExecutionGroup::constructConsolidatedMemoryBuffer(MemoryProxy *mem
 
 void ExecutionGroup::finalizeChunkExecution(int chunkNumber, MemoryBuffer **memoryBuffers)
 {
-	if (this->chunkExecutionStates[chunkNumber] == COM_ES_SCHEDULED)
-		this->chunkExecutionStates[chunkNumber] = COM_ES_EXECUTED;
+	if (this->m_chunkExecutionStates[chunkNumber] == COM_ES_SCHEDULED)
+		this->m_chunkExecutionStates[chunkNumber] = COM_ES_EXECUTED;
 	
-	this->chunksFinished++;
+	this->m_chunksFinished++;
 	if (memoryBuffers) {
-		for (unsigned int index = 0; index < this->cachedMaxReadBufferOffset; index++) {
+		for (unsigned int index = 0; index < this->m_cachedMaxReadBufferOffset; index++) {
 			MemoryBuffer *buffer = memoryBuffers[index];
 			if (buffer) {
 				if (buffer->isTemporarily()) {
@@ -435,30 +435,30 @@ void ExecutionGroup::finalizeChunkExecution(int chunkNumber, MemoryBuffer **memo
 		}
 		delete[] memoryBuffers;
 	}
-	if (bTree) {
+	if (this->m_bTree) {
 		// status report is only performed for top level Execution Groups.
-		float progress = chunksFinished;
-		progress /= numberOfChunks;
-		bTree->progress(bTree->prh, progress);
+		float progress = this->m_chunksFinished;
+		progress /= this->m_numberOfChunks;
+		this->m_bTree->progress(this->m_bTree->prh, progress);
 	}
 }
 
 inline void ExecutionGroup::determineChunkRect(rcti *rect, const unsigned int xChunk, const unsigned int yChunk) const
 {
-	if (singleThreaded) {
-		BLI_init_rcti(rect, 0, this->width, 0, this->height);
+	if (this->m_singleThreaded) {
+		BLI_init_rcti(rect, 0, this->m_width, 0, this->m_height);
 	}
 	else {
-		const unsigned int minx = xChunk * chunkSize;
-		const unsigned int miny = yChunk * chunkSize;
-		BLI_init_rcti(rect, minx, min(minx + this->chunkSize, this->width), miny, min(miny + this->chunkSize, this->height));
+		const unsigned int minx = xChunk * this->m_chunkSize;
+		const unsigned int miny = yChunk * this->m_chunkSize;
+		BLI_init_rcti(rect, minx, min(minx + this->m_chunkSize, this->m_width), miny, min(miny + this->m_chunkSize, this->m_height));
 	}
 }
 
 void ExecutionGroup::determineChunkRect(rcti *rect, const unsigned int chunkNumber) const
 {
-	const unsigned int yChunk = chunkNumber / numberOfXChunks;
-	const unsigned int xChunk = chunkNumber - (yChunk * numberOfXChunks);
+	const unsigned int yChunk = chunkNumber / this->m_numberOfXChunks;
+	const unsigned int xChunk = chunkNumber - (yChunk * this->m_numberOfXChunks);
 	determineChunkRect(rect, xChunk, yChunk);
 }
 
@@ -477,13 +477,13 @@ MemoryBuffer *ExecutionGroup::allocateOutputBuffer(int chunkNumber, rcti *rect)
 
 bool ExecutionGroup::scheduleAreaWhenPossible(ExecutionSystem *graph, rcti *area)
 {
-	if (singleThreaded) {
+	if (this->m_singleThreaded) {
 		return scheduleChunkWhenPossible(graph, 0, 0);
 	}
 	// find all chunks inside the rect
 	// determine minxchunk, minychunk, maxxchunk, maxychunk where x and y are chunknumbers
 
-	float chunkSizef = this->chunkSize;
+	float chunkSizef = this->m_chunkSize;
 
 	int indexx, indexy;
 	const int minxchunk = floor(area->xmin / chunkSizef);
@@ -505,8 +505,8 @@ bool ExecutionGroup::scheduleAreaWhenPossible(ExecutionSystem *graph, rcti *area
 
 bool ExecutionGroup::scheduleChunk(unsigned int chunkNumber)
 {
-	if (this->chunkExecutionStates[chunkNumber] == COM_ES_NOT_SCHEDULED) {
-		this->chunkExecutionStates[chunkNumber] = COM_ES_SCHEDULED;
+	if (this->m_chunkExecutionStates[chunkNumber] == COM_ES_NOT_SCHEDULED) {
+		this->m_chunkExecutionStates[chunkNumber] = COM_ES_SCHEDULED;
 		WorkScheduler::schedule(this, chunkNumber);
 		return true;
 	}
@@ -515,20 +515,20 @@ bool ExecutionGroup::scheduleChunk(unsigned int chunkNumber)
 
 bool ExecutionGroup::scheduleChunkWhenPossible(ExecutionSystem *graph, int xChunk, int yChunk)
 {
-	if (xChunk < 0 || xChunk >= (int)this->numberOfXChunks) {
+	if (xChunk < 0 || xChunk >= (int)this->m_numberOfXChunks) {
 		return true;
 	}
-	if (yChunk < 0 || yChunk >= (int)this->numberOfYChunks) {
+	if (yChunk < 0 || yChunk >= (int)this->m_numberOfYChunks) {
 		return true;
 	}
-	int chunkNumber = yChunk * this->numberOfXChunks + xChunk;
+	int chunkNumber = yChunk * this->m_numberOfXChunks + xChunk;
 	// chunk is already executed
-	if (this->chunkExecutionStates[chunkNumber] == COM_ES_EXECUTED) {
+	if (this->m_chunkExecutionStates[chunkNumber] == COM_ES_EXECUTED) {
 		return true;
 	}
 
 	// chunk is scheduled, but not executed
-	if (this->chunkExecutionStates[chunkNumber] == COM_ES_SCHEDULED) {
+	if (this->m_chunkExecutionStates[chunkNumber] == COM_ES_SCHEDULED) {
 		return false;
 	}
 
@@ -542,8 +542,8 @@ bool ExecutionGroup::scheduleChunkWhenPossible(ExecutionSystem *graph, int xChun
 	bool canBeExecuted = true;
 	rcti area;
 
-	for (index = 0; index < cachedReadOperations.size(); index++) {
-		ReadBufferOperation *readOperation = (ReadBufferOperation *)cachedReadOperations[index];
+	for (index = 0; index < this->m_cachedReadOperations.size(); index++) {
+		ReadBufferOperation *readOperation = (ReadBufferOperation *)this->m_cachedReadOperations[index];
 		BLI_init_rcti(&area, 0, 0, 0, 0);
 		MemoryProxy *memoryProxy = memoryProxies[index];
 		determineDependingAreaOfInterest(&rect, readOperation, &area);
@@ -574,13 +574,13 @@ void ExecutionGroup::determineDependingAreaOfInterest(rcti *input, ReadBufferOpe
 void ExecutionGroup::determineDependingMemoryProxies(vector<MemoryProxy *> *memoryProxies)
 {
 	unsigned int index;
-	for (index = 0; index < this->cachedReadOperations.size(); index++) {
-		ReadBufferOperation *readOperation = (ReadBufferOperation *) this->cachedReadOperations[index];
+	for (index = 0; index < this->m_cachedReadOperations.size(); index++) {
+		ReadBufferOperation *readOperation = (ReadBufferOperation *) this->m_cachedReadOperations[index];
 		memoryProxies->push_back(readOperation->getMemoryProxy());
 	}
 }
 
 bool ExecutionGroup::isOpenCL()
 {
-	return this->openCL;
+	return this->m_openCL;
 }
diff --git a/source/blender/compositor/intern/COM_ExecutionGroup.h b/source/blender/compositor/intern/COM_ExecutionGroup.h
index 53c2e890bea..43c2bfac52e 100644
--- a/source/blender/compositor/intern/COM_ExecutionGroup.h
+++ b/source/blender/compositor/intern/COM_ExecutionGroup.h
@@ -67,81 +67,81 @@ private:
 	/**
 	 * @brief list of operations in this ExecutionGroup
 	 */
-	vector<NodeOperation *> operations;
+	vector<NodeOperation *> m_operations;
 	
 	/**
 	 * @brief is this ExecutionGroup an input ExecutionGroup
 	 * an input execution group is a group that is at the end of the calculation (the output is important for the user)
 	 */
-	int isOutput;
+	int m_isOutput;
 	
 	/**
 	 * @brief Width of the output
 	 */
-	unsigned int width;
+	unsigned int m_width;
 	
 	/**
 	 * @brief Height of the output
 	 */
-	unsigned int height;
+	unsigned int m_height;
 	
 	/**
 	 * @brief size of a single chunk, being Width or of height
 	 * a chunk is always a square, except at the edges of the MemoryBuffer
 	 */
-	unsigned int chunkSize;
+	unsigned int m_chunkSize;
 	
 	/**
 	 * @brief number of chunks in the x-axis
 	 */
-	unsigned int numberOfXChunks;
+	unsigned int m_numberOfXChunks;
 	
 	/**
 	 * @brief number of chunks in the y-axis
 	 */
-	unsigned int numberOfYChunks;
+	unsigned int m_numberOfYChunks;
 	
 	/**
 	 * @brief total number of chunks
 	 */
-	unsigned int numberOfChunks;
+	unsigned int m_numberOfChunks;
 	
 	/**
 	 * @brief contains this ExecutionGroup a complex NodeOperation.
 	 */
-	bool complex;
+	bool m_complex;
 	
 	/**
 	 * @brief can this ExecutionGroup be scheduled on an OpenCLDevice
 	 */
-	bool openCL;
+	bool m_openCL;
 	
 	/**
 	 * @brief Is this Execution group SingleThreaded
 	 */
-	bool singleThreaded;
+	bool m_singleThreaded;
 	
 	/**
 	 * @brief what is the maximum number field of all ReadBufferOperation in this ExecutionGroup.
 	 * @note this is used to construct the MemoryBuffers that will be passed during execution.
 	 */
-	unsigned int cachedMaxReadBufferOffset;
+	unsigned int m_cachedMaxReadBufferOffset;
 	
 	/**
 	 * @brief a cached vector of all read operations in the execution group.
 	 */
-	vector<NodeOperation *> cachedReadOperations;
+	vector<NodeOperation *> m_cachedReadOperations;
 	
 	/**
 	 * @brief reference to the original bNodeTree, this field is only set for the 'top' execution group.
 	 * @note can only be used to call the callbacks for progress, status and break
 	 */
-	const bNodeTree *bTree;
+	const bNodeTree *m_bTree;
 	
 	/**
 	 * @brief total number of chunks that have been calculated for this ExecutionGroup
 	 */
-	unsigned int chunksFinished;
+	unsigned int m_chunksFinished;
 	
 	/**
 	 * @brief the chunkExecutionStates holds per chunk the execution state. this state can be
@@ -149,7 +149,7 @@ private:
 	 *   - COM_ES_SCHEDULED: scheduled
 	 *   - COM_ES_EXECUTED: executed
 	 */
-	ChunkExecutionState *chunkExecutionStates;
+	ChunkExecutionState *m_chunkExecutionStates;
 	
 	/**
 	 * @brief indicator when this ExecutionGroup has valid NodeOperations in its vector for Execution
@@ -160,7 +160,7 @@ private:
 	 * @see complex
 	 * @see openCL
 	 */
-	bool initialized;
+	bool m_initialized;
 	
 	// methods
 	/**
@@ -258,13 +258,13 @@ public:
 	 * @note ViewerOperation, CompositeOperation, PreviewOperation.
 	 * @see NodeOperation.isOutputOperation
 	 */
-	const int isOutputExecutionGroup() const { return this->isOutput; }
+	const int isOutputExecutionGroup() const { return this->m_isOutput; }
 
 	/**
 	 * @brief set whether this ExecutionGroup is an output
 	 * @param isOutput
 	 */
-	void setOutputExecutionGroup(int isOutput) { this->isOutput = isOutput; }
+	void setOutputExecutionGroup(int isOutput) { this->m_isOutput = isOutput; }
 
 	/**
 	 * @brief determine the resolution of this ExecutionGroup
@@ -276,17 +276,17 @@ public:
 	 * @brief set the resolution of this executiongroup
 	 * @param resolution
 	 */
-	void setResolution(unsigned int resolution[]) { this->width = resolution[0]; this->height = resolution[1]; }
+	void setResolution(unsigned int resolution[]) { this->m_width = resolution[0]; this->m_height = resolution[1]; }
 	
 	/**
 	 * @brief get the width of this execution group
 	 */
-	const unsigned int getWidth() { return this->width; }
+	const unsigned int getWidth() { return this->m_width; }
 	
 	/**
 	 * @brief get the height of this execution group
 	 */
-	const unsigned int getHeight() { return this->height; }
+	const unsigned int getHeight() { return this->m_height; }
 	
 	/**
 	 * @brief does this ExecutionGroup contains a complex NodeOperation
@@ -387,7 +387,7 @@ public:
 	 */
 	bool isOpenCL();
 
-	void setChunksize(int chunksize) { this->chunkSize = chunksize; }
+	void setChunksize(int chunksize) { this->m_chunkSize = chunksize; }
 
 	/**
 	 * @brief get the Render priority of this ExecutionGroup
diff --git a/source/blender/compositor/intern/COM_ExecutionSystem.cpp b/source/blender/compositor/intern/COM_ExecutionSystem.cpp
index 5001cabbd9f..d5477cc1414 100644
--- a/source/blender/compositor/intern/COM_ExecutionSystem.cpp
+++ b/source/blender/compositor/intern/COM_ExecutionSystem.cpp
@@ -47,36 +47,36 @@
 
 ExecutionSystem::ExecutionSystem(RenderData *rd, bNodeTree *editingtree, bool rendering)
 {
-	context.setbNodeTree(editingtree);
+	this->m_context.setbNodeTree(editingtree);
 	bNode *gnode;
 	for (gnode = (bNode *)editingtree->nodes.first; gnode; gnode = (bNode *)gnode->next) {
 		if (gnode->type == NODE_GROUP && gnode->typeinfo->group_edit_get(gnode)) {
-			context.setActivegNode(gnode);
+			this->m_context.setActivegNode(gnode);
 			break;
 		}
 	}
 
 	/* initialize the CompositorContext */
 	if (rendering) {
-		context.setQuality((CompositorQuality)editingtree->render_quality);
+		this->m_context.setQuality((CompositorQuality)editingtree->render_quality);
 	}
 	else {
-		context.setQuality((CompositorQuality)editingtree->edit_quality);
+		this->m_context.setQuality((CompositorQuality)editingtree->edit_quality);
 	}
-	context.setRendering(rendering);
-	context.setHasActiveOpenCLDevices(WorkScheduler::hasGPUDevices() && (editingtree->flag & NTREE_COM_OPENCL));
+	this->m_context.setRendering(rendering);
+	this->m_context.setHasActiveOpenCLDevices(WorkScheduler::hasGPUDevices() && (editingtree->flag & NTREE_COM_OPENCL));
 
 	ExecutionSystemHelper::addbNodeTree(*this, 0, editingtree, NULL);
 
-	context.setRenderData(rd);
+	this->m_context.setRenderData(rd);
 	this->convertToOperations();
 	this->groupOperations(); /* group operations in ExecutionGroups */
 	unsigned int index;
 	unsigned int resolution[2];
-	for (index = 0; index < this->groups.size(); index++) {
+	for (index = 0; index < this->m_groups.size(); index++) {
 		resolution[0] = 0;
 		resolution[1] = 0;
-		ExecutionGroup *executionGroup = groups[index];
+		ExecutionGroup *executionGroup = this->m_groups[index];
 		executionGroup->determineResolution(resolution);
 	}
 
@@ -88,32 +88,32 @@ ExecutionSystem::ExecutionSystem(RenderData *rd, bNodeTree *editingtree, bool re
 ExecutionSystem::~ExecutionSystem()
 {
 	unsigned int index;
-	for (index = 0; index < this->connections.size(); index++) {
-		SocketConnection *connection = this->connections[index];
+	for (index = 0; index < this->m_connections.size(); index++) {
+		SocketConnection *connection = this->m_connections[index];
 		delete connection;
 	}
-	this->connections.clear();
-	for (index = 0; index < this->nodes.size(); index++) {
-		Node *node = this->nodes[index];
+	this->m_connections.clear();
+	for (index = 0; index < this->m_nodes.size(); index++) {
+		Node *node = this->m_nodes[index];
 		delete node;
 	}
-	this->nodes.clear();
-	for (index = 0; index < this->operations.size(); index++) {
-		NodeOperation *operation = this->operations[index];
+	this->m_nodes.clear();
+	for (index = 0; index < this->m_operations.size(); index++) {
+		NodeOperation *operation = this->m_operations[index];
 		delete operation;
 	}
-	this->operations.clear();
-	for (index = 0; index < this->groups.size(); index++) {
-		ExecutionGroup *group = this->groups[index];
+	this->m_operations.clear();
+	for (index = 0; index < this->m_groups.size(); index++) {
+		ExecutionGroup *group = this->m_groups[index];
 		delete group;
 	}
-	this->groups.clear();
+	this->m_groups.clear();
 }
 
 void ExecutionSystem::execute()
 {
 	unsigned int order = 0;
-	for (vector<NodeOperation *>::iterator iter = this->operations.begin(); iter != operations.end(); ++iter) {
+	for (vector<NodeOperation *>::iterator iter = this->m_operations.begin(); iter != this->m_operations.end(); ++iter) {
 		NodeBase *node = *iter;
 		NodeOperation *operation = (NodeOperation *) node;
 		if (operation->isReadBufferOperation()) {
@@ -124,18 +124,18 @@ void ExecutionSystem::execute()
 	}
 	unsigned int index;
 
-	for (index = 0; index < this->operations.size(); index++) {
-		NodeOperation *operation = this->operations[index];
-		operation->setbNodeTree(this->context.getbNodeTree());
+	for (index = 0; index < this->m_operations.size(); index++) {
+		NodeOperation *operation = this->m_operations[index];
+		operation->setbNodeTree(this->m_context.getbNodeTree());
 		operation->initExecution();
 	}
-	for (index = 0; index < this->groups.size(); index++) {
-		ExecutionGroup *executionGroup = this->groups[index];
-		executionGroup->setChunksize(context.getChunksize());
+	for (index = 0; index < this->m_groups.size(); index++) {
+		ExecutionGroup *executionGroup = this->m_groups[index];
+		executionGroup->setChunksize(this->m_context.getChunksize());
 		executionGroup->initExecution();
 	}
 
-	WorkScheduler::start(this->context);
+	WorkScheduler::start(this->m_context);
 
 	executeGroups(COM_PRIORITY_HIGH);
 	executeGroups(COM_PRIORITY_MEDIUM);
@@ -144,12 +144,12 @@ void ExecutionSystem::execute()
 	WorkScheduler::finish();
 	WorkScheduler::stop();
 
-	for (index = 0; index < this->operations.size(); index++) {
-		NodeOperation *operation = this->operations[index];
+	for (index = 0; index < this->m_operations.size(); index++) {
+		NodeOperation *operation = this->m_operations[index];
 		operation->deinitExecution();
 	}
-	for (index = 0; index < this->groups.size(); index++) {
-		ExecutionGroup *executionGroup = this->groups[index];
+	for (index = 0; index < this->m_groups.size(); index++) {
+		ExecutionGroup *executionGroup = this->m_groups[index];
 		executionGroup->deinitExecution();
 	}
 }
@@ -168,7 +168,7 @@ void ExecutionSystem::executeGroups(CompositorPriority priority)
 
 void ExecutionSystem::addOperation(NodeOperation *operation)
 {
-	ExecutionSystemHelper::addOperation(this->operations, operation);
+	ExecutionSystemHelper::addOperation(this->m_operations, operation);
 //	operation->setBTree
 }
 
@@ -231,13 +231,13 @@ void ExecutionSystem::addReadWriteBufferOperations(NodeOperation *operation)
 void ExecutionSystem::convertToOperations()
 {
 	unsigned int index;
-	for (index = 0; index < this->nodes.size(); index++) {
-		Node *node = (Node *)this->nodes[index];
-		node->convertToOperations(this, &this->context);
+	for (index = 0; index < this->m_nodes.size(); index++) {
+		Node *node = (Node *)this->m_nodes[index];
+		node->convertToOperations(this, &this->m_context);
 	}
 
-	for (index = 0; index < this->connections.size(); index++) {
-		SocketConnection *connection = this->connections[index];
+	for (index = 0; index < this->m_connections.size(); index++) {
+		SocketConnection *connection = this->m_connections[index];
 		if (connection->isValid()) {
 			if (connection->getFromSocket()->getDataType() != connection->getToSocket()->getDataType()) {
 				Converter::convertDataType(connection, this);
@@ -246,18 +246,18 @@ void ExecutionSystem::convertToOperations()
 	}
 
 	// determine all resolutions of the operations (Width/Height)
-	for (index = 0; index < this->operations.size(); index++) {
-		NodeOperation *operation = this->operations[index];
-		if (operation->isOutputOperation(context.isRendering()) && !operation->isPreviewOperation()) {
+	for (index = 0; index < this->m_operations.size(); index++) {
+		NodeOperation *operation = this->m_operations[index];
+		if (operation->isOutputOperation(this->m_context.isRendering()) && !operation->isPreviewOperation()) {
 			unsigned int resolution[2] = {0, 0};
 			unsigned int preferredResolution[2] = {0, 0};
 			operation->determineResolution(resolution, preferredResolution);
 			operation->setResolution(resolution);
 		}
 	}
-	for (index = 0; index < this->operations.size(); index++) {
-		NodeOperation *operation = this->operations[index];
-		if (operation->isOutputOperation(context.isRendering()) && operation->isPreviewOperation()) {
+	for (index = 0; index < this->m_operations.size(); index++) {
+		NodeOperation *operation = this->m_operations[index];
+		if (operation->isOutputOperation(this->m_context.isRendering()) && operation->isPreviewOperation()) {
 			unsigned int resolution[2] = {0, 0};
 			unsigned int preferredResolution[2] = {0, 0};
 			operation->determineResolution(resolution, preferredResolution);
@@ -266,8 +266,8 @@ void ExecutionSystem::convertToOperations()
 	}
 
 	// add convert resolution operations when needed.
-	for (index = 0; index < this->connections.size(); index++) {
-		SocketConnection *connection = this->connections[index];
+	for (index = 0; index < this->m_connections.size(); index++) {
+		SocketConnection *connection = this->m_connections[index];
 		if (connection->isValid()) {
 			if (connection->needsResolutionConversion()) {
 				Converter::convertResolution(connection, this);
@@ -282,13 +282,13 @@ void ExecutionSystem::groupOperations()
 	NodeOperation *operation;
 	unsigned int index;
 	// surround complex operations with ReadBufferOperation and WriteBufferOperation
-	for (index = 0; index < this->operations.size(); index++) {
-		operation = this->operations[index];
+	for (index = 0; index < this->m_operations.size(); index++) {
+		operation = this->m_operations[index];
 		if (operation->isComplex()) {
 			this->addReadWriteBufferOperations(operation);
 		}
 	}
-	ExecutionSystemHelper::findOutputNodeOperations(&outputOperations, this->getOperations(), this->context.isRendering());
+	ExecutionSystemHelper::findOutputNodeOperations(&outputOperations, this->getOperations(), this->m_context.isRendering());
 	for (vector<NodeOperation *>::iterator iter = outputOperations.begin(); iter != outputOperations.end(); ++iter) {
 		operation = *iter;
 		ExecutionGroup *group = new ExecutionGroup();
@@ -300,15 +300,15 @@ void ExecutionSystem::groupOperations()
 
 void ExecutionSystem::addSocketConnection(SocketConnection *connection)
 {
-	this->connections.push_back(connection);
+	this->m_connections.push_back(connection);
 }
 
 
 void ExecutionSystem::findOutputExecutionGroup(vector<ExecutionGroup *> *result, CompositorPriority priority) const
 {
 	unsigned int index;
-	for (index = 0; index < this->groups.size(); index++) {
-		ExecutionGroup *group = this->groups[index];
+	for (index = 0; index < this->m_groups.size(); index++) {
+		ExecutionGroup *group = this->m_groups[index];
 		if (group->isOutputExecutionGroup() && group->getRenderPriotrity() == priority) {
 			result->push_back(group);
 		}
@@ -318,8 +318,8 @@ void ExecutionSystem::findOutputExecutionGroup(vector<ExecutionGroup *> *result,
 void ExecutionSystem::findOutputExecutionGroup(vector<ExecutionGroup *> *result) const
 {
 	unsigned int index;
-	for (index = 0; index < this->groups.size(); index++) {
-		ExecutionGroup *group = this->groups[index];
+	for (index = 0; index < this->m_groups.size(); index++) {
+		ExecutionGroup *group = this->m_groups[index];
 		if (group->isOutputExecutionGroup()) {
 			result->push_back(group);
 		}
diff --git a/source/blender/compositor/intern/COM_ExecutionSystem.h b/source/blender/compositor/intern/COM_ExecutionSystem.h
index 293a35b3518..e51bd7f3026 100644
--- a/source/blender/compositor/intern/COM_ExecutionSystem.h
+++ b/source/blender/compositor/intern/COM_ExecutionSystem.h
@@ -108,27 +108,27 @@ private:
 	/**
 	 * @brief the context used during execution
 	 */
-	CompositorContext context;
+	CompositorContext m_context;
 
 	/**
 	 * @brief vector of nodes
 	 */
-	vector<Node *> nodes;
+	vector<Node *> m_nodes;
 
 	/**
 	 * @brief vector of operations
 	 */
-	vector<NodeOperation *> operations;
+	vector<NodeOperation *> m_operations;
 
 	/**
 	 * @brief vector of groups
 	 */
-	vector<ExecutionGroup *> groups
+	vector<ExecutionGroup *> m_groups;
 
 	/**
 	 * @brief vector of connections
-	 */;
-	vector<SocketConnection *> connections;
+	 */
+	vector<SocketConnection *> m_connections;
 
 private: //methods
 	/**
@@ -200,27 +200,27 @@ public:
 	/**
 	 * @brief get the reference to the compositor context
 	 */
-	CompositorContext& getContext() { return this->context; }
+	CompositorContext& getContext() { return this->m_context; }
 
 	/**
 	 * @brief get the reference to the compositor nodes
 	 */
-	vector<Node *>& getNodes() { return this->nodes; }
+	vector<Node *>& getNodes() { return this->m_nodes; }
 
 	/**
 	 * @brief get the reference to the compositor connections
 	 */
-	vector<SocketConnection *>& getConnections() { return this->connections; }
+	vector<SocketConnection *>& getConnections() { return this->m_connections; }
 
 	/**
 	 * @brief get the reference to the list of execution groups
 	 */
-	vector<ExecutionGroup *>& getExecutionGroups() { return this->groups; }
+	vector<ExecutionGroup *>& getExecutionGroups() { return this->m_groups; }
 
 	/**
 	 * @brief get the reference to the list of operations
 	 */
-	vector<NodeOperation *>& getOperations() { return this->operations; }
+	vector<NodeOperation *>& getOperations() { return this->m_operations; }
 
 private:
 
diff --git a/source/blender/compositor/intern/COM_InputSocket.cpp b/source/blender/compositor/intern/COM_InputSocket.cpp
index 3ca74f157b4..94cb5ff5396 100644
--- a/source/blender/compositor/intern/COM_InputSocket.cpp
+++ b/source/blender/compositor/intern/COM_InputSocket.cpp
@@ -27,37 +27,37 @@
 
 InputSocket::InputSocket(DataType datatype) : Socket(datatype)
 {
-	this->connection = NULL;
-	this->resizeMode = COM_SC_CENTER;
+	this->m_connection = NULL;
+	this->m_resizeMode = COM_SC_CENTER;
 }
 InputSocket::InputSocket(DataType datatype, InputSocketResizeMode resizeMode) : Socket(datatype)
 {
-	this->connection = NULL;
-	this->resizeMode = resizeMode;
+	this->m_connection = NULL;
+	this->m_resizeMode = resizeMode;
 }
 
 InputSocket::InputSocket(InputSocket *from) : Socket(from->getDataType())
 {
-	this->connection = NULL;
-	this->resizeMode = from->getResizeMode();
+	this->m_connection = NULL;
+	this->m_resizeMode = from->getResizeMode();
 }
 
 int InputSocket::isInputSocket() const { return true; }
-const int InputSocket::isConnected() const { return this->connection != NULL; }
+const int InputSocket::isConnected() const { return this->m_connection != NULL; }
 
 void InputSocket::setConnection(SocketConnection *connection)
 {
-	this->connection = connection;
+	this->m_connection = connection;
 }
 SocketConnection *InputSocket::getConnection()
 {
-	return this->connection;
+	return this->m_connection;
 }
 
 void InputSocket::determineResolution(unsigned int resolution[], unsigned int preferredResolution[])
 {
 	if (this->isConnected()) {
-		this->connection->getFromSocket()->determineResolution(resolution, preferredResolution);
+		this->m_connection->getFromSocket()->determineResolution(resolution, preferredResolution);
 	}
 	else {
 		return;
@@ -140,7 +140,7 @@ SocketReader *InputSocket::getReader()
 NodeOperation *InputSocket::getOperation() const
 {
 	if (isConnected()) {
-		return (NodeOperation *)this->connection->getFromSocket()->getNode();
+		return (NodeOperation *)this->m_connection->getFromSocket()->getNode();
 	}
 	else {
 		return NULL;
diff --git a/source/blender/compositor/intern/COM_InputSocket.h b/source/blender/compositor/intern/COM_InputSocket.h
index c066b5d8303..5d0923ff204 100644
--- a/source/blender/compositor/intern/COM_InputSocket.h
+++ b/source/blender/compositor/intern/COM_InputSocket.h
@@ -65,12 +65,12 @@ private:
 	 * @brief connection connected to this InputSocket.
 	 * An input socket can only have a single connection
 	 */
-	SocketConnection *connection;
+	SocketConnection *m_connection;
 	
 	/**
 	 * @brief resize mode of this socket
 	 */
-	InputSocketResizeMode resizeMode;
+	InputSocketResizeMode m_resizeMode;
 	
 	
 public:
@@ -126,7 +126,7 @@ public:
 	 * @param resizeMode the new resize mode.
 	 */
 	void setResizeMode(InputSocketResizeMode resizeMode) {
-		this->resizeMode = resizeMode;
+		this->m_resizeMode = resizeMode;
 	}
 	
 	/**
@@ -134,7 +134,7 @@ public:
 	 * @return InputSocketResizeMode
 	 */
 	InputSocketResizeMode getResizeMode() const {
-		return this->resizeMode;
+		return this->m_resizeMode;
 	}
 	
 	const ChannelInfo *getChannelInfo(const int channelnumber);
diff --git a/source/blender/compositor/intern/COM_MemoryBuffer.cpp b/source/blender/compositor/intern/COM_MemoryBuffer.cpp
index ceed53c4c0d..8dd1e55274f 100644
--- a/source/blender/compositor/intern/COM_MemoryBuffer.cpp
+++ b/source/blender/compositor/intern/COM_MemoryBuffer.cpp
@@ -32,43 +32,43 @@ unsigned int MemoryBuffer::determineBufferSize()
 
 int MemoryBuffer::getWidth() const
 {
-	return this->rect.xmax - this->rect.xmin;
+	return this->m_rect.xmax - this->m_rect.xmin;
 }
 int MemoryBuffer::getHeight() const
 {
-	return this->rect.ymax - this->rect.ymin;
+	return this->m_rect.ymax - this->m_rect.ymin;
 }
 
 MemoryBuffer::MemoryBuffer(MemoryProxy *memoryProxy, unsigned int chunkNumber, rcti *rect)
 {
-	BLI_init_rcti(&this->rect, rect->xmin, rect->xmax, rect->ymin, rect->ymax);
-	this->memoryProxy = memoryProxy;
-	this->chunkNumber = chunkNumber;
-	this->buffer = (float *)MEM_mallocN(sizeof(float) * determineBufferSize() * COM_NUMBER_OF_CHANNELS, "COM_MemoryBuffer");
-	this->state = COM_MB_ALLOCATED;
-	this->datatype = COM_DT_COLOR;
-	this->chunkWidth = this->rect.xmax - this->rect.xmin;
+	BLI_init_rcti(&this->m_rect, rect->xmin, rect->xmax, rect->ymin, rect->ymax);
+	this->m_memoryProxy = memoryProxy;
+	this->m_chunkNumber = chunkNumber;
+	this->m_buffer = (float *)MEM_mallocN(sizeof(float) * determineBufferSize() * COM_NUMBER_OF_CHANNELS, "COM_MemoryBuffer");
+	this->m_state = COM_MB_ALLOCATED;
+	this->m_datatype = COM_DT_COLOR;
+	this->m_chunkWidth = this->m_rect.xmax - this->m_rect.xmin;
 }
 
 MemoryBuffer::MemoryBuffer(MemoryProxy *memoryProxy, rcti *rect)
 {
-	BLI_init_rcti(&this->rect, rect->xmin, rect->xmax, rect->ymin, rect->ymax);
-	this->memoryProxy = memoryProxy;
-	this->chunkNumber = -1;
-	this->buffer = (float *)MEM_mallocN(sizeof(float) * determineBufferSize() * COM_NUMBER_OF_CHANNELS, "COM_MemoryBuffer");
-	this->state = COM_MB_TEMPORARILY;
-	this->datatype = COM_DT_COLOR;
-	this->chunkWidth = this->rect.xmax - this->rect.xmin;
+	BLI_init_rcti(&this->m_rect, rect->xmin, rect->xmax, rect->ymin, rect->ymax);
+	this->m_memoryProxy = memoryProxy;
+	this->m_chunkNumber = -1;
+	this->m_buffer = (float *)MEM_mallocN(sizeof(float) * determineBufferSize() * COM_NUMBER_OF_CHANNELS, "COM_MemoryBuffer");
+	this->m_state = COM_MB_TEMPORARILY;
+	this->m_datatype = COM_DT_COLOR;
+	this->m_chunkWidth = this->m_rect.xmax - this->m_rect.xmin;
 }
 MemoryBuffer *MemoryBuffer::duplicate()
 {
-	MemoryBuffer *result = new MemoryBuffer(this->memoryProxy, &this->rect);
-	memcpy(result->buffer, this->buffer, this->determineBufferSize() * COM_NUMBER_OF_CHANNELS * sizeof(float));
+	MemoryBuffer *result = new MemoryBuffer(this->m_memoryProxy, &this->m_rect);
+	memcpy(result->m_buffer, this->m_buffer, this->determineBufferSize() * COM_NUMBER_OF_CHANNELS * sizeof(float));
 	return result;
 }
 void MemoryBuffer::clear()
 {
-	memset(this->buffer, 0, this->determineBufferSize() * COM_NUMBER_OF_CHANNELS * sizeof(float));
+	memset(this->m_buffer, 0, this->determineBufferSize() * COM_NUMBER_OF_CHANNELS * sizeof(float));
 }
 
 float *MemoryBuffer::convertToValueBuffer()
@@ -78,7 +78,7 @@ float *MemoryBuffer::convertToValueBuffer()
 
 	float *result = new float[size];
 
-	const float *fp_src = this->buffer;
+	const float *fp_src = this->m_buffer;
 	float       *fp_dst = result;
 
 	for (i = 0; i < size; i++, fp_dst++, fp_src += COM_NUMBER_OF_CHANNELS) {
@@ -90,9 +90,9 @@ float *MemoryBuffer::convertToValueBuffer()
 
 MemoryBuffer::~MemoryBuffer()
 {
-	if (this->buffer) {
-		MEM_freeN(this->buffer);
-		this->buffer = NULL;
+	if (this->m_buffer) {
+		MEM_freeN(this->m_buffer);
+		this->m_buffer = NULL;
 	}
 }
 
@@ -102,30 +102,30 @@ void MemoryBuffer::copyContentFrom(MemoryBuffer *otherBuffer)
 		return;
 	}
 	unsigned int otherY;
-	unsigned int minX = max(this->rect.xmin, otherBuffer->rect.xmin);
-	unsigned int maxX = min(this->rect.xmax, otherBuffer->rect.xmax);
-	unsigned int minY = max(this->rect.ymin, otherBuffer->rect.ymin);
-	unsigned int maxY = min(this->rect.ymax, otherBuffer->rect.ymax);
+	unsigned int minX = max(this->m_rect.xmin, otherBuffer->m_rect.xmin);
+	unsigned int maxX = min(this->m_rect.xmax, otherBuffer->m_rect.xmax);
+	unsigned int minY = max(this->m_rect.ymin, otherBuffer->m_rect.ymin);
+	unsigned int maxY = min(this->m_rect.ymax, otherBuffer->m_rect.ymax);
 	int offset;
 	int otherOffset;
 
 
 	for (otherY = minY; otherY < maxY; otherY++) {
-		otherOffset = ((otherY - otherBuffer->rect.ymin) * otherBuffer->chunkWidth + minX - otherBuffer->rect.xmin) * COM_NUMBER_OF_CHANNELS;
-		offset = ((otherY - this->rect.ymin) * this->chunkWidth + minX - this->rect.xmin) * COM_NUMBER_OF_CHANNELS;
-		memcpy(&this->buffer[offset], &otherBuffer->buffer[otherOffset], (maxX - minX) * COM_NUMBER_OF_CHANNELS * sizeof(float));
+		otherOffset = ((otherY - otherBuffer->m_rect.ymin) * otherBuffer->m_chunkWidth + minX - otherBuffer->m_rect.xmin) * COM_NUMBER_OF_CHANNELS;
+		offset = ((otherY - this->m_rect.ymin) * this->m_chunkWidth + minX - this->m_rect.xmin) * COM_NUMBER_OF_CHANNELS;
+		memcpy(&this->m_buffer[offset], &otherBuffer->m_buffer[otherOffset], (maxX - minX) * COM_NUMBER_OF_CHANNELS * sizeof(float));
 	}
 }
 
 void MemoryBuffer::read(float result[4], int x, int y)
 {
-	if (x >= this->rect.xmin && x < this->rect.xmax &&
-	    y >= this->rect.ymin && y < this->rect.ymax)
+	if (x >= this->m_rect.xmin && x < this->m_rect.xmax &&
+	    y >= this->m_rect.ymin && y < this->m_rect.ymax)
 	{
-		const int dx = x - this->rect.xmin;
-		const int dy = y - this->rect.ymin;
-		const int offset = (this->chunkWidth * dy + dx) * COM_NUMBER_OF_CHANNELS;
-		copy_v4_v4(result, &this->buffer[offset]);
+		const int dx = x - this->m_rect.xmin;
+		const int dy = y - this->m_rect.ymin;
+		const int offset = (this->m_chunkWidth * dy + dx) * COM_NUMBER_OF_CHANNELS;
+		copy_v4_v4(result, &this->m_buffer[offset]);
 	}
 	else {
 		zero_v4(result);
@@ -133,21 +133,21 @@ void MemoryBuffer::read(float result[4], int x, int y)
 }
 void MemoryBuffer::writePixel(int x, int y, const float color[4])
 {
-	if (x >= this->rect.xmin && x < this->rect.xmax &&
-	    y >= this->rect.ymin && y < this->rect.ymax)
+	if (x >= this->m_rect.xmin && x < this->m_rect.xmax &&
+	    y >= this->m_rect.ymin && y < this->m_rect.ymax)
 	{
-		const int offset = (this->chunkWidth * y + x) * COM_NUMBER_OF_CHANNELS;
-		copy_v4_v4(&this->buffer[offset], color);
+		const int offset = (this->m_chunkWidth * y + x) * COM_NUMBER_OF_CHANNELS;
+		copy_v4_v4(&this->m_buffer[offset], color);
 	}
 }
 
 void MemoryBuffer::addPixel(int x, int y, const float color[4])
 {
-	if (x >= this->rect.xmin && x < this->rect.xmax &&
-	    y >= this->rect.ymin && y < this->rect.ymax)
+	if (x >= this->m_rect.xmin && x < this->m_rect.xmax &&
+	    y >= this->m_rect.ymin && y < this->m_rect.ymax)
 	{
-		const int offset = (this->chunkWidth * y + x) * COM_NUMBER_OF_CHANNELS;
-		add_v4_v4(&this->buffer[offset], color);
+		const int offset = (this->m_chunkWidth * y + x) * COM_NUMBER_OF_CHANNELS;
+		add_v4_v4(&this->m_buffer[offset], color);
 	}
 }
 
diff --git a/source/blender/compositor/intern/COM_MemoryBuffer.h b/source/blender/compositor/intern/COM_MemoryBuffer.h
index 63d9d54bcee..63b41aeddde 100644
--- a/source/blender/compositor/intern/COM_MemoryBuffer.h
+++ b/source/blender/compositor/intern/COM_MemoryBuffer.h
@@ -56,39 +56,39 @@ private:
 	/**
 	 * @brief proxy of the memory (same for all chunks in the same buffer)
 	 */
-	MemoryProxy *memoryProxy;
+	MemoryProxy *m_memoryProxy;
 	
 	/**
 	 * @brief the type of buffer COM_DT_VALUE, COM_DT_VECTOR, COM_DT_COLOR
 	 */
-	DataType datatype;
+	DataType m_datatype;
 	
 	
 	/**
 	 * @brief region of this buffer inside reative to the MemoryProxy
 	 */
-	rcti rect;
+	rcti m_rect;
 	
 	/**
 	 * brief refers to the chunknumber within the executiongroup where related to the MemoryProxy
 	 * @see memoryProxy
 	 */
-	unsigned int chunkNumber;
+	unsigned int m_chunkNumber;
 	
 	/**
 	 * @brief width of the chunk
 	 */
-	unsigned int chunkWidth;
+	unsigned int m_chunkWidth;
 	
 	/**
 	 * @brief state of the buffer
 	 */
-	MemoryBufferState state;
+	MemoryBufferState m_state;
 	
 	/**
 	 * @brief the actual float buffer/data
 	 */
-	float *buffer;
+	float *m_buffer;
 
 public:
 	/**
@@ -109,19 +109,19 @@ public:
 	/**
 	 * @brief read the ChunkNumber of this MemoryBuffer
 	 */
-	unsigned int getChunkNumber() { return this->chunkNumber; }
+	unsigned int getChunkNumber() { return this->m_chunkNumber; }
 	
 	/**
 	 * @brief get the data of this MemoryBuffer
 	 * @note buffer should already be available in memory
 	 */
-	float *getBuffer() { return this->buffer; }
+	float *getBuffer() { return this->m_buffer; }
 	
 	/**
 	 * @brief after execution the state will be set to available by calling this method
 	 */
 	void setCreatedState() {
-		this->state = COM_MB_AVAILABLE;
+		this->m_state = COM_MB_AVAILABLE;
 	}
 	
 	void read(float result[4], int x, int y);
@@ -133,7 +133,7 @@ public:
 	/**
 	 * @brief is this MemoryBuffer a temporarily buffer (based on an area, not on a chunk)
 	 */
-	inline const bool isTemporarily() const { return this->state == COM_MB_TEMPORARILY; }
+	inline const bool isTemporarily() const { return this->m_state == COM_MB_TEMPORARILY; }
 	
 	/**
 	 * @brief add the content from otherBuffer to this MemoryBuffer
@@ -144,7 +144,7 @@ public:
 	/**
 	 * @brief get the rect of this MemoryBuffer
 	 */
-	rcti *getRect() { return &this->rect; }
+	rcti *getRect() { return &this->m_rect; }
 	
 	/**
 	 * @brief get the width of this MemoryBuffer
diff --git a/source/blender/compositor/intern/COM_MemoryProxy.cpp b/source/blender/compositor/intern/COM_MemoryProxy.cpp
index 3a2c690d7de..90ca0baea06 100644
--- a/source/blender/compositor/intern/COM_MemoryProxy.cpp
+++ b/source/blender/compositor/intern/COM_MemoryProxy.cpp
@@ -25,8 +25,8 @@
 
 MemoryProxy::MemoryProxy()
 {
-	this->writeBufferOperation = NULL;
-	this->executor = NULL;
+	this->m_writeBufferOperation = NULL;
+	this->m_executor = NULL;
 }
 
 void MemoryProxy::allocate(unsigned int width, unsigned int height)
@@ -37,14 +37,14 @@ void MemoryProxy::allocate(unsigned int width, unsigned int height)
 	result.ymin = 0;
 	result.ymax = height;
 
-	buffer = new MemoryBuffer(this, 1, &result);
+	this->m_buffer = new MemoryBuffer(this, 1, &result);
 }
 
 void MemoryProxy::free()
 {
-	if (buffer) {
-		delete buffer;
-		buffer = NULL;
+	if (this->m_buffer) {
+		delete this->m_buffer;
+		this->m_buffer = NULL;
 	}
 }
 
diff --git a/source/blender/compositor/intern/COM_MemoryProxy.h b/source/blender/compositor/intern/COM_MemoryProxy.h
index 8ac817ffe7b..f02da215b5f 100644
--- a/source/blender/compositor/intern/COM_MemoryProxy.h
+++ b/source/blender/compositor/intern/COM_MemoryProxy.h
@@ -23,8 +23,8 @@
 class MemoryProxy;
 
 
-#ifndef _COM_MemoryProxy_h
-#define _COM_MemoryProxy_h
+#ifndef _COM_MemoryProxy_h_
+#define _COM_MemoryProxy_h_
 #include "COM_ExecutionGroup.h"
 
 class ExecutionGroup;
@@ -40,27 +40,27 @@ private:
 	/**
 	 * @brief reference to the ouput operation of the executiongroup
 	 */
-	WriteBufferOperation *writeBufferOperation;
+	WriteBufferOperation *m_writeBufferOperation;
 	
 	/**
 	 * @brief reference to the executor. the Execution group that can fill a chunk
 	 */
-	ExecutionGroup *executor;
+	ExecutionGroup *m_executor;
 	
 	/**
 	 * @brief datatype of this MemoryProxy
 	 */
-	DataType datatype;
+	DataType m_datatype;
 	
 	/**
 	 * @brief channel information of this buffer
 	 */
-	ChannelInfo channelInfo[COM_NUMBER_OF_CHANNELS];
+	ChannelInfo m_channelInfo[COM_NUMBER_OF_CHANNELS];
 
 	/**
 	 * @brief the allocated memory
 	 */
-	MemoryBuffer *buffer;
+	MemoryBuffer *m_buffer;
 
 public:
 	MemoryProxy();
@@ -69,24 +69,24 @@ public:
 	 * @brief set the ExecutionGroup that can be scheduled to calculate a certain chunk.
 	 * @param group the ExecutionGroup to set
 	 */
-	void setExecutor(ExecutionGroup *executor) { this->executor = executor; }
+	void setExecutor(ExecutionGroup *executor) { this->m_executor = executor; }
 
 	/**
 	 * @brief get the ExecutionGroup that can be scheduled to calculate a certain chunk.
 	 */
-	ExecutionGroup *getExecutor() { return this->executor; }
+	ExecutionGroup *getExecutor() { return this->m_executor; }
 
 	/**
 	 * @brief set the WriteBufferOperation that is responsible for writing to this MemoryProxy
 	 * @param operation
 	 */
-	void setWriteBufferOperation(WriteBufferOperation *operation) { this->writeBufferOperation = operation; }
+	void setWriteBufferOperation(WriteBufferOperation *operation) { this->m_writeBufferOperation = operation; }
 
 	/**
 	 * @brief get the WriteBufferOperation that is responsible for writing to this MemoryProxy
 	 * @return WriteBufferOperation
 	 */
-	WriteBufferOperation *getWriteBufferOperation() { return this->writeBufferOperation; }
+	WriteBufferOperation *getWriteBufferOperation() { return this->m_writeBufferOperation; }
 
 	/**
 	 * @brief allocate memory of size widht x height
@@ -101,7 +101,7 @@ public:
 	/**
 	 * @brief get the allocated memory
 	 */
-	inline MemoryBuffer *getBuffer() { return this->buffer; }
+	inline MemoryBuffer *getBuffer() { return this->m_buffer; }
 
 #ifdef WITH_CXX_GUARDEDALLOC
 	MEM_CXX_CLASS_ALLOC_FUNCS("COM:MemoryProxy")
diff --git a/source/blender/compositor/intern/COM_Node.cpp b/source/blender/compositor/intern/COM_Node.cpp
index 06b6164be3c..15b8a3933a7 100644
--- a/source/blender/compositor/intern/COM_Node.cpp
+++ b/source/blender/compositor/intern/COM_Node.cpp
@@ -41,7 +41,7 @@
 
 Node::Node(bNode *editorNode, bool create_sockets)
 {
-	this->editorNode = editorNode;
+	this->m_editorNode = editorNode;
 	
 	if (create_sockets) {
 		bNodeSocket *input = (bNodeSocket *)editorNode->inputs.first;
@@ -66,12 +66,12 @@ Node::Node(bNode *editorNode, bool create_sockets)
 }
 Node::Node()
 {
-	this->editorNode = NULL;
+	this->m_editorNode = NULL;
 }
 
 bNode *Node::getbNode()
 {
-	return this->editorNode;
+	return this->m_editorNode;
 }
 
 void Node::addSetValueOperation(ExecutionSystem *graph, InputSocket *inputsocket, int editorNodeInputSocketIndex)
diff --git a/source/blender/compositor/intern/COM_Node.h b/source/blender/compositor/intern/COM_Node.h
index 090b1455440..39309b442d1 100644
--- a/source/blender/compositor/intern/COM_Node.h
+++ b/source/blender/compositor/intern/COM_Node.h
@@ -51,12 +51,12 @@ private:
 	/**
 	 * @brief stores the reference to the SDNA bNode struct
 	 */
-	bNode *editorNode;
+	bNode *m_editorNode;
 
 	/**
 	 * @brief Is this node part of the active group
 	 */
-	bool inActiveGroup;
+	bool m_inActiveGroup;
 
 public:
 	Node(bNode *editorNode, bool create_sockets = true);
@@ -70,7 +70,7 @@ public:
 	 * @brief Is this node in the active group (the group that is being edited)
 	 * @param isInActiveGroup
 	 */
-	void setIsInActiveGroup(bool isInActiveGroup) { this->inActiveGroup = isInActiveGroup; }
+	void setIsInActiveGroup(bool isInActiveGroup) { this->m_inActiveGroup = isInActiveGroup; }
 	
 	/**
 	 * @brief Is this node part of the active group
@@ -78,7 +78,7 @@ public:
 	 * the active group will be the main tree (all nodes that are not part of a group will be active)
 	 * @return bool [false:true]
 	 */
-	inline bool isInActiveGroup() { return this->inActiveGroup; }
+	inline bool isInActiveGroup() { return this->m_inActiveGroup; }
 
 	/**
 	 * @brief convert node to operation
diff --git a/source/blender/compositor/intern/COM_NodeBase.cpp b/source/blender/compositor/intern/COM_NodeBase.cpp
index 1a895cf93b1..8dbda5f649c 100644
--- a/source/blender/compositor/intern/COM_NodeBase.cpp
+++ b/source/blender/compositor/intern/COM_NodeBase.cpp
@@ -39,13 +39,13 @@ NodeBase::NodeBase()
 
 NodeBase::~NodeBase()
 {
-	while (!this->outputsockets.empty()) {
-		delete (this->outputsockets.back());
-		this->outputsockets.pop_back();
+	while (!this->m_outputsockets.empty()) {
+		delete (this->m_outputsockets.back());
+		this->m_outputsockets.pop_back();
 	}
-	while (!this->inputsockets.empty()) {
-		delete (this->inputsockets.back());
-		this->inputsockets.pop_back();
+	while (!this->m_inputsockets.empty()) {
+		delete (this->m_inputsockets.back());
+		this->m_inputsockets.pop_back();
 	}
 }
 
@@ -63,7 +63,7 @@ void NodeBase::addInputSocket(DataType datatype, InputSocketResizeMode resizeMod
 	InputSocket *socket = new InputSocket(datatype, resizeMode);
 	socket->setEditorSocket(bSocket);
 	socket->setNode(this);
-	this->inputsockets.push_back(socket);
+	this->m_inputsockets.push_back(socket);
 }
 
 void NodeBase::addOutputSocket(DataType datatype)
@@ -76,21 +76,21 @@ void NodeBase::addOutputSocket(DataType datatype, bNodeSocket *bSocket)
 	OutputSocket *socket = new OutputSocket(datatype);
 	socket->setEditorSocket(bSocket);
 	socket->setNode(this);
-	this->outputsockets.push_back(socket);
+	this->m_outputsockets.push_back(socket);
 }
 const bool NodeBase::isInputNode() const
 {
-	return this->inputsockets.size() == 0;
+	return this->m_inputsockets.size() == 0;
 }
 
 OutputSocket *NodeBase::getOutputSocket(unsigned int index)
 {
-	BLI_assert(index < this->outputsockets.size());
-	return this->outputsockets[index];
+	BLI_assert(index < this->m_outputsockets.size());
+	return this->m_outputsockets[index];
 }
 
 InputSocket *NodeBase::getInputSocket(unsigned int index)
 {
-	BLI_assert(index < this->inputsockets.size());
-	return this->inputsockets[index];
+	BLI_assert(index < this->m_inputsockets.size());
+	return this->m_inputsockets[index];
 }
diff --git a/source/blender/compositor/intern/COM_NodeBase.h b/source/blender/compositor/intern/COM_NodeBase.h
index fc9f79d2686..7095cda39e3 100644
--- a/source/blender/compositor/intern/COM_NodeBase.h
+++ b/source/blender/compositor/intern/COM_NodeBase.h
@@ -47,23 +47,23 @@ private:
 	/**
 	 * @brief the list of actual inputsockets @see InputSocket
 	 */
-	vector<InputSocket *> inputsockets;
+	vector<InputSocket *> m_inputsockets;
 
 	/**
 	 * @brief the list of actual outputsockets @see OutputSocket
 	 */
-	vector<OutputSocket *> outputsockets;
+	vector<OutputSocket *> m_outputsockets;
 
 protected:
 	/**
 	 * @brief get access to the vector of input sockets
 	 */
-	inline vector<InputSocket *>& getInputSockets() { return this->inputsockets; }
+	inline vector<InputSocket *>& getInputSockets() { return this->m_inputsockets; }
 	
 	/**
 	 * @brief get access to the vector of input sockets
 	 */
-	inline vector<OutputSocket *>& getOutputSockets() { return this->outputsockets; }
+	inline vector<OutputSocket *>& getOutputSockets() { return this->m_outputsockets; }
 
 
 public:
@@ -91,12 +91,12 @@ public:
 	/**
 	 * @brief Return the number of input sockets of this node.
 	 */
-	const unsigned int getNumberOfInputSockets() const { return this->inputsockets.size(); }
+	const unsigned int getNumberOfInputSockets() const { return this->m_inputsockets.size(); }
 
 	/**
 	 * @brief Return the number of output sockets of this node.
 	 */
-	const unsigned int getNumberOfOutputSockets() const { return this->outputsockets.size(); }
+	const unsigned int getNumberOfOutputSockets() const { return this->m_outputsockets.size(); }
 
 	/**
 	 * get the reference to a certain outputsocket
diff --git a/source/blender/compositor/intern/COM_OpenCLDevice.cpp b/source/blender/compositor/intern/COM_OpenCLDevice.cpp
index c9d27b8543c..2dd44f8140f 100644
--- a/source/blender/compositor/intern/COM_OpenCLDevice.cpp
+++ b/source/blender/compositor/intern/COM_OpenCLDevice.cpp
@@ -27,24 +27,24 @@ typedef enum COM_VendorID  {NVIDIA=0x10DE, AMD=0x1002} COM_VendorID;
 
 OpenCLDevice::OpenCLDevice(cl_context context, cl_device_id device, cl_program program, cl_int vendorId)
 {
-	this->device = device;
-	this->context = context;
-	this->program = program;
-	this->queue = NULL;
-	this->vendorID = vendorId;
+	this->m_device = device;
+	this->m_context = context;
+	this->m_program = program;
+	this->m_queue = NULL;
+	this->m_vendorID = vendorId;
 }
 
 bool OpenCLDevice::initialize()
 {
 	cl_int error;
-	queue = clCreateCommandQueue(context, device, 0, &error);
+	this->m_queue = clCreateCommandQueue(this->m_context, this->m_device, 0, &error);
 	return false;
 }
 
 void OpenCLDevice::deinitialize()
 {
-	if (queue) {
-		clReleaseCommandQueue(queue);
+	if (this->m_queue) {
+		clReleaseCommandQueue(this->m_queue);
 	}
 }
 
@@ -76,8 +76,8 @@ cl_mem OpenCLDevice::COM_clAttachMemoryBufferToKernelParameter(cl_kernel kernel,
 		CL_FLOAT
 	};
 
-	cl_mem clBuffer = clCreateImage2D(this->context, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR, &imageFormat, result->getWidth(),
-									  result->getHeight(), 0, result->getBuffer(), &error);
+	cl_mem clBuffer = clCreateImage2D(this->m_context, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR, &imageFormat, result->getWidth(),
+	                                  result->getHeight(), 0, result->getBuffer(), &error);
 
 	if (error != CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error, clewErrorString(error));  }
 	if (error == CL_SUCCESS) cleanup->push_back(clBuffer);
@@ -124,7 +124,7 @@ void OpenCLDevice::COM_clEnqueueRange(cl_kernel kernel, MemoryBuffer *outputMemo
 	cl_int error;
 	const size_t size[] = {outputMemoryBuffer->getWidth(), outputMemoryBuffer->getHeight()};
 
-	error = clEnqueueNDRangeKernel(this->queue, kernel, 2, NULL, size, 0, 0, 0, NULL);
+	error = clEnqueueNDRangeKernel(this->m_queue, kernel, 2, NULL, size, 0, 0, 0, NULL);
 	if (error != CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error, clewErrorString(error));  }
 }
 
@@ -139,7 +139,7 @@ void OpenCLDevice::COM_clEnqueueRange(cl_kernel kernel, MemoryBuffer *outputMemo
 	size_t size[2];
 	cl_int2 offset;
 
-	if (this->vendorID == NVIDIA){localSize = 32;}
+	if (this->m_vendorID == NVIDIA) {localSize = 32;}
 	bool breaked = false;
 	for (offsety = 0; offsety < height && (!breaked); offsety += localSize) {
 		offset[1] = offsety;
@@ -160,9 +160,9 @@ void OpenCLDevice::COM_clEnqueueRange(cl_kernel kernel, MemoryBuffer *outputMemo
 
 			error = clSetKernelArg(kernel, offsetIndex, sizeof(cl_int2), &offset);
 			if (error != CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error, clewErrorString(error)); }
-			error = clEnqueueNDRangeKernel(this->queue, kernel, 2, NULL, size, 0, 0, 0, NULL);
+			error = clEnqueueNDRangeKernel(this->m_queue, kernel, 2, NULL, size, 0, 0, 0, NULL);
 			if (error != CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error, clewErrorString(error));  }
-			clFlush(this->queue);
+			clFlush(this->m_queue);
 			if (operation->isBreaked()) {
 				breaked = false;
 			}
@@ -173,7 +173,7 @@ void OpenCLDevice::COM_clEnqueueRange(cl_kernel kernel, MemoryBuffer *outputMemo
 cl_kernel OpenCLDevice::COM_clCreateKernel(const char *kernelname, list<cl_kernel> *clKernelsToCleanUp)
 {
 	cl_int error;
-	cl_kernel kernel = clCreateKernel(this->program, kernelname, &error);
+	cl_kernel kernel = clCreateKernel(this->m_program, kernelname, &error);
 	if (error != CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error, clewErrorString(error)); }
 	else {
 		if (clKernelsToCleanUp) clKernelsToCleanUp->push_back(kernel);
diff --git a/source/blender/compositor/intern/COM_OpenCLDevice.h b/source/blender/compositor/intern/COM_OpenCLDevice.h
index d132f330651..30a90dabc3e 100644
--- a/source/blender/compositor/intern/COM_OpenCLDevice.h
+++ b/source/blender/compositor/intern/COM_OpenCLDevice.h
@@ -38,27 +38,27 @@ private:
 	/**
 	 * @brief opencl context
 	 */
-	cl_context context;
+	cl_context m_context;
 	
 	/**
 	 * @brief opencl device
 	 */
-	cl_device_id device;
+	cl_device_id m_device;
 	
 	/**
 	 * @brief opencl program
 	 */
-	cl_program program;
+	cl_program m_program;
 	
 	/**
 	 * @brief opencl command queue
 	 */
-	cl_command_queue queue;
+	cl_command_queue m_queue;
 
 	/**
 	 * @brief opencl vendor ID
 	 */
-	cl_int vendorID;
+	cl_int m_vendorID;
 
 public:
 	/**
@@ -91,9 +91,9 @@ public:
 	 */
 	void execute(WorkPackage *work);
 
-	cl_context getContext(){return this->context;}
+	cl_context getContext(){ return this->m_context; }
 
-	cl_command_queue getQueue(){return this->queue;}
+	cl_command_queue getQueue(){ return this->m_queue; }
 
 	cl_mem COM_clAttachMemoryBufferToKernelParameter(cl_kernel kernel, int parameterIndex, int offsetIndex, list<cl_mem> *cleanup, MemoryBuffer **inputMemoryBuffers, SocketReader *reader);
 	void COM_clAttachMemoryBufferOffsetToKernelParameter(cl_kernel kernel, int offsetIndex, MemoryBuffer *memoryBuffers);
diff --git a/source/blender/compositor/intern/COM_OutputSocket.cpp b/source/blender/compositor/intern/COM_OutputSocket.cpp
index 484254fe6de..865ab0472e8 100644
--- a/source/blender/compositor/intern/COM_OutputSocket.cpp
+++ b/source/blender/compositor/intern/COM_OutputSocket.cpp
@@ -31,7 +31,7 @@ OutputSocket::OutputSocket(DataType datatype) : Socket(datatype)
 }
 
 int OutputSocket::isOutputSocket() const { return true; }
-const int OutputSocket::isConnected() const { return this->connections.size() != 0; }
+const int OutputSocket::isConnected() const { return this->m_connections.size() != 0; }
 
 void OutputSocket::determineResolution(unsigned int resolution[], unsigned int preferredResolution[])
 {
@@ -51,37 +51,37 @@ void OutputSocket::determineResolution(unsigned int resolution[], unsigned int p
 
 void OutputSocket::addConnection(SocketConnection *connection)
 {
-	this->connections.push_back(connection);
+	this->m_connections.push_back(connection);
 }
 
 void OutputSocket::relinkConnections(OutputSocket *relinkToSocket, bool single)
 {
 	if (isConnected()) {
 		if (single) {
-			SocketConnection *connection = this->connections[0];
+			SocketConnection *connection = this->m_connections[0];
 			connection->setFromSocket(relinkToSocket);
 			relinkToSocket->addConnection(connection);
-			this->connections.erase(this->connections.begin());
+			this->m_connections.erase(this->m_connections.begin());
 		}
 		else {
 			unsigned int index;
-			for (index = 0; index < this->connections.size(); index++) {
-				SocketConnection *connection = this->connections[index];
+			for (index = 0; index < this->m_connections.size(); index++) {
+				SocketConnection *connection = this->m_connections[index];
 				connection->setFromSocket(relinkToSocket);
 				relinkToSocket->addConnection(connection);
 			}
-			this->connections.clear();
+			this->m_connections.clear();
 		}
 	}
 }
 void OutputSocket::removeFirstConnection()
 {
-	SocketConnection *connection = this->connections[0];
+	SocketConnection *connection = this->m_connections[0];
 	InputSocket *inputSocket = connection->getToSocket();
 	if (inputSocket != NULL) {
 		inputSocket->setConnection(NULL);
 	}
-	this->connections.erase(this->connections.begin());
+	this->m_connections.erase(this->m_connections.begin());
 }
 
 void OutputSocket::clearConnections()
@@ -94,8 +94,8 @@ void OutputSocket::clearConnections()
 WriteBufferOperation *OutputSocket::findAttachedWriteBufferOperation() const
 {
 	unsigned int index;
-	for (index = 0; index < this->connections.size(); index++) {
-		SocketConnection *connection = this->connections[index];
+	for (index = 0; index < this->m_connections.size(); index++) {
+		SocketConnection *connection = this->m_connections[index];
 		NodeBase *node = connection->getToNode();
 		if (node->isOperation()) {
 			NodeOperation *operation = (NodeOperation *)node;
diff --git a/source/blender/compositor/intern/COM_OutputSocket.h b/source/blender/compositor/intern/COM_OutputSocket.h
index c073703c423..4810e1ae065 100644
--- a/source/blender/compositor/intern/COM_OutputSocket.h
+++ b/source/blender/compositor/intern/COM_OutputSocket.h
@@ -42,7 +42,7 @@ class WriteBufferOperation;
  */
 class OutputSocket : public Socket {
 private:
-	vector<SocketConnection *> connections;
+	vector<SocketConnection *> m_connections;
 		
 	void removeFirstConnection();
 public:
@@ -50,7 +50,7 @@ public:
 	OutputSocket(DataType datatype, int inputSocketDataTypeDeterminatorIndex);
 	OutputSocket(OutputSocket *from);
 	void addConnection(SocketConnection *connection);
-	SocketConnection *getConnection(unsigned int index) { return this->connections[index]; }
+	SocketConnection *getConnection(unsigned int index) { return this->m_connections[index]; }
 	const int isConnected() const;
 	int isOutputSocket() const;
 	
@@ -66,7 +66,7 @@ public:
 	 */
 	void relinkConnections(OutputSocket *relinkToSocket) { this->relinkConnections(relinkToSocket, false); };
 	void relinkConnections(OutputSocket *relinkToSocket, bool single);
-	const int getNumberOfConnections() { return connections.size(); }
+	const int getNumberOfConnections() { return this->m_connections.size(); }
 	
 	void clearConnections();
 	
diff --git a/source/blender/compositor/intern/COM_SingleThreadedNodeOperation.cpp b/source/blender/compositor/intern/COM_SingleThreadedNodeOperation.cpp
index 01043664412..a6f81410b74 100644
--- a/source/blender/compositor/intern/COM_SingleThreadedNodeOperation.cpp
+++ b/source/blender/compositor/intern/COM_SingleThreadedNodeOperation.cpp
@@ -24,7 +24,7 @@
 
 SingleThreadedNodeOperation::SingleThreadedNodeOperation() : NodeOperation()
 {
-	this->cachedInstance = NULL;
+	this->m_cachedInstance = NULL;
 	setComplex(true);
 }
 
@@ -35,26 +35,26 @@ void SingleThreadedNodeOperation::initExecution()
 
 void SingleThreadedNodeOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
 {
-	this->cachedInstance->read(color, x, y);
+	this->m_cachedInstance->read(color, x, y);
 }
 
 void SingleThreadedNodeOperation::deinitExecution()
 {
 	deinitMutex();
-	if (this->cachedInstance) {
-		delete cachedInstance;
-		this->cachedInstance = NULL;
+	if (this->m_cachedInstance) {
+		delete this->m_cachedInstance;
+		this->m_cachedInstance = NULL;
 	}
 }
 void *SingleThreadedNodeOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
 {
-	if (this->cachedInstance) return this->cachedInstance;
+	if (this->m_cachedInstance) return this->m_cachedInstance;
 	
 	lockMutex();
-	if (this->cachedInstance == NULL) {
+	if (this->m_cachedInstance == NULL) {
 		//
-		this->cachedInstance = createMemoryBuffer(rect, memoryBuffers);
+		this->m_cachedInstance = createMemoryBuffer(rect, memoryBuffers);
 	}
 	unlockMutex();
-	return this->cachedInstance;
+	return this->m_cachedInstance;
 }
diff --git a/source/blender/compositor/intern/COM_SingleThreadedNodeOperation.h b/source/blender/compositor/intern/COM_SingleThreadedNodeOperation.h
index b1bf28c9c07..c6db5381f48 100644
--- a/source/blender/compositor/intern/COM_SingleThreadedNodeOperation.h
+++ b/source/blender/compositor/intern/COM_SingleThreadedNodeOperation.h
@@ -26,11 +26,11 @@
 
 class SingleThreadedNodeOperation : public NodeOperation {
 private:
-	MemoryBuffer *cachedInstance;
+	MemoryBuffer *m_cachedInstance;
 	
 protected:
 	inline bool isCached() {
-		return cachedInstance != NULL;
+		return this->m_cachedInstance != NULL;
 	}
 
 public:
diff --git a/source/blender/compositor/intern/COM_Socket.cpp b/source/blender/compositor/intern/COM_Socket.cpp
index 11739a4e9c5..30f28f9dddb 100644
--- a/source/blender/compositor/intern/COM_Socket.cpp
+++ b/source/blender/compositor/intern/COM_Socket.cpp
@@ -26,18 +26,18 @@
 
 Socket::Socket(DataType datatype)
 {
-	this->datatype = datatype;
-	this->editorSocket = NULL;
-	this->node = NULL;
+	this->m_datatype = datatype;
+	this->m_editorSocket = NULL;
+	this->m_node = NULL;
 }
 
 DataType Socket::getDataType() const
 {
-	return this->datatype;
+	return this->m_datatype;
 }
 
 int Socket::isInputSocket() const { return false; }
 int Socket::isOutputSocket() const { return false; }
 const int Socket::isConnected() const { return false; }
-void Socket::setNode(NodeBase *node) { this->node = node; }
-NodeBase *Socket::getNode() const { return this->node; }
+void Socket::setNode(NodeBase *node) { this->m_node = node; }
+NodeBase *Socket::getNode() const { return this->m_node; }
diff --git a/source/blender/compositor/intern/COM_Socket.h b/source/blender/compositor/intern/COM_Socket.h
index 9feef1bae93..5607d2f4569 100644
--- a/source/blender/compositor/intern/COM_Socket.h
+++ b/source/blender/compositor/intern/COM_Socket.h
@@ -53,15 +53,15 @@ private:
 	/**
 	 * Reference to the node where this Socket belongs to
 	 */
-	NodeBase *node;
+	NodeBase *m_node;
 	
 	/**
 	 * the datatype of this socket. Is used for automatically data transformation.
 	 * @section data-conversion
 	 */
-	DataType datatype;
+	DataType m_datatype;
 	
-	bNodeSocket *editorSocket;
+	bNodeSocket *m_editorSocket;
 public:
 	Socket(DataType datatype);
 	
@@ -75,8 +75,8 @@ public:
 	int isOutputSocket() const;
 	virtual void determineResolution(int resolution[], unsigned int preferredResolution[]) {}
 
-	void setEditorSocket(bNodeSocket *editorSocket) { this->editorSocket = editorSocket; }
-	bNodeSocket *getbNodeSocket() const { return this->editorSocket; }
+	void setEditorSocket(bNodeSocket *editorSocket) { this->m_editorSocket = editorSocket; }
+	bNodeSocket *getbNodeSocket() const { return this->m_editorSocket; }
 	
 #ifdef WITH_CXX_GUARDEDALLOC
 	MEM_CXX_CLASS_ALLOC_FUNCS("COM:Socket")
diff --git a/source/blender/compositor/intern/COM_SocketConnection.cpp b/source/blender/compositor/intern/COM_SocketConnection.cpp
index 1edeb6158b9..1f2cba72dc0 100644
--- a/source/blender/compositor/intern/COM_SocketConnection.cpp
+++ b/source/blender/compositor/intern/COM_SocketConnection.cpp
@@ -25,8 +25,8 @@
 
 SocketConnection::SocketConnection()
 {
-	this->fromSocket = NULL;
-	this->toSocket = NULL;
+	this->m_fromSocket = NULL;
+	this->m_toSocket = NULL;
 	this->setIgnoreResizeCheck(false);
 }
 
@@ -35,19 +35,19 @@ void SocketConnection::setFromSocket(OutputSocket *fromsocket)
 	if (fromsocket == NULL) {
 		throw "ERROR";
 	}
-	this->fromSocket = fromsocket;
+	this->m_fromSocket = fromsocket;
 }
 
-OutputSocket *SocketConnection::getFromSocket() const { return this->fromSocket; }
+OutputSocket *SocketConnection::getFromSocket() const { return this->m_fromSocket; }
 void SocketConnection::setToSocket(InputSocket *tosocket)
 {
 	if (tosocket == NULL) {
 		throw "ERROR";
 	}
-	this->toSocket = tosocket;
+	this->m_toSocket = tosocket;
 }
 
-InputSocket *SocketConnection::getToSocket() const { return this->toSocket; }
+InputSocket *SocketConnection::getToSocket() const { return this->m_toSocket; }
 
 NodeBase *SocketConnection::getFromNode() const
 {
@@ -79,10 +79,10 @@ bool SocketConnection::isValid() const
 
 bool SocketConnection::needsResolutionConversion() const
 {
-	if (this->ignoreResizeCheck) { return false; }
+	if (this->m_ignoreResizeCheck) { return false; }
 	NodeOperation *fromOperation = (NodeOperation *)this->getFromNode();
 	NodeOperation *toOperation = (NodeOperation *)this->getToNode();
-	if (this->toSocket->getResizeMode() == COM_SC_NO_RESIZE) { return false; }
+	if (this->m_toSocket->getResizeMode() == COM_SC_NO_RESIZE) { return false; }
 	const unsigned int fromWidth = fromOperation->getWidth();
 	const unsigned int fromHeight = fromOperation->getHeight();
 	const unsigned int toWidth = toOperation->getWidth();
diff --git a/source/blender/compositor/intern/COM_SocketConnection.h b/source/blender/compositor/intern/COM_SocketConnection.h
index 101e06af61c..9777bd45be2 100644
--- a/source/blender/compositor/intern/COM_SocketConnection.h
+++ b/source/blender/compositor/intern/COM_SocketConnection.h
@@ -48,17 +48,17 @@ private:
 	/**
 	 * @brief Startpoint of the connection
 	 */
-	OutputSocket *fromSocket;
+	OutputSocket *m_fromSocket;
 	
 	/**
 	 * @brief Endpoint of the connection
 	 */
-	InputSocket *toSocket;
+	InputSocket *m_toSocket;
 	
 	/**
 	 * @brief has the resize already been done for this connection
 	 */
-	bool ignoreResizeCheck;
+	bool m_ignoreResizeCheck;
 public:
 	SocketConnection();
 	
@@ -104,12 +104,12 @@ public:
 	/**
 	 * @brief set, whether the resize has already been done for this SocketConnection
 	 */
-	void setIgnoreResizeCheck(bool check) { this->ignoreResizeCheck = check; }
+	void setIgnoreResizeCheck(bool check) { this->m_ignoreResizeCheck = check; }
 	
 	/**
 	 * @brief has the resize already been done for this SocketConnection
 	 */
-	bool isIgnoreResizeCheck() const { return this->ignoreResizeCheck; }
+	bool isIgnoreResizeCheck() const { return this->m_ignoreResizeCheck; }
 	
 	/**
 	 * @brief does this SocketConnection need resolution conversion
diff --git a/source/blender/compositor/intern/COM_WorkPackage.cpp b/source/blender/compositor/intern/COM_WorkPackage.cpp
index 07974b9aafc..fa332ffa23e 100644
--- a/source/blender/compositor/intern/COM_WorkPackage.cpp
+++ b/source/blender/compositor/intern/COM_WorkPackage.cpp
@@ -24,6 +24,6 @@
 
 WorkPackage::WorkPackage(ExecutionGroup *group, unsigned int chunkNumber)
 {
-	this->executionGroup = group;
-	this->chunkNumber = chunkNumber;
+	this->m_executionGroup = group;
+	this->m_chunkNumber = chunkNumber;
 }
diff --git a/source/blender/compositor/intern/COM_WorkPackage.h b/source/blender/compositor/intern/COM_WorkPackage.h
index 6ee9d616a34..953a164e95e 100644
--- a/source/blender/compositor/intern/COM_WorkPackage.h
+++ b/source/blender/compositor/intern/COM_WorkPackage.h
@@ -36,12 +36,12 @@ private:
 	/**
 	 * @brief executionGroup with the operations-setup to be evaluated
 	 */
-	ExecutionGroup *executionGroup;
+	ExecutionGroup *m_executionGroup;
 
 	/**
 	 * @brief number of the chunk to be executed
 	 */
-	unsigned int chunkNumber;
+	unsigned int m_chunkNumber;
 public:
 	/**
 	 * @constructor
@@ -53,12 +53,12 @@ public:
 	/**
 	 * @brief get the ExecutionGroup
 	 */
-	ExecutionGroup *getExecutionGroup() const { return this->executionGroup; }
+	ExecutionGroup *getExecutionGroup() const { return this->m_executionGroup; }
 
 	/**
 	 * @brief get the number of the chunk
 	 */
-	unsigned int getChunkNumber() const { return this->chunkNumber; }
+	unsigned int getChunkNumber() const { return this->m_chunkNumber; }
 
 #ifdef WITH_CXX_GUARDEDALLOC
 	MEM_CXX_CLASS_ALLOC_FUNCS("COM:WorkPackage")
diff --git a/source/blender/compositor/nodes/COM_AlphaOverNode.h b/source/blender/compositor/nodes/COM_AlphaOverNode.h
index f7375d9a7c5..e25e9e11975 100644
--- a/source/blender/compositor/nodes/COM_AlphaOverNode.h
+++ b/source/blender/compositor/nodes/COM_AlphaOverNode.h
@@ -20,8 +20,8 @@
  *		Monique Dewanchand
  */
 
-#ifndef _COM_AlphaOverNode_h
-#define _COM_AlphaOverNode_h
+#ifndef _COM_AlphaOverNode_h_
+#define _COM_AlphaOverNode_h_
 
 #include "COM_Node.h"
 
diff --git a/source/blender/compositor/nodes/COM_BlurNode.h b/source/blender/compositor/nodes/COM_BlurNode.h
index e7daff1c414..95b0516dae0 100644
--- a/source/blender/compositor/nodes/COM_BlurNode.h
+++ b/source/blender/compositor/nodes/COM_BlurNode.h
@@ -29,7 +29,6 @@
  * @brief BlurNode
  * @ingroup Node
  */
-
 class BlurNode : public Node {
 public:
 	BlurNode(bNode *editorNode);
diff --git a/source/blender/compositor/nodes/COM_BokehBlurNode.h b/source/blender/compositor/nodes/COM_BokehBlurNode.h
index 5ce75a7d42b..c2bc7552ac0 100644
--- a/source/blender/compositor/nodes/COM_BokehBlurNode.h
+++ b/source/blender/compositor/nodes/COM_BokehBlurNode.h
@@ -29,7 +29,6 @@
  * @brief BokehBlurNode
  * @ingroup Node
  */
-
 class BokehBlurNode : public Node {
 public:
 	BokehBlurNode(bNode *editorNode);
diff --git a/source/blender/compositor/nodes/COM_ChannelMatteNode.h b/source/blender/compositor/nodes/COM_ChannelMatteNode.h
index 45d03e18a6a..4efb06c9f87 100644
--- a/source/blender/compositor/nodes/COM_ChannelMatteNode.h
+++ b/source/blender/compositor/nodes/COM_ChannelMatteNode.h
@@ -19,8 +19,8 @@
  *		Dalai Felinto
  */
 
-#ifndef COM_ChannelMatteNODE_H
-#define COM_ChannelMatteNODE_H
+#ifndef _COM_ChannelMatteNode_h_
+#define _COM_ChannelMatteNode_h_
 
 #include "COM_Node.h"
 
@@ -28,8 +28,7 @@
  * @brief ChannelMatteNode
  * @ingroup Node
  */
-class ChannelMatteNode : public Node
-{
+class ChannelMatteNode : public Node {
 public:
 	ChannelMatteNode(bNode *editorNode);
 	void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
diff --git a/source/blender/compositor/nodes/COM_ChromaMatteNode.h b/source/blender/compositor/nodes/COM_ChromaMatteNode.h
index ed8250b0329..ddd350aab40 100644
--- a/source/blender/compositor/nodes/COM_ChromaMatteNode.h
+++ b/source/blender/compositor/nodes/COM_ChromaMatteNode.h
@@ -19,8 +19,8 @@
  *		Dalai Felinto
  */
 
-#ifndef COM_ChromaMatteNODE_H
-#define COM_ChromaMatteNODE_H
+#ifndef _COM_ChromaMatteNode_h_
+#define _COM_ChromaMatteNode_h_
 
 #include "COM_Node.h"
 
@@ -28,8 +28,7 @@
  * @brief ChromaMatteNode
  * @ingroup Node
  */
-class ChromaMatteNode : public Node
-{
+class ChromaMatteNode : public Node {
 public:
 	ChromaMatteNode(bNode *editorNode);
 	void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
diff --git a/source/blender/compositor/nodes/COM_ColorBalanceNode.h b/source/blender/compositor/nodes/COM_ColorBalanceNode.h
index c2bdc306e20..cdad02fc831 100644
--- a/source/blender/compositor/nodes/COM_ColorBalanceNode.h
+++ b/source/blender/compositor/nodes/COM_ColorBalanceNode.h
@@ -20,8 +20,8 @@
  *		Monique Dewanchand
  */
 
-#ifndef COM_ColorBalanceNODE_H
-#define COM_ColorBalanceNODE_H
+#ifndef _COM_ColorBalanceNode_h_
+#define _COM_ColorBalanceNode_h_
 
 #include "COM_Node.h"
 
@@ -29,8 +29,7 @@
  * @brief ColorBalanceNode
  * @ingroup Node
  */
-class ColorBalanceNode : public Node
-{
+class ColorBalanceNode : public Node {
 public:
 	ColorBalanceNode(bNode *editorNode);
 	void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
diff --git a/source/blender/compositor/nodes/COM_ColorMatteNode.h b/source/blender/compositor/nodes/COM_ColorMatteNode.h
index 375c914a122..92a4fa79408 100644
--- a/source/blender/compositor/nodes/COM_ColorMatteNode.h
+++ b/source/blender/compositor/nodes/COM_ColorMatteNode.h
@@ -19,8 +19,8 @@
  *		Dalai Felinto
  */
 
-#ifndef COM_ColorMatteNODE_H
-#define COM_ColorMatteNODE_H
+#ifndef _COM_ColorMatteNode_h_
+#define _COM_ColorMatteNode_h_
 
 #include "COM_Node.h"
 
@@ -28,8 +28,7 @@
  * @brief ColorMatteNode
  * @ingroup Node
  */
-class ColorMatteNode : public Node
-{
+class ColorMatteNode : public Node {
 public:
 	ColorMatteNode(bNode *editorNode);
 	void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
diff --git a/source/blender/compositor/nodes/COM_ColorRampNode.h b/source/blender/compositor/nodes/COM_ColorRampNode.h
index 4d706e126e1..6c256c09e68 100644
--- a/source/blender/compositor/nodes/COM_ColorRampNode.h
+++ b/source/blender/compositor/nodes/COM_ColorRampNode.h
@@ -20,8 +20,8 @@
  *		Monique Dewanchand
  */
 
-#ifndef COM_ColorRampNODE_H
-#define COM_ColorRampNODE_H
+#ifndef _COM_ColorRampNode_h_
+#define _COM_ColorRampNode_h_
 
 #include "COM_Node.h"
 
@@ -29,8 +29,7 @@
  * @brief ColorRampNode
  * @ingroup Node
  */
-class ColorRampNode : public Node
-{
+class ColorRampNode : public Node {
 public:
 	ColorRampNode(bNode *editorNode);
 	void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
diff --git a/source/blender/compositor/nodes/COM_ColorSpillNode.h b/source/blender/compositor/nodes/COM_ColorSpillNode.h
index d8ce6878fa0..1d976fc65ae 100644
--- a/source/blender/compositor/nodes/COM_ColorSpillNode.h
+++ b/source/blender/compositor/nodes/COM_ColorSpillNode.h
@@ -20,8 +20,8 @@
  *		Monique Dewanchand
  */
 
-#ifndef COM_ColorSpillNODE_H
-#define COM_ColorSpillNODE_H
+#ifndef _COM_ColorSpillNode_h_
+#define _COM_ColorSpillNode_h_
 
 #include "COM_Node.h"
 
@@ -29,8 +29,7 @@
  * @brief ColorSpillNode
  * @ingroup Node
  */
-class ColorSpillNode : public Node
-{
+class ColorSpillNode : public Node {
 public:
 	ColorSpillNode(bNode *editorNode);
 	void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
diff --git a/source/blender/compositor/nodes/COM_ColorToBWNode.h b/source/blender/compositor/nodes/COM_ColorToBWNode.h
index 34a157c73d8..9262634edda 100644
--- a/source/blender/compositor/nodes/COM_ColorToBWNode.h
+++ b/source/blender/compositor/nodes/COM_ColorToBWNode.h
@@ -20,8 +20,8 @@
  *		Monique Dewanchand
  */
 
-#ifndef _COM_ColourToBWNode_h
-#define _COM_ColourToBWNode_h
+#ifndef _COM_ColourToBWNode_h_
+#define _COM_ColourToBWNode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
diff --git a/source/blender/compositor/nodes/COM_CombineHSVANode.h b/source/blender/compositor/nodes/COM_CombineHSVANode.h
index d8aba71d456..95d3cf9ecdd 100644
--- a/source/blender/compositor/nodes/COM_CombineHSVANode.h
+++ b/source/blender/compositor/nodes/COM_CombineHSVANode.h
@@ -20,8 +20,8 @@
  *		Monique Dewanchand
  */
 
-#ifndef _COM_CombineHSVANode_h
-#define _COM_CombineHSVANode_h
+#ifndef _COM_CombineHSVANode_h_
+#define _COM_CombineHSVANode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
diff --git a/source/blender/compositor/nodes/COM_CombineRGBANode.h b/source/blender/compositor/nodes/COM_CombineRGBANode.h
index 1f25d8deed9..5cc0b1ea6da 100644
--- a/source/blender/compositor/nodes/COM_CombineRGBANode.h
+++ b/source/blender/compositor/nodes/COM_CombineRGBANode.h
@@ -20,8 +20,8 @@
  *		Monique Dewanchand
  */
 
-#ifndef _COM_CombineRGBANode_h
-#define _COM_CombineRGBANode_h
+#ifndef _COM_CombineRGBANode_h_
+#define _COM_CombineRGBANode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
diff --git a/source/blender/compositor/nodes/COM_CombineYCCANode.h b/source/blender/compositor/nodes/COM_CombineYCCANode.h
index 3b143aabc7f..6ff2938c161 100644
--- a/source/blender/compositor/nodes/COM_CombineYCCANode.h
+++ b/source/blender/compositor/nodes/COM_CombineYCCANode.h
@@ -19,8 +19,8 @@
  *		Dalai Felinto
  */
 
-#ifndef _COM_CombineYCCANode_h
-#define _COM_CombineYCCANode_h
+#ifndef _COM_CombineYCCANode_h_
+#define _COM_CombineYCCANode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
diff --git a/source/blender/compositor/nodes/COM_CombineYUVANode.h b/source/blender/compositor/nodes/COM_CombineYUVANode.h
index 1eae44c83a5..e3d8f36a5dd 100644
--- a/source/blender/compositor/nodes/COM_CombineYUVANode.h
+++ b/source/blender/compositor/nodes/COM_CombineYUVANode.h
@@ -19,8 +19,8 @@
  *		Dalai Felinto
  */
 
-#ifndef _COM_CombineYUVANode_h
-#define _COM_CombineYUVANode_h
+#ifndef _COM_CombineYUVANode_h_
+#define _COM_CombineYUVANode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
diff --git a/source/blender/compositor/nodes/COM_CompositorNode.h b/source/blender/compositor/nodes/COM_CompositorNode.h
index 585dae7761e..54d52d7db9e 100644
--- a/source/blender/compositor/nodes/COM_CompositorNode.h
+++ b/source/blender/compositor/nodes/COM_CompositorNode.h
@@ -20,8 +20,8 @@
  *		Monique Dewanchand
  */
 
-#ifndef _COM_CompositorNode_h
-#define _COM_CompositorNode_h
+#ifndef _COM_CompositorNode_h_
+#define _COM_CompositorNode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
diff --git a/source/blender/compositor/nodes/COM_ConvertAlphaNode.h b/source/blender/compositor/nodes/COM_ConvertAlphaNode.h
index d9077c23a02..a80f8de1607 100644
--- a/source/blender/compositor/nodes/COM_ConvertAlphaNode.h
+++ b/source/blender/compositor/nodes/COM_ConvertAlphaNode.h
@@ -19,8 +19,8 @@
  *		Dalai Felinto
  */
 
-#ifndef _COM_ConvertAlphaNode_h
-#define _COM_ConvertAlphaNode_h
+#ifndef _COM_ConvertAlphaNode_h_
+#define _COM_ConvertAlphaNode_h_
 
 #include "COM_Node.h"
 
diff --git a/source/blender/compositor/nodes/COM_CropNode.h b/source/blender/compositor/nodes/COM_CropNode.h
index 44fdeecc180..1003728a9d4 100644
--- a/source/blender/compositor/nodes/COM_CropNode.h
+++ b/source/blender/compositor/nodes/COM_CropNode.h
@@ -25,6 +25,10 @@
 
 #include "COM_Node.h"
 
+/**
+ * @brief CropNode
+ * @ingroup Node
+ */
 class CropNode : public Node {
 public:
 	CropNode(bNode *editorNode);
diff --git a/source/blender/compositor/nodes/COM_DefocusNode.h b/source/blender/compositor/nodes/COM_DefocusNode.h
index a3cffbd98c4..7d69b6413bb 100644
--- a/source/blender/compositor/nodes/COM_DefocusNode.h
+++ b/source/blender/compositor/nodes/COM_DefocusNode.h
@@ -29,7 +29,6 @@
  * @brief DefocusNode
  * @ingroup Node
  */
-
 class DefocusNode : public Node {
 public:
 	DefocusNode(bNode *editorNode);
diff --git a/source/blender/compositor/nodes/COM_DifferenceMatteNode.h b/source/blender/compositor/nodes/COM_DifferenceMatteNode.h
index faaf235bf34..191b7361c3c 100644
--- a/source/blender/compositor/nodes/COM_DifferenceMatteNode.h
+++ b/source/blender/compositor/nodes/COM_DifferenceMatteNode.h
@@ -20,8 +20,8 @@
  *		Monique Dewanchand
  */
 
-#ifndef COM_DifferenceMatteNODE_H
-#define COM_DifferenceMatteNODE_H
+#ifndef _COM_DifferenceMatteNode_h_
+#define _COM_DifferenceMatteNode_h_
 
 #include "COM_Node.h"
 
@@ -29,8 +29,7 @@
  * @brief DifferenceMatteNode
  * @ingroup Node
  */
-class DifferenceMatteNode : public Node
-{
+class DifferenceMatteNode : public Node {
 public:
 	DifferenceMatteNode(bNode *editorNode);
 	void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
diff --git a/source/blender/compositor/nodes/COM_DilateErodeNode.cpp b/source/blender/compositor/nodes/COM_DilateErodeNode.cpp
index 285bfa0470e..6a11f086b95 100644
--- a/source/blender/compositor/nodes/COM_DilateErodeNode.cpp
+++ b/source/blender/compositor/nodes/COM_DilateErodeNode.cpp
@@ -77,7 +77,7 @@ void DilateErodeNode::convertToOperations(ExecutionSystem *graph, CompositorCont
 		CompositorQuality quality = context->getQuality();
 
 		/* initialize node data */
-		NodeBlurData *data = (NodeBlurData *)&this->alpha_blur;
+		NodeBlurData *data = (NodeBlurData *)&this->m_alpha_blur;
 		memset(data, 0, sizeof(*data));
 		data->filtertype = R_FILTER_GAUSS;
 
diff --git a/source/blender/compositor/nodes/COM_DilateErodeNode.h b/source/blender/compositor/nodes/COM_DilateErodeNode.h
index ac374d7375b..4b02042ffc9 100644
--- a/source/blender/compositor/nodes/COM_DilateErodeNode.h
+++ b/source/blender/compositor/nodes/COM_DilateErodeNode.h
@@ -30,7 +30,7 @@
  * @ingroup Node
  */
 class DilateErodeNode : public Node {
-	NodeBlurData alpha_blur; /* only used for blurring alpha, since the dilate/erode node doesnt have this */
+	NodeBlurData m_alpha_blur; /* only used for blurring alpha, since the dilate/erode node doesnt have this */
 public:
 	DilateErodeNode(bNode *editorNode);
 	void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
diff --git a/source/blender/compositor/nodes/COM_DisplaceNode.h b/source/blender/compositor/nodes/COM_DisplaceNode.h
index ecbe07b06b9..af6afc25366 100644
--- a/source/blender/compositor/nodes/COM_DisplaceNode.h
+++ b/source/blender/compositor/nodes/COM_DisplaceNode.h
@@ -19,8 +19,8 @@
  *		Dalai Felinto
  */
 
-#ifndef _COM_DisplaceNode_h
-#define _COM_DisplaceNode_h
+#ifndef _COM_DisplaceNode_h_
+#define _COM_DisplaceNode_h_
 
 #include "COM_Node.h"
 
diff --git a/source/blender/compositor/nodes/COM_DistanceMatteNode.h b/source/blender/compositor/nodes/COM_DistanceMatteNode.h
index 42582ef10a0..4e6682424e8 100644
--- a/source/blender/compositor/nodes/COM_DistanceMatteNode.h
+++ b/source/blender/compositor/nodes/COM_DistanceMatteNode.h
@@ -19,8 +19,8 @@
  *		Dalai Felinto
  */
 
-#ifndef COM_DistanceMatteNODE_H
-#define COM_DistanceMatteNODE_H
+#ifndef _COM_DistanceMatteNode_h_
+#define _COM_DistanceMatteNode_h_
 
 #include "COM_Node.h"
 
@@ -28,8 +28,7 @@
  * @brief DistanceMatteNode
  * @ingroup Node
  */
-class DistanceMatteNode : public Node
-{
+class DistanceMatteNode : public Node {
 public:
 	DistanceMatteNode(bNode *editorNode);
 	void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
diff --git a/source/blender/compositor/nodes/COM_FilterNode.h b/source/blender/compositor/nodes/COM_FilterNode.h
index 17f590b9cfc..d65166944d8 100644
--- a/source/blender/compositor/nodes/COM_FilterNode.h
+++ b/source/blender/compositor/nodes/COM_FilterNode.h
@@ -20,8 +20,8 @@
  *		Monique Dewanchand
  */
 
-#ifndef COM_FILTERNODE_H
-#define COM_FILTERNODE_H
+#ifndef _COM_FilterNode_h_
+#define _COM_FilterNode_h_
 
 #include "COM_Node.h"
 
@@ -29,11 +29,10 @@
  * @brief FilterNode
  * @ingroup Node
  */
-class FilterNode : public Node
-{
+class FilterNode : public Node {
 public:
 	FilterNode(bNode *editorNode);
 	void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
 };
 
-#endif // COM_FILTERNODE_H
+#endif // _COM_FilterNode_h_
diff --git a/source/blender/compositor/nodes/COM_HueSaturationValueCorrectNode.h b/source/blender/compositor/nodes/COM_HueSaturationValueCorrectNode.h
index ed5f2b51ce3..dd5f70f6579 100644
--- a/source/blender/compositor/nodes/COM_HueSaturationValueCorrectNode.h
+++ b/source/blender/compositor/nodes/COM_HueSaturationValueCorrectNode.h
@@ -20,8 +20,8 @@
  *		Monique Dewanchand
  */
 
-#ifndef _COM_HueSaturationValueCorrectNode_h
-#define _COM_HueSaturationValueCorrectNode_h
+#ifndef _COM_HueSaturationValueCorrectNode_h_
+#define _COM_HueSaturationValueCorrectNode_h_
 
 #include "COM_Node.h"
 
diff --git a/source/blender/compositor/nodes/COM_HueSaturationValueNode.h b/source/blender/compositor/nodes/COM_HueSaturationValueNode.h
index 92c18019196..47b89a35269 100644
--- a/source/blender/compositor/nodes/COM_HueSaturationValueNode.h
+++ b/source/blender/compositor/nodes/COM_HueSaturationValueNode.h
@@ -20,8 +20,8 @@
  *		Monique Dewanchand
  */
 
-#ifndef _COM_HueSaturationValueNode_h
-#define _COM_HueSaturationValueNode_h
+#ifndef _COM_HueSaturationValueNode_h_
+#define _COM_HueSaturationValueNode_h_
 
 #include "COM_Node.h"
 
diff --git a/source/blender/compositor/nodes/COM_ImageNode.h b/source/blender/compositor/nodes/COM_ImageNode.h
index 384dd6c09ff..49006efbed5 100644
--- a/source/blender/compositor/nodes/COM_ImageNode.h
+++ b/source/blender/compositor/nodes/COM_ImageNode.h
@@ -34,7 +34,6 @@ extern "C" {
  * @ingroup Node
  */
 class ImageNode : public Node {
-
 private:
 	NodeOperation *doMultilayerCheck(ExecutionSystem *system, RenderLayer *rl, Image *image, ImageUser *user, int framenumber, int outputsocketIndex, int pass, DataType datatype);
 public:
diff --git a/source/blender/compositor/nodes/COM_KeyingNode.cpp b/source/blender/compositor/nodes/COM_KeyingNode.cpp
index be5fd773b60..cc6fc6e1236 100644
--- a/source/blender/compositor/nodes/COM_KeyingNode.cpp
+++ b/source/blender/compositor/nodes/COM_KeyingNode.cpp
@@ -144,7 +144,7 @@ OutputSocket *KeyingNode::setupFeather(ExecutionSystem *graph, CompositorContext
 	CompositorQuality quality = context->getQuality();
 
 	/* initialize node data */
-	NodeBlurData *data = (NodeBlurData *)&this->alpha_blur;
+	NodeBlurData *data = (NodeBlurData *)&this->m_alpha_blur;
 	memset(data, 0, sizeof(*data));
 	data->filtertype = R_FILTER_GAUSS;
 
diff --git a/source/blender/compositor/nodes/COM_KeyingNode.h b/source/blender/compositor/nodes/COM_KeyingNode.h
index fefcfa46d49..294a27bb52c 100644
--- a/source/blender/compositor/nodes/COM_KeyingNode.h
+++ b/source/blender/compositor/nodes/COM_KeyingNode.h
@@ -24,12 +24,12 @@
 #include "COM_Node.h"
 
 /**
-  * @brief KeyingNode
-  * @ingroup Node
-  */
+ * @brief KeyingNode
+ * @ingroup Node
+ */
 class KeyingNode : public Node {
 protected:
-	NodeBlurData alpha_blur; /* only used for blurring alpha, since the dilate/erode node doesnt have this */
+	NodeBlurData m_alpha_blur; /* only used for blurring alpha, since the dilate/erode node doesnt have this */
 
 	OutputSocket *setupPreBlur(ExecutionSystem *graph, InputSocket *inputImage, int size, OutputSocket **originalImage);
 	OutputSocket *setupPostBlur(ExecutionSystem *graph, OutputSocket *postBlurInput, int size);
diff --git a/source/blender/compositor/nodes/COM_KeyingScreenNode.h b/source/blender/compositor/nodes/COM_KeyingScreenNode.h
index 7c87219ef6e..9b8ac88bb6e 100644
--- a/source/blender/compositor/nodes/COM_KeyingScreenNode.h
+++ b/source/blender/compositor/nodes/COM_KeyingScreenNode.h
@@ -25,9 +25,9 @@
 #include "DNA_node_types.h"
 
 /**
-  * @brief KeyingScreenNode
-  * @ingroup Node
-  */
+ * @brief KeyingScreenNode
+ * @ingroup Node
+ */
 class KeyingScreenNode : public Node {
 public:
 	KeyingScreenNode(bNode *editorNode);
diff --git a/source/blender/compositor/nodes/COM_LuminanceMatteNode.h b/source/blender/compositor/nodes/COM_LuminanceMatteNode.h
index c699a0d1168..37f3c31113f 100644
--- a/source/blender/compositor/nodes/COM_LuminanceMatteNode.h
+++ b/source/blender/compositor/nodes/COM_LuminanceMatteNode.h
@@ -19,8 +19,8 @@
  *		Dalai Felinto
  */
 
-#ifndef COM_LuminanceMatteNODE_H
-#define COM_LuminanceMatteNODE_H
+#ifndef _COM_LuminanceMatteNode_h_
+#define _COM_LuminanceMatteNode_h_
 
 #include "COM_Node.h"
 
@@ -28,11 +28,10 @@
  * @brief LuminanceMatteNode
  * @ingroup Node
  */
-class LuminanceMatteNode : public Node
-{
+class LuminanceMatteNode : public Node {
 public:
 	LuminanceMatteNode(bNode *editorNode);
 	void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
 };
 
-#endif // COM_LuminanceMatteNODE_H
+#endif // _COM_LuminanceMatteNode_h_
diff --git a/source/blender/compositor/nodes/COM_MapUVNode.h b/source/blender/compositor/nodes/COM_MapUVNode.h
index a1df790f192..2e5616e0bd0 100644
--- a/source/blender/compositor/nodes/COM_MapUVNode.h
+++ b/source/blender/compositor/nodes/COM_MapUVNode.h
@@ -19,8 +19,8 @@
  *		Dalai Felinto
  */
 
-#ifndef _COM_MapUVNode_h
-#define _COM_MapUVNode_h
+#ifndef _COM_MapUVNode_h_
+#define _COM_MapUVNode_h_
 
 #include "COM_Node.h"
 
diff --git a/source/blender/compositor/nodes/COM_MapValueNode.h b/source/blender/compositor/nodes/COM_MapValueNode.h
index c7a842dff95..22aa5459ec0 100644
--- a/source/blender/compositor/nodes/COM_MapValueNode.h
+++ b/source/blender/compositor/nodes/COM_MapValueNode.h
@@ -20,8 +20,8 @@
  *		Monique Dewanchand
  */
 
-#ifndef _COM_MapValueNode_h
-#define _COM_MapValueNode_h
+#ifndef _COM_MapValueNode_h_
+#define _COM_MapValueNode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
@@ -34,4 +34,5 @@ public:
 	MapValueNode(bNode *editorNode);
 	void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
 };
-#endif
+
+#endif // _COM_MapValueNode_h_
diff --git a/source/blender/compositor/nodes/COM_MaskNode.h b/source/blender/compositor/nodes/COM_MaskNode.h
index 8a9bc50eac7..cdd5d3c362e 100644
--- a/source/blender/compositor/nodes/COM_MaskNode.h
+++ b/source/blender/compositor/nodes/COM_MaskNode.h
@@ -21,6 +21,9 @@
  *		Sergey Sharybin
  */
 
+#ifndef _COM_MaskNode_h_
+#define _COM_MaskNode_h_
+
 #include "COM_Node.h"
 #include "DNA_node_types.h"
 
@@ -29,10 +32,10 @@
  * @ingroup Node
  */
 class MaskNode : public Node {
-
-
 public:
 	MaskNode(bNode *editorNode);
 	void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
 
 };
+
+#endif // _COM_MaskNode_h_
diff --git a/source/blender/compositor/nodes/COM_MathNode.h b/source/blender/compositor/nodes/COM_MathNode.h
index 16d65843b0d..4f8e64754e7 100644
--- a/source/blender/compositor/nodes/COM_MathNode.h
+++ b/source/blender/compositor/nodes/COM_MathNode.h
@@ -20,8 +20,8 @@
  *		Monique Dewanchand
  */
 
-#ifndef _COM_MathNode_h
-#define _COM_MathNode_h
+#ifndef _COM_MathNode_h_
+#define _COM_MathNode_h_
 
 #include "COM_Node.h"
 
diff --git a/source/blender/compositor/nodes/COM_MixNode.h b/source/blender/compositor/nodes/COM_MixNode.h
index 99e8b4d48f0..76076d01427 100644
--- a/source/blender/compositor/nodes/COM_MixNode.h
+++ b/source/blender/compositor/nodes/COM_MixNode.h
@@ -20,8 +20,8 @@
  *		Monique Dewanchand
  */
 
-#ifndef _COM_MixNode_h
-#define _COM_MixNode_h
+#ifndef _COM_MixNode_h_
+#define _COM_MixNode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
diff --git a/source/blender/compositor/nodes/COM_MovieClipNode.h b/source/blender/compositor/nodes/COM_MovieClipNode.h
index d70881a6725..52ea11ea8e9 100644
--- a/source/blender/compositor/nodes/COM_MovieClipNode.h
+++ b/source/blender/compositor/nodes/COM_MovieClipNode.h
@@ -20,6 +20,9 @@
  *		Monique Dewanchand
  */
 
+#ifndef _COM_MovieClipNode_h_
+#define _COM_MovieClipNode_h_
+
 #include "COM_Node.h"
 #include "DNA_node_types.h"
 
@@ -28,10 +31,9 @@
  * @ingroup Node
  */
 class MovieClipNode : public Node {
-
-
 public:
 	MovieClipNode(bNode *editorNode);
 	void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
-
 };
+
+#endif // _COM_MovieClipNode_h_
diff --git a/source/blender/compositor/nodes/COM_NormalNode.h b/source/blender/compositor/nodes/COM_NormalNode.h
index bf684298e65..660d90040bd 100644
--- a/source/blender/compositor/nodes/COM_NormalNode.h
+++ b/source/blender/compositor/nodes/COM_NormalNode.h
@@ -20,8 +20,8 @@
  *		Monique Dewanchand
  */
 
-#ifndef COM_NORMALNODE_H
-#define COM_NORMALNODE_H
+#ifndef _COM_NormalNode_h_
+#define _COM_NormalNode_h_
 
 #include "COM_Node.h"
 
@@ -29,8 +29,7 @@
  * @brief NormalNode
  * @ingroup Node
  */
-class NormalNode : public Node
-{
+class NormalNode : public Node {
 public:
 	NormalNode(bNode *editorNode);
 	void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
diff --git a/source/blender/compositor/nodes/COM_OutputFileNode.h b/source/blender/compositor/nodes/COM_OutputFileNode.h
index 79c9b577643..e3194436f7f 100644
--- a/source/blender/compositor/nodes/COM_OutputFileNode.h
+++ b/source/blender/compositor/nodes/COM_OutputFileNode.h
@@ -21,8 +21,8 @@
  *		Lukas Tönne
  */
 
-#ifndef _COM_OutputFileNode_h
-#define _COM_OutputFileNode_h
+#ifndef _COM_OutputFileNode_h_
+#define _COM_OutputFileNode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
diff --git a/source/blender/compositor/nodes/COM_SeparateHSVANode.h b/source/blender/compositor/nodes/COM_SeparateHSVANode.h
index 4a7e86849dc..6199237ebda 100644
--- a/source/blender/compositor/nodes/COM_SeparateHSVANode.h
+++ b/source/blender/compositor/nodes/COM_SeparateHSVANode.h
@@ -20,8 +20,8 @@
  *		Monique Dewanchand
  */
 
-#ifndef _COM_SeparateHSVANode_h
-#define _COM_SeparateHSVANode_h
+#ifndef _COM_SeparateHSVANode_h_
+#define _COM_SeparateHSVANode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
diff --git a/source/blender/compositor/nodes/COM_SeparateRGBANode.h b/source/blender/compositor/nodes/COM_SeparateRGBANode.h
index c1be02753da..35321304d99 100644
--- a/source/blender/compositor/nodes/COM_SeparateRGBANode.h
+++ b/source/blender/compositor/nodes/COM_SeparateRGBANode.h
@@ -20,8 +20,8 @@
  *		Monique Dewanchand
  */
 
-#ifndef _COM_SeparateRGBANode_h
-#define _COM_SeparateRGBANode_h
+#ifndef _COM_SeparateRGBANode_h_
+#define _COM_SeparateRGBANode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
diff --git a/source/blender/compositor/nodes/COM_SeparateYCCANode.h b/source/blender/compositor/nodes/COM_SeparateYCCANode.h
index 4b216841e2a..542e1693932 100644
--- a/source/blender/compositor/nodes/COM_SeparateYCCANode.h
+++ b/source/blender/compositor/nodes/COM_SeparateYCCANode.h
@@ -19,8 +19,8 @@
  *		Dalai Felinto
  */
 
-#ifndef _COM_SeparateYCCANode_h
-#define _COM_SeparateYCCANode_h
+#ifndef _COM_SeparateYCCANode_h_
+#define _COM_SeparateYCCANode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
diff --git a/source/blender/compositor/nodes/COM_SeparateYUVANode.h b/source/blender/compositor/nodes/COM_SeparateYUVANode.h
index e1763e37dff..e51c0ce4fa6 100644
--- a/source/blender/compositor/nodes/COM_SeparateYUVANode.h
+++ b/source/blender/compositor/nodes/COM_SeparateYUVANode.h
@@ -19,8 +19,8 @@
  *		Dalai Felinto
  */
 
-#ifndef _COM_SeparateYUVANode_h
-#define _COM_SeparateYUVANode_h
+#ifndef _COM_SeparateYUVANode_h_
+#define _COM_SeparateYUVANode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
diff --git a/source/blender/compositor/nodes/COM_SetAlphaNode.h b/source/blender/compositor/nodes/COM_SetAlphaNode.h
index 0707cf5dac1..e82fa210a89 100644
--- a/source/blender/compositor/nodes/COM_SetAlphaNode.h
+++ b/source/blender/compositor/nodes/COM_SetAlphaNode.h
@@ -20,8 +20,8 @@
  *		Monique Dewanchand
  */
 
-#ifndef _COM_SetAlphaNode_h
-#define _COM_SetAlphaNode_h
+#ifndef _COM_SetAlphaNode_h_
+#define _COM_SetAlphaNode_h_
 
 #include "COM_Node.h"
 
diff --git a/source/blender/compositor/nodes/COM_SplitViewerNode.h b/source/blender/compositor/nodes/COM_SplitViewerNode.h
index 6c532d4e813..f17cfd57cbf 100644
--- a/source/blender/compositor/nodes/COM_SplitViewerNode.h
+++ b/source/blender/compositor/nodes/COM_SplitViewerNode.h
@@ -20,8 +20,8 @@
  *		Monique Dewanchand
  */
 
-#ifndef _COM_SplitViewerNode_h
-#define _COM_SplitViewerNode_h
+#ifndef _COM_SplitViewerNode_h_
+#define _COM_SplitViewerNode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
diff --git a/source/blender/compositor/nodes/COM_Stabilize2dNode.h b/source/blender/compositor/nodes/COM_Stabilize2dNode.h
index 589e090b48c..3363ff4142c 100644
--- a/source/blender/compositor/nodes/COM_Stabilize2dNode.h
+++ b/source/blender/compositor/nodes/COM_Stabilize2dNode.h
@@ -20,6 +20,9 @@
  *		Monique Dewanchand
  */
 
+#ifndef _COM_Stabilize2dNode_h_
+#define _COM_Stabilize2dNode_h_
+
 #include "COM_Node.h"
 #include "DNA_node_types.h"
 
@@ -32,3 +35,5 @@ public:
 	Stabilize2dNode(bNode *editorNode);
 	void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
 };
+
+#endif
diff --git a/source/blender/compositor/nodes/COM_SwitchNode.h b/source/blender/compositor/nodes/COM_SwitchNode.h
index be3d54c3000..16d9e18885b 100644
--- a/source/blender/compositor/nodes/COM_SwitchNode.h
+++ b/source/blender/compositor/nodes/COM_SwitchNode.h
@@ -20,8 +20,8 @@
  *		Monique Dewanchand
  */
 
-#ifndef _COM_SwitchNode_h
-#define _COM_SwitchNode_h
+#ifndef _COM_SwitchNode_h_
+#define _COM_SwitchNode_h_
 
 #include "COM_Node.h"
 #include "COM_NodeOperation.h"
diff --git a/source/blender/compositor/nodes/COM_TransformNode.h b/source/blender/compositor/nodes/COM_TransformNode.h
index da40b655f29..57a7a0229ec 100644
--- a/source/blender/compositor/nodes/COM_TransformNode.h
+++ b/source/blender/compositor/nodes/COM_TransformNode.h
@@ -20,6 +20,9 @@
  *		Monique Dewanchand
  */
 
+#ifndef _COM_TransformNode_h_
+#define _COM_TransformNode_h_
+
 #include "COM_Node.h"
 #include "DNA_node_types.h"
 
@@ -32,3 +35,5 @@ public:
 	TransformNode(bNode *editorNode);
 	void convertToOperations(ExecutionSystem *graph, CompositorContext *context);
 };
+
+#endif // _COM_TransformNode_h_
diff --git a/source/blender/compositor/nodes/COM_ViewerNode.h b/source/blender/compositor/nodes/COM_ViewerNode.h
index e1f1226f1f1..3a9954b8aea 100644
--- a/source/blender/compositor/nodes/COM_ViewerNode.h
+++ b/source/blender/compositor/nodes/COM_ViewerNode.h
@@ -20,8 +20,8 @@
  *		Monique Dewanchand
  */
 
-#ifndef _COM_ViewerNode_h
-#define _COM_ViewerNode_h
+#ifndef _COM_ViewerNode_h_
+#define _COM_ViewerNode_h_
 
 #include "COM_Node.h"
 #include "DNA_node_types.h"
diff --git a/source/blender/compositor/nodes/COM_ZCombineNode.h b/source/blender/compositor/nodes/COM_ZCombineNode.h
index a2ceedfc2cd..61f4037be90 100644
--- a/source/blender/compositor/nodes/COM_ZCombineNode.h
+++ b/source/blender/compositor/nodes/COM_ZCombineNode.h
@@ -20,8 +20,8 @@
  *		Monique Dewanchand
  */
 
-#ifndef _COM_ZCombineNode_h
-#define _COM_ZCombineNode_h
+#ifndef _COM_ZCombineNode_h_
+#define _COM_ZCombineNode_h_
 
 #include "COM_Node.h"