//-
// ==========================================================================
// Copyright 1995,2006,2008 Autodesk, Inc. All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk
// license agreement provided at the time of installation or download,
// or which otherwise accompanies this software in either electronic
// or hard copy form.
// ==========================================================================
//+

#include <maya/MSimple.h>
#include <maya/MIOStream.h>
#include <maya/MRenderView.h>
#include <maya/M3dView.h>
#include <math.h>
#include <maya/MSyntax.h>
#include <maya/MArgDatabase.h>

//
//	renderViewRender command declaration
//
class renderViewRender : public MPxCommand 
{							
public:					
	renderViewRender() {};
	~renderViewRender() {};

	virtual MStatus	doIt ( const MArgList& );
	
	static void*	creator();
	
	static MSyntax	newSyntax();
	MStatus parseSyntax (MArgDatabase &argData);

	static const char * cmdName;

private:
	bool doNotClearBackground;				

};													

static const char * kDoNotClearBackground		= "-b";
static const char * kDoNotClearBackgroundLong	= "-background";

const char * renderViewRender::cmdName = "renderViewRender";

void* renderViewRender::creator()					
{													
	return new renderViewRender;					
}													

MSyntax renderViewRender::newSyntax()
{
	MStatus status;
	MSyntax syntax;
	syntax.addFlag( kDoNotClearBackground, kDoNotClearBackgroundLong );
	CHECK_MSTATUS_AND_RETURN(status, syntax);
	return syntax;
}

//
// Description:
//		Read the values of the additionnal flags for this command.
//
MStatus renderViewRender::parseSyntax (MArgDatabase &argData)
{
	// Get the flag values, otherwise the default values are used.
	doNotClearBackground = argData.isFlagSet( kDoNotClearBackground );
	
	return MS::kSuccess;
}

//
// Description:
//		register the command
//
MStatus initializePlugin( MObject obj )			
{															
	MFnPlugin	plugin( obj, PLUGIN_COMPANY, "4.5" );	
	MStatus		stat;										
	stat = plugin.registerCommand(	renderViewRender::cmdName,
									renderViewRender::creator,
									renderViewRender::newSyntax);	
	if ( !stat )												
		stat.perror( "registerCommand" );							
	return stat;												
}																

//
// Description:
//		unregister the command
//
MStatus uninitializePlugin( MObject obj )						
{																
	MFnPlugin	plugin( obj );									
	MStatus		stat;											
	stat = plugin.deregisterCommand( renderViewRender::cmdName );				
	if ( !stat )									
		stat.perror( "deregisterCommand" );			
	return stat;									
}

RV_PIXEL evaluate(int x, int y)
//
//	Description:
//		Generates a simple procedural circular pattern to be sent to the 
//		Render View.
//
//	Arguments:
//		x, y - coordinates in the current tile (the pattern is centred 
//			   around (0,0) ).
//
//	Return Value:
//		An RV_PIXEL structure containing the colour of pixel (x,y).
//
{
	unsigned int distance = (unsigned int) sqrt(double((x*x) + (y*y)));

	RV_PIXEL pixel;
	// Always fully red.
	pixel.r = 255.0f;		
	// Green and blue varies according to the distance.
	pixel.g = pixel.b = 155.0f + (distance % 20) * 5;
	pixel.a = 255.0f;

	return pixel;
}

