blender-archive/source/blender/compositor/intern/COM_InputSocket.cpp

/*
 * Copyright 2011, Blender Foundation.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * Contributor: 
 *		Jeroen Bakker 
 *		Monique Dewanchand
 */

#include "COM_Socket.h"
#include "COM_Node.h"
#include "COM_SocketConnection.h"
#include "COM_ExecutionSystem.h"

InputSocket::InputSocket(DataType datatype) :Socket(datatype)
{
	this->connection = NULL;
	this->resizeMode = COM_SC_CENTER;
}
InputSocket::InputSocket(DataType datatype, InputSocketResizeMode resizeMode) :Socket(datatype)
{
	this->connection = NULL;
	this->resizeMode = resizeMode;
}

InputSocket::InputSocket(InputSocket *from) :Socket(from->getDataType())
{
	this->connection = NULL;
	this->resizeMode = from->getResizeMode();
}

int InputSocket::isInputSocket() const { return true; }
const int InputSocket::isConnected() const { return this->connection != NULL; }

void InputSocket::setConnection(SocketConnection *connection)
{
	this->connection = connection;
}
SocketConnection *InputSocket::getConnection()
{
	return this->connection;
}

void InputSocket::determineResolution(unsigned int resolution[],unsigned int preferredResolution[])
{
	if (this->isConnected()) {
		this->connection->getFromSocket()->determineResolution(resolution, preferredResolution);
	}
	else {
		return;
	}
}

DataType InputSocket::convertToSupportedDataType(DataType datatype)
{
	int supportedDataTypes = getDataType();
	if (supportedDataTypes&datatype) {
		return datatype;
	}
	bool candoValue = supportedDataTypes&COM_DT_VALUE;
	bool candoVector = supportedDataTypes&COM_DT_VECTOR;
	bool candoColor = supportedDataTypes&COM_DT_COLOR;
	
	if (datatype == COM_DT_VALUE) {
		if (candoColor) {
			return COM_DT_COLOR;
		}
		else if (candoVector) {
			return COM_DT_VECTOR;
		}
	}
	else if (datatype == COM_DT_VECTOR) {
		if (candoColor) {
			return COM_DT_COLOR;
		}
		else if (candoValue) {
			return COM_DT_VALUE;
		}
	}
	else if (datatype == COM_DT_COLOR) {
		if (candoVector) {
			return COM_DT_VECTOR;
		}
		else if (candoValue) {
			return COM_DT_VALUE;
		}
	}
	return this->getDataType();
}

void InputSocket::determineActualDataType()
{
	/// @note: this method is only called for inputsocket that are not connected.
	/// @note: passes COM_DT_COLOR, the convertToSupportedDataType converts this to a capable DataType
	this->setActualDataType(this->convertToSupportedDataType(COM_DT_COLOR));
	#if 0	// XXX TODO check for proxy node and use output data type?
	if (this->getGroupOutputSocket()) {
		if (!this->isInsideOfGroupNode()) {
			this->getGroupOutputSocket()->determineActualDataType();
		}
	}
	#endif
}

void InputSocket::notifyActualInputType(DataType datatype)
{
	DataType supportedDataType = convertToSupportedDataType(datatype);
	this->setActualDataType(supportedDataType);
	this->fireActualDataTypeSet();
}

void InputSocket::fireActualDataTypeSet()
{
	this->getNode()->notifyActualDataTypeSet(this, this->getActualDataType());
}
void InputSocket::relinkConnections(InputSocket *relinkToSocket)
{
	if (!isConnected()) {
		return;
	}
	SocketConnection *connection = this->getConnection();
	connection->setToSocket(relinkToSocket);
	relinkToSocket->setConnection(connection);
	this->setConnection(NULL);
}

void InputSocket::relinkConnectionsDuplicate(InputSocket *relinkToSocket, int editorNodeInputSocketIndex, ExecutionSystem *graph)
{
	if (!this->isConnected()) {
		Node *node = (Node*)this->getNode();
		switch (this->getActualDataType()) {
		case COM_DT_UNKNOWN:
		case COM_DT_COLOR:
			node->addSetColorOperation(graph, relinkToSocket, editorNodeInputSocketIndex);
			break;
		case COM_DT_VECTOR:
			node->addSetVectorOperation(graph, relinkToSocket, editorNodeInputSocketIndex);
			break;
		case COM_DT_VALUE:
			node->addSetValueOperation(graph, relinkToSocket, editorNodeInputSocketIndex);
			break;
		}
		return;
	}
	SocketConnection * newConnection = new SocketConnection();
	OutputSocket * fromSocket = this->getConnection()->getFromSocket();
	newConnection->setToSocket(relinkToSocket);
	newConnection->setFromSocket(fromSocket);
	relinkToSocket->setConnection(newConnection);
	fromSocket->addConnection(newConnection);
	graph->addSocketConnection(newConnection);
}

void InputSocket::relinkConnections(InputSocket *relinkToSocket,  int editorNodeInputSocketIndex, ExecutionSystem *graph)
{
	if (isConnected()) {
		relinkConnections(relinkToSocket);
	}
	else {
		Node *node = (Node*)this->getNode();
		switch (this->getActualDataType()) {
		case COM_DT_UNKNOWN:
		case COM_DT_COLOR:
			node->addSetColorOperation(graph, relinkToSocket, editorNodeInputSocketIndex);
			break;
		case COM_DT_VECTOR:
			node->addSetVectorOperation(graph, relinkToSocket, editorNodeInputSocketIndex);
			break;
		case COM_DT_VALUE:
			node->addSetValueOperation(graph, relinkToSocket, editorNodeInputSocketIndex);
			break;
		}
	}
}

const ChannelInfo *InputSocket::getChannelInfo(const int channelnumber)
{
	if (this->isConnected() && this->connection->getFromSocket()) {
		return this->connection->getFromSocket()->getChannelInfo(channelnumber);
	}
	else {
		return NULL;
	}
}

bool InputSocket::isStatic()
{
	if (isConnected()) {
		NodeBase *node = this->getConnection()->getFromNode();
		if (node) {
			return node->isStatic();
		}
	}
	return true;
}
SocketReader *InputSocket::getReader()
{
	return this->getOperation();
}

NodeOperation *InputSocket::getOperation() const
{
	if (isConnected()) {
		return (NodeOperation*)this->connection->getFromSocket()->getNode();
	}
	else {
		return NULL;
	}
}

float *InputSocket::getStaticValues()
{
	/* XXX only works for socket types with actual float input values.
	 * currently all compositor socket types (value, rgba, vector) support this.
	 */
	bNodeSocket *b_socket = this->getbNodeSocket();
	static float default_null = 0.0f;
	
	switch (this->getDataType()) {
	case COM_DT_VALUE:
		return &((bNodeSocketValueFloat*)b_socket->default_value)->value;
	case COM_DT_COLOR:
		return ((bNodeSocketValueRGBA*)b_socket->default_value)->value;
	case COM_DT_VECTOR:
		return ((bNodeSocketValueVector*)b_socket->default_value)->value;
	default:
		/* XXX this should never happen, just added to please the compiler */
		return &default_null;
	}
}