/*
-Copyright (C) 2001-2006, William Joseph.
-All Rights Reserved.
+ Copyright (C) 2001-2006, William Joseph.
+ All Rights Reserved.
-This file is part of GtkRadiant.
+ This file is part of GtkRadiant.
-GtkRadiant 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.
+ GtkRadiant 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.
-GtkRadiant 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.
+ GtkRadiant 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 GtkRadiant; if not, write to the Free Software
-Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-*/
+ You should have received a copy of the GNU General Public License
+ along with GtkRadiant; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
-#if !defined(INCLUDED_PATCH_H)
+#if !defined( INCLUDED_PATCH_H )
#define INCLUDED_PATCH_H
/// \file
/// The surface is recursively tesselated until the angle between each triangle
/// edge is smaller than a specified tolerance.
-
+#include "globaldefs.h"
#include "nameable.h"
#include "ifilter.h"
#include "imap.h"
#include "xml/ixml.h"
#include "dragplanes.h"
-enum EPatchType
-{
- ePatchTypeQuake3,
- ePatchTypeDoom3,
+enum EPatchType {
+ ePatchTypeQuake3,
+ ePatchTypeDoom3,
};
extern int g_PatchSubdivideThreshold;
extern std::size_t MAX_PATCH_WIDTH;
extern std::size_t MAX_PATCH_HEIGHT;
-#define MAX_PATCH_ROWCTRL (((MAX_PATCH_WIDTH-1)-1)/2)
-#define MAX_PATCH_COLCTRL (((MAX_PATCH_HEIGHT-1)-1)/2)
+#define MAX_PATCH_ROWCTRL ( ( ( MAX_PATCH_WIDTH - 1 ) - 1 ) / 2 )
+#define MAX_PATCH_COLCTRL ( ( ( MAX_PATCH_HEIGHT - 1 ) - 1 ) / 2 )
-enum EPatchCap
-{
- eCapBevel,
- eCapEndCap,
- eCapIBevel,
- eCapIEndCap,
- eCapCylinder,
+enum EPatchCap {
+ eCapBevel,
+ eCapEndCap,
+ eCapIBevel,
+ eCapIEndCap,
+ eCapCylinder,
};
-enum EPatchPrefab
-{
- ePlane,
- eBevel,
- eEndCap,
- eCylinder,
- eDenseCylinder,
- eVeryDenseCylinder,
- eSqCylinder,
- eCone,
- eSphere,
- eXactCylinder,
- eXactSphere,
- eXactCone,
+enum EPatchPrefab {
+ ePlane,
+ eBevel,
+ eEndCap,
+ eCylinder,
+ eDenseCylinder,
+ eVeryDenseCylinder,
+ eSqCylinder,
+ eCone,
+ eSphere,
+ eXactCylinder,
+ eXactSphere,
+ eXactCone,
};
-enum EMatrixMajor
-{
- ROW, COL,
+enum EMatrixMajor {
+ ROW, COL,
};
-struct BezierCurve
-{
- Vector3 crd;
- Vector3 left;
- Vector3 right;
+struct BezierCurve {
+ Vector3 crd;
+ Vector3 left;
+ Vector3 right;
};
const std::size_t BEZIERCURVETREE_MAX_INDEX = std::size_t(1) << (std::numeric_limits<std::size_t>::digits - 1);
-struct BezierCurveTree
-{
- std::size_t index;
- BezierCurveTree* left;
- BezierCurveTree* right;
+struct BezierCurveTree {
+ std::size_t index;
+ BezierCurveTree *left;
+ BezierCurveTree *right;
};
-inline bool BezierCurveTree_isLeaf(const BezierCurveTree* node)
+inline bool BezierCurveTree_isLeaf(const BezierCurveTree *node)
{
- return node->left == 0 && node->right == 0;
+ return node->left == 0 && node->right == 0;
}
void BezierCurveTree_Delete(BezierCurveTree *pCurve);
-inline VertexPointer vertexpointer_arbitrarymeshvertex(const ArbitraryMeshVertex* array)
+inline VertexPointer vertexpointer_arbitrarymeshvertex(const ArbitraryMeshVertex *array)
{
- return VertexPointer(VertexPointer::pointer(&array->vertex), sizeof(ArbitraryMeshVertex));
+ return VertexPointer(VertexPointer::pointer(&array->vertex), sizeof(ArbitraryMeshVertex));
}
-typedef PatchControl* PatchControlIter;
-typedef const PatchControl* PatchControlConstIter;
+typedef PatchControl *PatchControlIter;
+typedef const PatchControl *PatchControlConstIter;
inline void copy_ctrl(PatchControlIter ctrl, PatchControlConstIter begin, PatchControlConstIter end)
{
- std::copy(begin, end, ctrl);
+ std::copy(begin, end, ctrl);
}
const Colour4b colour_corner(0, 255, 0, 255);
class Patch;
-class PatchFilter
-{
+class PatchFilter {
public:
- virtual bool filter(const Patch& patch) const = 0;
+ virtual bool filter(const Patch &patch) const = 0;
};
-bool patch_filtered(Patch& patch);
-void add_patch_filter(PatchFilter& filter, int mask, bool invert = false);
+bool patch_filtered(Patch &patch);
+
+void add_patch_filter(PatchFilter &filter, int mask, bool invert = false);
+
+void Patch_addTextureChangedCallback(const SignalHandler &handler);
-void Patch_addTextureChangedCallback(const SignalHandler& handler);
void Patch_textureChanged();
-inline void BezierCurveTreeArray_deleteAll(Array<BezierCurveTree*>& curveTrees)
+inline void BezierCurveTreeArray_deleteAll(Array<BezierCurveTree *> &curveTrees)
{
- for(Array<BezierCurveTree*>::iterator i = curveTrees.begin(); i != curveTrees.end(); ++i)
- {
- BezierCurveTree_Delete(*i);
- }
+ for (Array<BezierCurveTree *>::iterator i = curveTrees.begin(); i != curveTrees.end(); ++i) {
+ BezierCurveTree_Delete(*i);
+ }
}
-inline void PatchControlArray_invert(Array<PatchControl>& ctrl, std::size_t width, std::size_t height)
+inline void PatchControlArray_invert(Array<PatchControl> &ctrl, std::size_t width, std::size_t height)
{
- Array<PatchControl> tmp(width);
-
- PatchControlIter from = ctrl.data() + (width * (height - 1));
- PatchControlIter to = ctrl.data();
- for(std::size_t h = 0; h != ((height - 1) >> 1); ++h, to += width, from -= width)
- {
- copy_ctrl(tmp.data(), to, to + width);
- copy_ctrl(to, from, from + width);
- copy_ctrl(from, tmp.data(), tmp.data() + width);
- }
+ Array<PatchControl> tmp(width);
+
+ PatchControlIter from = ctrl.data() + (width * (height - 1));
+ PatchControlIter to = ctrl.data();
+ for (std::size_t h = 0; h != ((height - 1) >> 1); ++h, to += width, from -= width) {
+ copy_ctrl(tmp.data(), to, to + width);
+ copy_ctrl(to, from, from + width);
+ copy_ctrl(from, tmp.data(), tmp.data() + width);
+ }
}
-class PatchTesselation
-{
+class PatchTesselation {
public:
- PatchTesselation()
- : m_numStrips(0), m_lenStrips(0), m_nArrayWidth(0), m_nArrayHeight(0)
- {
- }
- Array<ArbitraryMeshVertex> m_vertices;
- Array<RenderIndex> m_indices;
- std::size_t m_numStrips;
- std::size_t m_lenStrips;
-
- Array<std::size_t> m_arrayWidth;
- std::size_t m_nArrayWidth;
- Array<std::size_t> m_arrayHeight;
- std::size_t m_nArrayHeight;
-
- Array<BezierCurveTree*> m_curveTreeU;
- Array<BezierCurveTree*> m_curveTreeV;
+ PatchTesselation()
+ : m_numStrips(0), m_lenStrips(0), m_nArrayWidth(0), m_nArrayHeight(0)
+ {
+ }
+
+ Array<ArbitraryMeshVertex> m_vertices;
+ Array<RenderIndex> m_indices;
+ std::size_t m_numStrips;
+ std::size_t m_lenStrips;
+
+ Array<std::size_t> m_arrayWidth;
+ std::size_t m_nArrayWidth;
+ Array<std::size_t> m_arrayHeight;
+ std::size_t m_nArrayHeight;
+
+ Array<BezierCurveTree *> m_curveTreeU;
+ Array<BezierCurveTree *> m_curveTreeV;
};
-class RenderablePatchWireframe : public OpenGLRenderable
-{
- PatchTesselation& m_tess;
+class RenderablePatchWireframe : public OpenGLRenderable {
+ PatchTesselation &m_tess;
public:
- RenderablePatchWireframe(PatchTesselation& tess) : m_tess(tess)
- {
- }
- void render(RenderStateFlags state) const
- {
+ RenderablePatchWireframe(PatchTesselation &tess) : m_tess(tess)
{
- #if NV_DRIVER_BUG
- glVertexPointer(3, GL_FLOAT, 0, 0);
- glDrawArrays(GL_TRIANGLE_FAN, 0, 0);
- #endif
+ }
- std::size_t n = 0;
- glVertexPointer(3, GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_tess.m_vertices.data()->vertex);
- for(std::size_t i = 0; i <= m_tess.m_curveTreeV.size(); ++i)
- {
- glDrawArrays(GL_LINE_STRIP, GLint(n), GLsizei(m_tess.m_nArrayWidth));
+ void render(RenderStateFlags state) const
+ {
+ {
+#if NV_DRIVER_BUG
+ glVertexPointer(3, GL_FLOAT, 0, 0);
+ glDrawArrays(GL_TRIANGLE_FAN, 0, 0);
+#endif
- if(i == m_tess.m_curveTreeV.size()) break;
+ std::size_t n = 0;
+ glVertexPointer(3, GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_tess.m_vertices.data()->vertex);
+ for (std::size_t i = 0; i <= m_tess.m_curveTreeV.size(); ++i) {
+ glDrawArrays(GL_LINE_STRIP, GLint(n), GLsizei(m_tess.m_nArrayWidth));
- if(!BezierCurveTree_isLeaf(m_tess.m_curveTreeV[i]))
- glDrawArrays(GL_LINE_STRIP, GLint(m_tess.m_curveTreeV[i]->index), GLsizei(m_tess.m_nArrayWidth));
+ if (i == m_tess.m_curveTreeV.size()) {
+ break;
+ }
- n += (m_tess.m_arrayHeight[i]*m_tess.m_nArrayWidth);
-
- }
- }
+ if (!BezierCurveTree_isLeaf(m_tess.m_curveTreeV[i])) {
+ glDrawArrays(GL_LINE_STRIP, GLint(m_tess.m_curveTreeV[i]->index), GLsizei(m_tess.m_nArrayWidth));
+ }
- {
- const ArbitraryMeshVertex* p = m_tess.m_vertices.data();
- std::size_t n = m_tess.m_nArrayWidth * sizeof(ArbitraryMeshVertex);
- for(std::size_t i = 0; i <= m_tess.m_curveTreeU.size(); ++i)
- {
- glVertexPointer(3, GL_FLOAT, GLsizei(n), &p->vertex);
- glDrawArrays(GL_LINE_STRIP, 0, GLsizei(m_tess.m_nArrayHeight));
+ n += (m_tess.m_arrayHeight[i] * m_tess.m_nArrayWidth);
- if(i == m_tess.m_curveTreeU.size()) break;
+ }
+ }
- if(!BezierCurveTree_isLeaf(m_tess.m_curveTreeU[i]))
{
- glVertexPointer(3, GL_FLOAT, GLsizei(n), &(m_tess.m_vertices.data() + (m_tess.m_curveTreeU[i]->index))->vertex);
- glDrawArrays(GL_LINE_STRIP, 0, GLsizei(m_tess.m_nArrayHeight));
+ const ArbitraryMeshVertex *p = m_tess.m_vertices.data();
+ std::size_t n = m_tess.m_nArrayWidth * sizeof(ArbitraryMeshVertex);
+ for (std::size_t i = 0; i <= m_tess.m_curveTreeU.size(); ++i) {
+ glVertexPointer(3, GL_FLOAT, GLsizei(n), &p->vertex);
+ glDrawArrays(GL_LINE_STRIP, 0, GLsizei(m_tess.m_nArrayHeight));
+
+ if (i == m_tess.m_curveTreeU.size()) {
+ break;
+ }
+
+ if (!BezierCurveTree_isLeaf(m_tess.m_curveTreeU[i])) {
+ glVertexPointer(3, GL_FLOAT, GLsizei(n),
+ &(m_tess.m_vertices.data() + (m_tess.m_curveTreeU[i]->index))->vertex);
+ glDrawArrays(GL_LINE_STRIP, 0, GLsizei(m_tess.m_nArrayHeight));
+ }
+
+ p += m_tess.m_arrayWidth[i];
+ }
}
-
- p += m_tess.m_arrayWidth[i];
- }
}
- }
};
-class RenderablePatchFixedWireframe : public OpenGLRenderable
-{
- PatchTesselation& m_tess;
+class RenderablePatchFixedWireframe : public OpenGLRenderable {
+ PatchTesselation &m_tess;
public:
- RenderablePatchFixedWireframe(PatchTesselation& tess) : m_tess(tess)
- {
- }
- void render(RenderStateFlags state) const
- {
- glVertexPointer(3, GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_tess.m_vertices.data()->vertex);
- const RenderIndex* strip_indices = m_tess.m_indices.data();
- for(std::size_t i = 0; i<m_tess.m_numStrips; i++, strip_indices += m_tess.m_lenStrips)
- {
- glDrawElements(GL_QUAD_STRIP, GLsizei(m_tess.m_lenStrips), RenderIndexTypeID, strip_indices);
- }
- }
+ RenderablePatchFixedWireframe(PatchTesselation &tess) : m_tess(tess)
+ {
+ }
+
+ void render(RenderStateFlags state) const
+ {
+ glVertexPointer(3, GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_tess.m_vertices.data()->vertex);
+ const RenderIndex *strip_indices = m_tess.m_indices.data();
+ for (std::size_t i = 0; i < m_tess.m_numStrips; i++, strip_indices += m_tess.m_lenStrips) {
+ glDrawElements(GL_QUAD_STRIP, GLsizei(m_tess.m_lenStrips), RenderIndexTypeID, strip_indices);
+ }
+ }
};
-class RenderablePatchSolid : public OpenGLRenderable
-{
- PatchTesselation& m_tess;
+class RenderablePatchSolid : public OpenGLRenderable {
+ PatchTesselation &m_tess;
public:
- RenderablePatchSolid(PatchTesselation& tess) : m_tess(tess)
- {
- }
- void RenderNormals() const;
- void render(RenderStateFlags state) const
- {
-#if 0
- if((state & RENDER_FILL) == 0)
+ RenderablePatchSolid(PatchTesselation &tess) : m_tess(tess)
{
- RenderablePatchWireframe(m_tess).render(state);
}
- else
-#endif
+
+ void RenderNormals() const;
+
+ void render(RenderStateFlags state) const
{
- if((state & RENDER_BUMP) != 0)
- {
- if(GlobalShaderCache().useShaderLanguage())
- {
- glNormalPointer(GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_tess.m_vertices.data()->normal);
- glVertexAttribPointerARB(c_attr_TexCoord0, 2, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_tess.m_vertices.data()->texcoord);
- glVertexAttribPointerARB(c_attr_Tangent, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_tess.m_vertices.data()->tangent);
- glVertexAttribPointerARB(c_attr_Binormal, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_tess.m_vertices.data()->bitangent);
- }
- else
+#if 0
+ if ( ( state & RENDER_FILL ) == 0 ) {
+ RenderablePatchWireframe( m_tess ).render( state );
+ }
+ else
+#endif
{
- glVertexAttribPointerARB(11, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_tess.m_vertices.data()->normal);
- glVertexAttribPointerARB(8, 2, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_tess.m_vertices.data()->texcoord);
- glVertexAttribPointerARB(9, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_tess.m_vertices.data()->tangent);
- glVertexAttribPointerARB(10, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_tess.m_vertices.data()->bitangent);
+ if ((state & RENDER_BUMP) != 0) {
+ if (GlobalShaderCache().useShaderLanguage()) {
+ glNormalPointer(GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_tess.m_vertices.data()->normal);
+ glVertexAttribPointerARB(c_attr_TexCoord0, 2, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex),
+ &m_tess.m_vertices.data()->texcoord);
+ glVertexAttribPointerARB(c_attr_Tangent, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex),
+ &m_tess.m_vertices.data()->tangent);
+ glVertexAttribPointerARB(c_attr_Binormal, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex),
+ &m_tess.m_vertices.data()->bitangent);
+ } else {
+ glVertexAttribPointerARB(11, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex),
+ &m_tess.m_vertices.data()->normal);
+ glVertexAttribPointerARB(8, 2, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex),
+ &m_tess.m_vertices.data()->texcoord);
+ glVertexAttribPointerARB(9, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex),
+ &m_tess.m_vertices.data()->tangent);
+ glVertexAttribPointerARB(10, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex),
+ &m_tess.m_vertices.data()->bitangent);
+ }
+ } else {
+ glNormalPointer(GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_tess.m_vertices.data()->normal);
+ glTexCoordPointer(2, GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_tess.m_vertices.data()->texcoord);
+ }
+ glVertexPointer(3, GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_tess.m_vertices.data()->vertex);
+ const RenderIndex *strip_indices = m_tess.m_indices.data();
+ for (std::size_t i = 0; i < m_tess.m_numStrips; i++, strip_indices += m_tess.m_lenStrips) {
+ glDrawElements(GL_QUAD_STRIP, GLsizei(m_tess.m_lenStrips), RenderIndexTypeID, strip_indices);
+ }
}
- }
- else
- {
- glNormalPointer(GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_tess.m_vertices.data()->normal);
- glTexCoordPointer(2, GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_tess.m_vertices.data()->texcoord);
- }
- glVertexPointer(3, GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_tess.m_vertices.data()->vertex);
- const RenderIndex* strip_indices = m_tess.m_indices.data();
- for(std::size_t i = 0; i<m_tess.m_numStrips; i++, strip_indices += m_tess.m_lenStrips)
- {
- glDrawElements(GL_QUAD_STRIP, GLsizei(m_tess.m_lenStrips), RenderIndexTypeID, strip_indices);
- }
- }
-
-#if defined(_DEBUG)
- RenderNormals();
+
+#if GDEF_DEBUG
+ RenderNormals();
#endif
- }
+ }
};
// parametric surface defined by quadratic bezier control curves
class Patch :
- public XMLImporter,
- public XMLExporter,
- public TransformNode,
- public Bounded,
- public Cullable,
- public Snappable,
- public Undoable,
- public Filterable,
- public Nameable
-{
- class xml_state_t
- {
- public:
- enum EState
- {
- eDefault,
- ePatch,
- eMatrix,
- eShader,
- };
- xml_state_t(EState state)
- : m_state(state)
- {}
- EState state() const
- {
- return m_state;
- }
- const char* content() const
- {
- return m_content.c_str();
- }
- std::size_t write(const char* buffer, std::size_t length)
- {
- return m_content.write(buffer, length);
- }
- private:
- EState m_state;
- StringOutputStream m_content;
- };
+ public XMLImporter,
+ public XMLExporter,
+ public TransformNode,
+ public Bounded,
+ public Cullable,
+ public Snappable,
+ public Undoable,
+ public Filterable,
+ public Nameable {
+ class xml_state_t {
+ public:
+ enum EState {
+ eDefault,
+ ePatch,
+ eMatrix,
+ eShader,
+ };
+
+ xml_state_t(EState state)
+ : m_state(state)
+ {}
+
+ EState state() const
+ {
+ return m_state;
+ }
- std::vector<xml_state_t> m_xml_state;
+ const char *content() const
+ {
+ return m_content.c_str();
+ }
- typedef Array<PatchControl> PatchControlArray;
+ std::size_t write(const char *buffer, std::size_t length)
+ {
+ return m_content.write(buffer, length);
+ }
- class SavedState : public UndoMemento
- {
- public:
- SavedState(
- std::size_t width,
- std::size_t height,
- const PatchControlArray& ctrl,
- const char* shader,
- bool patchDef3,
- std::size_t subdivisions_x,
- std::size_t subdivisions_y
- ) :
- m_width(width),
- m_height(height),
- m_shader(shader),
- m_ctrl(ctrl),
- m_patchDef3(patchDef3),
- m_subdivisions_x(subdivisions_x),
- m_subdivisions_y(subdivisions_y)
- {
- }
+ private:
+ EState m_state;
+ StringOutputStream m_content;
+ };
- void release()
- {
- delete this;
- }
+ std::vector<xml_state_t> m_xml_state;
+
+ typedef Array<PatchControl> PatchControlArray;
+
+ class SavedState : public UndoMemento {
+ public:
+ SavedState(
+ std::size_t width,
+ std::size_t height,
+ const PatchControlArray &ctrl,
+ const char *shader,
+ bool patchDef3,
+ std::size_t subdivisions_x,
+ std::size_t subdivisions_y
+ ) :
+ m_width(width),
+ m_height(height),
+ m_shader(shader),
+ m_ctrl(ctrl),
+ m_patchDef3(patchDef3),
+ m_subdivisions_x(subdivisions_x),
+ m_subdivisions_y(subdivisions_y)
+ {
+ }
- std::size_t m_width, m_height;
- CopiedString m_shader;
- PatchControlArray m_ctrl;
- bool m_patchDef3;
- std::size_t m_subdivisions_x;
- std::size_t m_subdivisions_y;
- };
+ void release()
+ {
+ delete this;
+ }
+
+ std::size_t m_width, m_height;
+ CopiedString m_shader;
+ PatchControlArray m_ctrl;
+ bool m_patchDef3;
+ std::size_t m_subdivisions_x;
+ std::size_t m_subdivisions_y;
+ };
public:
- class Observer
- {
- public:
- virtual void allocate(std::size_t size) = 0;
- };
+ class Observer {
+ public:
+ virtual void allocate(std::size_t size) = 0;
+ };
private:
- typedef UniqueSet<Observer*> Observers;
- Observers m_observers;
+ typedef UniqueSet<Observer *> Observers;
+ Observers m_observers;
- scene::Node* m_node;
+ scene::Node *m_node;
- AABB m_aabb_local; // local bbox
+ AABB m_aabb_local; // local bbox
- CopiedString m_shader;
- Shader* m_state;
+ CopiedString m_shader;
+ Shader *m_state;
- std::size_t m_width;
- std::size_t m_height;
+ std::size_t m_width;
+ std::size_t m_height;
public:
- bool m_patchDef3;
- std::size_t m_subdivisions_x;
- std::size_t m_subdivisions_y;
+ bool m_patchDef3;
+ std::size_t m_subdivisions_x;
+ std::size_t m_subdivisions_y;
private:
-
- UndoObserver* m_undoable_observer;
- MapFile* m_map;
- // dynamically allocated array of control points, size is m_width*m_height
- PatchControlArray m_ctrl;
- PatchControlArray m_ctrlTransformed;
+ UndoObserver *m_undoable_observer;
+ MapFile *m_map;
+
+// dynamically allocated array of control points, size is m_width*m_height
+ PatchControlArray m_ctrl;
+ PatchControlArray m_ctrlTransformed;
- PatchTesselation m_tess;
- RenderablePatchSolid m_render_solid;
- RenderablePatchWireframe m_render_wireframe;
- RenderablePatchFixedWireframe m_render_wireframe_fixed;
+ PatchTesselation m_tess;
+ RenderablePatchSolid m_render_solid;
+ RenderablePatchWireframe m_render_wireframe;
+ RenderablePatchFixedWireframe m_render_wireframe_fixed;
- static Shader* m_state_ctrl;
- static Shader* m_state_lattice;
- VertexBuffer<PointVertex> m_ctrl_vertices;
- RenderableVertexBuffer m_render_ctrl;
- IndexBuffer m_lattice_indices;
- RenderableIndexBuffer m_render_lattice;
+ static Shader *m_state_ctrl;
+ static Shader *m_state_lattice;
+
VertexBuffer<PointVertex> m_ctrl_vertices;
+ RenderableVertexBuffer m_render_ctrl;
+ IndexBuffer m_lattice_indices;
+ RenderableIndexBuffer m_render_lattice;
- bool m_bOverlay;
+ bool m_bOverlay;
- bool m_transformChanged;
- Callback m_evaluateTransform;
- Callback m_boundsChanged;
+ bool m_transformChanged;
+ Callback<void()> m_evaluateTransform;
+ Callback<void()> m_boundsChanged;
- void construct()
- {
- m_bOverlay = false;
- m_width = m_height = 0;
+ void construct()
+ {
+ m_bOverlay = false;
+ m_width = m_height = 0;
- m_patchDef3 = false;
- m_subdivisions_x = 0;
- m_subdivisions_y = 0;
+ m_patchDef3 = false;
+ m_subdivisions_x = 0;
+ m_subdivisions_y = 0;
- check_shader();
- captureShader();
+ check_shader();
+ captureShader();
- m_xml_state.push_back(xml_state_t::eDefault);
- }
+ m_xml_state.push_back(xml_state_t::eDefault);
+ }
public:
- Callback m_lightsChanged;
-
- static int m_CycleCapIndex;// = 0;
- static EPatchType m_type;
-
- STRING_CONSTANT(Name, "Patch");
-
- Patch(scene::Node& node, const Callback& evaluateTransform, const Callback& boundsChanged) :
- m_node(&node),
- m_shader(texdef_name_default()),
- m_state(0),
- m_undoable_observer(0),
- m_map(0),
- m_render_solid(m_tess),
- m_render_wireframe(m_tess),
- m_render_wireframe_fixed(m_tess),
- m_render_ctrl(GL_POINTS, m_ctrl_vertices),
- m_render_lattice(GL_LINES, m_lattice_indices, m_ctrl_vertices),
- m_transformChanged(false),
- m_evaluateTransform(evaluateTransform),
- m_boundsChanged(boundsChanged)
- {
- construct();
- }
- Patch(const Patch& other, scene::Node& node, const Callback& evaluateTransform, const Callback& boundsChanged) :
- m_node(&node),
- m_shader(texdef_name_default()),
- m_state(0),
- m_undoable_observer(0),
- m_map(0),
- m_render_solid(m_tess),
- m_render_wireframe(m_tess),
- m_render_wireframe_fixed(m_tess),
- m_render_ctrl(GL_POINTS, m_ctrl_vertices),
- m_render_lattice(GL_LINES, m_lattice_indices, m_ctrl_vertices),
- m_transformChanged(false),
- m_evaluateTransform(evaluateTransform),
- m_boundsChanged(boundsChanged)
- {
- construct();
-
- m_patchDef3 = other.m_patchDef3;
- m_subdivisions_x = other.m_subdivisions_x;
- m_subdivisions_y = other.m_subdivisions_y;
- setDims(other.m_width, other.m_height);
- copy_ctrl(m_ctrl.data(), other.m_ctrl.data(), other.m_ctrl.data()+(m_width*m_height));
- SetShader(other.m_shader.c_str());
- controlPointsChanged();
- }
-
- Patch(const Patch& other) :
- XMLImporter(other),
- XMLExporter(other),
- TransformNode(other),
- Bounded(other),
- Cullable(other),
- Snappable(),
- Undoable(other),
- Filterable(other),
- Nameable(other),
- m_state(0),
- m_undoable_observer(0),
- m_map(0),
- m_render_solid(m_tess),
- m_render_wireframe(m_tess),
- m_render_wireframe_fixed(m_tess),
- m_render_ctrl(GL_POINTS, m_ctrl_vertices),
- m_render_lattice(GL_LINES, m_lattice_indices, m_ctrl_vertices),
- m_transformChanged(false),
- m_evaluateTransform(other.m_evaluateTransform),
- m_boundsChanged(other.m_boundsChanged)
- {
- m_bOverlay = false;
-
- m_patchDef3 = other.m_patchDef3;
- m_subdivisions_x = other.m_subdivisions_x;
- m_subdivisions_y = other.m_subdivisions_y;
- setDims(other.m_width, other.m_height);
- copy_ctrl(m_ctrl.data(), other.m_ctrl.data(), other.m_ctrl.data()+(m_width*m_height));
- SetShader(other.m_shader.c_str());
- controlPointsChanged();
- }
-
- ~Patch()
- {
- BezierCurveTreeArray_deleteAll(m_tess.m_curveTreeU);
- BezierCurveTreeArray_deleteAll(m_tess.m_curveTreeV);
-
- releaseShader();
-
- ASSERT_MESSAGE(m_observers.empty(), "Patch::~Patch: observers still attached");
- }
-
- InstanceCounter m_instanceCounter;
- void instanceAttach(const scene::Path& path)
- {
- if(++m_instanceCounter.m_count == 1)
- {
- m_state->incrementUsed();
- m_map = path_find_mapfile(path.begin(), path.end());
- m_undoable_observer = GlobalUndoSystem().observer(this);
- GlobalFilterSystem().registerFilterable(*this);
- }
- else
- {
- ASSERT_MESSAGE(path_find_mapfile(path.begin(), path.end()) == m_map, "node is instanced across more than one file");
- }
- }
- void instanceDetach(const scene::Path& path)
- {
- if(--m_instanceCounter.m_count == 0)
- {
- m_map = 0;
- m_undoable_observer = 0;
- GlobalUndoSystem().release(this);
- GlobalFilterSystem().unregisterFilterable(*this);
- m_state->decrementUsed();
- }
- }
-
- const char* name() const
- {
- return "patch";
- }
- void attach(const NameCallback& callback)
- {
- }
- void detach(const NameCallback& callback)
- {
- }
-
- void attach(Observer* observer)
- {
- observer->allocate(m_width * m_height);
-
- m_observers.insert(observer);
- }
- void detach(Observer* observer)
- {
- m_observers.erase(observer);
- }
-
- void updateFiltered()
- {
- if(m_node != 0)
- {
- if(patch_filtered(*this))
- {
- m_node->enable(scene::Node::eFiltered);
- }
- else
- {
- m_node->disable(scene::Node::eFiltered);
- }
- }
- }
-
- void onAllocate(std::size_t size)
- {
- for(Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
- {
- (*i)->allocate(size);
- }
- }
-
- const Matrix4& localToParent() const
- {
- return g_matrix4_identity;
- }
- const AABB& localAABB() const
- {
- return m_aabb_local;
- }
- VolumeIntersectionValue intersectVolume(const VolumeTest& test, const Matrix4& localToWorld) const
- {
- return test.TestAABB(m_aabb_local, localToWorld);
- }
- void render_solid(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
- {
- renderer.SetState(m_state, Renderer::eFullMaterials);
- renderer.addRenderable(m_render_solid, localToWorld);
- }
- void render_wireframe(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
- {
- renderer.SetState(m_state, Renderer::eFullMaterials);
- if(m_patchDef3)
- {
- renderer.addRenderable(m_render_wireframe_fixed, localToWorld);
- }
- else
- {
- renderer.addRenderable(m_render_wireframe, localToWorld);
- }
- }
-
- void render_component(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
- {
- renderer.SetState(m_state_lattice, Renderer::eWireframeOnly);
- renderer.SetState(m_state_lattice, Renderer::eFullMaterials);
- renderer.addRenderable(m_render_lattice, localToWorld);
-
- renderer.SetState(m_state_ctrl, Renderer::eWireframeOnly);
- renderer.SetState(m_state_ctrl, Renderer::eFullMaterials);
- renderer.addRenderable(m_render_ctrl, localToWorld);
- }
- void testSelect(Selector& selector, SelectionTest& test)
- {
- SelectionIntersection best;
- IndexPointer::index_type* pIndex = m_tess.m_indices.data();
- for(std::size_t s=0; s<m_tess.m_numStrips; s++)
- {
- test.TestQuadStrip(vertexpointer_arbitrarymeshvertex(m_tess.m_vertices.data()), IndexPointer(pIndex, m_tess.m_lenStrips), best);
- pIndex += m_tess.m_lenStrips;
- }
- if(best.valid())
- {
- selector.addIntersection(best);
- }
- }
- void transform(const Matrix4& matrix)
- {
- for(PatchControlIter i = m_ctrlTransformed.data(); i != m_ctrlTransformed.data() + m_ctrlTransformed.size(); ++i)
- {
- matrix4_transform_point(matrix, (*i).m_vertex);
- }
-
- if(matrix4_handedness(matrix) == MATRIX4_LEFTHANDED)
- {
- PatchControlArray_invert(m_ctrlTransformed, m_width, m_height);
- }
- UpdateCachedData();
- }
- void transformChanged()
- {
- m_transformChanged = true;
- m_lightsChanged();
- SceneChangeNotify();
- }
- typedef MemberCaller<Patch, &Patch::transformChanged> TransformChangedCaller;
-
- void evaluateTransform()
- {
- if(m_transformChanged)
- {
- m_transformChanged = false;
- revertTransform();
- m_evaluateTransform();
- }
- }
-
- void revertTransform()
- {
- m_ctrlTransformed = m_ctrl;
- }
- void freezeTransform()
- {
- undoSave();
- evaluateTransform();
- ASSERT_MESSAGE(m_ctrlTransformed.size() == m_ctrl.size(), "Patch::freeze: size mismatch");
- std::copy(m_ctrlTransformed.begin(), m_ctrlTransformed.end(), m_ctrl.begin());
- }
-
- void controlPointsChanged()
- {
- transformChanged();
- evaluateTransform();
- UpdateCachedData();
- }
- bool isValid() const;
-
- void snapto(float snap)
- {
- undoSave();
-
- for(PatchControlIter i = m_ctrl.data(); i != m_ctrl.data() + m_ctrl.size(); ++i)
- {
- vector3_snap((*i).m_vertex, snap);
- }
-
- controlPointsChanged();
- }
-
-
+ Callback<void()> m_lightsChanged;
+
+ static int m_CycleCapIndex; // = 0;
+ static EPatchType m_type;
+
+ STRING_CONSTANT(Name, "Patch");
+
+ Patch(scene::Node &node, const Callback<void()> &evaluateTransform, const Callback<void()> &boundsChanged) :
+ m_node(&node),
+ m_shader(texdef_name_default()),
+ m_state(0),
+ m_undoable_observer(0),
+ m_map(0),
+ m_render_solid(m_tess),
+ m_render_wireframe(m_tess),
+ m_render_wireframe_fixed(m_tess),
+ m_render_ctrl(GL_POINTS, m_ctrl_vertices),
+ m_render_lattice(GL_LINES, m_lattice_indices, m_ctrl_vertices),
+ m_transformChanged(false),
+ m_evaluateTransform(evaluateTransform),
+ m_boundsChanged(boundsChanged)
+ {
+ construct();
+ }
+
+ Patch(const Patch &other, scene::Node &node, const Callback<void()> &evaluateTransform,
+ const Callback<void()> &boundsChanged) :
+ m_node(&node),
+ m_shader(texdef_name_default()),
+ m_state(0),
+ m_undoable_observer(0),
+ m_map(0),
+ m_render_solid(m_tess),
+ m_render_wireframe(m_tess),
+ m_render_wireframe_fixed(m_tess),
+ m_render_ctrl(GL_POINTS, m_ctrl_vertices),
+ m_render_lattice(GL_LINES, m_lattice_indices, m_ctrl_vertices),
+ m_transformChanged(false),
+ m_evaluateTransform(evaluateTransform),
+ m_boundsChanged(boundsChanged)
+ {
+ construct();
+
+ m_patchDef3 = other.m_patchDef3;
+ m_subdivisions_x = other.m_subdivisions_x;
+ m_subdivisions_y = other.m_subdivisions_y;
+ setDims(other.m_width, other.m_height);
+ copy_ctrl(m_ctrl.data(), other.m_ctrl.data(), other.m_ctrl.data() + (m_width * m_height));
+ SetShader(other.m_shader.c_str());
+ controlPointsChanged();
+ }
+ Patch(const Patch &other) :
+ XMLImporter(other),
+ XMLExporter(other),
+ TransformNode(other),
+ Bounded(other),
+ Cullable(other),
+ Snappable(),
+ Undoable(other),
+ Filterable(other),
+ Nameable(other),
+ m_state(0),
+ m_undoable_observer(0),
+ m_map(0),
+ m_render_solid(m_tess),
+ m_render_wireframe(m_tess),
+ m_render_wireframe_fixed(m_tess),
+ m_render_ctrl(GL_POINTS, m_ctrl_vertices),
+ m_render_lattice(GL_LINES, m_lattice_indices, m_ctrl_vertices),
+ m_transformChanged(false),
+ m_evaluateTransform(other.m_evaluateTransform),
+ m_boundsChanged(other.m_boundsChanged)
+ {
+ m_bOverlay = false;
+
+ m_patchDef3 = other.m_patchDef3;
+ m_subdivisions_x = other.m_subdivisions_x;
+ m_subdivisions_y = other.m_subdivisions_y;
+ setDims(other.m_width, other.m_height);
+ copy_ctrl(m_ctrl.data(), other.m_ctrl.data(), other.m_ctrl.data() + (m_width * m_height));
+ SetShader(other.m_shader.c_str());
+ controlPointsChanged();
+ }
+
+ ~Patch()
+ {
+ BezierCurveTreeArray_deleteAll(m_tess.m_curveTreeU);
+ BezierCurveTreeArray_deleteAll(m_tess.m_curveTreeV);
- void RenderDebug(RenderStateFlags state) const;
- void RenderNormals(RenderStateFlags state) const;
+ releaseShader();
- void pushElement(const XMLElement& element)
- {
- switch(m_xml_state.back().state())
- {
- case xml_state_t::eDefault:
- ASSERT_MESSAGE(string_equal(element.name(), "patch"), "parse error");
- m_xml_state.push_back(xml_state_t::ePatch);
- break;
- case xml_state_t::ePatch:
- if(string_equal(element.name(), "matrix"))
- {
- setDims(atoi(element.attribute("width")), atoi(element.attribute("height")));
- m_xml_state.push_back(xml_state_t::eMatrix);
- }
- else if(string_equal(element.name(), "shader"))
- {
- m_xml_state.push_back(xml_state_t::eShader);
- }
- break;
- default:
- ERROR_MESSAGE("parse error");
+ ASSERT_MESSAGE(m_observers.empty(), "Patch::~Patch: observers still attached");
}
- }
- void popElement(const char* name)
- {
- switch(m_xml_state.back().state())
+ InstanceCounter m_instanceCounter;
+
+ void instanceAttach(const scene::Path &path)
{
- case xml_state_t::eDefault:
- ERROR_MESSAGE("parse error");
- break;
- case xml_state_t::ePatch:
- break;
- case xml_state_t::eMatrix:
- {
- StringTokeniser content(m_xml_state.back().content());
-
- for(PatchControlIter i = m_ctrl.data(), end = m_ctrl.data() + m_ctrl.size(); i != end; ++i)
- {
- (*i).m_vertex[0] = string_read_float(content.getToken());
- (*i).m_vertex[1] = string_read_float(content.getToken());
- (*i).m_vertex[2] = string_read_float(content.getToken());
- (*i).m_texcoord[0] = string_read_float(content.getToken());
- (*i).m_texcoord[1] = string_read_float(content.getToken());
- }
- controlPointsChanged();
- }
- break;
- case xml_state_t::eShader:
- {
- SetShader(m_xml_state.back().content());
- }
- break;
- default:
- ERROR_MESSAGE("parse error");
- }
-
- ASSERT_MESSAGE(!m_xml_state.empty(), "popping empty stack");
- m_xml_state.pop_back();
- }
- std::size_t write(const char* buffer, std::size_t length)
- {
- switch(m_xml_state.back().state())
- {
- case xml_state_t::eDefault:
- break;
- case xml_state_t::ePatch:
- break;
- case xml_state_t::eMatrix:
- case xml_state_t::eShader:
- return m_xml_state.back().write(buffer, length);
- break;
- default:
- ERROR_MESSAGE("parse error");
- }
- return length;
- }
-
- void exportXML(XMLImporter& importer)
- {
- StaticElement patchElement("patch");
- importer.pushElement(patchElement);
-
- {
- const StaticElement element("shader");
- importer.pushElement(element);
- importer.write(m_shader.c_str(), strlen(m_shader.c_str()));
- importer.popElement(element.name());
- }
-
- {
- char width[16], height[16];
- sprintf(width, "%u", Unsigned(m_width));
- sprintf(height, "%u", Unsigned(m_height));
- StaticElement element("matrix");
- element.insertAttribute("width", width);
- element.insertAttribute("height", height);
-
- importer.pushElement(element);
- {
- for(PatchControlIter i = m_ctrl.data(), end = m_ctrl.data() + m_ctrl.size(); i != end; ++i)
- {
- importer << (*i).m_vertex[0]
- << ' ' << (*i).m_vertex[1]
- << ' ' << (*i).m_vertex[2]
- << ' ' << (*i).m_texcoord[0]
- << ' ' << (*i).m_texcoord[1];
+ if (++m_instanceCounter.m_count == 1) {
+ m_state->incrementUsed();
+ m_map = path_find_mapfile(path.begin(), path.end());
+ m_undoable_observer = GlobalUndoSystem().observer(this);
+ GlobalFilterSystem().registerFilterable(*this);
+ } else {
+ ASSERT_MESSAGE(path_find_mapfile(path.begin(), path.end()) == m_map,
+ "node is instanced across more than one file");
}
- }
- importer.popElement(element.name());
- }
-
- importer.popElement(patchElement.name());
- }
-
- void UpdateCachedData();
-
- const char *GetShader() const
- {
- return m_shader.c_str();
- }
- void SetShader(const char* name)
- {
- ASSERT_NOTNULL(name);
-
- if(shader_equal(m_shader.c_str(), name))
- return;
-
- undoSave();
-
- if(m_instanceCounter.m_count != 0)
- {
- m_state->decrementUsed();
- }
- releaseShader();
- m_shader = name;
- captureShader();
- if(m_instanceCounter.m_count != 0)
- {
- m_state->incrementUsed();
- }
-
- check_shader();
- Patch_textureChanged();
- }
- int getShaderFlags() const
- {
- if(m_state != 0)
- {
- return m_state->getFlags();
- }
- return 0;
- }
-
- typedef PatchControl* iterator;
- typedef const PatchControl* const_iterator;
-
- iterator begin()
- {
- return m_ctrl.data();
- }
- const_iterator begin() const
- {
- return m_ctrl.data();
- }
- iterator end()
- {
- return m_ctrl.data() + m_ctrl.size();
- }
- const_iterator end() const
- {
- return m_ctrl.data() + m_ctrl.size();
- }
-
- PatchControlArray& getControlPoints()
- {
- return m_ctrl;
- }
- PatchControlArray& getControlPointsTransformed()
- {
- return m_ctrlTransformed;
- }
-
- void setDims (std::size_t w, std::size_t h);
- std::size_t getWidth() const
- {
- return m_width;
- }
- std::size_t getHeight() const
- {
- return m_height;
- }
- PatchControl& ctrlAt(std::size_t row, std::size_t col)
- {
- return m_ctrl[row*m_width+col];
- }
- const PatchControl& ctrlAt(std::size_t row, std::size_t col) const
- {
- return m_ctrl[row*m_width+col];
- }
-
- void ConstructPrefab(const AABB& aabb, EPatchPrefab eType, int axis, std::size_t width = 3, std::size_t height = 3);
- void constructPlane(const AABB& aabb, int axis, std::size_t width, std::size_t height);
- void InvertMatrix();
- void TransposeMatrix();
- void Redisperse(EMatrixMajor mt);
- void Smooth(EMatrixMajor mt);
- void InsertRemove(bool bInsert, bool bColumn, bool bFirst);
- Patch* MakeCap(Patch* patch, EPatchCap eType, EMatrixMajor mt, bool bFirst);
- void ConstructSeam(EPatchCap eType, Vector3* p, std::size_t width);
-
- void FlipTexture(int nAxis);
- void TranslateTexture(float s, float t);
- void ScaleTexture(float s, float t);
- void RotateTexture(float angle);
- void SetTextureRepeat(float s, float t); // call with s=1 t=1 for FIT
- void CapTexture();
- void NaturalTexture();
- void ProjectTexture(int nAxis);
-
- void undoSave()
- {
- if(m_map != 0)
- {
- m_map->changed();
- }
- if(m_undoable_observer != 0)
- {
- m_undoable_observer->save(this);
- }
- }
-
- UndoMemento* exportState() const
- {
- return new SavedState(m_width, m_height, m_ctrl, m_shader.c_str(), m_patchDef3, m_subdivisions_x, m_subdivisions_y);
- }
- void importState(const UndoMemento* state)
- {
- undoSave();
-
- const SavedState& other = *(static_cast<const SavedState*>(state));
-
- // begin duplicate of SavedState copy constructor, needs refactoring
-
- // copy construct
- {
- m_width = other.m_width;
- m_height = other.m_height;
- SetShader(other.m_shader.c_str());
- m_ctrl = other.m_ctrl;
- onAllocate(m_ctrl.size());
- m_patchDef3 = other.m_patchDef3;
- m_subdivisions_x = other.m_subdivisions_x;
- m_subdivisions_y = other.m_subdivisions_y;
- }
-
- // end duplicate code
-
- Patch_textureChanged();
-
- controlPointsChanged();
- }
-
- static void constructStatic(EPatchType type)
- {
- Patch::m_type = type;
- Patch::m_state_ctrl = GlobalShaderCache().capture("$POINT");
- Patch::m_state_lattice = GlobalShaderCache().capture("$LATTICE");
- }
-
- static void destroyStatic()
- {
- GlobalShaderCache().release("$LATTICE");
- GlobalShaderCache().release("$POINT");
- }
-private:
- void captureShader()
- {
- m_state = GlobalShaderCache().capture(m_shader.c_str());
- }
-
- void releaseShader()
- {
- GlobalShaderCache().release(m_shader.c_str());
- }
-
- void check_shader()
- {
- if(!shader_valid(GetShader()))
- {
- globalErrorStream() << "patch has invalid texture name: '" << GetShader() << "'\n";
- }
- }
-
- void InsertPoints(EMatrixMajor mt, bool bFirst);
- void RemovePoints(EMatrixMajor mt, bool bFirst);
-
- void AccumulateBBox();
-
- void TesselateSubMatrixFixed(ArbitraryMeshVertex* vertices, std::size_t strideX, std::size_t strideY, unsigned int nFlagsX, unsigned int nFlagsY, PatchControl* subMatrix[3][3]);
-
- // uses binary trees representing bezier curves to recursively tesselate a bezier sub-patch
- void TesselateSubMatrix( const BezierCurveTree *BX, const BezierCurveTree *BY,
- std::size_t offStartX, std::size_t offStartY,
- std::size_t offEndX, std::size_t offEndY,
- std::size_t nFlagsX, std::size_t nFlagsY,
- Vector3& left, Vector3& mid, Vector3& right,
- Vector2& texLeft, Vector2& texMid, Vector2& texRight,
- bool bTranspose );
-
- // tesselates the entire surface
- void BuildTesselationCurves(EMatrixMajor major);
- void accumulateVertexTangentSpace(std::size_t index, Vector3 tangentX[6], Vector3 tangentY[6], Vector2 tangentS[6], Vector2 tangentT[6], std::size_t index0, std::size_t index1);
- void BuildVertexArray();
-};
+ }
-inline bool Patch_importHeader(Patch& patch, Tokeniser& tokeniser)
-{
- tokeniser.nextLine();
- RETURN_FALSE_IF_FAIL(Tokeniser_parseToken(tokeniser, "{"));
- return true;
-}
+ void instanceDetach(const scene::Path &path)
+ {
+ if (--m_instanceCounter.m_count == 0) {
+ m_map = 0;
+ m_undoable_observer = 0;
+ GlobalUndoSystem().release(this);
+ GlobalFilterSystem().unregisterFilterable(*this);
+ m_state->decrementUsed();
+ }
+ }
-inline bool Patch_importShader(Patch& patch, Tokeniser& tokeniser)
-{
- // parse shader name
- tokeniser.nextLine();
- const char* texture = tokeniser.getToken();
- if(texture == 0)
- {
- Tokeniser_unexpectedError(tokeniser, texture, "#texture-name");
- return false;
- }
- if(string_equal(texture, "NULL"))
- {
- patch.SetShader(texdef_name_default());
- }
- else
- {
- StringOutputStream shader(string_length(GlobalTexturePrefix_get()) + string_length(texture));
- shader << GlobalTexturePrefix_get() << texture;
- patch.SetShader(shader.c_str());
- }
- return true;
-}
+ const char *name() const
+ {
+ return "patch";
+ }
-inline bool PatchDoom3_importShader(Patch& patch, Tokeniser& tokeniser)
-{
- // parse shader name
- tokeniser.nextLine();
- const char *shader = tokeniser.getToken();
- if(shader == 0)
- {
- Tokeniser_unexpectedError(tokeniser, shader, "#shader-name");
- return false;
- }
- if(string_equal(shader, "_emptyname"))
- {
- shader = texdef_name_default();
- }
- patch.SetShader(shader);
- return true;
-}
+ void attach(const NameCallback &callback)
+ {
+ }
-inline bool Patch_importParams(Patch& patch, Tokeniser& tokeniser)
-{
- tokeniser.nextLine();
- RETURN_FALSE_IF_FAIL(Tokeniser_parseToken(tokeniser, "("));
-
- // parse matrix dimensions
- {
- std::size_t c, r;
- RETURN_FALSE_IF_FAIL(Tokeniser_getSize(tokeniser, c));
- RETURN_FALSE_IF_FAIL(Tokeniser_getSize(tokeniser, r));
-
- patch.setDims(c, r);
- }
-
- if(patch.m_patchDef3)
- {
- RETURN_FALSE_IF_FAIL(Tokeniser_getSize(tokeniser, patch.m_subdivisions_x));
- RETURN_FALSE_IF_FAIL(Tokeniser_getSize(tokeniser, patch.m_subdivisions_y));
- }
-
- // ignore contents/flags/value
- int tmp;
- RETURN_FALSE_IF_FAIL(Tokeniser_getInteger(tokeniser, tmp));
- RETURN_FALSE_IF_FAIL(Tokeniser_getInteger(tokeniser, tmp));
- RETURN_FALSE_IF_FAIL(Tokeniser_getInteger(tokeniser, tmp));
-
- RETURN_FALSE_IF_FAIL(Tokeniser_parseToken(tokeniser, ")"));
- return true;
-}
+ void detach(const NameCallback &callback)
+ {
+ }
-inline bool Patch_importMatrix(Patch& patch, Tokeniser& tokeniser)
-{
- // parse matrix
- tokeniser.nextLine();
- RETURN_FALSE_IF_FAIL(Tokeniser_parseToken(tokeniser, "("));
- {
- for(std::size_t c=0; c<patch.getWidth(); c++)
- {
- tokeniser.nextLine();
- RETURN_FALSE_IF_FAIL(Tokeniser_parseToken(tokeniser, "("));
- for(std::size_t r=0; r<patch.getHeight(); r++)
- {
- RETURN_FALSE_IF_FAIL(Tokeniser_parseToken(tokeniser, "("));
-
- RETURN_FALSE_IF_FAIL(Tokeniser_getFloat(tokeniser, patch.ctrlAt(r,c).m_vertex[0]));
- RETURN_FALSE_IF_FAIL(Tokeniser_getFloat(tokeniser, patch.ctrlAt(r,c).m_vertex[1]));
- RETURN_FALSE_IF_FAIL(Tokeniser_getFloat(tokeniser, patch.ctrlAt(r,c).m_vertex[2]));
- RETURN_FALSE_IF_FAIL(Tokeniser_getFloat(tokeniser, patch.ctrlAt(r,c).m_texcoord[0]));
- RETURN_FALSE_IF_FAIL(Tokeniser_getFloat(tokeniser, patch.ctrlAt(r,c).m_texcoord[1]));
-
- RETURN_FALSE_IF_FAIL(Tokeniser_parseToken(tokeniser, ")"));
- }
- RETURN_FALSE_IF_FAIL(Tokeniser_parseToken(tokeniser, ")"));
- }
- }
- tokeniser.nextLine();
- RETURN_FALSE_IF_FAIL(Tokeniser_parseToken(tokeniser, ")"));
- return true;
-}
+ void attach(Observer *observer)
+ {
+ observer->allocate(m_width * m_height);
-inline bool Patch_importFooter(Patch& patch, Tokeniser& tokeniser)
-{
- patch.controlPointsChanged();
+ m_observers.insert(observer);
+ }
- tokeniser.nextLine();
- RETURN_FALSE_IF_FAIL(Tokeniser_parseToken(tokeniser, "}"));
+ void detach(Observer *observer)
+ {
+ m_observers.erase(observer);
+ }
- tokeniser.nextLine();
- RETURN_FALSE_IF_FAIL(Tokeniser_parseToken(tokeniser, "}"));
- return true;
-}
+ void updateFiltered()
+ {
+ if (m_node != 0) {
+ if (patch_filtered(*this)) {
+ m_node->enable(scene::Node::eFiltered);
+ } else {
+ m_node->disable(scene::Node::eFiltered);
+ }
+ }
+ }
-class PatchTokenImporter : public MapImporter
-{
- Patch& m_patch;
-public:
- PatchTokenImporter(Patch& patch) : m_patch(patch)
- {
- }
- bool importTokens(Tokeniser& tokeniser)
- {
- RETURN_FALSE_IF_FAIL(Patch_importHeader(m_patch, tokeniser));
- RETURN_FALSE_IF_FAIL(Patch_importShader(m_patch, tokeniser));
- RETURN_FALSE_IF_FAIL(Patch_importParams(m_patch, tokeniser));
- RETURN_FALSE_IF_FAIL(Patch_importMatrix(m_patch, tokeniser));
- RETURN_FALSE_IF_FAIL(Patch_importFooter(m_patch, tokeniser));
+ void onAllocate(std::size_t size)
+ {
+ for (Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i) {
+ (*i)->allocate(size);
+ }
+ }
- return true;
- }
-};
+ const Matrix4 &localToParent() const
+ {
+ return g_matrix4_identity;
+ }
-class PatchDoom3TokenImporter : public MapImporter
-{
- Patch& m_patch;
-public:
- PatchDoom3TokenImporter(Patch& patch) : m_patch(patch)
- {
- }
- bool importTokens(Tokeniser& tokeniser)
- {
- RETURN_FALSE_IF_FAIL(Patch_importHeader(m_patch, tokeniser));
- RETURN_FALSE_IF_FAIL(PatchDoom3_importShader(m_patch, tokeniser));
- RETURN_FALSE_IF_FAIL(Patch_importParams(m_patch, tokeniser));
- RETURN_FALSE_IF_FAIL(Patch_importMatrix(m_patch, tokeniser));
- RETURN_FALSE_IF_FAIL(Patch_importFooter(m_patch, tokeniser));
+ const AABB &localAABB() const
+ {
+ return m_aabb_local;
+ }
- return true;
- }
-};
+ VolumeIntersectionValue intersectVolume(const VolumeTest &test, const Matrix4 &localToWorld) const
+ {
+ return test.TestAABB(m_aabb_local, localToWorld);
+ }
-inline void Patch_exportHeader(const Patch& patch, TokenWriter& writer)
-{
- writer.writeToken("{");
- writer.nextLine();
- writer.writeToken(patch.m_patchDef3 ? "patchDef3" : "patchDef2");
- writer.nextLine();
- writer.writeToken("{");
- writer.nextLine();
-}
+ void render_solid(Renderer &renderer, const VolumeTest &volume, const Matrix4 &localToWorld) const
+ {
+ renderer.SetState(m_state, Renderer::eFullMaterials);
+ renderer.addRenderable(m_render_solid, localToWorld);
+ }
-inline void Patch_exportShader(const Patch& patch, TokenWriter& writer)
-{
- // write shader name
- if(*(shader_get_textureName(patch.GetShader())) == '\0')
- {
- writer.writeToken("NULL");
- }
- else
- {
- writer.writeToken(shader_get_textureName(patch.GetShader()));
- }
- writer.nextLine();
-}
+ void render_wireframe(Renderer &renderer, const VolumeTest &volume, const Matrix4 &localToWorld) const
+ {
+ renderer.SetState(m_state, Renderer::eFullMaterials);
+ if (m_patchDef3) {
+ renderer.addRenderable(m_render_wireframe_fixed, localToWorld);
+ } else {
+ renderer.addRenderable(m_render_wireframe, localToWorld);
+ }
+ }
-inline void PatchDoom3_exportShader(const Patch& patch, TokenWriter& writer)
-{
- // write shader name
- if(*(shader_get_textureName(patch.GetShader())) == '\0')
- {
- writer.writeString("_emptyname");
- }
- else
- {
- writer.writeString(patch.GetShader());
- }
- writer.nextLine();
-}
+ void render_component(Renderer &renderer, const VolumeTest &volume, const Matrix4 &localToWorld) const
+ {
+ renderer.SetState(m_state_lattice, Renderer::eWireframeOnly);
+ renderer.SetState(m_state_lattice, Renderer::eFullMaterials);
+ renderer.addRenderable(m_render_lattice, localToWorld);
-inline void Patch_exportParams(const Patch& patch, TokenWriter& writer)
-{
- // write matrix dimensions
- writer.writeToken("(");
- writer.writeUnsigned(patch.getWidth());
- writer.writeUnsigned(patch.getHeight());
- if(patch.m_patchDef3)
- {
- writer.writeUnsigned(patch.m_subdivisions_x);
- writer.writeUnsigned(patch.m_subdivisions_y);
- }
- writer.writeInteger(0);
- writer.writeInteger(0);
- writer.writeInteger(0);
- writer.writeToken(")");
- writer.nextLine();
-}
+ renderer.SetState(m_state_ctrl, Renderer::eWireframeOnly);
+ renderer.SetState(m_state_ctrl, Renderer::eFullMaterials);
+ renderer.addRenderable(m_render_ctrl, localToWorld);
+ }
-inline void Patch_exportMatrix(const Patch& patch, TokenWriter& writer)
-{
- // write matrix
- writer.writeToken("(");
- writer.nextLine();
- for(std::size_t c=0; c<patch.getWidth(); c++)
- {
- writer.writeToken("(");
- for(std::size_t r=0; r<patch.getHeight(); r++)
+ void testSelect(Selector &selector, SelectionTest &test)
{
- writer.writeToken("(");
+ SelectionIntersection best;
+ IndexPointer::index_type *pIndex = m_tess.m_indices.data();
+ for (std::size_t s = 0; s < m_tess.m_numStrips; s++) {
+ test.TestQuadStrip(vertexpointer_arbitrarymeshvertex(m_tess.m_vertices.data()),
+ IndexPointer(pIndex, m_tess.m_lenStrips), best);
+ pIndex += m_tess.m_lenStrips;
+ }
+ if (best.valid()) {
+ selector.addIntersection(best);
+ }
+ }
- writer.writeFloat(patch.ctrlAt(r,c).m_vertex[0]);
- writer.writeFloat(patch.ctrlAt(r,c).m_vertex[1]);
- writer.writeFloat(patch.ctrlAt(r,c).m_vertex[2]);
- writer.writeFloat(patch.ctrlAt(r,c).m_texcoord[0]);
- writer.writeFloat(patch.ctrlAt(r,c).m_texcoord[1]);
+ void transform(const Matrix4 &matrix)
+ {
+ for (PatchControlIter i = m_ctrlTransformed.data();
+ i != m_ctrlTransformed.data() + m_ctrlTransformed.size(); ++i) {
+ matrix4_transform_point(matrix, (*i).m_vertex);
+ }
- writer.writeToken(")");
+ if (matrix4_handedness(matrix) == MATRIX4_LEFTHANDED) {
+ PatchControlArray_invert(m_ctrlTransformed, m_width, m_height);
+ }
+ UpdateCachedData();
}
- writer.writeToken(")");
- writer.nextLine();
- }
- writer.writeToken(")");
- writer.nextLine();
-}
-
-inline void Patch_exportFooter(const Patch& patch, TokenWriter& writer)
-{
- writer.writeToken("}");
- writer.nextLine();
- writer.writeToken("}");
- writer.nextLine();
-}
-class PatchTokenExporter : public MapExporter
-{
- const Patch& m_patch;
-public:
- PatchTokenExporter(Patch& patch) : m_patch(patch)
- {
- }
- void exportTokens(TokenWriter& writer) const
- {
- Patch_exportHeader(m_patch, writer);
- Patch_exportShader(m_patch, writer);
- Patch_exportParams(m_patch, writer);
- Patch_exportMatrix(m_patch, writer);
- Patch_exportFooter(m_patch, writer);
- }
-};
+ void transformChanged()
+ {
+ m_transformChanged = true;
+ m_lightsChanged();
+ SceneChangeNotify();
+ }
-class PatchDoom3TokenExporter : public MapExporter
-{
- const Patch& m_patch;
-public:
- PatchDoom3TokenExporter(Patch& patch) : m_patch(patch)
- {
- }
- void exportTokens(TokenWriter& writer) const
- {
- Patch_exportHeader(m_patch, writer);
- PatchDoom3_exportShader(m_patch, writer);
- Patch_exportParams(m_patch, writer);
- Patch_exportMatrix(m_patch, writer);
- Patch_exportFooter(m_patch, writer);
- }
-};
+ typedef MemberCaller<Patch, void(), &Patch::transformChanged> TransformChangedCaller;
-class PatchControlInstance
-{
-public:
- PatchControl* m_ctrl;
- ObservedSelectable m_selectable;
-
- PatchControlInstance(PatchControl* ctrl, const SelectionChangeCallback& observer)
- : m_ctrl(ctrl), m_selectable(observer)
- {
- }
-
- void testSelect(Selector& selector, SelectionTest& test)
- {
- SelectionIntersection best;
- test.TestPoint(m_ctrl->m_vertex, best);
- if(best.valid())
- {
- Selector_add(selector, m_selectable, best);
- }
- }
- void snapto(float snap)
- {
- vector3_snap(m_ctrl->m_vertex, snap);
- }
-};
+ void evaluateTransform()
+ {
+ if (m_transformChanged) {
+ m_transformChanged = false;
+ revertTransform();
+ m_evaluateTransform();
+ }
+ }
+ void revertTransform()
+ {
+ m_ctrlTransformed = m_ctrl;
+ }
-class PatchInstance :
-public Patch::Observer,
-public scene::Instance,
-public Selectable,
-public Renderable,
-public SelectionTestable,
-public ComponentSelectionTestable,
-public ComponentEditable,
-public ComponentSnappable,
-public PlaneSelectable,
-public LightCullable
-{
- class TypeCasts
- {
- InstanceTypeCastTable m_casts;
- public:
- TypeCasts()
+ void freezeTransform()
{
- InstanceStaticCast<PatchInstance, Selectable>::install(m_casts);
- InstanceContainedCast<PatchInstance, Bounded>::install(m_casts);
- InstanceContainedCast<PatchInstance, Cullable>::install(m_casts);
- InstanceStaticCast<PatchInstance, Renderable>::install(m_casts);
- InstanceStaticCast<PatchInstance, SelectionTestable>::install(m_casts);
- InstanceStaticCast<PatchInstance, ComponentSelectionTestable>::install(m_casts);
- InstanceStaticCast<PatchInstance, ComponentEditable>::install(m_casts);
- InstanceStaticCast<PatchInstance, ComponentSnappable>::install(m_casts);
- InstanceStaticCast<PatchInstance, PlaneSelectable>::install(m_casts);
- InstanceIdentityCast<PatchInstance>::install(m_casts);
- InstanceContainedCast<PatchInstance, Transformable>::install(m_casts);
+ undoSave();
+ evaluateTransform();
+ ASSERT_MESSAGE(m_ctrlTransformed.size() == m_ctrl.size(), "Patch::freeze: size mismatch");
+ std::copy(m_ctrlTransformed.begin(), m_ctrlTransformed.end(), m_ctrl.begin());
}
- InstanceTypeCastTable& get()
+
+ void controlPointsChanged()
{
- return m_casts;
+ transformChanged();
+ evaluateTransform();
+ UpdateCachedData();
}
- };
+ bool isValid() const;
- Patch& m_patch;
- typedef std::vector<PatchControlInstance> PatchControlInstances;
- PatchControlInstances m_ctrl_instances;
+ void snapto(float snap)
+ {
+ undoSave();
+
+ for (PatchControlIter i = m_ctrl.data(); i != m_ctrl.data() + m_ctrl.size(); ++i) {
+ vector3_snap((*i).m_vertex, snap);
+ }
- ObservedSelectable m_selectable;
+ controlPointsChanged();
+ }
- DragPlanes m_dragPlanes;
- mutable RenderablePointVector m_render_selected;
- mutable AABB m_aabb_component;
+ void RenderDebug(RenderStateFlags state) const;
- static Shader* m_state_selpoint;
+ void RenderNormals(RenderStateFlags state) const;
- const LightList* m_lightList;
+ void pushElement(const XMLElement &element)
+ {
+ switch (m_xml_state.back().state()) {
+ case xml_state_t::eDefault:
+ ASSERT_MESSAGE(string_equal(element.name(), "patch"), "parse error");
+ m_xml_state.push_back(xml_state_t::ePatch);
+ break;
+ case xml_state_t::ePatch:
+ if (string_equal(element.name(), "matrix")) {
+ setDims(atoi(element.attribute("width")), atoi(element.attribute("height")));
+ m_xml_state.push_back(xml_state_t::eMatrix);
+ } else if (string_equal(element.name(), "shader")) {
+ m_xml_state.push_back(xml_state_t::eShader);
+ }
+ break;
+ default:
+ ERROR_MESSAGE("parse error");
+ }
- TransformModifier m_transform;
-public:
+ }
- typedef LazyStatic<TypeCasts> StaticTypeCasts;
-
- void lightsChanged()
- {
- m_lightList->lightsChanged();
- }
- typedef MemberCaller<PatchInstance, &PatchInstance::lightsChanged> LightsChangedCaller;
-
- STRING_CONSTANT(Name, "PatchInstance");
-
- PatchInstance(const scene::Path& path, scene::Instance* parent, Patch& patch) :
- Instance(path, parent, this, StaticTypeCasts::instance().get()),
- m_patch(patch),
- m_selectable(SelectedChangedCaller(*this)),
- m_dragPlanes(SelectedChangedComponentCaller(*this)),
- m_render_selected(GL_POINTS),
- m_transform(Patch::TransformChangedCaller(m_patch), ApplyTransformCaller(*this))
- {
- m_patch.instanceAttach(Instance::path());
- m_patch.attach(this);
-
- m_lightList = &GlobalShaderCache().attach(*this);
- m_patch.m_lightsChanged = LightsChangedCaller(*this);
-
- Instance::setTransformChangedCallback(LightsChangedCaller(*this));
- }
- ~PatchInstance()
- {
- Instance::setTransformChangedCallback(Callback());
-
- m_patch.m_lightsChanged = Callback();
- GlobalShaderCache().detach(*this);
-
- m_patch.detach(this);
- m_patch.instanceDetach(Instance::path());
- }
-
- void selectedChanged(const Selectable& selectable)
- {
- GlobalSelectionSystem().getObserver(SelectionSystem::ePrimitive)(selectable);
- GlobalSelectionSystem().onSelectedChanged(*this, selectable);
-
- Instance::selectedChanged();
- }
- typedef MemberCaller1<PatchInstance, const Selectable&, &PatchInstance::selectedChanged> SelectedChangedCaller;
-
- void selectedChangedComponent(const Selectable& selectable)
- {
- GlobalSelectionSystem().getObserver(SelectionSystem::eComponent)(selectable);
- GlobalSelectionSystem().onComponentSelection(*this, selectable);
- }
- typedef MemberCaller1<PatchInstance, const Selectable&, &PatchInstance::selectedChangedComponent> SelectedChangedComponentCaller;
-
- Patch& getPatch()
- {
- return m_patch;
- }
- Bounded& get(NullType<Bounded>)
- {
- return m_patch;
- }
- Cullable& get(NullType<Cullable>)
- {
- return m_patch;
- }
- Transformable& get(NullType<Transformable>)
- {
- return m_transform;
- }
-
- static void constructStatic()
- {
- m_state_selpoint = GlobalShaderCache().capture("$SELPOINT");
- }
-
- static void destroyStatic()
- {
- GlobalShaderCache().release("$SELPOINT");
- }
-
-
- void allocate(std::size_t size)
- {
- m_ctrl_instances.clear();
- m_ctrl_instances.reserve(size);
- for(Patch::iterator i = m_patch.begin(); i != m_patch.end(); ++i)
- {
- m_ctrl_instances.push_back(PatchControlInstance(&(*i), SelectedChangedComponentCaller(*this)));
- }
- }
-
- void setSelected(bool select)
- {
- m_selectable.setSelected(select);
- }
- bool isSelected() const
- {
- return m_selectable.isSelected();
- }
-
-
- void update_selected() const
- {
- m_render_selected.clear();
- Patch::iterator ctrl = m_patch.getControlPointsTransformed().begin();
- for(PatchControlInstances::const_iterator i = m_ctrl_instances.begin(); i != m_ctrl_instances.end(); ++i, ++ctrl)
- {
- if((*i).m_selectable.isSelected())
- {
- const Colour4b colour_selected(0, 0, 255, 255);
- m_render_selected.push_back(PointVertex(reinterpret_cast<Vertex3f&>((*ctrl).m_vertex), colour_selected));
- }
- }
- }
+ void popElement(const char *name)
+ {
+ switch (m_xml_state.back().state()) {
+ case xml_state_t::eDefault:
+ ERROR_MESSAGE("parse error");
+ break;
+ case xml_state_t::ePatch:
+ break;
+ case xml_state_t::eMatrix: {
+ StringTokeniser content(m_xml_state.back().content());
+
+ for (PatchControlIter i = m_ctrl.data(), end = m_ctrl.data() + m_ctrl.size(); i != end; ++i) {
+ (*i).m_vertex[0] = string_read_float(content.getToken());
+ (*i).m_vertex[1] = string_read_float(content.getToken());
+ (*i).m_vertex[2] = string_read_float(content.getToken());
+ (*i).m_texcoord[0] = string_read_float(content.getToken());
+ (*i).m_texcoord[1] = string_read_float(content.getToken());
+ }
+ controlPointsChanged();
+ }
+ break;
+ case xml_state_t::eShader: {
+ SetShader(m_xml_state.back().content());
+ }
+ break;
+ default:
+ ERROR_MESSAGE("parse error");
+ }
-#if 0
- void render(Renderer& renderer, const VolumeTest& volume) const
- {
- if(GlobalSelectionSystem().Mode() == SelectionSystem::eComponent
- && m_selectable.isSelected())
+ ASSERT_MESSAGE(!m_xml_state.empty(), "popping empty stack");
+ m_xml_state.pop_back();
+ }
+
+ std::size_t write(const char *buffer, std::size_t length)
+ {
+ switch (m_xml_state.back().state()) {
+ case xml_state_t::eDefault:
+ break;
+ case xml_state_t::ePatch:
+ break;
+ case xml_state_t::eMatrix:
+ case xml_state_t::eShader:
+ return m_xml_state.back().write(buffer, length);
+ break;
+ default:
+ ERROR_MESSAGE("parse error");
+ }
+ return length;
+ }
+
+ void exportXML(XMLImporter &importer)
{
- renderer.Highlight(Renderer::eFace, false);
+ StaticElement patchElement("patch");
+ importer.pushElement(patchElement);
+
+ {
+ const StaticElement element("shader");
+ importer.pushElement(element);
+ importer.write(m_shader.c_str(), strlen(m_shader.c_str()));
+ importer.popElement(element.name());
+ }
- m_patch.render(renderer, volume, localToWorld());
+ {
+ char width[16], height[16];
+ sprintf(width, "%u", Unsigned(m_width));
+ sprintf(height, "%u", Unsigned(m_height));
+ StaticElement element("matrix");
+ element.insertAttribute("width", width);
+ element.insertAttribute("height", height);
+
+ importer.pushElement(element);
+ {
+ for (PatchControlIter i = m_ctrl.data(), end = m_ctrl.data() + m_ctrl.size(); i != end; ++i) {
+ importer << (*i).m_vertex[0]
+ << ' ' << (*i).m_vertex[1]
+ << ' ' << (*i).m_vertex[2]
+ << ' ' << (*i).m_texcoord[0]
+ << ' ' << (*i).m_texcoord[1];
+ }
+ }
+ importer.popElement(element.name());
+ }
- if(GlobalSelectionSystem().ComponentMode() == SelectionSystem::eVertex)
- {
- renderer.Highlight(Renderer::ePrimitive, false);
+ importer.popElement(patchElement.name());
+ }
- m_patch.render_component(renderer, volume, localToWorld());
+ void UpdateCachedData();
- renderComponentsSelected(renderer, volume);
- }
+ const char *GetShader() const
+ {
+ return m_shader.c_str();
}
- else
- m_patch.render(renderer, volume, localToWorld());
- }
-#endif
- void renderSolid(Renderer& renderer, const VolumeTest& volume) const
- {
- m_patch.evaluateTransform();
- renderer.setLights(*m_lightList);
- m_patch.render_solid(renderer, volume, localToWorld());
+ void SetShader(const char *name)
+ {
+ ASSERT_NOTNULL(name);
- renderComponentsSelected(renderer, volume);
- }
+ if (shader_equal(m_shader.c_str(), name)) {
+ return;
+ }
- void renderWireframe(Renderer& renderer, const VolumeTest& volume) const
- {
- m_patch.evaluateTransform();
- m_patch.render_wireframe(renderer, volume, localToWorld());
+ undoSave();
- renderComponentsSelected(renderer, volume);
- }
+ if (m_instanceCounter.m_count != 0) {
+ m_state->decrementUsed();
+ }
+ releaseShader();
+ m_shader = name;
+ captureShader();
+ if (m_instanceCounter.m_count != 0) {
+ m_state->incrementUsed();
+ }
- void renderComponentsSelected(Renderer& renderer, const VolumeTest& volume) const
- {
- m_patch.evaluateTransform();
- update_selected();
- if(!m_render_selected.empty())
- {
- renderer.Highlight(Renderer::ePrimitive, false);
- renderer.SetState(m_state_selpoint, Renderer::eWireframeOnly);
- renderer.SetState(m_state_selpoint, Renderer::eFullMaterials);
- renderer.addRenderable(m_render_selected, localToWorld());
+ check_shader();
+ Patch_textureChanged();
}
- }
- void renderComponents(Renderer& renderer, const VolumeTest& volume) const
- {
- m_patch.evaluateTransform();
- if(GlobalSelectionSystem().ComponentMode() == SelectionSystem::eVertex)
+
+ int getShaderFlags() const
{
- m_patch.render_component(renderer, volume, localToWorld());
+ if (m_state != 0) {
+ return m_state->getFlags();
+ }
+ return 0;
}
- }
- void testSelect(Selector& selector, SelectionTest& test)
- {
- test.BeginMesh(localToWorld(), true);
- m_patch.testSelect(selector, test);
- }
+ typedef PatchControl *iterator;
+ typedef const PatchControl *const_iterator;
- void selectCtrl(bool select)
- {
- for(PatchControlInstances::iterator i = m_ctrl_instances.begin(); i != m_ctrl_instances.end(); ++i)
+ iterator begin()
{
- (*i).m_selectable.setSelected(select);
+ return m_ctrl.data();
}
- }
- bool isSelectedComponents() const
- {
- for(PatchControlInstances::const_iterator i = m_ctrl_instances.begin(); i != m_ctrl_instances.end(); ++i)
+
+ const_iterator begin() const
{
- if((*i).m_selectable.isSelected())
- {
- return true;
- }
+ return m_ctrl.data();
}
- return false;
- }
- void setSelectedComponents(bool select, SelectionSystem::EComponentMode mode)
- {
- if(mode == SelectionSystem::eVertex)
+
+ iterator end()
{
- selectCtrl(select);
+ return m_ctrl.data() + m_ctrl.size();
}
- else if(mode == SelectionSystem::eFace)
+
+ const_iterator end() const
{
- m_dragPlanes.setSelected(select);
+ return m_ctrl.data() + m_ctrl.size();
}
- }
- const AABB& getSelectedComponentsBounds() const
- {
- m_aabb_component = AABB();
- for(PatchControlInstances::const_iterator i = m_ctrl_instances.begin(); i != m_ctrl_instances.end(); ++i)
+ PatchControlArray &getControlPoints()
{
- if((*i).m_selectable.isSelected())
- {
- aabb_extend_by_point_safe(m_aabb_component, (*i).m_ctrl->m_vertex);
- }
+ return m_ctrl;
}
- return m_aabb_component;
- }
+ PatchControlArray &getControlPointsTransformed()
+ {
+ return m_ctrlTransformed;
+ }
- void testSelectComponents(Selector& selector, SelectionTest& test, SelectionSystem::EComponentMode mode)
- {
- test.BeginMesh(localToWorld());
+ void setDims(std::size_t w, std::size_t h);
- switch(mode)
+ std::size_t getWidth() const
{
- case SelectionSystem::eVertex:
- {
- for(PatchControlInstances::iterator i = m_ctrl_instances.begin(); i != m_ctrl_instances.end(); ++i)
- {
- (*i).testSelect(selector, test);
- }
- }
- break;
- default:
- break;
+ return m_width;
}
- }
- bool selectedVertices()
- {
- for(PatchControlInstances::iterator i = m_ctrl_instances.begin(); i != m_ctrl_instances.end(); ++i)
+ std::size_t getHeight() const
{
- if((*i).m_selectable.isSelected())
- {
- return true;
- }
+ return m_height;
}
- return false;
- }
- void transformComponents(const Matrix4& matrix)
- {
- if(selectedVertices())
+ PatchControl &ctrlAt(std::size_t row, std::size_t col)
{
- PatchControlIter ctrl = m_patch.getControlPointsTransformed().begin();
- for(PatchControlInstances::iterator i = m_ctrl_instances.begin(); i != m_ctrl_instances.end(); ++i, ++ctrl)
- {
- if((*i).m_selectable.isSelected())
- {
- matrix4_transform_point(matrix, (*ctrl).m_vertex);
- }
- }
- m_patch.UpdateCachedData();
+ return m_ctrl[row * m_width + col];
}
- if(m_dragPlanes.isSelected()) // this should only be true when the transform is a pure translation.
+ const PatchControl &ctrlAt(std::size_t row, std::size_t col) const
{
- m_patch.transform(m_dragPlanes.evaluateTransform(vector4_to_vector3(matrix.t())));
+ return m_ctrl[row * m_width + col];
}
- }
+ void ConstructPrefab(const AABB &aabb, EPatchPrefab eType, int axis, std::size_t width = 3, std::size_t height = 3);
- void selectPlanes(Selector& selector, SelectionTest& test, const PlaneCallback& selectedPlaneCallback)
- {
- test.BeginMesh(localToWorld());
+ void constructPlane(const AABB &aabb, int axis, std::size_t width, std::size_t height);
- m_dragPlanes.selectPlanes(m_patch.localAABB(), selector, test, selectedPlaneCallback);
- }
- void selectReversedPlanes(Selector& selector, const SelectedPlanes& selectedPlanes)
- {
- m_dragPlanes.selectReversedPlanes(m_patch.localAABB(), selector, selectedPlanes);
- }
-
-
- void snapComponents(float snap)
- {
- if(selectedVertices())
- {
- m_patch.undoSave();
- for(PatchControlInstances::iterator i = m_ctrl_instances.begin(); i != m_ctrl_instances.end(); ++i)
- {
- if((*i).m_selectable.isSelected())
- {
- (*i).snapto(snap);
- }
- }
- m_patch.controlPointsChanged();
- }
- }
+ void InvertMatrix();
- void evaluateTransform()
- {
- Matrix4 matrix(m_transform.calculateTransform());
+ void TransposeMatrix();
- if(m_transform.getType() == TRANSFORM_PRIMITIVE)
- {
- m_patch.transform(matrix);
- }
- else
- {
- transformComponents(matrix);
- }
- }
- void applyTransform()
- {
- m_patch.revertTransform();
- evaluateTransform();
- m_patch.freezeTransform();
- }
- typedef MemberCaller<PatchInstance, &PatchInstance::applyTransform> ApplyTransformCaller;
+ void Redisperse(EMatrixMajor mt);
+ void Smooth(EMatrixMajor mt);
- bool testLight(const RendererLight& light) const
- {
- return light.testAABB(worldAABB());
- }
-};
+ void InsertRemove(bool bInsert, bool bColumn, bool bFirst);
+ Patch *MakeCap(Patch *patch, EPatchCap eType, EMatrixMajor mt, bool bFirst);
-template<typename TokenImporter, typename TokenExporter>
-class PatchNode :
- public scene::Node::Symbiot,
- public scene::Instantiable,
- public scene::Cloneable
-{
- typedef PatchNode<TokenImporter, TokenExporter> Self;
+ void ConstructSeam(EPatchCap eType, Vector3 *p, std::size_t width);
- class TypeCasts
- {
- InstanceTypeCastTable m_casts;
- public:
- TypeCasts()
- {
- NodeStaticCast<PatchNode, scene::Instantiable>::install(m_casts);
- NodeStaticCast<PatchNode, scene::Cloneable>::install(m_casts);
- NodeContainedCast<PatchNode, Snappable>::install(m_casts);
- NodeContainedCast<PatchNode, TransformNode>::install(m_casts);
- NodeContainedCast<PatchNode, Patch>::install(m_casts);
- NodeContainedCast<PatchNode, XMLImporter>::install(m_casts);
- NodeContainedCast<PatchNode, XMLExporter>::install(m_casts);
- NodeContainedCast<PatchNode, MapImporter>::install(m_casts);
- NodeContainedCast<PatchNode, MapExporter>::install(m_casts);
- NodeContainedCast<PatchNode, Nameable>::install(m_casts);
- }
- InstanceTypeCastTable& get()
- {
- return m_casts;
- }
- };
+ void FlipTexture(int nAxis);
+ void TranslateTexture(float s, float t);
- scene::Node m_node;
- InstanceSet m_instances;
- Patch m_patch;
- TokenImporter m_importMap;
- TokenExporter m_exportMap;
+ void ScaleTexture(float s, float t);
-public:
+ void RotateTexture(float angle);
- typedef LazyStatic<TypeCasts> StaticTypeCasts;
-
- Snappable& get(NullType<Snappable>)
- {
- return m_patch;
- }
- TransformNode& get(NullType<TransformNode>)
- {
- return m_patch;
- }
- Patch& get(NullType<Patch>)
- {
- return m_patch;
- }
- XMLImporter& get(NullType<XMLImporter>)
- {
- return m_patch;
- }
- XMLExporter& get(NullType<XMLExporter>)
- {
- return m_patch;
- }
- MapImporter& get(NullType<MapImporter>)
- {
- return m_importMap;
- }
- MapExporter& get(NullType<MapExporter>)
- {
- return m_exportMap;
- }
- Nameable& get(NullType<Nameable>)
- {
- return m_patch;
- }
-
- PatchNode(bool patchDef3 = false) :
- m_node(this, this, StaticTypeCasts::instance().get()),
- m_patch(m_node, InstanceSetEvaluateTransform<PatchInstance>::Caller(m_instances), InstanceSet::BoundsChangedCaller(m_instances)),
- m_importMap(m_patch),
- m_exportMap(m_patch)
- {
- m_patch.m_patchDef3 = patchDef3;
- }
- PatchNode(const PatchNode& other) :
- scene::Node::Symbiot(other),
- scene::Instantiable(other),
- scene::Cloneable(other),
- m_node(this, this, StaticTypeCasts::instance().get()),
- m_patch(other.m_patch, m_node, InstanceSetEvaluateTransform<PatchInstance>::Caller(m_instances), InstanceSet::BoundsChangedCaller(m_instances)),
- m_importMap(m_patch),
- m_exportMap(m_patch)
- {
- }
- void release()
- {
- delete this;
- }
- scene::Node& node()
- {
- return m_node;
- }
- Patch& get()
- {
- return m_patch;
- }
- const Patch& get() const
- {
- return m_patch;
- }
-
- scene::Node& clone() const
- {
- return (new PatchNode(*this))->node();
- }
-
- scene::Instance* create(const scene::Path& path, scene::Instance* parent)
- {
- return new PatchInstance(path, parent, m_patch);
- }
- void forEachInstance(const scene::Instantiable::Visitor& visitor)
- {
- m_instances.forEachInstance(visitor);
- }
- void insert(scene::Instantiable::Observer* observer, const scene::Path& path, scene::Instance* instance)
- {
- m_instances.insert(observer, path, instance);
- }
- scene::Instance* erase(scene::Instantiable::Observer* observer, const scene::Path& path)
- {
- return m_instances.erase(observer, path);
- }
-};
+ void SetTextureRepeat(float s, float t); // call with s=1 t=1 for FIT
+ void CapTexture();
+ void NaturalTexture();
+
+ void ProjectTexture(int nAxis);
+
+ void undoSave()
+ {
+ if (m_map != 0) {
+ m_map->changed();
+ }
+ if (m_undoable_observer != 0) {
+ m_undoable_observer->save(this);
+ }
+ }
+
+ UndoMemento *exportState() const
+ {
+ return new SavedState(m_width, m_height, m_ctrl, m_shader.c_str(), m_patchDef3, m_subdivisions_x,
+ m_subdivisions_y);
+ }
+
+ void importState(const UndoMemento *state)
+ {
+ undoSave();
+
+ const SavedState &other = *(static_cast<const SavedState *>( state ));
+
+ // begin duplicate of SavedState copy constructor, needs refactoring
+
+ // copy construct
+ {
+ m_width = other.m_width;
+ m_height = other.m_height;
+ SetShader(other.m_shader.c_str());
+ m_ctrl = other.m_ctrl;
+ onAllocate(m_ctrl.size());
+ m_patchDef3 = other.m_patchDef3;
+ m_subdivisions_x = other.m_subdivisions_x;
+ m_subdivisions_y = other.m_subdivisions_y;
+ }
+
+ // end duplicate code
+
+ Patch_textureChanged();
+
+ controlPointsChanged();
+ }
+
+ static void constructStatic(EPatchType type)
+ {
+ Patch::m_type = type;
+ Patch::m_state_ctrl = GlobalShaderCache().capture("$POINT");
+ Patch::m_state_lattice = GlobalShaderCache().capture("$LATTICE");
+ }
+
+ static void destroyStatic()
+ {
+ GlobalShaderCache().release("$LATTICE");
+ GlobalShaderCache().release("$POINT");
+ }
+
+private:
+ void captureShader()
+ {
+ m_state = GlobalShaderCache().capture(m_shader.c_str());
+ }
+
+ void releaseShader()
+ {
+ GlobalShaderCache().release(m_shader.c_str());
+ }
+
+ void check_shader()
+ {
+ if (!shader_valid(GetShader())) {
+ globalErrorStream() << "patch has invalid texture name: '" << GetShader() << "'\n";
+ }
+ }
+
+ void InsertPoints(EMatrixMajor mt, bool bFirst);
+
+ void RemovePoints(EMatrixMajor mt, bool bFirst);
+
+ void AccumulateBBox();
+
+ void TesselateSubMatrixFixed(ArbitraryMeshVertex *vertices, std::size_t strideX, std::size_t strideY,
+ unsigned int nFlagsX, unsigned int nFlagsY, PatchControl *subMatrix[3][3]);
+
+// uses binary trees representing bezier curves to recursively tesselate a bezier sub-patch
+ void TesselateSubMatrix(const BezierCurveTree *BX, const BezierCurveTree *BY,
+ std::size_t offStartX, std::size_t offStartY,
+ std::size_t offEndX, std::size_t offEndY,
+ std::size_t nFlagsX, std::size_t nFlagsY,
+ Vector3 &left, Vector3 &mid, Vector3 &right,
+ Vector2 &texLeft, Vector2 &texMid, Vector2 &texRight,
+ bool bTranspose);
+
+// tesselates the entire surface
+ void BuildTesselationCurves(EMatrixMajor major);
+
+ void accumulateVertexTangentSpace(std::size_t index, Vector3 tangentX[6], Vector3 tangentY[6], Vector2 tangentS[6],
+ Vector2 tangentT[6], std::size_t index0, std::size_t index1);
+
+ void BuildVertexArray();
+};
+
+inline bool Patch_importHeader(Patch &patch, Tokeniser &tokeniser)
+{
+ tokeniser.nextLine();
+ RETURN_FALSE_IF_FAIL(Tokeniser_parseToken(tokeniser, "{"));
+ return true;
+}
+
+inline bool Patch_importShader(Patch &patch, Tokeniser &tokeniser)
+{
+ // parse shader name
+ tokeniser.nextLine();
+ const char *texture = tokeniser.getToken();
+ if (texture == 0) {
+ Tokeniser_unexpectedError(tokeniser, texture, "#texture-name");
+ return false;
+ }
+ if (string_equal(texture, "NULL")) {
+ patch.SetShader(texdef_name_default());
+ } else {
+ StringOutputStream shader(string_length(GlobalTexturePrefix_get()) + string_length(texture));
+ shader << GlobalTexturePrefix_get() << texture;
+ patch.SetShader(shader.c_str());
+ }
+ return true;
+}
+
+inline bool PatchDoom3_importShader(Patch &patch, Tokeniser &tokeniser)
+{
+ // parse shader name
+ tokeniser.nextLine();
+ const char *shader = tokeniser.getToken();
+ if (shader == 0) {
+ Tokeniser_unexpectedError(tokeniser, shader, "#shader-name");
+ return false;
+ }
+ if (string_equal(shader, "_emptyname")) {
+ shader = texdef_name_default();
+ }
+ patch.SetShader(shader);
+ return true;
+}
+
+inline bool Patch_importParams(Patch &patch, Tokeniser &tokeniser)
+{
+ tokeniser.nextLine();
+ RETURN_FALSE_IF_FAIL(Tokeniser_parseToken(tokeniser, "("));
+
+ // parse matrix dimensions
+ {
+ std::size_t c, r;
+ RETURN_FALSE_IF_FAIL(Tokeniser_getSize(tokeniser, c));
+ RETURN_FALSE_IF_FAIL(Tokeniser_getSize(tokeniser, r));
+
+ patch.setDims(c, r);
+ }
+
+ if (patch.m_patchDef3) {
+ RETURN_FALSE_IF_FAIL(Tokeniser_getSize(tokeniser, patch.m_subdivisions_x));
+ RETURN_FALSE_IF_FAIL(Tokeniser_getSize(tokeniser, patch.m_subdivisions_y));
+ }
+
+ // ignore contents/flags/value
+ int tmp;
+ RETURN_FALSE_IF_FAIL(Tokeniser_getInteger(tokeniser, tmp));
+ RETURN_FALSE_IF_FAIL(Tokeniser_getInteger(tokeniser, tmp));
+ RETURN_FALSE_IF_FAIL(Tokeniser_getInteger(tokeniser, tmp));
+
+ RETURN_FALSE_IF_FAIL(Tokeniser_parseToken(tokeniser, ")"));
+ return true;
+}
+
+inline bool Patch_importMatrix(Patch &patch, Tokeniser &tokeniser)
+{
+ // parse matrix
+ tokeniser.nextLine();
+ RETURN_FALSE_IF_FAIL(Tokeniser_parseToken(tokeniser, "("));
+ {
+ for (std::size_t c = 0; c < patch.getWidth(); c++) {
+ tokeniser.nextLine();
+ RETURN_FALSE_IF_FAIL(Tokeniser_parseToken(tokeniser, "("));
+ for (std::size_t r = 0; r < patch.getHeight(); r++) {
+ RETURN_FALSE_IF_FAIL(Tokeniser_parseToken(tokeniser, "("));
+
+ RETURN_FALSE_IF_FAIL(Tokeniser_getFloat(tokeniser, patch.ctrlAt(r, c).m_vertex[0]));
+ RETURN_FALSE_IF_FAIL(Tokeniser_getFloat(tokeniser, patch.ctrlAt(r, c).m_vertex[1]));
+ RETURN_FALSE_IF_FAIL(Tokeniser_getFloat(tokeniser, patch.ctrlAt(r, c).m_vertex[2]));
+ RETURN_FALSE_IF_FAIL(Tokeniser_getFloat(tokeniser, patch.ctrlAt(r, c).m_texcoord[0]));
+ RETURN_FALSE_IF_FAIL(Tokeniser_getFloat(tokeniser, patch.ctrlAt(r, c).m_texcoord[1]));
+
+ RETURN_FALSE_IF_FAIL(Tokeniser_parseToken(tokeniser, ")"));
+ }
+ RETURN_FALSE_IF_FAIL(Tokeniser_parseToken(tokeniser, ")"));
+ }
+ }
+ tokeniser.nextLine();
+ RETURN_FALSE_IF_FAIL(Tokeniser_parseToken(tokeniser, ")"));
+ return true;
+}
+
+inline bool Patch_importFooter(Patch &patch, Tokeniser &tokeniser)
+{
+ patch.controlPointsChanged();
+
+ tokeniser.nextLine();
+ RETURN_FALSE_IF_FAIL(Tokeniser_parseToken(tokeniser, "}"));
+
+ tokeniser.nextLine();
+ RETURN_FALSE_IF_FAIL(Tokeniser_parseToken(tokeniser, "}"));
+ return true;
+}
+
+class PatchTokenImporter : public MapImporter {
+ Patch &m_patch;
+public:
+ PatchTokenImporter(Patch &patch) : m_patch(patch)
+ {
+ }
+
+ bool importTokens(Tokeniser &tokeniser)
+ {
+ RETURN_FALSE_IF_FAIL(Patch_importHeader(m_patch, tokeniser));
+ RETURN_FALSE_IF_FAIL(Patch_importShader(m_patch, tokeniser));
+ RETURN_FALSE_IF_FAIL(Patch_importParams(m_patch, tokeniser));
+ RETURN_FALSE_IF_FAIL(Patch_importMatrix(m_patch, tokeniser));
+ RETURN_FALSE_IF_FAIL(Patch_importFooter(m_patch, tokeniser));
+
+ return true;
+ }
+};
+
+class PatchDoom3TokenImporter : public MapImporter {
+ Patch &m_patch;
+public:
+ PatchDoom3TokenImporter(Patch &patch) : m_patch(patch)
+ {
+ }
+
+ bool importTokens(Tokeniser &tokeniser)
+ {
+ RETURN_FALSE_IF_FAIL(Patch_importHeader(m_patch, tokeniser));
+ RETURN_FALSE_IF_FAIL(PatchDoom3_importShader(m_patch, tokeniser));
+ RETURN_FALSE_IF_FAIL(Patch_importParams(m_patch, tokeniser));
+ RETURN_FALSE_IF_FAIL(Patch_importMatrix(m_patch, tokeniser));
+ RETURN_FALSE_IF_FAIL(Patch_importFooter(m_patch, tokeniser));
+
+ return true;
+ }
+};
+
+inline void Patch_exportHeader(const Patch &patch, TokenWriter &writer)
+{
+ writer.writeToken("{");
+ writer.nextLine();
+ writer.writeToken(patch.m_patchDef3 ? "patchDef3" : "patchDef2");
+ writer.nextLine();
+ writer.writeToken("{");
+ writer.nextLine();
+}
+
+inline void Patch_exportShader(const Patch &patch, TokenWriter &writer)
+{
+ // write shader name
+ if (*(shader_get_textureName(patch.GetShader())) == '\0') {
+ writer.writeToken("NULL");
+ } else {
+ writer.writeToken(shader_get_textureName(patch.GetShader()));
+ }
+ writer.nextLine();
+}
+
+inline void PatchDoom3_exportShader(const Patch &patch, TokenWriter &writer)
+{
+ // write shader name
+ if (*(shader_get_textureName(patch.GetShader())) == '\0') {
+ writer.writeString("_emptyname");
+ } else {
+ writer.writeString(patch.GetShader());
+ }
+ writer.nextLine();
+}
+
+inline void Patch_exportParams(const Patch &patch, TokenWriter &writer)
+{
+ // write matrix dimensions
+ writer.writeToken("(");
+ writer.writeUnsigned(patch.getWidth());
+ writer.writeUnsigned(patch.getHeight());
+ if (patch.m_patchDef3) {
+ writer.writeUnsigned(patch.m_subdivisions_x);
+ writer.writeUnsigned(patch.m_subdivisions_y);
+ }
+ writer.writeInteger(0);
+ writer.writeInteger(0);
+ writer.writeInteger(0);
+ writer.writeToken(")");
+ writer.nextLine();
+}
+
+inline void Patch_exportMatrix(const Patch &patch, TokenWriter &writer)
+{
+ // write matrix
+ writer.writeToken("(");
+ writer.nextLine();
+ for (std::size_t c = 0; c < patch.getWidth(); c++) {
+ writer.writeToken("(");
+ for (std::size_t r = 0; r < patch.getHeight(); r++) {
+ writer.writeToken("(");
+
+ writer.writeFloat(patch.ctrlAt(r, c).m_vertex[0]);
+ writer.writeFloat(patch.ctrlAt(r, c).m_vertex[1]);
+ writer.writeFloat(patch.ctrlAt(r, c).m_vertex[2]);
+ writer.writeFloat(patch.ctrlAt(r, c).m_texcoord[0]);
+ writer.writeFloat(patch.ctrlAt(r, c).m_texcoord[1]);
+
+ writer.writeToken(")");
+ }
+ writer.writeToken(")");
+ writer.nextLine();
+ }
+ writer.writeToken(")");
+ writer.nextLine();
+}
+
+inline void Patch_exportFooter(const Patch &patch, TokenWriter &writer)
+{
+ writer.writeToken("}");
+ writer.nextLine();
+ writer.writeToken("}");
+ writer.nextLine();
+}
+
+class PatchTokenExporter : public MapExporter {
+ const Patch &m_patch;
+public:
+ PatchTokenExporter(Patch &patch) : m_patch(patch)
+ {
+ }
+
+ void exportTokens(TokenWriter &writer) const
+ {
+ Patch_exportHeader(m_patch, writer);
+ Patch_exportShader(m_patch, writer);
+ Patch_exportParams(m_patch, writer);
+ Patch_exportMatrix(m_patch, writer);
+ Patch_exportFooter(m_patch, writer);
+ }
+};
+
+class PatchDoom3TokenExporter : public MapExporter {
+ const Patch &m_patch;
+public:
+ PatchDoom3TokenExporter(Patch &patch) : m_patch(patch)
+ {
+ }
+
+ void exportTokens(TokenWriter &writer) const
+ {
+ Patch_exportHeader(m_patch, writer);
+ PatchDoom3_exportShader(m_patch, writer);
+ Patch_exportParams(m_patch, writer);
+ Patch_exportMatrix(m_patch, writer);
+ Patch_exportFooter(m_patch, writer);
+ }
+};
+
+class PatchControlInstance {
+public:
+ PatchControl *m_ctrl;
+ ObservedSelectable m_selectable;
+
+ PatchControlInstance(PatchControl *ctrl, const SelectionChangeCallback &observer)
+ : m_ctrl(ctrl), m_selectable(observer)
+ {
+ }
+
+ void testSelect(Selector &selector, SelectionTest &test)
+ {
+ SelectionIntersection best;
+ test.TestPoint(m_ctrl->m_vertex, best);
+ if (best.valid()) {
+ Selector_add(selector, m_selectable, best);
+ }
+ }
+
+ void snapto(float snap)
+ {
+ vector3_snap(m_ctrl->m_vertex, snap);
+ }
+};
+
+
+class PatchInstance :
+ public Patch::Observer,
+ public scene::Instance,
+ public Selectable,
+ public Renderable,
+ public SelectionTestable,
+ public ComponentSelectionTestable,
+ public ComponentEditable,
+ public ComponentSnappable,
+ public PlaneSelectable,
+ public LightCullable {
+ class TypeCasts {
+ InstanceTypeCastTable m_casts;
+ public:
+ TypeCasts()
+ {
+ InstanceStaticCast<PatchInstance, Selectable>::install(m_casts);
+ InstanceContainedCast<PatchInstance, Bounded>::install(m_casts);
+ InstanceContainedCast<PatchInstance, Cullable>::install(m_casts);
+ InstanceStaticCast<PatchInstance, Renderable>::install(m_casts);
+ InstanceStaticCast<PatchInstance, SelectionTestable>::install(m_casts);
+ InstanceStaticCast<PatchInstance, ComponentSelectionTestable>::install(m_casts);
+ InstanceStaticCast<PatchInstance, ComponentEditable>::install(m_casts);
+ InstanceStaticCast<PatchInstance, ComponentSnappable>::install(m_casts);
+ InstanceStaticCast<PatchInstance, PlaneSelectable>::install(m_casts);
+ InstanceIdentityCast<PatchInstance>::install(m_casts);
+ InstanceContainedCast<PatchInstance, Transformable>::install(m_casts);
+ }
+
+ InstanceTypeCastTable &get()
+ {
+ return m_casts;
+ }
+ };
+
+
+ Patch &m_patch;
+ typedef std::vector<PatchControlInstance> PatchControlInstances;
+ PatchControlInstances m_ctrl_instances;
+
+ ObservedSelectable m_selectable;
+
+ DragPlanes m_dragPlanes;
+
+ mutable RenderablePointVector m_render_selected;
+ mutable AABB m_aabb_component;
+
+ static Shader *m_state_selpoint;
+
+ const LightList *m_lightList;
+
+ TransformModifier m_transform;
+public:
+
+ typedef LazyStatic<TypeCasts> StaticTypeCasts;
+
+ void lightsChanged()
+ {
+ m_lightList->lightsChanged();
+ }
+
+ typedef MemberCaller<PatchInstance, void(), &PatchInstance::lightsChanged> LightsChangedCaller;
+
+ STRING_CONSTANT(Name, "PatchInstance");
+
+ PatchInstance(const scene::Path &path, scene::Instance *parent, Patch &patch) :
+ Instance(path, parent, this, StaticTypeCasts::instance().get()),
+ m_patch(patch),
+ m_selectable(SelectedChangedCaller(*this)),
+ m_dragPlanes(SelectedChangedComponentCaller(*this)),
+ m_render_selected(GL_POINTS),
+ m_transform(Patch::TransformChangedCaller(m_patch), ApplyTransformCaller(*this))
+ {
+ m_patch.instanceAttach(Instance::path());
+ m_patch.attach(this);
+
+ m_lightList = &GlobalShaderCache().attach(*this);
+ m_patch.m_lightsChanged = LightsChangedCaller(*this);
+
+ Instance::setTransformChangedCallback(LightsChangedCaller(*this));
+ }
+
+ ~PatchInstance()
+ {
+ Instance::setTransformChangedCallback(Callback<void()>());
+
+ m_patch.m_lightsChanged = Callback<void()>();
+ GlobalShaderCache().detach(*this);
+
+ m_patch.detach(this);
+ m_patch.instanceDetach(Instance::path());
+ }
+
+ void selectedChanged(const Selectable &selectable)
+ {
+ GlobalSelectionSystem().getObserver(SelectionSystem::ePrimitive)(selectable);
+ GlobalSelectionSystem().onSelectedChanged(*this, selectable);
+
+ Instance::selectedChanged();
+ }
+
+ typedef MemberCaller<PatchInstance, void(
+ const Selectable &), &PatchInstance::selectedChanged> SelectedChangedCaller;
+
+ void selectedChangedComponent(const Selectable &selectable)
+ {
+ GlobalSelectionSystem().getObserver(SelectionSystem::eComponent)(selectable);
+ GlobalSelectionSystem().onComponentSelection(*this, selectable);
+ }
+
+ typedef MemberCaller<PatchInstance, void(
+ const Selectable &), &PatchInstance::selectedChangedComponent> SelectedChangedComponentCaller;
+
+ Patch &getPatch()
+ {
+ return m_patch;
+ }
+
+ Bounded &get(NullType<Bounded>)
+ {
+ return m_patch;
+ }
+
+ Cullable &get(NullType<Cullable>)
+ {
+ return m_patch;
+ }
+
+ Transformable &get(NullType<Transformable>)
+ {
+ return m_transform;
+ }
+
+ static void constructStatic()
+ {
+ m_state_selpoint = GlobalShaderCache().capture("$SELPOINT");
+ }
+
+ static void destroyStatic()
+ {
+ GlobalShaderCache().release("$SELPOINT");
+ }
+
+
+ void allocate(std::size_t size)
+ {
+ m_ctrl_instances.clear();
+ m_ctrl_instances.reserve(size);
+ for (Patch::iterator i = m_patch.begin(); i != m_patch.end(); ++i) {
+ m_ctrl_instances.push_back(PatchControlInstance(&(*i), SelectedChangedComponentCaller(*this)));
+ }
+ }
+
+ void setSelected(bool select)
+ {
+ m_selectable.setSelected(select);
+ }
+
+ bool isSelected() const
+ {
+ return m_selectable.isSelected();
+ }
+
+
+ void update_selected() const
+ {
+ m_render_selected.clear();
+ Patch::iterator ctrl = m_patch.getControlPointsTransformed().begin();
+ for (PatchControlInstances::const_iterator i = m_ctrl_instances.begin();
+ i != m_ctrl_instances.end(); ++i, ++ctrl) {
+ if ((*i).m_selectable.isSelected()) {
+ const Colour4b colour_selected(0, 0, 255, 255);
+ m_render_selected.push_back(
+ PointVertex(reinterpret_cast<Vertex3f &>((*ctrl).m_vertex ), colour_selected));
+ }
+ }
+ }
+
+#if 0
+ void render( Renderer& renderer, const VolumeTest& volume ) const {
+ if ( GlobalSelectionSystem().Mode() == SelectionSystem::eComponent
+ && m_selectable.isSelected() ) {
+ renderer.Highlight( Renderer::eFace, false );
+
+ m_patch.render( renderer, volume, localToWorld() );
+
+ if ( GlobalSelectionSystem().ComponentMode() == SelectionSystem::eVertex ) {
+ renderer.Highlight( Renderer::ePrimitive, false );
+
+ m_patch.render_component( renderer, volume, localToWorld() );
+
+ renderComponentsSelected( renderer, volume );
+ }
+ }
+ else{
+ m_patch.render( renderer, volume, localToWorld() );
+ }
+}
+#endif
+
+ void renderSolid(Renderer &renderer, const VolumeTest &volume) const
+ {
+ m_patch.evaluateTransform();
+ renderer.setLights(*m_lightList);
+ m_patch.render_solid(renderer, volume, localToWorld());
+
+ renderComponentsSelected(renderer, volume);
+ }
+
+ void renderWireframe(Renderer &renderer, const VolumeTest &volume) const
+ {
+ m_patch.evaluateTransform();
+ m_patch.render_wireframe(renderer, volume, localToWorld());
+
+ renderComponentsSelected(renderer, volume);
+ }
+
+ void renderComponentsSelected(Renderer &renderer, const VolumeTest &volume) const
+ {
+ m_patch.evaluateTransform();
+ update_selected();
+ if (!m_render_selected.empty()) {
+ renderer.Highlight(Renderer::ePrimitive, false);
+ renderer.SetState(m_state_selpoint, Renderer::eWireframeOnly);
+ renderer.SetState(m_state_selpoint, Renderer::eFullMaterials);
+ renderer.addRenderable(m_render_selected, localToWorld());
+ }
+ }
+
+ void renderComponents(Renderer &renderer, const VolumeTest &volume) const
+ {
+ m_patch.evaluateTransform();
+ if (GlobalSelectionSystem().ComponentMode() == SelectionSystem::eVertex) {
+ m_patch.render_component(renderer, volume, localToWorld());
+ }
+ }
+
+ void testSelect(Selector &selector, SelectionTest &test)
+ {
+ test.BeginMesh(localToWorld(), true);
+ m_patch.testSelect(selector, test);
+ }
+
+ void selectCtrl(bool select)
+ {
+ for (PatchControlInstances::iterator i = m_ctrl_instances.begin(); i != m_ctrl_instances.end(); ++i) {
+ (*i).m_selectable.setSelected(select);
+ }
+ }
+
+ bool isSelectedComponents() const
+ {
+ for (PatchControlInstances::const_iterator i = m_ctrl_instances.begin(); i != m_ctrl_instances.end(); ++i) {
+ if ((*i).m_selectable.isSelected()) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ void setSelectedComponents(bool select, SelectionSystem::EComponentMode mode)
+ {
+ if (mode == SelectionSystem::eVertex) {
+ selectCtrl(select);
+ } else if (mode == SelectionSystem::eFace) {
+ m_dragPlanes.setSelected(select);
+ }
+ }
+
+ const AABB &getSelectedComponentsBounds() const
+ {
+ m_aabb_component = AABB();
+
+ for (PatchControlInstances::const_iterator i = m_ctrl_instances.begin(); i != m_ctrl_instances.end(); ++i) {
+ if ((*i).m_selectable.isSelected()) {
+ aabb_extend_by_point_safe(m_aabb_component, (*i).m_ctrl->m_vertex);
+ }
+ }
+
+ return m_aabb_component;
+ }
+
+ void testSelectComponents(Selector &selector, SelectionTest &test, SelectionSystem::EComponentMode mode)
+ {
+ test.BeginMesh(localToWorld());
+
+ switch (mode) {
+ case SelectionSystem::eVertex: {
+ for (PatchControlInstances::iterator i = m_ctrl_instances.begin(); i != m_ctrl_instances.end(); ++i) {
+ (*i).testSelect(selector, test);
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ }
+
+ bool selectedVertices()
+ {
+ for (PatchControlInstances::iterator i = m_ctrl_instances.begin(); i != m_ctrl_instances.end(); ++i) {
+ if ((*i).m_selectable.isSelected()) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ void transformComponents(const Matrix4 &matrix)
+ {
+ if (selectedVertices()) {
+ PatchControlIter ctrl = m_patch.getControlPointsTransformed().begin();
+ for (PatchControlInstances::iterator i = m_ctrl_instances.begin();
+ i != m_ctrl_instances.end(); ++i, ++ctrl) {
+ if ((*i).m_selectable.isSelected()) {
+ matrix4_transform_point(matrix, (*ctrl).m_vertex);
+ }
+ }
+ m_patch.UpdateCachedData();
+ }
+
+ if (m_dragPlanes.isSelected()) { // this should only be true when the transform is a pure translation.
+ m_patch.transform(m_dragPlanes.evaluateTransform(vector4_to_vector3(matrix.t())));
+ }
+ }
+
+
+ void selectPlanes(Selector &selector, SelectionTest &test, const PlaneCallback &selectedPlaneCallback)
+ {
+ test.BeginMesh(localToWorld());
+
+ m_dragPlanes.selectPlanes(m_patch.localAABB(), selector, test, selectedPlaneCallback);
+ }
+
+ void selectReversedPlanes(Selector &selector, const SelectedPlanes &selectedPlanes)
+ {
+ m_dragPlanes.selectReversedPlanes(m_patch.localAABB(), selector, selectedPlanes);
+ }
+
+
+ void snapComponents(float snap)
+ {
+ if (selectedVertices()) {
+ m_patch.undoSave();
+ for (PatchControlInstances::iterator i = m_ctrl_instances.begin(); i != m_ctrl_instances.end(); ++i) {
+ if ((*i).m_selectable.isSelected()) {
+ (*i).snapto(snap);
+ }
+ }
+ m_patch.controlPointsChanged();
+ }
+ }
+
+ void evaluateTransform()
+ {
+ Matrix4 matrix(m_transform.calculateTransform());
+
+ if (m_transform.getType() == TRANSFORM_PRIMITIVE) {
+ m_patch.transform(matrix);
+ } else {
+ transformComponents(matrix);
+ }
+ }
+
+ void applyTransform()
+ {
+ m_patch.revertTransform();
+ evaluateTransform();
+ m_patch.freezeTransform();
+ }
+
+ typedef MemberCaller<PatchInstance, void(), &PatchInstance::applyTransform> ApplyTransformCaller;
+
+
+ bool testLight(const RendererLight &light) const
+ {
+ return light.testAABB(worldAABB());
+ }
+};
+
+
+template<typename TokenImporter, typename TokenExporter>
+class PatchNode :
+ public scene::Node::Symbiot,
+ public scene::Instantiable,
+ public scene::Cloneable {
+ typedef PatchNode<TokenImporter, TokenExporter> Self;
+
+ class TypeCasts {
+ InstanceTypeCastTable m_casts;
+ public:
+ TypeCasts()
+ {
+ NodeStaticCast<PatchNode, scene::Instantiable>::install(m_casts);
+ NodeStaticCast<PatchNode, scene::Cloneable>::install(m_casts);
+ NodeContainedCast<PatchNode, Snappable>::install(m_casts);
+ NodeContainedCast<PatchNode, TransformNode>::install(m_casts);
+ NodeContainedCast<PatchNode, Patch>::install(m_casts);
+ NodeContainedCast<PatchNode, XMLImporter>::install(m_casts);
+ NodeContainedCast<PatchNode, XMLExporter>::install(m_casts);
+ NodeContainedCast<PatchNode, MapImporter>::install(m_casts);
+ NodeContainedCast<PatchNode, MapExporter>::install(m_casts);
+ NodeContainedCast<PatchNode, Nameable>::install(m_casts);
+ }
+
+ InstanceTypeCastTable &get()
+ {
+ return m_casts;
+ }
+ };
+
+
+ scene::Node m_node;
+ InstanceSet m_instances;
+ Patch m_patch;
+ TokenImporter m_importMap;
+ TokenExporter m_exportMap;
+
+public:
+
+ typedef LazyStatic<TypeCasts> StaticTypeCasts;
+
+ Snappable &get(NullType<Snappable>)
+ {
+ return m_patch;
+ }
+
+ TransformNode &get(NullType<TransformNode>)
+ {
+ return m_patch;
+ }
+
+ Patch &get(NullType<Patch>)
+ {
+ return m_patch;
+ }
+
+ XMLImporter &get(NullType<XMLImporter>)
+ {
+ return m_patch;
+ }
+
+ XMLExporter &get(NullType<XMLExporter>)
+ {
+ return m_patch;
+ }
+
+ MapImporter &get(NullType<MapImporter>)
+ {
+ return m_importMap;
+ }
+
+ MapExporter &get(NullType<MapExporter>)
+ {
+ return m_exportMap;
+ }
+
+ Nameable &get(NullType<Nameable>)
+ {
+ return m_patch;
+ }
+
+ PatchNode(bool patchDef3 = false) :
+ m_node(this, this, StaticTypeCasts::instance().get()),
+ m_patch(m_node, InstanceSetEvaluateTransform<PatchInstance>::Caller(m_instances),
+ InstanceSet::BoundsChangedCaller(m_instances)),
+ m_importMap(m_patch),
+ m_exportMap(m_patch)
+ {
+ m_patch.m_patchDef3 = patchDef3;
+ }
+
+ PatchNode(const PatchNode &other) :
+ scene::Node::Symbiot(other),
+ scene::Instantiable(other),
+ scene::Cloneable(other),
+ m_node(this, this, StaticTypeCasts::instance().get()),
+ m_patch(other.m_patch, m_node, InstanceSetEvaluateTransform<PatchInstance>::Caller(m_instances),
+ InstanceSet::BoundsChangedCaller(m_instances)),
+ m_importMap(m_patch),
+ m_exportMap(m_patch)
+ {
+ }
+
+ void release()
+ {
+ delete this;
+ }
+
+ scene::Node &node()
+ {
+ return m_node;
+ }
+
+ Patch &get()
+ {
+ return m_patch;
+ }
+
+ const Patch &get() const
+ {
+ return m_patch;
+ }
+
+ scene::Node &clone() const
+ {
+ return (new PatchNode(*this))->node();
+ }
+
+ scene::Instance *create(const scene::Path &path, scene::Instance *parent)
+ {
+ return new PatchInstance(path, parent, m_patch);
+ }
+
+ void forEachInstance(const scene::Instantiable::Visitor &visitor)
+ {
+ m_instances.forEachInstance(visitor);
+ }
+
+ void insert(scene::Instantiable::Observer *observer, const scene::Path &path, scene::Instance *instance)
+ {
+ m_instances.insert(observer, path, instance);
+ }
+
+ scene::Instance *erase(scene::Instantiable::Observer *observer, const scene::Path &path)
+ {
+ return m_instances.erase(observer, path);
+ }
+};
typedef PatchNode<PatchTokenImporter, PatchTokenExporter> PatchNodeQuake3;
typedef PatchNode<PatchDoom3TokenImporter, PatchDoom3TokenExporter> PatchNodeDoom3;
-inline Patch* Node_getPatch(scene::Node& node)
+inline Patch *Node_getPatch(scene::Node &node)
{
- return NodeTypeCast<Patch>::cast(node);
+
return NodeTypeCast<Patch>::cast(node);
}
-inline PatchInstance* Instance_getPatch(scene::Instance& instance)
+inline PatchInstance *Instance_getPatch(scene::Instance &instance)
{
- return InstanceTypeCast<PatchInstance>::cast(instance);
+
return InstanceTypeCast<PatchInstance>::cast(instance);
}
template<typename Functor>
-class PatchSelectedVisitor : public SelectionSystem::Visitor
-{
- const Functor& m_functor;
+class PatchSelectedVisitor : public SelectionSystem::Visitor {
+ const Functor &m_functor;
public:
- PatchSelectedVisitor(const Functor& functor) : m_functor(functor)
- {
- }
- void visit(scene::Instance& instance) const
- {
- PatchInstance* patch = Instance_getPatch(instance);
- if(patch != 0)
+ PatchSelectedVisitor(const Functor &functor) : m_functor(functor)
+ {
+ }
+
+ void visit(scene::Instance &instance) const
{
- m_functor(*patch);
+ PatchInstance *patch = Instance_getPatch(instance);
+ if (patch != 0) {
+ m_functor(*patch);
+ }
}
- }
};
template<typename Functor>
-inline void Scene_forEachSelectedPatch(const Functor& functor)
+inline void Scene_forEachSelectedPatch(const Functor &functor)
{
- GlobalSelectionSystem().foreachSelected(PatchSelectedVisitor<Functor>(functor));
+ GlobalSelectionSystem().foreachSelected(PatchSelectedVisitor<Functor>(functor));
}
template<typename Functor>
-class PatchVisibleSelectedVisitor : public SelectionSystem::Visitor
-{
- const Functor& m_functor;
+class PatchVisibleSelectedVisitor : public SelectionSystem::Visitor {
+ const Functor &m_functor;
public:
- PatchVisibleSelectedVisitor(const Functor& functor) : m_functor(functor)
- {
- }
- void visit(scene::Instance& instance) const
- {
- PatchInstance* patch = Instance_getPatch(instance);
- if(patch != 0
- && instance.path().top().get().visible())
- {
- m_functor(*patch);
- }
- }
+ PatchVisibleSelectedVisitor(const Functor &functor) : m_functor(functor)
+ {
+ }
+
+ void visit(scene::Instance &instance) const
+ {
+ PatchInstance *patch = Instance_getPatch(instance);
+ if (patch != 0
+ && instance.path().top().get().visible()) {
+ m_functor(*patch);
+ }
+ }
};
template<typename Functor>
-inline void Scene_forEachVisibleSelectedPatchInstance(const Functor& functor)
+inline void Scene_forEachVisibleSelectedPatchInstance(const Functor &functor)
{
- GlobalSelectionSystem().foreachSelected(PatchVisibleSelectedVisitor<Functor>(functor));
+ GlobalSelectionSystem().foreachSelected(PatchVisibleSelectedVisitor<Functor>(functor));
}
template<typename Functor>
-class PatchForEachWalker : public scene::Graph::Walker
-{
- const Functor& m_functor;
+class PatchForEachWalker : public scene::Graph::Walker {
+ const Functor &m_functor;
public:
- PatchForEachWalker(const Functor& functor) : m_functor(functor)
- {
- }
- bool pre(const scene::Path& path, scene::Instance& instance) const
- {
- if(path.top().get().visible())
- {
- Patch* patch = Node_getPatch(path.top());
- if(patch != 0)
- {
- m_functor(*patch);
- }
+ PatchForEachWalker(const Functor &functor) : m_functor(functor)
+ {
+ }
+
+ bool pre(const scene::Path &path, scene::Instance &instance) const
+ {
+ if (path.top().get().visible()) {
+ Patch *patch = Node_getPatch(path.top());
+ if (patch != 0) {
+ m_functor(*patch);
+ }
+ }
+ return true;
}
- return true;
- }
};
template<typename Functor>
-inline void Scene_forEachVisiblePatch(const Functor& functor)
+inline void Scene_forEachVisiblePatch(const Functor &functor)
{
- GlobalSceneGraph().traverse(PatchForEachWalker<Functor>(functor));
+ GlobalSceneGraph().traverse(PatchForEachWalker<Functor>(functor));
}
template<typename Functor>
-class PatchForEachSelectedWalker : public scene::Graph::Walker
-{
- const Functor& m_functor;
+class PatchForEachSelectedWalker : public scene::Graph::Walker {
+ const Functor &m_functor;
public:
- PatchForEachSelectedWalker(const Functor& functor) : m_functor(functor)
- {
- }
- bool pre(const scene::Path& path, scene::Instance& instance) const
- {
- if(path.top().get().visible())
- {
- Patch* patch = Node_getPatch(path.top());
- if(patch != 0
- && Instance_getSelectable(instance)->isSelected())
- {
- m_functor(*patch);
- }
+ PatchForEachSelectedWalker(const Functor &functor) : m_functor(functor)
+ {
+ }
+
+ bool pre(const scene::Path &path, scene::Instance &instance) const
+ {
+ if (path.top().get().visible()) {
+ Patch *patch = Node_getPatch(path.top());
+ if (patch != 0
+ && Instance_getSelectable(instance)->isSelected()) {
+ m_functor(*patch);
+ }
+ }
+ return true;
}
- return true;
- }
};
template<typename Functor>
-inline void Scene_forEachVisibleSelectedPatch(const Functor& functor)
+inline void Scene_forEachVisibleSelectedPatch(const Functor &functor)
{
- GlobalSceneGraph().traverse(PatchForEachSelectedWalker<Functor>(functor));
+ GlobalSceneGraph().traverse(PatchForEachSelectedWalker<Functor>(functor));
}
template<typename Functor>
-class PatchForEachInstanceWalker : public scene::Graph::Walker
-{
- const Functor& m_functor;
+class PatchForEachInstanceWalker : public scene::Graph::Walker {
+ const Functor &m_functor;
public:
- PatchForEachInstanceWalker(const Functor& functor) : m_functor(functor)
- {
- }
- bool pre(const scene::Path& path, scene::Instance& instance) const
- {
- if(path.top().get().visible())
- {
- PatchInstance* patch = Instance_getPatch(instance);
- if(patch != 0)
- {
- m_functor(*patch);
- }
+ PatchForEachInstanceWalker(const Functor &functor) : m_functor(functor)
+ {
+ }
+
+ bool pre(const scene::Path &path, scene::Instance &instance) const
+ {
+ if (path.top().get().visible()) {
+ PatchInstance *patch = Instance_getPatch(instance);
+ if (patch != 0) {
+ m_functor(*patch);
+ }
+ }
+ return true;
}
- return true;
- }
};
template<typename Functor>
-inline void Scene_forEachVisiblePatchInstance(const Functor& functor)
+inline void Scene_forEachVisiblePatchInstance(const Functor &functor)
{
- GlobalSceneGraph().traverse(PatchForEachInstanceWalker<Functor>(functor));
+ GlobalSceneGraph().traverse(PatchForEachInstanceWalker<Functor>(functor));
}
#endif
projects / xonotic / netradiant.git / blobdiff