MStatus renderViewRender::doIt( const MArgList& args )
//
//	Description:
//		Implements the MEL renderViewRender command.  This command
//		Draws a 640x480 tiled pattern of red and white circles into Maya's
//		Render View window.  
//
//	Arguments:
//		args - The argument list that was passed to the command from MEL.
//				-background/-b renders the pattern without clearing the Render View
//
//	Return Value:
//		MS::kSuccess - command succeeded
//		MS::kFailure - command failed (returning this value will cause the 
//                     MEL script that is being run to terminate unless the
//                     error is caught using a "catch" statement.
//
{
	MStatus stat = MS::kSuccess;

	// Check if the render view exists. It should always exist, unless
	// Maya is running in batch mode.
	//
	if (!MRenderView::doesRenderEditorExist())
	{
		setResult( "Cannot renderViewRender in batch render mode. "
				   "Please run in interactive mode, "
				   "so that the render editor exists." );
		return MS::kFailure;
	}
	else
	{
		cout<<"Past doesRenderEditorExist()"<<endl;
	}
	
	// get optional flags
	MArgDatabase	argData( syntax(), args );
	parseSyntax( argData );

	// Pick a camera, and tell the Render View that we will be rendering
	// from its point of view.  Just use the camera for the active 
	// modelling view.  
	//
	M3dView curView = M3dView::active3dView();
	MDagPath camDagPath;
	curView.getCamera( camDagPath );
	cout<<"Rendering camera"<<camDagPath.fullPathName().asChar()<<endl;
	
	if( MRenderView::setCurrentCamera( camDagPath ) != MS::kSuccess )
	{
		setResult( "renderViewRender: error occurred in setCurrentCamera." );
		return MS::kFailure;
	}

	// We'll render a 640x480 image.  Tell the Render View to get ready
	// to receive 640x480 pixels of data.
	//
	unsigned int image_width = 640, image_height = 480;
	if (MRenderView::startRender( image_width, image_height, doNotClearBackground) != MS::kSuccess)
	{
		setResult( "renderViewRender: error occured in startRender." );
		return MS::kFailure;
	}

	// The image will be composed of tiles consisting of circular red and
	// white patterns.
	//
	unsigned int num_side_tiles = 8;
	unsigned int average_tiles_width = image_width / num_side_tiles;
	unsigned int average_tiles_height = image_height / num_side_tiles;
	
	// Draw each tile
	//
	for (unsigned int tile_y = 0; tile_y < num_side_tiles; tile_y++)
	{
		for (unsigned int tile_x = 0; tile_x < num_side_tiles; tile_x++)
		{
			// Find the min/max width/height.
			int min_x = tile_x * average_tiles_width;
			int max_x;

			// If this is the last tile in width, adjust the max position 
			// so that the entire width is covered.
			//
			if ((tile_x+1) == num_side_tiles)
				max_x = image_width-1;
			else
				max_x = (tile_x + 1) * average_tiles_width - 1;
					
			int min_y = tile_y * average_tiles_height;
			int max_y;

			// If this is the last tile in height, adjust the max position 
			// so that the entire height is covered.
			//
			if ((tile_y+1) == num_side_tiles)
				max_y = image_height-1;
			else
				max_y = (tile_y + 1) * average_tiles_height - 1;
			
			unsigned int tile_width = max_x - min_x + 1; 
			unsigned int tile_height = max_y - min_y + 1;

			// Fill up the pixel array with some the pattern, which is 
			// generated by the 'evaluate' function.  The Render View
			// accepts floating point pixel values only.
			//
			RV_PIXEL* pixels = new RV_PIXEL[tile_width * tile_height];
			unsigned int index = 0;
			for (unsigned int j = 0; j < tile_height; j++ )
			{
				for (unsigned int i = 0; i < tile_width; i++)
				{
					pixels[index] = evaluate(i - (tile_width / 2), 
											 j - (tile_height / 2));
					index++;
				}
			}

			// Send the data to the render view.
			//
			if (MRenderView::updatePixels(min_x, max_x, min_y, max_y, pixels) != MS::kSuccess)
			{
				setResult( "renderViewRender: error occured in updatePixels." );
				delete [] pixels;
				return MS::kFailure;
			}

			delete [] pixels;

			// Force the Render View to refresh the display of the affected 
			// region.
			//
			if (MRenderView::refresh(min_x, max_x, min_y, max_y) != MS::kSuccess)
			{
				setResult( "renderViewRender: error occured in refresh." );
				return MS::kFailure;
			}
		}
	}

	// Inform the Render View that we have completed rendering the entire image.
	//
	if (MRenderView::endRender() != MS::kSuccess)
	{
		setResult( "renderViewRender: error occured in endRender." );
		return MS::kFailure;
	}

	setResult( "renderViewRender completed." );
	return stat;
}