first commit

include/engine/core/material.h

@@ -0,0 +1,184 @@
+/* -----------------------------------------------------------------------------
+	GSFramework
+	Copyright 2001-2013 Emmanuel Julien. All Rights Reserved.
+----------------------------------------------------------------------------- */
+
+
+#ifndef	__NMATERIAL__
+#define	__NMATERIAL__
+
+
+#include "core/material_channel.h"
+#include "core/physic_material.h"
+#include "math/matrix4.h"
+#include "color/color.h"
+#include "memory/nshared_ptr.h"
+#include "memory/nauto_ptr.h"
+#include "nstring/nstring.h"
+
+
+namespace GS {
+    namespace Core {
+        /// Basic material definition.
+        struct BasicMaterial {
+            Color diffuse; ///< Diffuse color.
+            Color specular; ///< Specular color.
+            Color self; ///< Self color.
+            Color ambient; ///< Ambient color.
+
+            float glossiness; ///< Glossiness.
+            float opacity; ///< Opacity (eg. 1 - transparency or alpha).
+            float reflection; ///< Reflection [0;1]
+            float irefraction; ///< Index of refraction.
+            float athreshold; ///< Alpha threshold [0;1].
+
+            float depth_bias; ///< Depth bias.
+
+            uint renderword; ///< Render word.
+            uint blendop; ///< Blending operator.
+        };
+
+        /*!
+            @short	Material.
+
+            A material describe the rendering properties of a surface.
+            It usually embeds several textures which can have a very different use
+            depending on whether they are used by a fixed function hardware renderer or
+            a programmable renderer or even the raytracer.
+
+            @note	A material can have up to nTextureStageLimit texture levels.
+            @author Emmanuel Julien (ejulien@gsworks.fr)
+        */
+        struct Material : public BasicMaterial, public PhysicMaterial, public SharedObject {
+            NPLACEMENT_NEW(Material)
+
+            /*!
+                @short	Maximum texture stage count.
+                @note	1 is the lowest acceptable value as C++ does not allow 0 sized
+                        array declaration. (Default: 6)
+            */
+            static const int max_texture_stage = 6;
+
+            /// Material render word (bit mask).
+            enum RenderWord {
+                Render_None = 0,
+
+                Render_Unlit = (1 << 0),
+                Render_Smooth = (1 << 1),
+                Render_NormalTangent = (1 << 2),
+                Render_NoFog = (1 << 3),
+
+                Render_DoubleSided = (1 << 4),
+                Render_Wire = (1 << 5),
+                Render_VertexColor = (1 << 6),
+                Render_ParralaxDisp = (1 << 7),
+                Render_Toon = (1 << 8),
+
+                Render_NoZWrite = (1 << 9),
+                Render_NoZTest = (1 << 10),
+                Render_AlphaTest = (1 << 11),
+
+                Render_AlphaSoftZ = (1 << 12), ///< Soft particle.
+                Render_AlphaInShadow = (1 << 13), ///< Render alpha/opacity in shadow maps.
+
+                Render_UseFramebuffer = (1 << 14),
+                Render_Skinned = (1 << 15)
+            };
+
+            /// Blending operator.
+            enum BlendOperator {
+                Blend_None = 0,
+                Blend_Alpha,
+                Blend_Add
+            };
+
+            /// Filtering type (exclusive).
+            enum FilterType {
+                Filter_None = 0,
+                Filter_Point = 1,
+                Filter_Linear = 2,
+
+                Filter_Default = Filter_Point
+            };
+
+            enum UVMode {
+                UV_UV = 0, ///< Geometry standard UV buffer.
+                UV_LSN, ///< Geometry local space transformed normal component.
+                UV_FrontMap, ///< Front mapping.
+                UV_SphericalEnvironment ///< Spherical Environment mapping.
+            };
+
+            enum Operator {
+                Operator_Default = 0, ///< Default operator for a given renderer (usually a function of channel member).
+                Operator_Multiply, ///< Multiply stage.
+                Operator_Add ///< Add stage.
+            };
+
+            /*!
+                @short	Texture stage.
+
+                A texture stage describes a texture layer in a material.
+                It links a texture object together with the material layer specific
+                attributes such as UV wrapping, texture sampling method (point, linear,
+                etc...). A texture stage is also associated with the channel it modify
+                (diffuse, color, specular, etc... see StageChannel). It is the
+                renderer's responsibility to render a given material as accurately as
+                possible and to provide acceptable fall back in the case a material is
+                too complex to be rendered.
+
+                @author Emmanuel Julien (ejulien@gsworks.fr)
+            */
+            struct TextureStage {
+                MaterialChannel channel; ///< Texture channel.
+                String t; ///< Shared texture object.
+
+                uchar uv_index; ///< UV map index in geometry UV list.
+                UVMode uv_mode; ///< UV mode.
+                Matrix4 uv_matrix; ///< UV matrix.
+
+                Operator op; ///< Stage combine operator.
+
+                /// Reset the texture stage.
+                void Reset();
+
+                TextureStage() { Reset(); }
+            };
+
+            String name;
+            String shader;
+
+            uint texstage_count;
+            Array<TextureStage> texstage;
+
+            /// Return the texture stage for a given channel (if any).
+            TextureStage *GetChannelStage(MaterialChannel) const;
+
+            /*!
+                @short	Create a new texture stage.
+                @note	If a stage is already assigned to the material channel
+                        it will be returned and no new stage will be allocated.
+            */
+            TextureStage *NewStage(MaterialChannel, const char *uri = 0, UVMode = UV_UV, uchar uv_index = 0);
+
+            void Reset();
+
+            /*!
+                @name	Serialization.
+                @{
+            */
+            bool FromMetaTag(NML::Tag &);
+
+            NML::Tag *AsMetaTag() const;
+
+            /// @}
+
+            Material();
+        };
+
+        typedef SharedPtr<Material> sMaterial;
+        typedef List<Material *> MaterialList;
+    } // Core
+} // GS
+
+
+#endif	// __NMATERIAL__