• Main
• Home
• Features
• Screenshots
• Downloads
• License
• Team profile
• Documentation
• Manual
• FAQ
• Reference

Search this page:

PCMProcess.h

Go to the documentation of this file.

//
// This source file is a part of ParCompMark
// Parallel Compositing Benchmark Framework
//
// for latest info see http://parcompmark.sourceforge.net

//
// Copyright (C) 2006 IT2 ParCompMark Dev. Team
// 
// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.


#ifndef __PCM_PROCESS_H__
#  define __PCM_PROCESS_H__

//
// Inner includes
//

#  include "PCMPremeditations.h"

#  include "PCMThread.h"

#  include "PCMName.h"

#  include "PCMException.h"

#  include "PCMLogger.h"

#  include "PCMOpenGLRenderingEngine.h"

#  include "PCMContext.h"

#  include "PCMThread.h"

#  include "PCMName.h"

#  include "PCMBuffer.h"

#  include "PCMGLXRenderWindow.h"

#  include "PCMSqVM.h"

#  include "PCMOutputNode.h"

#  include "PCMStringConverter.h"

//
// Outer includes
//

#  include <pcapi.h>

#  include <string>

#  include <sstream>

#  include <list>

//
// Scripting bind includes (for Squirrel)
//

#  include <squirrel/squirrel.h>
#  include <squirrel/sqstdio.h>
#  include <squirrel/sqstdaux.h>
#  include <squirrel/sqplus.h>

namespace ParCompMark
{

