1024 lines
29 KiB
C++
1024 lines
29 KiB
C++
/*
|
|
Copyright (C) 2001-2006, William Joseph.
|
|
All Rights Reserved.
|
|
|
|
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 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
|
|
*/
|
|
|
|
#include "model.h"
|
|
#include "globaldefs.h"
|
|
|
|
#include "picomodel.h"
|
|
|
|
#include "iarchive.h"
|
|
#include "idatastream.h"
|
|
#include "imodel.h"
|
|
#include "modelskin.h"
|
|
|
|
#include "cullable.h"
|
|
#include "renderable.h"
|
|
#include "selectable.h"
|
|
|
|
#include "math/frustum.h"
|
|
#include "string/string.h"
|
|
#include "generic/static.h"
|
|
#include "shaderlib.h"
|
|
#include "scenelib.h"
|
|
#include "instancelib.h"
|
|
#include "transformlib.h"
|
|
#include "traverselib.h"
|
|
#include "render.h"
|
|
|
|
class VectorLightList : public LightList {
|
|
typedef std::vector<const RendererLight *> Lights;
|
|
Lights m_lights;
|
|
public:
|
|
void addLight(const RendererLight &light)
|
|
{
|
|
m_lights.push_back(&light);
|
|
}
|
|
|
|
void clear()
|
|
{
|
|
m_lights.clear();
|
|
}
|
|
|
|
void evaluateLights() const
|
|
{
|
|
}
|
|
|
|
void lightsChanged() const
|
|
{
|
|
}
|
|
|
|
void forEachLight(const RendererLightCallback &callback) const
|
|
{
|
|
for (Lights::const_iterator i = m_lights.begin(); i != m_lights.end(); ++i) {
|
|
callback(*(*i));
|
|
}
|
|
}
|
|
};
|
|
|
|
class PicoSurface :
|
|
public OpenGLRenderable {
|
|
AABB m_aabb_local;
|
|
CopiedString m_shader;
|
|
Shader *m_state;
|
|
|
|
Array<ArbitraryMeshVertex> m_vertices;
|
|
Array<RenderIndex> m_indices;
|
|
|
|
public:
|
|
|
|
PicoSurface()
|
|
{
|
|
constructNull();
|
|
CaptureShader();
|
|
}
|
|
|
|
PicoSurface(picoSurface_t *surface)
|
|
{
|
|
CopyPicoSurface(surface);
|
|
CaptureShader();
|
|
}
|
|
|
|
~PicoSurface()
|
|
{
|
|
ReleaseShader();
|
|
}
|
|
|
|
void render(RenderStateFlags state) const
|
|
{
|
|
if ((state & RENDER_BUMP) != 0) {
|
|
if (GlobalShaderCache().useShaderLanguage()) {
|
|
glNormalPointer(GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_vertices.data()->normal);
|
|
glVertexAttribPointerARB(c_attr_TexCoord0, 2, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex),
|
|
&m_vertices.data()->texcoord);
|
|
glVertexAttribPointerARB(c_attr_Tangent, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex),
|
|
&m_vertices.data()->tangent);
|
|
glVertexAttribPointerARB(c_attr_Binormal, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex),
|
|
&m_vertices.data()->bitangent);
|
|
} else {
|
|
glVertexAttribPointerARB(11, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_vertices.data()->normal);
|
|
glVertexAttribPointerARB(8, 2, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_vertices.data()->texcoord);
|
|
glVertexAttribPointerARB(9, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_vertices.data()->tangent);
|
|
glVertexAttribPointerARB(10, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex),
|
|
&m_vertices.data()->bitangent);
|
|
}
|
|
} else {
|
|
glNormalPointer(GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_vertices.data()->normal);
|
|
glTexCoordPointer(2, GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_vertices.data()->texcoord);
|
|
}
|
|
glVertexPointer(3, GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_vertices.data()->vertex);
|
|
glDrawElements(GL_TRIANGLES, GLsizei(m_indices.size()), RenderIndexTypeID, m_indices.data());
|
|
|
|
#if 0
|
|
GLfloat modelview[16];
|
|
glGetFloatv(GL_MODELVIEW_MATRIX, modelview); // I know this is slow as hell, but hey - we're in _DEBUG
|
|
Matrix4 modelview_inv(
|
|
modelview[0], modelview[1], modelview[2], modelview[3],
|
|
modelview[4], modelview[5], modelview[6], modelview[7],
|
|
modelview[8], modelview[9], modelview[10], modelview[11],
|
|
modelview[12], modelview[13], modelview[14], modelview[15]);
|
|
matrix4_full_invert(modelview_inv);
|
|
Matrix4 modelview_inv_transposed = matrix4_transposed(modelview_inv);
|
|
|
|
glBegin(GL_LINES);
|
|
|
|
for (Array<ArbitraryMeshVertex>::const_iterator i = m_vertices.begin(); i != m_vertices.end(); ++i) {
|
|
Vector3 normal = normal3f_to_vector3((*i).normal);
|
|
normal = matrix4_transformed_direction(modelview_inv, vector3_normalised(
|
|
matrix4_transformed_direction(modelview_inv_transposed, normal))); // do some magic
|
|
Vector3 normalTransformed = vector3_added(vertex3f_to_vector3((*i).vertex), vector3_scaled(normal, 8));
|
|
glVertex3fv(vertex3f_to_array((*i).vertex));
|
|
glVertex3fv(vector3_to_array(normalTransformed));
|
|
}
|
|
glEnd();
|
|
#endif
|
|
}
|
|
|
|
VolumeIntersectionValue intersectVolume(const VolumeTest &test, const Matrix4 &localToWorld) const
|
|
{
|
|
return test.TestAABB(m_aabb_local, localToWorld);
|
|
}
|
|
|
|
const AABB &localAABB() const
|
|
{
|
|
return m_aabb_local;
|
|
}
|
|
|
|
void render(Renderer &renderer, const Matrix4 &localToWorld, Shader *state) const
|
|
{
|
|
renderer.SetState(state, Renderer::eFullMaterials);
|
|
renderer.addRenderable(*this, localToWorld);
|
|
}
|
|
|
|
void render(Renderer &renderer, const Matrix4 &localToWorld) const
|
|
{
|
|
render(renderer, localToWorld, m_state);
|
|
}
|
|
|
|
void testSelect(Selector &selector, SelectionTest &test, const Matrix4 &localToWorld)
|
|
{
|
|
test.BeginMesh(localToWorld);
|
|
|
|
SelectionIntersection best;
|
|
testSelect(test, best);
|
|
if (best.valid()) {
|
|
selector.addIntersection(best);
|
|
}
|
|
}
|
|
|
|
const char *getShader() const
|
|
{
|
|
return m_shader.c_str();
|
|
}
|
|
|
|
Shader *getState() const
|
|
{
|
|
return m_state;
|
|
}
|
|
|
|
private:
|
|
|
|
void CaptureShader()
|
|
{
|
|
m_state = GlobalShaderCache().capture(m_shader.c_str());
|
|
}
|
|
|
|
void ReleaseShader()
|
|
{
|
|
GlobalShaderCache().release(m_shader.c_str());
|
|
}
|
|
|
|
void UpdateAABB()
|
|
{
|
|
m_aabb_local = AABB();
|
|
for (std::size_t i = 0; i < m_vertices.size(); ++i) {
|
|
aabb_extend_by_point_safe(m_aabb_local, reinterpret_cast<const Vector3 &>( m_vertices[i].vertex ));
|
|
}
|
|
|
|
|
|
for (Array<RenderIndex>::iterator i = m_indices.begin(); i != m_indices.end(); i += 3) {
|
|
ArbitraryMeshVertex &a = m_vertices[*(i + 0)];
|
|
ArbitraryMeshVertex &b = m_vertices[*(i + 1)];
|
|
ArbitraryMeshVertex &c = m_vertices[*(i + 2)];
|
|
|
|
ArbitraryMeshTriangle_sumTangents(a, b, c);
|
|
}
|
|
|
|
for (Array<ArbitraryMeshVertex>::iterator i = m_vertices.begin(); i != m_vertices.end(); ++i) {
|
|
vector3_normalise(reinterpret_cast<Vector3 &>((*i).tangent ));
|
|
vector3_normalise(reinterpret_cast<Vector3 &>((*i).bitangent ));
|
|
}
|
|
}
|
|
|
|
void testSelect(SelectionTest &test, SelectionIntersection &best)
|
|
{
|
|
test.TestTriangles(
|
|
VertexPointer(VertexPointer::pointer(&m_vertices.data()->vertex), sizeof(ArbitraryMeshVertex)),
|
|
IndexPointer(m_indices.data(), IndexPointer::index_type(m_indices.size())),
|
|
best
|
|
);
|
|
}
|
|
|
|
void CopyPicoSurface(picoSurface_t *surface)
|
|
{
|
|
picoShader_t *shader = PicoGetSurfaceShader(surface);
|
|
if (shader == 0) {
|
|
m_shader = "";
|
|
} else {
|
|
m_shader = PicoGetShaderName(shader);
|
|
}
|
|
|
|
m_vertices.resize(PicoGetSurfaceNumVertexes(surface));
|
|
m_indices.resize(PicoGetSurfaceNumIndexes(surface));
|
|
|
|
for (std::size_t i = 0; i < m_vertices.size(); ++i) {
|
|
picoVec_t *xyz = PicoGetSurfaceXYZ(surface, int(i));
|
|
m_vertices[i].vertex = vertex3f_from_array(xyz);
|
|
|
|
picoVec_t *normal = PicoGetSurfaceNormal(surface, int(i));
|
|
m_vertices[i].normal = normal3f_from_array(normal);
|
|
|
|
picoVec_t *st = PicoGetSurfaceST(surface, 0, int(i));
|
|
m_vertices[i].texcoord = TexCoord2f(st[0], st[1]);
|
|
|
|
#if 0
|
|
picoVec_t* color = PicoGetSurfaceColor( surface, 0, int(i) );
|
|
m_vertices[i].colour = Colour4b( color[0], color[1], color[2], color[3] );
|
|
#endif
|
|
}
|
|
|
|
picoIndex_t *indexes = PicoGetSurfaceIndexes(surface, 0);
|
|
for (std::size_t j = 0; j < m_indices.size(); ++j) {
|
|
m_indices[j] = indexes[j];
|
|
}
|
|
|
|
UpdateAABB();
|
|
}
|
|
|
|
void constructQuad(std::size_t index, const Vector3 &a, const Vector3 &b, const Vector3 &c, const Vector3 &d,
|
|
const Vector3 &normal)
|
|
{
|
|
m_vertices[index * 4 + 0] = ArbitraryMeshVertex(
|
|
vertex3f_for_vector3(a),
|
|
normal3f_for_vector3(normal),
|
|
texcoord2f_from_array(aabb_texcoord_topleft)
|
|
);
|
|
m_vertices[index * 4 + 1] = ArbitraryMeshVertex(
|
|
vertex3f_for_vector3(b),
|
|
normal3f_for_vector3(normal),
|
|
texcoord2f_from_array(aabb_texcoord_topright)
|
|
);
|
|
m_vertices[index * 4 + 2] = ArbitraryMeshVertex(
|
|
vertex3f_for_vector3(c),
|
|
normal3f_for_vector3(normal),
|
|
texcoord2f_from_array(aabb_texcoord_botright)
|
|
);
|
|
m_vertices[index * 4 + 3] = ArbitraryMeshVertex(
|
|
vertex3f_for_vector3(d),
|
|
normal3f_for_vector3(normal),
|
|
texcoord2f_from_array(aabb_texcoord_botleft)
|
|
);
|
|
}
|
|
|
|
void constructNull()
|
|
{
|
|
AABB aabb(Vector3(0, 0, 0), Vector3(8, 8, 8));
|
|
|
|
Vector3 points[8];
|
|
aabb_corners(aabb, points);
|
|
|
|
m_vertices.resize(24);
|
|
|
|
constructQuad(0, points[2], points[1], points[5], points[6], aabb_normals[0]);
|
|
constructQuad(1, points[1], points[0], points[4], points[5], aabb_normals[1]);
|
|
constructQuad(2, points[0], points[1], points[2], points[3], aabb_normals[2]);
|
|
constructQuad(3, points[0], points[3], points[7], points[4], aabb_normals[3]);
|
|
constructQuad(4, points[3], points[2], points[6], points[7], aabb_normals[4]);
|
|
constructQuad(5, points[7], points[6], points[5], points[4], aabb_normals[5]);
|
|
|
|
m_indices.resize(36);
|
|
|
|
RenderIndex indices[36] = {
|
|
0, 1, 2, 0, 2, 3,
|
|
4, 5, 6, 4, 6, 7,
|
|
8, 9, 10, 8, 10, 11,
|
|
12, 13, 14, 12, 14, 15,
|
|
16, 17, 18, 16, 18, 19,
|
|
20, 21, 22, 10, 22, 23,
|
|
};
|
|
|
|
|
|
Array<RenderIndex>::iterator j = m_indices.begin();
|
|
for (RenderIndex *i = indices; i != indices + (sizeof(indices) / sizeof(RenderIndex)); ++i) {
|
|
*j++ = *i;
|
|
}
|
|
|
|
m_shader = "";
|
|
|
|
UpdateAABB();
|
|
}
|
|
};
|
|
|
|
|
|
typedef std::pair<CopiedString, int> PicoModelKey;
|
|
|
|
|
|
class PicoModel :
|
|
public Cullable,
|
|
public Bounded {
|
|
typedef std::vector<PicoSurface *> surfaces_t;
|
|
surfaces_t m_surfaces;
|
|
|
|
AABB m_aabb_local;
|
|
public:
|
|
Callback<void()> m_lightsChanged;
|
|
|
|
PicoModel()
|
|
{
|
|
constructNull();
|
|
}
|
|
|
|
PicoModel(picoModel_t *model)
|
|
{
|
|
CopyPicoModel(model);
|
|
}
|
|
|
|
~PicoModel()
|
|
{
|
|
for (surfaces_t::iterator i = m_surfaces.begin(); i != m_surfaces.end(); ++i) {
|
|
delete *i;
|
|
}
|
|
}
|
|
|
|
typedef surfaces_t::const_iterator const_iterator;
|
|
|
|
const_iterator begin() const
|
|
{
|
|
return m_surfaces.begin();
|
|
}
|
|
|
|
const_iterator end() const
|
|
{
|
|
return m_surfaces.end();
|
|
}
|
|
|
|
std::size_t size() const
|
|
{
|
|
return m_surfaces.size();
|
|
}
|
|
|
|
VolumeIntersectionValue intersectVolume(const VolumeTest &test, const Matrix4 &localToWorld) const
|
|
{
|
|
return test.TestAABB(m_aabb_local, localToWorld);
|
|
}
|
|
|
|
virtual const AABB &localAABB() const
|
|
{
|
|
return m_aabb_local;
|
|
}
|
|
|
|
void render(Renderer &renderer, const VolumeTest &volume, const Matrix4 &localToWorld,
|
|
std::vector<Shader *> states) const
|
|
{
|
|
for (surfaces_t::const_iterator i = m_surfaces.begin(); i != m_surfaces.end(); ++i) {
|
|
if ((*i)->intersectVolume(volume, localToWorld) != c_volumeOutside) {
|
|
(*i)->render(renderer, localToWorld, states[i - m_surfaces.begin()]);
|
|
}
|
|
}
|
|
}
|
|
|
|
void testSelect(Selector &selector, SelectionTest &test, const Matrix4 &localToWorld)
|
|
{
|
|
for (surfaces_t::iterator i = m_surfaces.begin(); i != m_surfaces.end(); ++i) {
|
|
if ((*i)->intersectVolume(test.getVolume(), localToWorld) != c_volumeOutside) {
|
|
(*i)->testSelect(selector, test, localToWorld);
|
|
}
|
|
}
|
|
}
|
|
|
|
private:
|
|
void CopyPicoModel(picoModel_t *model)
|
|
{
|
|
m_aabb_local = AABB();
|
|
|
|
/* each surface on the model will become a new map drawsurface */
|
|
int numSurfaces = PicoGetModelNumSurfaces(model);
|
|
//% SYs_FPrintf( SYS_VRB, "Model %s has %d surfaces\n", name, numSurfaces );
|
|
for (int s = 0; s < numSurfaces; ++s) {
|
|
/* get surface */
|
|
picoSurface_t *surface = PicoGetModelSurface(model, s);
|
|
if (surface == 0) {
|
|
continue;
|
|
}
|
|
|
|
/* only handle triangle surfaces initially (fixme: support patches) */
|
|
if (PicoGetSurfaceType(surface) != PICO_TRIANGLES) {
|
|
continue;
|
|
}
|
|
|
|
/* fix the surface's normals */
|
|
PicoFixSurfaceNormals(surface);
|
|
|
|
PicoSurface *picosurface = new PicoSurface(surface);
|
|
aabb_extend_by_aabb_safe(m_aabb_local, picosurface->localAABB());
|
|
m_surfaces.push_back(picosurface);
|
|
}
|
|
}
|
|
|
|
void constructNull()
|
|
{
|
|
PicoSurface *picosurface = new PicoSurface();
|
|
m_aabb_local = picosurface->localAABB();
|
|
m_surfaces.push_back(picosurface);
|
|
}
|
|
};
|
|
|
|
inline void
|
|
Surface_addLight(PicoSurface &surface, VectorLightList &lights, const Matrix4 &localToWorld, const RendererLight &light)
|
|
{
|
|
if (light.testAABB(aabb_for_oriented_aabb(surface.localAABB(), localToWorld))) {
|
|
lights.addLight(light);
|
|
}
|
|
}
|
|
|
|
class PicoModelInstance :
|
|
public scene::Instance,
|
|
public Renderable,
|
|
public SelectionTestable,
|
|
public LightCullable,
|
|
public SkinnedModel {
|
|
class TypeCasts {
|
|
InstanceTypeCastTable m_casts;
|
|
public:
|
|
TypeCasts()
|
|
{
|
|
InstanceContainedCast<PicoModelInstance, Bounded>::install(m_casts);
|
|
InstanceContainedCast<PicoModelInstance, Cullable>::install(m_casts);
|
|
InstanceStaticCast<PicoModelInstance, Renderable>::install(m_casts);
|
|
InstanceStaticCast<PicoModelInstance, SelectionTestable>::install(m_casts);
|
|
InstanceStaticCast<PicoModelInstance, SkinnedModel>::install(m_casts);
|
|
}
|
|
|
|
InstanceTypeCastTable &get()
|
|
{
|
|
return m_casts;
|
|
}
|
|
};
|
|
|
|
PicoModel &m_picomodel;
|
|
|
|
const LightList *m_lightList;
|
|
typedef Array<VectorLightList> SurfaceLightLists;
|
|
SurfaceLightLists m_surfaceLightLists;
|
|
|
|
class Remap {
|
|
public:
|
|
CopiedString first;
|
|
Shader *second;
|
|
|
|
Remap() : second(0)
|
|
{
|
|
}
|
|
};
|
|
|
|
typedef Array<Remap> SurfaceRemaps;
|
|
SurfaceRemaps m_skins;
|
|
|
|
PicoModelInstance(const PicoModelInstance &);
|
|
|
|
PicoModelInstance operator=(const PicoModelInstance &);
|
|
|
|
public:
|
|
typedef LazyStatic<TypeCasts> StaticTypeCasts;
|
|
|
|
void *m_test;
|
|
|
|
Bounded &get(NullType<Bounded>)
|
|
{
|
|
return m_picomodel;
|
|
}
|
|
|
|
Cullable &get(NullType<Cullable>)
|
|
{
|
|
return m_picomodel;
|
|
}
|
|
|
|
void lightsChanged()
|
|
{
|
|
m_lightList->lightsChanged();
|
|
}
|
|
|
|
typedef MemberCaller<PicoModelInstance, void(), &PicoModelInstance::lightsChanged> LightsChangedCaller;
|
|
|
|
void constructRemaps()
|
|
{
|
|
ASSERT_MESSAGE(m_skins.size() == m_picomodel.size(), "ERROR");
|
|
ModelSkin *skin = NodeTypeCast<ModelSkin>::cast(path().parent());
|
|
if (skin != 0 && skin->realised()) {
|
|
SurfaceRemaps::iterator j = m_skins.begin();
|
|
for (PicoModel::const_iterator i = m_picomodel.begin(); i != m_picomodel.end(); ++i, ++j) {
|
|
const char *remap = skin->getRemap((*i)->getShader());
|
|
if (!string_empty(remap)) {
|
|
(*j).first = remap;
|
|
(*j).second = GlobalShaderCache().capture(remap);
|
|
} else {
|
|
(*j).second = 0;
|
|
}
|
|
}
|
|
SceneChangeNotify();
|
|
}
|
|
}
|
|
|
|
void destroyRemaps()
|
|
{
|
|
ASSERT_MESSAGE(m_skins.size() == m_picomodel.size(), "ERROR");
|
|
for (SurfaceRemaps::iterator i = m_skins.begin(); i != m_skins.end(); ++i) {
|
|
if ((*i).second != 0) {
|
|
GlobalShaderCache().release((*i).first.c_str());
|
|
(*i).second = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
void skinChanged()
|
|
{
|
|
destroyRemaps();
|
|
constructRemaps();
|
|
}
|
|
|
|
PicoModelInstance(const scene::Path &path, scene::Instance *parent, PicoModel &picomodel) :
|
|
Instance(path, parent, this, StaticTypeCasts::instance().get()),
|
|
m_picomodel(picomodel),
|
|
m_surfaceLightLists(m_picomodel.size()),
|
|
m_skins(m_picomodel.size())
|
|
{
|
|
m_lightList = &GlobalShaderCache().attach(*this);
|
|
m_picomodel.m_lightsChanged = LightsChangedCaller(*this);
|
|
|
|
Instance::setTransformChangedCallback(LightsChangedCaller(*this));
|
|
|
|
constructRemaps();
|
|
}
|
|
|
|
~PicoModelInstance()
|
|
{
|
|
destroyRemaps();
|
|
|
|
Instance::setTransformChangedCallback(Callback<void()>());
|
|
|
|
m_picomodel.m_lightsChanged = Callback<void()>();
|
|
GlobalShaderCache().detach(*this);
|
|
}
|
|
|
|
void render(Renderer &renderer, const VolumeTest &volume, const Matrix4 &localToWorld) const
|
|
{
|
|
SurfaceLightLists::const_iterator j = m_surfaceLightLists.begin();
|
|
SurfaceRemaps::const_iterator k = m_skins.begin();
|
|
for (PicoModel::const_iterator i = m_picomodel.begin(); i != m_picomodel.end(); ++i, ++j, ++k) {
|
|
if ((*i)->intersectVolume(volume, localToWorld) != c_volumeOutside) {
|
|
renderer.setLights(*j);
|
|
(*i)->render(renderer, localToWorld, (*k).second != 0 ? (*k).second : (*i)->getState());
|
|
}
|
|
}
|
|
}
|
|
|
|
void renderSolid(Renderer &renderer, const VolumeTest &volume) const
|
|
{
|
|
m_lightList->evaluateLights();
|
|
|
|
render(renderer, volume, Instance::localToWorld());
|
|
}
|
|
|
|
void renderWireframe(Renderer &renderer, const VolumeTest &volume) const
|
|
{
|
|
renderSolid(renderer, volume);
|
|
}
|
|
|
|
void testSelect(Selector &selector, SelectionTest &test)
|
|
{
|
|
m_picomodel.testSelect(selector, test, Instance::localToWorld());
|
|
}
|
|
|
|
bool testLight(const RendererLight &light) const
|
|
{
|
|
return light.testAABB(worldAABB());
|
|
}
|
|
|
|
void insertLight(const RendererLight &light)
|
|
{
|
|
const Matrix4 &localToWorld = Instance::localToWorld();
|
|
SurfaceLightLists::iterator j = m_surfaceLightLists.begin();
|
|
for (PicoModel::const_iterator i = m_picomodel.begin(); i != m_picomodel.end(); ++i) {
|
|
Surface_addLight(*(*i), *j++, localToWorld, light);
|
|
}
|
|
}
|
|
|
|
void clearLights()
|
|
{
|
|
for (SurfaceLightLists::iterator i = m_surfaceLightLists.begin(); i != m_surfaceLightLists.end(); ++i) {
|
|
(*i).clear();
|
|
}
|
|
}
|
|
};
|
|
|
|
class PicoModelNode : public scene::Node::Symbiot, public scene::Instantiable {
|
|
class TypeCasts {
|
|
NodeTypeCastTable m_casts;
|
|
public:
|
|
TypeCasts()
|
|
{
|
|
NodeStaticCast<PicoModelNode, scene::Instantiable>::install(m_casts);
|
|
}
|
|
|
|
NodeTypeCastTable &get()
|
|
{
|
|
return m_casts;
|
|
}
|
|
};
|
|
|
|
|
|
scene::Node m_node;
|
|
InstanceSet m_instances;
|
|
PicoModel m_picomodel;
|
|
|
|
public:
|
|
typedef LazyStatic<TypeCasts> StaticTypeCasts;
|
|
|
|
PicoModelNode() : m_node(this, this, StaticTypeCasts::instance().get())
|
|
{
|
|
}
|
|
|
|
PicoModelNode(picoModel_t *model) : m_node(this, this, StaticTypeCasts::instance().get()), m_picomodel(model)
|
|
{
|
|
}
|
|
|
|
void release()
|
|
{
|
|
delete this;
|
|
}
|
|
|
|
scene::Node &node()
|
|
{
|
|
return m_node;
|
|
}
|
|
|
|
scene::Instance *create(const scene::Path &path, scene::Instance *parent)
|
|
{
|
|
return new PicoModelInstance(path, parent, m_picomodel);
|
|
}
|
|
|
|
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);
|
|
}
|
|
};
|
|
|
|
|
|
#if 0
|
|
|
|
template<typename Key, typename Type>
|
|
class create_new
|
|
{
|
|
public:
|
|
static Type* construct( const Key& key ){
|
|
return new Type( key );
|
|
}
|
|
static void destroy( Type* value ){
|
|
delete value;
|
|
}
|
|
};
|
|
|
|
template<typename Key, typename Type, typename creation_policy = create_new<Key, Type> >
|
|
class cache_element : public creation_policy
|
|
{
|
|
public:
|
|
inline cache_element() : m_count( 0 ), m_value( 0 ) {}
|
|
inline ~cache_element(){
|
|
ASSERT_MESSAGE( m_count == 0, "destroyed a reference before it was released\n" );
|
|
if ( m_count > 0 ) {
|
|
destroy();
|
|
}
|
|
}
|
|
inline Type* capture( const Key& key ){
|
|
if ( ++m_count == 1 ) {
|
|
construct( key );
|
|
}
|
|
return m_value;
|
|
}
|
|
inline void release(){
|
|
ASSERT_MESSAGE( !empty(), "failed to release reference - not found in cache\n" );
|
|
if ( --m_count == 0 ) {
|
|
destroy();
|
|
}
|
|
}
|
|
inline bool empty(){
|
|
return m_count == 0;
|
|
}
|
|
inline void refresh( const Key& key ){
|
|
m_value->refresh( key );
|
|
}
|
|
private:
|
|
inline void construct( const Key& key ){
|
|
m_value = creation_policy::construct( key );
|
|
}
|
|
inline void destroy(){
|
|
creation_policy::destroy( m_value );
|
|
}
|
|
|
|
std::size_t m_count;
|
|
Type* m_value;
|
|
};
|
|
|
|
class create_picomodel
|
|
{
|
|
typedef PicoModelKey key_type;
|
|
typedef PicoModel value_type;
|
|
public:
|
|
static value_type* construct( const key_type& key ){
|
|
picoModel_t* picomodel = PicoLoadModel( const_cast<char*>( key.first.c_str() ), key.second );
|
|
value_type* value = new value_type( picomodel );
|
|
PicoFreeModel( picomodel );
|
|
return value;
|
|
}
|
|
static void destroy( value_type* value ){
|
|
delete value;
|
|
}
|
|
};
|
|
|
|
#include <map>
|
|
|
|
class ModelCache
|
|
{
|
|
typedef PicoModel value_type;
|
|
|
|
public:
|
|
typedef PicoModelKey key_type;
|
|
typedef cache_element<key_type, value_type, create_picomodel> elem_type;
|
|
typedef std::map<key_type, elem_type> cache_type;
|
|
|
|
value_type* capture( const key_type& key ){
|
|
return m_cache[key].capture( key );
|
|
}
|
|
void release( const key_type& key ){
|
|
m_cache[key].release();
|
|
}
|
|
|
|
private:
|
|
cache_type m_cache;
|
|
};
|
|
|
|
ModelCache g_model_cache;
|
|
|
|
|
|
|
|
typedef struct remap_s {
|
|
char m_remapbuff[64 + 1024];
|
|
char *original;
|
|
char *remap;
|
|
} remap_t;
|
|
|
|
class RemapWrapper :
|
|
public Cullable,
|
|
public Bounded
|
|
{
|
|
public:
|
|
RemapWrapper( const char* name ){
|
|
parse_namestr( name );
|
|
|
|
m_model = g_model_cache.capture( ModelCache::key_type( m_name, m_frame ) );
|
|
|
|
construct_shaders();
|
|
}
|
|
virtual ~RemapWrapper(){
|
|
g_model_cache.release( ModelCache::key_type( m_name, m_frame ) );
|
|
|
|
for ( shaders_t::iterator i = m_shaders.begin(); i != m_shaders.end(); ++i )
|
|
{
|
|
GlobalShaderCache().release( ( *i ).c_str() );
|
|
}
|
|
|
|
for ( remaps_t::iterator j = m_remaps.begin(); j != m_remaps.end(); ++j )
|
|
{
|
|
delete ( *j );
|
|
}
|
|
}
|
|
|
|
VolumeIntersectionValue intersectVolume( const VolumeTest& test, const Matrix4& localToWorld ) const {
|
|
return m_model->intersectVolume( test, localToWorld );
|
|
}
|
|
|
|
virtual const AABB& localAABB() const {
|
|
return m_model->localAABB();
|
|
}
|
|
|
|
void render( Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld ) const {
|
|
m_model->render( renderer, volume, localToWorld, m_states );
|
|
}
|
|
|
|
void testSelect( Selector& selector, SelectionTest& test, const Matrix4& localToWorld ){
|
|
m_model->testSelect( selector, test, localToWorld );
|
|
}
|
|
|
|
private:
|
|
void add_remap( const char *remap ){
|
|
const char *ch;
|
|
remap_t *pRemap;
|
|
|
|
ch = remap;
|
|
|
|
while ( *ch && *ch != ';' )
|
|
ch++;
|
|
|
|
if ( *ch == '\0' ) {
|
|
// bad remap
|
|
globalErrorStream() << "WARNING: Shader _remap key found in a model entity without a ; character\n";
|
|
}
|
|
else {
|
|
pRemap = new remap_t;
|
|
|
|
strncpy( pRemap->m_remapbuff, remap, sizeof( pRemap->m_remapbuff ) );
|
|
|
|
pRemap->m_remapbuff[ch - remap] = '\0';
|
|
|
|
pRemap->original = pRemap->m_remapbuff;
|
|
pRemap->remap = pRemap->m_remapbuff + ( ch - remap ) + 1;
|
|
|
|
m_remaps.push_back( pRemap );
|
|
}
|
|
}
|
|
|
|
void parse_namestr( const char *name ){
|
|
const char *ptr, *s;
|
|
bool hasName, hasFrame;
|
|
|
|
hasName = hasFrame = false;
|
|
|
|
m_frame = 0;
|
|
|
|
for ( s = ptr = name; ; ++ptr )
|
|
{
|
|
if ( !hasName && ( *ptr == ':' || *ptr == '\0' ) ) {
|
|
// model name
|
|
hasName = true;
|
|
m_name = CopiedString( s, ptr );
|
|
s = ptr + 1;
|
|
}
|
|
else if ( *ptr == '?' || *ptr == '\0' ) {
|
|
// model frame
|
|
hasFrame = true;
|
|
m_frame = atoi( CopiedString( s, ptr ).c_str() );
|
|
s = ptr + 1;
|
|
}
|
|
else if ( *ptr == '&' || *ptr == '\0' ) {
|
|
// a remap
|
|
add_remap( CopiedString( s, ptr ).c_str() );
|
|
s = ptr + 1;
|
|
}
|
|
|
|
if ( *ptr == '\0' ) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void construct_shaders(){
|
|
const char* global_shader = shader_for_remap( "*" );
|
|
|
|
m_shaders.reserve( m_model->size() );
|
|
m_states.reserve( m_model->size() );
|
|
for ( PicoModel::iterator i = m_model->begin(); i != m_model->end(); ++i )
|
|
{
|
|
const char* shader = shader_for_remap( ( *i )->getShader() );
|
|
m_shaders.push_back(
|
|
( shader[0] != '\0' )
|
|
? shader
|
|
: ( global_shader[0] != '\0' )
|
|
? global_shader
|
|
: ( *i )->getShader() );
|
|
m_states.push_back( GlobalShaderCache().capture( m_shaders.back().c_str() ) );
|
|
}
|
|
}
|
|
|
|
inline const char* shader_for_remap( const char* remap ){
|
|
for ( remaps_t::iterator i = m_remaps.begin(); i != m_remaps.end(); ++i )
|
|
{
|
|
if ( shader_equal( remap, ( *i )->original ) ) {
|
|
return ( *i )->remap;
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
|
|
CopiedString m_name;
|
|
int m_frame;
|
|
PicoModel* m_model;
|
|
|
|
typedef std::vector<remap_t*> remaps_t;
|
|
remaps_t m_remaps;
|
|
typedef std::vector<CopiedString> shaders_t;
|
|
shaders_t m_shaders;
|
|
typedef std::vector<Shader*> states_t;
|
|
states_t m_states;
|
|
};
|
|
|
|
class RemapWrapperInstance : public scene::Instance, public Renderable, public SelectionTestable
|
|
{
|
|
RemapWrapper& m_remapwrapper;
|
|
public:
|
|
RemapWrapperInstance( const scene::Path& path, scene::Instance* parent, RemapWrapper& remapwrapper ) : Instance( path, parent ), m_remapwrapper( remapwrapper ){
|
|
scene::Instance::m_cullable = &m_remapwrapper;
|
|
scene::Instance::m_render = this;
|
|
scene::Instance::m_select = this;
|
|
}
|
|
|
|
void renderSolid( Renderer& renderer, const VolumeTest& volume ) const {
|
|
m_remapwrapper.render( renderer, volume, Instance::localToWorld() );
|
|
}
|
|
void renderWireframe( Renderer& renderer, const VolumeTest& volume ) const {
|
|
renderSolid( renderer, volume );
|
|
}
|
|
|
|
void testSelect( Selector& selector, SelectionTest& test ){
|
|
m_remapwrapper.testSelect( selector, test, Instance::localToWorld() );
|
|
}
|
|
};
|
|
|
|
class RemapWrapperNode : public scene::Node::Symbiot, public scene::Instantiable
|
|
{
|
|
scene::Node m_node;
|
|
typedef RemapWrapperInstance instance_type;
|
|
InstanceSet m_instances;
|
|
RemapWrapper m_remapwrapper;
|
|
public:
|
|
RemapWrapperNode( const char* name ) : m_node( this ), m_remapwrapper( name ){
|
|
m_node.m_instance = this;
|
|
}
|
|
|
|
void release(){
|
|
delete this;
|
|
}
|
|
scene::Node& node(){
|
|
return m_node;
|
|
}
|
|
|
|
scene::Instance* create( const scene::Path& path, scene::Instance* parent ){
|
|
return new instance_type( path, parent, m_remapwrapper );
|
|
}
|
|
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 );
|
|
}
|
|
};
|
|
|
|
scene::Node& LoadRemapModel( const char* name ){
|
|
return ( new RemapWrapperNode( name ) )->node();
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
size_t picoInputStreamReam(void *inputStream, unsigned char *buffer, size_t length)
|
|
{
|
|
return reinterpret_cast<InputStream *>( inputStream )->read(buffer, length);
|
|
}
|
|
|
|
scene::Node &loadPicoModel(const picoModule_t *module, ArchiveFile &file)
|
|
{
|
|
picoModel_t *model = PicoModuleLoadModelStream(module, &file.getInputStream(), picoInputStreamReam, file.size(), 0,
|
|
file.getName());
|
|
PicoModelNode *modelNode = new PicoModelNode(model);
|
|
PicoFreeModel(model);
|
|
return modelNode->node();
|
|
}
|