-
sparker
thiago
Manta Interactive Ray Tracer Development Mailing List
Text archives Help
- From: sparker@sci.utah.edu
- To: manta@sci.utah.edu
- Subject: [MANTA] r815 - in branches/vertical: Interface Model/Materials Model/Textures
- Date: Wed, 4 Jan 2006 13:20:04 -0700 (MST)
Author: sparker
Date: Wed Jan 4 13:19:57 2006
New Revision: 815
Modified:
branches/vertical/Interface/RayPacket.h
branches/vertical/Model/Materials/AmbientOcclusion.cc
branches/vertical/Model/Materials/AmbientOcclusion.h
branches/vertical/Model/Materials/CMakeLists.txt
branches/vertical/Model/Materials/Dielectric.cc
branches/vertical/Model/Materials/Flat.cc
branches/vertical/Model/Materials/Lambertian.cc
branches/vertical/Model/Materials/MetalMaterial.cc
branches/vertical/Model/Materials/NormalMaterial.cc
branches/vertical/Model/Materials/Phong.cc
branches/vertical/Model/Textures/CMakeLists.txt
Log:
More conversion
Modified: branches/vertical/Interface/RayPacket.h
==============================================================================
--- branches/vertical/Interface/RayPacket.h (original)
+++ branches/vertical/Interface/RayPacket.h Wed Jan 4 13:19:57 2006
@@ -419,7 +419,20 @@
flags |= HaveNormals;
}
-
+ void normalizeNormals()
+ {
+ if(flags & HaveUnitNormals)
+ return;
+ for(int i=rayBegin;i<rayEnd;i++){
+ Real sum = 0;
+ for(int j=0;j<3;j++)
+ sum += data->normal[j][i] * data->normal[j][i];
+ Real scale = 1/SCIRun::Sqrt(sum);
+ for(int j=0;j<3;j++)
+ data->normal[j][i] *= scale;
+ }
+ flags |= HaveUnitNormals;
+ }
// Hit positions
Point getHitPosition(int which) const
Modified: branches/vertical/Model/Materials/AmbientOcclusion.cc
==============================================================================
--- branches/vertical/Model/Materials/AmbientOcclusion.cc (original)
+++ branches/vertical/Model/Materials/AmbientOcclusion.cc Wed Jan 4
13:19:57 2006
@@ -9,69 +9,67 @@
#include <SCIRun/Core/Math/Trig.h>
using namespace Manta;
+using SCIRun::Sqrt;
// TODO: sort the rays generated in generateDirections to make them more
// coherent for ray packets.
AmbientOcclusion::AmbientOcclusion(const Color& color, float cutoff_dist,
int num_dirs)
{
- colortex = new Constant<Color>(color);
- cutoff = cutoff_dist;
- num_directions = num_dirs;
- inv_num_directions = 1.f/float(num_directions);
- generateDirections();
+ colortex = new Constant<Color>(color);
+ cutoff = cutoff_dist;
+ inv_num_directions = 1.f/float(num_dirs);
+ generateDirections(num_dirs);
}
-AmbientOcclusion::AmbientOcclusion(const Texture<Color>* color, float
cutoff_dist, int num_dirs) : colortex(color), cutoff(cutoff_dist),
num_directions(num_dirs)
+AmbientOcclusion::AmbientOcclusion(const Texture<Color>* color, float
cutoff_dist, int num_dirs)
+ : colortex(color), cutoff(cutoff_dist)
{
- inv_num_directions = 1.f/float(num_directions);
- generateDirections();
+ inv_num_directions = 1.f/float(num_directions);
+ generateDirections(num_dirs);
}
AmbientOcclusion::~AmbientOcclusion()
{
- if (directions) delete[] directions;
}
-void AmbientOcclusion::generateDirections()
-
+void AmbientOcclusion::generateDirections(int num_directions)
{
- directions = new Vector[num_directions];
- MT_RNG rng;
- // generate cosine weighted directions
- for ( int i = 0; i < num_directions; i++ )
- {
- double r1 = rng.genRealRand<double>();
- double r2 = rng.genRealRand<double>();
-
- double phi = 2.0 * Pi * r1;
- double r = sqrt(r2);
- double x = r * Cos(phi);
- double y = r * Sin(phi);
- double z = 1.0 - x*x - y*y;
- z = (z > 0.0) ? sqrt(z) : 0.0;
+ directions.resize(num_directions);
+ MT_RNG rng;
+ // generate cosine weighted directions
+ for ( int i = 0; i < num_directions; i++ )
+ {
+ double r1 = rng.genRealRand<double>();
+ double r2 = rng.genRealRand<double>();
+
+ double phi = 2.0 * Pi * r1;
+ double r = sqrt(r2);
+ double x = r * Cos(phi);
+ double y = r * Sin(phi);
+ double z = 1.0 - x*x - y*y;
+ z = (z > 0.0) ? Sqrt(z) : 0.0;
- directions[i] = Vector(x, y, z);
- }
+ directions[i] = Vector(x, y, z);
+ }
}
void AmbientOcclusion::shade(const RenderContext& context, RayPacket& rays)
const
{
- // Compute normals
- rays.computeNormals(context);
- rays.computeHitPositions();
-
- // Compute colors
- Color colors[RayPacket::MaxSize];
- colortex->mapValues(context, rays, colors);
-
- RayPacketData data;
- int start = 0;
- do
- {
- RayPacket shadowRays(data, 0, rays.getDepth(), 0);
- int end = context.shadowAlgorithm->computeShadows(context,
activeLights,
- rays, start,
shadowRays);
+ // Compute normals
+ rays.computeNormals(context);
+ rays.computeHitPositions();
+
+ // Compute colors
+ Color colors[RayPacket::MaxSize];
+ colortex->mapValues(context, rays, colors);
+
+ RayPacketData data;
+ int start = 0;
+ do {
+ RayPacket shadowRays(data, 0, rays.getDepth(), 0);
+ int end = context.shadowAlgorithm->computeShadows(context, activeLights,
+ rays, start,
shadowRays);
shadowRays.normalizeDirections();
for(int i=start;i<end;i++)
{
Modified: branches/vertical/Model/Materials/AmbientOcclusion.h
==============================================================================
--- branches/vertical/Model/Materials/AmbientOcclusion.h (original)
+++ branches/vertical/Model/Materials/AmbientOcclusion.h Wed Jan 4
13:19:57 2006
@@ -4,30 +4,30 @@
#include <Model/Materials/LitMaterial.h>
#include <Core/Color/Color.h>
#include <Interface/Texture.h>
+#include <vector>
namespace Manta
{
- class LightSet;
+ class LightSet;
- class AmbientOcclusion : public LitMaterial
- {
- public:
- AmbientOcclusion(const Color& color, float cutoff_dist, int
num_dirs);
- AmbientOcclusion(const Texture<Color>* color, float cutoff_dist, int
num_dirs);
- AmbientOcclusion() { }
- ~AmbientOcclusion();
+ class AmbientOcclusion : public LitMaterial
+ {
+ public:
+ AmbientOcclusion(const Color& color, float cutoff_dist, int num_dirs);
+ AmbientOcclusion(const Texture<Color>* color, float cutoff_dist, int
num_dirs);
+ AmbientOcclusion() { }
+ ~AmbientOcclusion();
- void generateDirections();
-
- // generate the directions
- void shade(const RenderContext& context, RayPacket& rays) const;
+ void generateDirections();
+
+ // generate the directions
+ void shade(const RenderContext& context, RayPacket& rays) const;
private:
- const Texture<Color>* colortex;
- float cutoff;
- Vector* directions;
- int num_directions;
- float inv_num_directions;
- };
+ const Texture<Color>* colortex;
+ float cutoff;
+ std::vector<Vector> directions;
+ float inv_num_directions;
+ };
}
#endif
Modified: branches/vertical/Model/Materials/CMakeLists.txt
==============================================================================
--- branches/vertical/Model/Materials/CMakeLists.txt (original)
+++ branches/vertical/Model/Materials/CMakeLists.txt Wed Jan 4 13:19:57
2006
@@ -4,18 +4,18 @@
#Materials/AmbientOcclusion.cc
Materials/Checker.h
Materials/Checker.cc
- #Materials/Dielectric.h
- #Materials/Dielectric.cc
- #Materials/Flat.h
- #Materials/Flat.cc
- #Materials/Lambertian.h
- #Materials/Lambertian.cc
+ Materials/Dielectric.h
+ Materials/Dielectric.cc
+ Materials/Flat.h
+ Materials/Flat.cc
+ Materials/Lambertian.h
+ Materials/Lambertian.cc
Materials/LitMaterial.h
Materials/LitMaterial.cc
- #Materials/MetalMaterial.h
- #Materials/MetalMaterial.cc
- #Materials/NormalMaterial.h
- #Materials/NormalMaterial.cc # Shade the material using it's normal.
+ Materials/MetalMaterial.h
+ Materials/MetalMaterial.cc
+ Materials/NormalMaterial.h
+ Materials/NormalMaterial.cc # Shade the material using it's normal.
Materials/Phong.h
Materials/Phong.cc
)
Modified: branches/vertical/Model/Materials/Dielectric.cc
==============================================================================
--- branches/vertical/Model/Materials/Dielectric.cc (original)
+++ branches/vertical/Model/Materials/Dielectric.cc Wed Jan 4 13:19:57
2006
@@ -55,12 +55,9 @@
void Dielectric::shade(const RenderContext& context, RayPacket& rays) const
{
- if(rays.getDepth() >= context.scene->getRenderParameters().maxDepth)
- {
- for(int i=0;i<rays.getSize();i++)
- {
- rays.setResult(i, Color::black());
- }
+ if(rays.getDepth() >= context.scene->getRenderParameters().maxDepth) {
+ for(int i=rays.begin();i<rays.end();i++)
+ rays.setColor(i, Color::black());
return;
}
@@ -80,9 +77,10 @@
RayPacketData reflected_data;
RayPacketData refracted_data;
- RayPacket reflected_rays(reflected_data, 0, rays.getDepth()+1,
RayPacket::NormalizedDirections);
- RayPacket refracted_rays(refracted_data, 0, rays.getDepth()+1,
RayPacket::NormalizedDirections);
+ RayPacket reflected_rays(reflected_data, 0, 0, rays.getDepth()+1,
RayPacket::NormalizedDirections);
+ RayPacket refracted_rays(refracted_data, 0, 0, rays.getDepth()+1,
RayPacket::NormalizedDirections);
+ Color results[RayPacket::MaxSize];
Color refl_attenuation[RayPacket::MaxSize];
Color refr_attenuation[RayPacket::MaxSize];
@@ -94,44 +92,40 @@
Real cutoff = localCutoffScale *
context.scene->getRenderParameters().importanceCutoff;
// Compute coefficients and set up raypackets
- for(int i=0;i<rays.getSize();i++)
- {
- RayPacket::Element& e = rays.get(i);
- e.color = Color::black();
+ for(int i=rays.begin();i<rays.end();i++) {
+ results[i] = Color::black();
- Real n_dot_v = Dot(e.normal, e.ray.direction());
+ Vector rayD = rays.getDirection(i);
+ Vector normal = rays.getNormal(i);
+ Real n_dot_v = Dot(normal, rayD);
Real eta_tmp_inv;
bool was_incoming = ( n_dot_v < 0 );
Color beers_color;
- if ( was_incoming )
- {
+ if ( was_incoming ) {
eta_tmp_inv = nt_values[i]/n_values[i];
n_dot_v = -n_dot_v;
beers_color = Color::white();
- }
- else
- {
- e.normal = -e.normal;
+ } else {
+ normal = -normal;
eta_tmp_inv = n_values[i]/nt_values[i];
- beers_color = sigma_a_values[i].Pow(e.hitInfo.minT());
+ beers_color = sigma_a_values[i].Pow(rays.getMinT(i));
}
Real cosine_sq = 1 + (n_dot_v*n_dot_v - 1) * (eta_tmp_inv*eta_tmp_inv);
- if ( cosine_sq <= 0 )
- {
+ Color in_importance = rays.getImportance(i);
+ Point hitpos = rays.getHitPosition(i);
+ if ( cosine_sq <= 0 ) {
// total internal reflection - no attenuation
- RayPacket::Element& r = reflected_rays.get(num_refl);
- r.importance = e.importance * beers_color;
- if(r.importance.luminance() > cutoff){
- Vector refl_dir = e.ray.direction() + 2*n_dot_v*e.normal;
- r.ray.set(e.hitPosition, refl_dir);
+ Color refl_importance = in_importance * beers_color;
+ if(refl_importance.luminance() > cutoff){
+ rays.setImportance(num_refl, refl_importance);
+ Vector refl_dir = rayD + 2*n_dot_v*normal;
+ reflected_rays.setRay(num_refl, hitpos, refl_dir);
refl_source[num_refl] = i;
refl_attenuation[num_refl] = beers_color;
num_refl++;
}
- }
- else
- {
+ } else {
Real cosine = Sqrt(cosine_sq);
Real k = 1 - cosine;
k*=(k*k)*(k*k);
@@ -142,23 +136,23 @@
// Possibly create refraction ray
refr_attenuation[num_refr] = beers_color * (1-R);
- RayPacket::Element& refr = refracted_rays.get(num_refr);
- refr.importance = e.importance * refr_attenuation[num_refr];
- if(refr.importance.luminance() > cutoff){
- Vector refr_dir = (e.ray.direction()*eta_tmp_inv +
- (n_dot_v*eta_tmp_inv - cosine) * e.normal);
- refr.ray.set(e.hitPosition, refr_dir);
+ Color refr_importance = in_importance * refr_attenuation[num_refr];
+ if(refr_importance.luminance() > cutoff){
+ refracted_rays.setImportance(num_refr, refr_importance);
+ Vector refr_dir = rayD*eta_tmp_inv +
+ (n_dot_v*eta_tmp_inv - cosine) * normal;
+ refracted_rays.setRay(num_refr, hitpos, refr_dir);
refr_source[num_refr] = i;
num_refr++;
}
// Possibly create reflection ray
refl_attenuation[num_refl] = beers_color * R;
- RayPacket::Element& refl = reflected_rays.get(num_refl);
- refl.importance = e.importance * refl_attenuation[num_refl];
- if(refl.importance.luminance() > cutoff){
- Vector refl_dir = e.ray.direction() + (2*n_dot_v)*e.normal;
- refl.ray.set(e.hitPosition, refl_dir);
+ Color refl_importance = in_importance * refl_attenuation[num_refl];
+ if(refl_importance.luminance() > cutoff){
+ reflected_rays.setImportance(num_refl, refl_importance);
+ Vector refl_dir = rayD + (2*n_dot_v)*normal;
+ reflected_rays.setRay(num_refl, hitpos, refl_dir);
refl_source[num_refl] = i;
num_refl++;
}
@@ -177,15 +171,9 @@
// compute their results
for (int i = 0; i < num_refl; i++)
- {
- RayPacket::Element& r = reflected_rays.get(i);
- RayPacket::Element& e = rays.get(refl_source[i]);
- e.color += refl_attenuation[i] * r.color;
- }
+ results[refl_source[i]] += refl_attenuation[i] *
reflected_rays.getColor(i);
for (int i = 0; i < num_refr; i++)
- {
- RayPacket::Element& r = refracted_rays.get(i);
- RayPacket::Element& e = rays.get(refr_source[i]);
- e.color += refr_attenuation[i] * r.color;
- }
+ results[refr_source[i]] += refr_attenuation[i] *
refracted_rays.getColor(i);
+ for(int i = rays.begin(); i < rays.end(); i++)
+ rays.setColor(i, results[i]);
}
Modified: branches/vertical/Model/Materials/Flat.cc
==============================================================================
--- branches/vertical/Model/Materials/Flat.cc (original)
+++ branches/vertical/Model/Materials/Flat.cc Wed Jan 4 13:19:57 2006
@@ -63,8 +63,6 @@
colortex->mapValues(context, rays, colors);
// Copy the colors into the ray packet.
- for(int i=0;i<rays.getSize();i++) {
-
- rays.setResult( i, colors[i] );
- }
+ for(int i=rays.begin();i<rays.end();i++)
+ rays.setColor( i, colors[i] );
}
Modified: branches/vertical/Model/Materials/Lambertian.cc
==============================================================================
--- branches/vertical/Model/Materials/Lambertian.cc (original)
+++ branches/vertical/Model/Materials/Lambertian.cc Wed Jan 4 13:19:57
2006
@@ -34,37 +34,58 @@
rays.computeNormals(context);
// Compute colors
- Color colors[RayPacket::MaxSize];
- colortex->mapValues(context, rays, colors);
+ Color diffuse[RayPacket::MaxSize];
+ colortex->mapValues(context, rays, diffuse);
// Compute ambient contributions for all rays
- activeLights->getAmbientLight()->computeAmbient(context, rays);
+ ColorArray totalLight;
+ activeLights->getAmbientLight()->computeAmbient(context, rays, totalLight);
// We normalized directions for proper dot product computation.
rays.normalizeDirections();
- RayPacketData data;
- int start = 0;
-
+ ShadowAlgorithm::StateBuffer stateBuffer;
+ bool firstTime = true;
+ bool done;
+ int count = 0;
do {
- RayPacket shadowRays(data, 0, rays.getDepth(), 0);
- int end = context.shadowAlgorithm->computeShadows(context, activeLights,
- rays, start,
shadowRays);
- // We normalized directions for proper dot product computation.
+ int map[RayPacket::MaxSize];
+ RayPacketData shadowData;
+ RayPacket shadowRays(shadowData, 0, 0, rays.getDepth(), 0);
+
+ // Call the shadowalgorithm(sa) to generate shadow rays. We may not be
+ // able to compute all of them, so we pass along a buffer for the sa
+ // object to store it's state. The firstTime flag tells the sa to fill
+ // in the state rather than using anything in the state buffer. Most
+ // sas will only need to store an int or two in the statebuffer.
+ done = context.shadowAlgorithm->computeShadows(context, activeLights,
+ rays, map, shadowRays,
+ firstTime, stateBuffer);
+
+ // We need normalized directions for proper dot product computation.
shadowRays.normalizeDirections();
- for(int i=start;i<end;i++){
- RayPacket::Element& e = rays.get(i);
- Color totalLight(e.ambientLight);
- for(int j=e.shadowBegin;j<e.shadowEnd;j++){
- RayPacket::Element& s = shadowRays.get(j);
- if(!s.hitInfo.wasHit()){
- ColorComponent cos_theta = Dot(s.ray.direction(), e.normal);
- totalLight += s.light*cos_theta;
- }
- }
- rays.setResult(i, colors[i]*totalLight);
+ for(int j=shadowRays.begin(); j < shadowRays.end(); j++){
+ if(!shadowRays.wasHit(j)){
+ // Not in shadow, so compute the direct and specular contributions.
+ int to = map[j];
+ Vector normal = rays.getNormal(to);
+ Vector shadowdir = shadowRays.getDirection(j);
+ ColorComponent cos_theta = Dot(shadowdir, normal);
+ Color light = shadowRays.getColor(j);
+ for(int k = 0; k < Color::NumComponents;k++)
+ totalLight[k][to] += light[k]*cos_theta;
}
- start = end;
- } while(start < rays.getSize());
+ }
+ firstTime = false;
+ } while(!done);
+
+ // Sum up diffuse/specular contributions
+ for(int i = rays.begin(); i < rays.end(); i++){
+ Color result;
+ for(int j=0;j<Color::NumComponents;j++)
+ result[j] = totalLight[j][i] * diffuse[i][j];
+ rays.setColor(i, result);
+ }
+
}
Modified: branches/vertical/Model/Materials/MetalMaterial.cc
==============================================================================
--- branches/vertical/Model/Materials/MetalMaterial.cc (original)
+++ branches/vertical/Model/Materials/MetalMaterial.cc Wed Jan 4 13:19:57
2006
@@ -40,25 +40,21 @@
rays.computeHitPositions();
RayPacketData rdata;
- RayPacket refl_rays(rdata, rays.getSize(), rays.getDepth()+1,
+ RayPacket refl_rays(rdata, rays.begin(), rays.end(), rays.getDepth()+1,
RayPacket::NormalizedDirections);
- for(int i=0;i<rays.getSize();i++)
- {
- RayPacket::Element& e = rays.get(i);
- Vector refl_dir = e.ray.direction() - e.normal*(2*Dot(e.normal,
e.ray.direction()));
- RayPacket::Element& r = refl_rays.get(i);
- r.ray.set(e.hitPosition, refl_dir);
- r.importance = e.importance;
- }
+ for(int i=rays.begin();i<rays.end();i++) {
+ Vector rayD = rays.getDirection(i);
+ Vector normal = rays.getNormal(i);
+ Vector refl_dir = rayD - normal*(2*Dot(normal, rayD));
+ refl_rays.setRay(i, rays.getHitPosition(i), refl_dir);
+ refl_rays.setImportance(i, rays.getImportance(i));
+ }
- refl_rays.resetHit();
+ refl_rays.resetHits();
context.renderer->traceRays(context, refl_rays);
- for(int i=0;i<rays.getSize();i++) {
- RayPacket::Element& e = rays.get(i);
- RayPacket::Element& r = refl_rays.get(i);
-
+ for(int i=rays.begin();i<rays.end();i++) {
// compute Schlick Fresnel approximation
- Real cosine = -Dot(e.normal, e.ray.direction());
+ Real cosine = -Dot(rays.getNormal(i), rays.getDirection(i));
if(cosine < 0) cosine =-cosine;
Real k = 1 - cosine;
k*=k*k*k*k;
@@ -69,12 +65,11 @@
ColorComponent kc = (ColorComponent)k;
Color R = specular[i] * (1-kc) + Color::white()*kc;
- e.color = R * r.color;
+ rays.setColor(i, R * refl_rays.getColor(i));
}
} else {
// Stuff black in it.
- for(int i=0;i<rays.getSize();i++) {
- rays.setResult(i, Color::black());
- }
+ for(int i=rays.begin();i<rays.end();i++)
+ rays.setColor(i, Color::black());
}
}
Modified: branches/vertical/Model/Materials/NormalMaterial.cc
==============================================================================
--- branches/vertical/Model/Materials/NormalMaterial.cc (original)
+++ branches/vertical/Model/Materials/NormalMaterial.cc Wed Jan 4 13:19:57
2006
@@ -8,15 +8,15 @@
void NormalMaterial::shade( const RenderContext &context, RayPacket &rays)
const {
- // Compute the normal for each ray.
- rays.computeNormals( context );
+ // Compute the normal for each ray.
+ rays.computeNormals( context );
- // Iterate over the packet and set the colors.
- for (int i=0;i<rays.getSize();++i) {
+ // Iterate over the packet and set the colors.
+ for (int i=rays.begin();i<rays.end();++i) {
// Copy the normal out.
- Vector normal = rays.get(i).normal;
- rays.setResult( i, Color( RGB( normal[0],normal[1], normal[2] )) );
+ Vector normal = rays.getNormal(i);
+ rays.setColor( i, Color( RGB( normal[0],normal[1], normal[2] )) );
#if 0
// Add a wireframe.
Modified: branches/vertical/Model/Materials/Phong.cc
==============================================================================
--- branches/vertical/Model/Materials/Phong.cc (original)
+++ branches/vertical/Model/Materials/Phong.cc Wed Jan 4 13:19:57 2006
@@ -76,14 +76,13 @@
// We need normalized directions for proper dot product computation.
rays.normalizeDirections();
- RayPacketData shadowData;
- int map[RayPacket::MaxSize];
-
ShadowAlgorithm::StateBuffer stateBuffer;
bool firstTime = true;
bool done;
int count = 0;
do {
+ int map[RayPacket::MaxSize];
+ RayPacketData shadowData;
RayPacket shadowRays(shadowData, 0, 0, rays.getDepth(), 0);
// Call the shadowalgorithm(sa) to generate shadow rays. We may not be
Modified: branches/vertical/Model/Textures/CMakeLists.txt
==============================================================================
--- branches/vertical/Model/Textures/CMakeLists.txt (original)
+++ branches/vertical/Model/Textures/CMakeLists.txt Wed Jan 4 13:19:57
2006
@@ -5,18 +5,18 @@
Textures/CheckerTexture.h
Textures/Constant.cc
Textures/Constant.h
- #Textures/ImageTexture.cc
- #Textures/ImageTexture.h
- #Textures/MarbleTexture.cc
- #Textures/MarbleTexture.h
- #Textures/OakTexture.cc
- #Textures/OakTexture.h
- #Textures/TexCoordTexture.cc
- #Textures/TexCoordTexture.h
- #Textures/TriVerTexture.cc
- #Textures/TriVerTexture.h
- #Textures/WoodTexture.cc
- #Textures/WoodTexture.h
+ Textures/ImageTexture.cc
+ Textures/ImageTexture.h
+ Textures/MarbleTexture.cc
+ Textures/MarbleTexture.h
+ Textures/OakTexture.cc
+ Textures/OakTexture.h
+ Textures/TexCoordTexture.cc
+ Textures/TexCoordTexture.h
+ Textures/TriVerTexture.cc
+ Textures/TriVerTexture.h
+ Textures/WoodTexture.cc
+ Textures/WoodTexture.h
)
- [MANTA] r815 - in branches/vertical: Interface Model/Materials Model/Textures, sparker, 01/04/2006
Archive powered by MHonArc 2.6.16.