  class Process:public Thread,
   public Name
  {

        //
        // Unit test class
        //
#  ifdef PARCOMPMARK_TEST
        friend class ParCompMarkTest::TestProcess;
#  endif

        //
        // Scripting binding (for Squirrel)
        //



   public:static void squirrelGlue()
        {
         ::SqPlus::SQClassDef < Process > (_T("Process")).func(&Process::addContext,
                                                                _T("addContext")).func(&Process::setProcessTypeSq,
                                                                                         _T("setProcessTypeSq")).
                func(&Process::getProcessTypeSq, _T("getProcessTypeSq")).func(&Process::setBufferByName,
                                                                          _T("setBufferByName")).
                func(&Process::getInitProcCode, _T("getInitProcCode")).func(&Process::setInitProcCode,
                                                                         _T("setInitProcCode")).
                func(&Process::getRunningProcCode, _T("getRunningProcCode")).func(&Process::setRunningProcCode,
                                                                                _T("setRunningProcCode")).
                func(&Process::getSortOrder, _T("getSortOrder")).func(&Process::setSortOrder,
                                                                  _T("setSortOrder")).func(&Process::getStopID,
                                                                                           _T("getStopID")).
                func(&Process::setStopID, _T("setStopID")).func(&Process::getOperate,
                                                                _T("getOperate")).func(&Process::setOperate,
                                                                                   _T("setOperate")).
                func(&Process::getDisplayOutput, _T("getDisplayOutput")).func(&Process::setDisplayOutput,
                                                                          _T("setDisplayOutput")).
                func(&Process::getGatherStatistics, _T("getGatherStatistics")).func(&Process::setGatherStatistics,
                                                                                 _T("setGatherStatistics")).
                func(&Process::getExportFrameStep, _T("getExportFrameStep")).func(&Process::setExportFrameStep,
                                                                                _T("setExportFrameStep")).
                func(&Process::getFrameFilenamePattern,
                  _T("getFrameFilenamePattern")).func(&Process::setFrameFilenamePattern,
                                                         _T("setFrameFilenamePattern")).enumInt(Process::COMPOSITE,
                                                                                                _T("COMPOSITE")).
                enumInt(Process::RENDER, _T("RENDER"));
        }


        //
        // Enumerations
        //

   public:

        enum ProcessType
        {

         COMPOSITE = 0,

         RENDER = 1
        };

        //
        // Typedefs
        //

   public:

        typedef Pointer < Process,
        Mutex > Pointer;

        typedef std::list < Context::Pointer > ContextList;

        typedef ContextList::iterator ContextListIterator;

        //
        // Class constants
        //



   public:

        static const std::string PROCESSINITNUT;

        static const std::string DEFAULTEXPORTPATTERN;


        //
        // Variables
        //



   protected:

        ContextList mContexts;

        ProcessType mProcessType;

        Node *mParent;

        GLXRenderWindow::Pointer mRenderWindow;

        OpenGLRenderingEngine::Pointer mRenderingEngine;

        SqVM::Pointer mSqVM;

        char *mInitProcCode;

        char *mRunningProcCode;

        Buffer::Pointer mBuffer;

        bool mInitialized;

        PCuint mSortOrder;

        PCid mStopID;

        bool mOperate;

        bool mDisplayOutput;

        bool mGatherStatistics;

        u32 mFrameNumber;

        Real mFrameTime;

        Real mStartTime;

        bool mStop;

        bool mStopAble;

        bool mCountedStop;

        OutputNode::Pointer mOutputDocument;

        bool mShowFrameletIcon;

        int mExportFrameStep;

        char *mFrameFilenamePattern;


        //
        // Constructors & destructor
        //



   public:

        Process();

        Process(const std::string & name, Node * parent);

        virtual ~ Process();


        //
        // Getters & setters
        //



   public:

        Process::ContextList & getContexts();

        Process::ProcessType & getProcessType();

        void setProcessType(const Process::ProcessType & processtype);

        Node *getParent() const;

        GLXRenderWindow::Pointer & getRenderWindow();

        OpenGLRenderingEngine::Pointer & getRenderingEngine();

        char *getInitProcCode();

        void setInitProcCode(const char *initproccode);

        char *getRunningProcCode();

        void setRunningProcCode(const char *runningproccode);

        Buffer::Pointer & getBuffer();

        const bool & getInitialized() const;

        PCuint & getSortOrder();

        void setSortOrder(const PCuint sortorder);

        PCid & getStopID();

        void setStopID(const PCid stopid);

        bool & getOperate();

        void setOperate(const bool operate);

        bool & getDisplayOutput();

        void setDisplayOutput(const bool displayoutput);

        bool & getGatherStatistics();

        void setGatherStatistics(const bool gatherstatistics);

        const u32 & getFrameNumber() const;

        const Real & getFrameTime() const;

        const Real & getStartTime() const;

        void setStartTime(const Real & starttime);

        const bool & getStop() const;

        void setStop(const bool & stop);

        const bool & getStopAble() const;

        void setStopAble(const bool & stopable);

        const bool & getCountedStop() const;

        void setCountedStop(const bool & countedstop);

        OutputNode::Pointer & getOutputDocument();

        const bool & getShowFrameletIcon() const;

        int &getExportFrameStep();

        void setExportFrameStep(const int exportframestep);

        char *getFrameFilenamePattern();

        void setFrameFilenamePattern(const char *framefilenamepattern);


        //
        // Methods
        //



   public:

        virtual void threadInitialize();

        virtual void threadFinalize();

        virtual void start();

        virtual u32 stop();

        virtual Context *addContext();

        virtual void initPC();

        virtual void openRenderWindow(const std::string caption =
                                  "PCM Framework", const std::string & displayName =
                                  "", const bool & fullScreen = true, const u32 & colourDepth =
                                  0, const u32 & width =
                                  GLXRenderWindow::MAXIMALSIZE, const u32 & height =
                                  GLXRenderWindow::MAXIMALSIZE, const s32 & left =
                                  GLXRenderWindow::CENTERED, const s32 & top =
                                  GLXRenderWindow::CENTERED, const u32 & fsaaSamples = 0);

        virtual void actualizeRenderWindow();

        virtual void setViewportForRendering();

        virtual void displayFrameletIcon();

        virtual void initProcess();

        virtual void runningProcess();

        virtual void setProcessTypeSq(const int processType);

        virtual int getProcessTypeSq();

        virtual void setBufferByName(const char *name);

        virtual void setFinito(const u32 & frameID);

   protected:

        virtual void task();

        virtual void refreshSortOrder();

        virtual void gatherStatistics();


  };

  //
  // Include header implementation
  //

#  include "PCMProcess_impl.h"

}

// Declare Process class (and its enums) for SqPlus binding
DECLARE_INSTANCE_TYPE_NAME(ParCompMark::Process, Process);

DECLARE_INSTANCE_TYPE_NAME(ParCompMark::Process::ProcessType, Process::ProcessType);

#endif

© Copyright - 2006 (IT)² ParCompMark Dev. Team