ps_attrib_maker_bin_op.h

Go to the documentation of this file.

/* Copyright, 2001 Nevrax Ltd.
 *
 * This file is part of NEVRAX NEL.
 * NEVRAX NEL 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, or (at your option)
 * any later version.

 * NEVRAX NEL 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 NEVRAX NEL; see the file COPYING. If not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

#ifndef NL_PS_ATTRIB_MAKER_BIN_OP_H
#define NL_PS_ATTRIB_MAKER_BIN_OP_H

#include "nel/misc/types_nl.h"
#include "ps_attrib_maker.h"
#include "ps_plane_basis.h"
#include "nel/misc/rgba.h"
#include <memory>

namespace NL3D {


struct CPSBinOp
{
        enum BinOp
        {
                selectArg1 = 0,
                selectArg2,
                modulate,
                add,
                subtract,
                last
        };
};

const uint PSBinOpBufSize = 1024;

template <class T> class CPSAttribMakerBinOp : public CPSAttribMaker<T>
{
public:


                CPSAttribMakerBinOp();

                CPSAttribMakerBinOp(const CPSAttribMakerBinOp &other);

                virtual ~CPSAttribMakerBinOp();

                
                


                virtual T               get                       (CPSLocated *loc, uint32 index); 
                virtual void   *make              (CPSLocated *loc,
                                                                           uint32 startIndex,
                                                                           void *tab,
                                                                           uint32 stride,
                                                                           uint32 numAttrib,
                                                                           bool allowNoCopy = false,
                                                                           uint32 srcStep = (1 << 16)
                                                                          ) const;
                
                virtual void    make4             (CPSLocated *loc,
                                                                           uint32 startIndex,
                                                                           void *tab,
                                                                           uint32 stride,
                                                                           uint32 numAttrib,
                                                                           uint32 srcStep = (1 << 16)
                                                                          ) const;      

                virtual void    makeN             (CPSLocated *loc,
                                                                           uint32 startIndex,
                                                                           void *tab,
                                                                           uint32 stride,
                                                                           uint32 numAttrib,
                                                                           uint32 nbReplicate,
                                                                           uint32 srcStep = (1 << 16)
                                                                          ) const;      

                virtual void    serial            (NLMISC::IStream &f) throw(NLMISC::EStream);                  
                virtual void    deleteElement (uint32 index);   
                virtual void    newElement        (CPSLocated *emitterLocated, uint32 emitterIndex);    
                virtual void    resize            (uint32 capacity, uint32 nbPresentElements);



                void setArg(uint argNb, CPSAttribMaker<T> *arg)
                {
                        nlassert(argNb < 2);
                        delete _Arg[argNb];
                        _Arg[argNb] = arg;
                        if (arg->hasMemory())
                        {
                                arg->resize(_MaxSize, _Size);
                        }               
                }

                CPSAttribMaker<T> *getArg(uint argNb)
                {
                        nlassert(argNb < 2);
                        return _Arg[argNb];
                }

                const CPSAttribMaker<T> *getArg(uint argNb) const
                {
                        nlassert(argNb < 2);
                        return _Arg[argNb];
                }



                void setOp(CPSBinOp::BinOp op)
                {
                        nlassert(supportOp(op));
                        _Op = op;
                }

                bool supportOp(CPSBinOp::BinOp op) { return true; }
                
                CPSBinOp::BinOp getOp(void) const { return _Op; }

        // from CPSAttribMaker
        virtual T getMinValue(void) const { return T() ; /* no mean by default */ }     
        virtual T getMaxValue(void) const { return T() ; /* no mean by default */ }

protected:
        void   *makePrivate     (T *buf1,
                                                 T *buf2,
                                                 CPSLocated *loc,
                                                 uint32 startIndex,
                                                 void *tab,
                                                 uint32 stride,
                                                 uint32 numAttrib,
                                                 bool allowNoCopy = false,
                                                 uint32 srcStep = (1 << 16)
                                                ) const;
        
        void    make4Private    (T *buf1,
                                                         T *buf2,
                                                         CPSLocated *loc,
                                                         uint32 startIndex,
                                                         void *tab,
                                                         uint32 stride,
                                                         uint32 numAttrib,
                                                         uint32 srcStep = (1 << 16)
                                                        ) const;

        void    makeNPrivate  (T *buf1,
                                                   T *buf2,
                                                   CPSLocated *loc,
                                                   uint32 startIndex,
                                                   void *tab,
                                                   uint32 stride,
                                                   uint32 numAttrib,
                                                   uint32 nbReplicate,
                                                   uint32 srcStep = (1 << 16)
                                                  ) const;
        
        CPSBinOp::BinOp   _Op; // the operator being used
        CPSAttribMaker<T> *_Arg[2]; // the arguments for the binary operator            
        void clean(void);       
        uint32 _Size, _MaxSize;
};


} // NL3D

#include "3d/ps_attrib_maker_bin_op_inline.h"


#endif // NL_PS_ATTRIB_MAKER_BIN_OP_H

/* End of ps_attrib_maker_bin_op.h */

---