MercuryTexture.h

Go to the documentation of this file.

#ifndef MERCURYTEXTURE_H
#define MERCURYTEXTURE_H

#include <map>
#include "PStack.h"
#include "global.h"

#include "MercuryObject.h"

using namespace std;

enum ColorBytes
{
    //Keep this in ascending order of number of bytes
    BLANK = 0,
    BLANK1,
    LUMINANCE_ALPHA,
    RGB,
    DEPTH_COMPONENT24,
    RGBA,
    RGBA_FLOAT,
};

int ColorBytesToSize(ColorBytes cb);

//NOTICE, that cube maps expect data in the form of minusX;plusX;minusY;plusY;minusZ;plusZ;
enum MAPPING
{
    STANDARD = 0,
    SPHERE,
    CUBE,
    DOT3
};

enum BLENDMODE
{
    BLEND = 0,
    MODULATE,
    DECAL,
    REPLACE,
    ADD,
    COMBINE
};

enum FILTER
{
    LINEAR,
    NEAREST,
};

enum MAPMODE
{
    CLAMP_UV = 0,
    REPEAT_V = 1,
    REPEAT_U = 2,
    REPEAT_UV = 3
};

struct ImageAttrs
{
    ImageAttrs()
    {
        m_height = 0;
        m_width = 0;
        m_ID = 0;
        m_dpi_x = m_dpi_y = 72.0;

        m_height_original = 0;
        m_width_original = 0;
        m_ColorByteType = RGB;
        m_cube = false;
        m_resizeFactor = MercuryPoint(1,1,1);
    }

    int m_height;
    int m_width;
    int m_height_original;
    int m_width_original;
    float m_dpi_x, m_dpi_y;
    ColorBytes m_ColorByteType;
    unsigned int m_ID;
    bool m_cube;
    MercuryPoint m_resizeFactor;
};

struct TextureAttrs
{
    TextureAttrs()
    {
        m_mapping = STANDARD;
        m_mapMode = CLAMP_UV;
        m_magFilter = LINEAR;
        m_blendMode = MODULATE;

        m_isDynamic = false;
        m_isDynamicShadow = false;

        m_isMipmap = true;

        m_MakeThisVBO = 0;
    }
    bool m_isDynamic;
    bool m_isDynamicShadow;
    bool m_isMipmap;
    int  m_MakeThisVBO;

    MAPPING m_mapping;

    int m_mapMode;

    FILTER m_magFilter;

    BLENDMODE m_blendMode;

    //I guess this is ok to put in here, since this needs to be carried around
    //because some things store vital information in here relevant for rendering
    //beyond what a standard texture provides.
    PStack m_extraData;
};

struct RawImageData
{
    RawImageData() :data(NULL) {};
    ~RawImageData() { SAFE_DELETE(data); }

    void CorrectSize();
    void ToRGBA();

    ImageAttrs attrs;
    unsigned char* data;
};

//class MercuryObject;

class MercuryTexture : public MercuryObject
{
public:
    MercuryTexture();
    MercuryTexture(const MercuryTexture& texture);
    virtual ~MercuryTexture();

    virtual void Message( int Message, PStack & data, const MString & name );
    virtual void CalculateMatrices();

    //Only dynamic textures can be targets for render to texture
    inline void SetIsDynamic(bool isDynamic) {m_attrs.m_isDynamic = isDynamic; }
    inline bool IsDynamic () const {return m_attrs.m_isDynamic; }

    inline void SetIsDynamicShadow(bool isDynamicShadow) {m_attrs.m_isDynamicShadow = isDynamicShadow; }
    inline bool IsDynamicShadow() const {return m_attrs.m_isDynamicShadow; }

    //rendering or drawing texture objects does nothing
    virtual void Prerender();
    virtual void Render() {};
    virtual void Draw() {};

    void AutoDestroy();

    void SetPath(MString path) { m_path = path; }

    inline void SetIsMipmap(bool value) { m_attrs.m_isMipmap = value; }
    inline bool IsMipmap() const { return m_attrs.m_isMipmap; }

    inline MAPPING GetMapping() const { return m_attrs.m_mapping; }
    inline void SetMapping(MAPPING mapping) { m_attrs.m_mapping = mapping; }

    inline FILTER GetMagFilter() const { return m_attrs.m_magFilter; }
    inline void SetMagFilter(FILTER filter) { m_attrs.m_magFilter = filter; }

    inline void SetMapMode(int mapMode) { m_attrs.m_mapMode = mapMode; }
    inline int GetMapMode() const { return m_attrs.m_mapMode; }

    inline int GetWidth() const { return m_imageAttrs.m_width; }
    inline int GetHeight() const { return m_imageAttrs.m_height; }
    inline void SetWidth(unsigned int w) { m_imageAttrs.m_width = w; }
    inline void SetHeight(unsigned int h) { m_imageAttrs.m_height = h; }

    inline int GetOriginalWidth() const { return m_imageAttrs.m_width_original; }
    inline int GetOriginalHeight() const { return m_imageAttrs.m_height_original; }
    inline void SetOriginalWidth( int width ) { m_imageAttrs.m_width_original = width; }
    inline void SetOriginalHeight( int height ) { m_imageAttrs.m_height_original = height; }

    inline float GetDpiX() const { return m_imageAttrs.m_dpi_x; }
    inline float GetDpiY() const { return m_imageAttrs.m_dpi_y; }
    inline void SetDpiX(const float dpi_x) { m_imageAttrs.m_dpi_x = dpi_x; }
    inline void SetDpiY(const float dpi_y) { m_imageAttrs.m_dpi_y = dpi_y; }
    inline const MString& GetPath() const { return m_path; }
    inline ColorBytes GetColorByteType() const { return m_imageAttrs.m_ColorByteType; }
    inline void SetColorByteType(ColorBytes type) { m_imageAttrs.m_ColorByteType = type; }
    inline unsigned int GetID() const { return m_imageAttrs.m_ID; }
    inline void SetID(unsigned int id) { m_imageAttrs.m_ID = id; }
    inline void SetAttributes(TextureAttrs& attrs) { m_attrs = attrs;  SetMatrixTainted(true);}
    inline const TextureAttrs& GetAttributes() const { return m_attrs; }
    inline const ImageAttrs& GetImageAttributes() const { return m_imageAttrs; }

    void operator=(const MercuryTexture& texture);
    CLASS_RTTI( MercuryTexture, MercuryObject );

    inline void MakeAttachToVBO( int iVBO ) { m_attrs.m_MakeThisVBO = iVBO; }

    void SendLoadMessage();
    void SendLoadFromRaw(RawImageData* data);
private:
    void SendRemoveMessage();
    void CorrectSize();
    MString m_path;
    TextureAttrs m_attrs; //Attributes
    ImageAttrs m_imageAttrs;
};

void CaclulateDiv2Texture( const RawImageData & riIn, RawImageData & riOut );

#endif

/*
 * (c) 2005 Joshua Allen
 * All rights reserved.
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, and/or sell copies of the Software, and to permit persons to
 * whom the Software is furnished to do so, provided that the above
 * copyright notice(s) and this permission notice appear in all copies of
 * the Software and that both the above copyright notice(s) and this
 * permission notice appear in supporting documentation.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
 * THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS
 * INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT
 * OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
 * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

---

Hosted by