mirror of
https://github.com/panda3d/panda3d.git
synced 2025-09-30 08:44:19 -04:00
Polylight Color storage corrected and SeaPatch removed
This commit is contained in:
Shalin Shodhan
parent
0d0b75e738
commit
2a6d6944b6
@ -79,7 +79,6 @@
|
||||
renderEffects.I renderEffects.h \
|
||||
renderModeAttrib.I renderModeAttrib.h \
|
||||
renderState.I renderState.h \
|
||||
seaPatchNode.h seaPatchNode.I \
|
||||
sceneGraphAnalyzer.h \
|
||||
sceneGraphReducer.I sceneGraphReducer.h \
|
||||
sceneSetup.I sceneSetup.h \
|
||||
@ -172,7 +171,6 @@
|
||||
sceneGraphAnalyzer.cxx \
|
||||
sceneGraphReducer.cxx \
|
||||
sceneSetup.cxx \
|
||||
seaPatchNode.cxx \
|
||||
selectiveChildNode.cxx \
|
||||
sequenceNode.cxx \
|
||||
showBoundsEffect.cxx \
|
||||
@ -256,7 +254,6 @@
|
||||
renderEffects.I renderEffects.h \
|
||||
renderModeAttrib.I renderModeAttrib.h \
|
||||
renderState.I renderState.h \
|
||||
seaPatchNode.I seaPatchNode.h \
|
||||
sceneGraphAnalyzer.h \
|
||||
sceneGraphReducer.I sceneGraphReducer.h \
|
||||
sceneSetup.I sceneSetup.h \
|
||||
|
||||
@ -72,7 +72,6 @@
|
||||
#include "renderEffects.h"
|
||||
#include "renderModeAttrib.h"
|
||||
#include "renderState.h"
|
||||
#include "seaPatchNode.h"
|
||||
#include "selectiveChildNode.h"
|
||||
#include "sequenceNode.h"
|
||||
#include "showBoundsEffect.h"
|
||||
@ -225,7 +224,6 @@ init_libpgraph() {
|
||||
RenderEffects::init_type();
|
||||
RenderModeAttrib::init_type();
|
||||
RenderState::init_type();
|
||||
SeaPatchNode::init_type();
|
||||
SelectiveChildNode::init_type();
|
||||
SequenceNode::init_type();
|
||||
ShowBoundsEffect::init_type();
|
||||
|
||||
@ -67,7 +67,7 @@ draw_with_decals(CullableObject *object, GraphicsStateGuardianBase *gsg) {
|
||||
while (base != (CullableObject *)NULL && base->_geom != (Geom *)NULL) {
|
||||
gsg->set_state_and_transform(base->_state->compose(state), base->_transform);
|
||||
base->_geom->draw(gsg);
|
||||
|
||||
|
||||
base = base->_next;
|
||||
}
|
||||
|
||||
@ -79,7 +79,6 @@ draw_with_decals(CullableObject *object, GraphicsStateGuardianBase *gsg) {
|
||||
while (decal != (CullableObject *)NULL) {
|
||||
gsg->set_state_and_transform(decal->_state->compose(state), decal->_transform);
|
||||
decal->_geom->draw(gsg);
|
||||
|
||||
decal = decal->_next;
|
||||
}
|
||||
}
|
||||
|
||||
@ -29,6 +29,7 @@
|
||||
#include "pvector.h"
|
||||
#include "pset.h"
|
||||
|
||||
|
||||
class GraphicsStateGuardianBase;
|
||||
class TransformState;
|
||||
class RenderState;
|
||||
|
||||
@ -137,16 +137,16 @@ bool FadeLODNode::
|
||||
cull_callback(CullTraverser *trav, CullTraverserData &data) {
|
||||
PandaNode *node = data.node();
|
||||
CDReader cdata(_cycler);
|
||||
if(_fade_mode) {
|
||||
if (_fade_mode) {
|
||||
float in_alpha;
|
||||
float out_alpha;
|
||||
_fade_timer -= ClockObject::get_global_clock()->get_dt();
|
||||
if(_fade_timer <= (cdata->_fade_time / 2.0)) {
|
||||
if (_fade_timer <= (cdata->_fade_time / 2.0)) {
|
||||
//SECOND HALF OF FADE:
|
||||
//Fade out the old LOD with z write off and
|
||||
//draw the opaque new LOD with z write on
|
||||
out_alpha = (_fade_timer*2.0) / cdata->_fade_time;
|
||||
if(out_alpha < 0.0) {
|
||||
if (out_alpha < 0.0) {
|
||||
out_alpha = 0.0;
|
||||
}
|
||||
|
||||
@ -167,13 +167,12 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
|
||||
|
||||
trav->traverse(next_data_in);
|
||||
trav->traverse(next_data_out);
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
// FIRST HALF OF FADE
|
||||
// Fade the new LOD in with z writing off
|
||||
// Keep drawing the old LOD opaque with z writing on
|
||||
in_alpha = (1.0 - (_fade_timer / cdata->_fade_time))*2.0;
|
||||
if(in_alpha > 1.0) {
|
||||
if (in_alpha > 1.0) {
|
||||
in_alpha = 1.0;
|
||||
}
|
||||
|
||||
@ -194,18 +193,16 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
|
||||
trav->traverse(next_data_out);
|
||||
trav->traverse(next_data_in);
|
||||
}
|
||||
if(_fade_timer < 0) { // Fading Complete
|
||||
if (_fade_timer < 0) { // Fading Complete
|
||||
_fade_mode = false;
|
||||
}
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
if (data._net_transform->is_singular()) {
|
||||
// If we're under a singular transform, we can't compute the LOD;
|
||||
// select none of them instead.
|
||||
//select_child(get_num_children());
|
||||
return false;
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
LPoint3f camera_pos(0, 0, 0);
|
||||
// Get the LOD center in camera space
|
||||
CPT(TransformState) rel_transform =
|
||||
@ -214,16 +211,15 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
|
||||
// Determine which child to traverse
|
||||
int index = cdata->_lod.compute_child(camera_pos, center);
|
||||
//printf("CHILD: %d PREVIOUS %d \n",index,_previous_child);
|
||||
if(index != _previous_child) { // Transition occurred
|
||||
_fade_mode = true;
|
||||
if (index != _previous_child) { // Transition occurred
|
||||
_fade_mode = true;
|
||||
_fade_timer = cdata->_fade_time;
|
||||
_fade_out = _previous_child;
|
||||
_fade_in = index;
|
||||
_previous_child = index;
|
||||
_previous_child = index;
|
||||
CullTraverserData next_data_transition(data, node->get_child(_fade_out));
|
||||
trav->traverse(next_data_transition);
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
// No transition... handle things as usual
|
||||
// Traverse only one valid child
|
||||
CullTraverserData next_data_normal(data, node->get_child(index));
|
||||
|
||||
@ -27,7 +27,6 @@
|
||||
#include "renderEffects.cxx"
|
||||
#include "renderModeAttrib.cxx"
|
||||
#include "renderState.cxx"
|
||||
#include "seaPatchNode.cxx"
|
||||
#include "sceneGraphAnalyzer.cxx"
|
||||
#include "sceneGraphReducer.cxx"
|
||||
#include "selectiveChildNode.cxx"
|
||||
|
||||
@ -74,7 +74,7 @@ add_light(const string &lightname, const NodePath &newlight) {
|
||||
nassertr(newlight.node() != (PolylightNode *)NULL,false);
|
||||
|
||||
// Check if light name is unique
|
||||
if(_lightgroup.find(lightname) != _lightgroup.end()) {
|
||||
if (_lightgroup.find(lightname) != _lightgroup.end()) {
|
||||
cerr << "Light name already exists. Please choose another name\n";
|
||||
return false;
|
||||
}
|
||||
@ -96,7 +96,7 @@ INLINE bool PolylightEffect::
|
||||
remove_light(const string &lightname) {
|
||||
|
||||
// Check if light name exists
|
||||
if(_lightgroup.find(lightname) == _lightgroup.end()) {
|
||||
if (_lightgroup.find(lightname) == _lightgroup.end()) {
|
||||
cerr << "Light name does not exist\n";
|
||||
return false;
|
||||
}
|
||||
@ -155,7 +155,7 @@ get_weight() const {
|
||||
// _contribution_type is a string that controls how
|
||||
// this division occurs.
|
||||
// "proximal" : A light only contributes if the node
|
||||
// is inside its volume
|
||||
// is inside its volume
|
||||
// "all" : All lights added to the effect are used in
|
||||
// division irrespective of their light volumes
|
||||
////////////////////////////////////////////////////////////////////
|
||||
|
||||
@ -57,71 +57,66 @@ do_poly_light(const CullTraverserData *data, const TransformState *node_transfor
|
||||
r = 1.0;
|
||||
g = 1.0;
|
||||
b = 1.0;
|
||||
if(is_enabled()) {
|
||||
if (is_enabled()) {
|
||||
LIGHTGROUP::const_iterator light_iter;
|
||||
// Cycle through all the lights in this effect's lightgroup
|
||||
for (light_iter = _lightgroup.begin(); light_iter != _lightgroup.end(); light_iter++){
|
||||
const PolylightNode *light = DCAST(PolylightNode,light_iter->second.node());
|
||||
// light holds the current PolylightNode
|
||||
if(light->is_enabled()) { // if enabled get all the properties
|
||||
float light_radius = light->get_radius();
|
||||
PolylightNode::Attenuation_Type light_attenuation = light->get_attenuation();
|
||||
float light_a0 = light->get_a0();
|
||||
float light_a1 = light->get_a1();
|
||||
float light_a2 = light->get_a2();
|
||||
if(light_a0 == 0 && light_a1 == 0 && light_a2 == 0) { // To prevent division by zero
|
||||
// light holds the current PolylightNode
|
||||
if (light->is_enabled()) { // if enabled get all the properties
|
||||
float light_radius = light->get_radius();
|
||||
PolylightNode::Attenuation_Type light_attenuation = light->get_attenuation();
|
||||
float light_a0 = light->get_a0();
|
||||
float light_a1 = light->get_a1();
|
||||
float light_a2 = light->get_a2();
|
||||
if (light_a0 == 0 && light_a1 == 0 && light_a2 == 0) { // To prevent division by zero
|
||||
light_a0 = 1.0;
|
||||
}
|
||||
Colorf light_color;
|
||||
if(light->is_flickering()) { // If flickering, modify color
|
||||
light_color = light->flicker();
|
||||
}
|
||||
else {
|
||||
light_color = light->get_color();
|
||||
}
|
||||
|
||||
// Calculate the distance of the node from the light
|
||||
//dist = light_iter->second->get_distance(data->_node_path.get_node_path());
|
||||
}
|
||||
Colorf light_color;
|
||||
if (light->is_flickering()) { // If flickering, modify color
|
||||
light_color = light->flicker();
|
||||
} else {
|
||||
light_color = light->get_color_scenegraph();
|
||||
}
|
||||
// Calculate the distance of the node from the light
|
||||
//dist = light_iter->second->get_distance(data->_node_path.get_node_path());
|
||||
const NodePath lightnp = light_iter->second;
|
||||
LPoint3f point = data->_node_path.get_node_path().get_relative_point(lightnp,
|
||||
light->get_pos());
|
||||
dist = (point - _effect_center).length();
|
||||
|
||||
if(dist < light_radius) { // If node is in range of this light
|
||||
if(light_attenuation == PolylightNode::ALINEAR) {
|
||||
light_scale = (light_radius - dist)/light_radius;
|
||||
}
|
||||
else if(light_attenuation == PolylightNode::AQUADRATIC) {
|
||||
fd = 1.0 / (light_a0 + light_a1 * dist + light_a2 * dist * dist);
|
||||
if(fd < 1.0) {
|
||||
light_scale = fd;
|
||||
}
|
||||
else {
|
||||
light_scale = 1.0;
|
||||
}
|
||||
}
|
||||
else {
|
||||
light_scale = 1.0;
|
||||
}
|
||||
// Keep accumulating each lights contribution... we divide by
|
||||
// number of lights later.
|
||||
Rcollect += light_color[0] * light_scale;
|
||||
Gcollect += light_color[1] * light_scale;
|
||||
Bcollect += light_color[2] * light_scale;
|
||||
num_lights++;
|
||||
} // if dist< radius
|
||||
} // if light is enabled
|
||||
if (dist < light_radius) { // If node is in range of this light
|
||||
if (light_attenuation == PolylightNode::ALINEAR) {
|
||||
light_scale = (light_radius - dist)/light_radius;
|
||||
} else if (light_attenuation == PolylightNode::AQUADRATIC) {
|
||||
fd = 1.0 / (light_a0 + light_a1 * dist + light_a2 * dist * dist);
|
||||
if (fd < 1.0) {
|
||||
light_scale = fd;
|
||||
} else {
|
||||
light_scale = 1.0;
|
||||
}
|
||||
} else {
|
||||
light_scale = 1.0;
|
||||
}
|
||||
// Keep accumulating each lights contribution... we divide by
|
||||
// number of lights later.
|
||||
Rcollect += light_color[0] * light_scale;
|
||||
Gcollect += light_color[1] * light_scale;
|
||||
Bcollect += light_color[2] * light_scale;
|
||||
num_lights++;
|
||||
} // if dist< radius
|
||||
} // if light is enabled
|
||||
} // for all lights
|
||||
|
||||
|
||||
if( _contribution_type == CALL) {
|
||||
if ( _contribution_type == CALL) {
|
||||
// Sometimes to prevent snapping of color at light volume boundaries
|
||||
// just divide total contribution by all the lights in the effect
|
||||
// whether or not they contribute color
|
||||
// just divide total contribution by all the lights in the effect
|
||||
// whether or not they contribute color
|
||||
num_lights = _lightgroup.size();
|
||||
}
|
||||
|
||||
if(num_lights == 0) {
|
||||
if (num_lights == 0) {
|
||||
no_lights_closeby = true;
|
||||
num_lights = 1;
|
||||
}
|
||||
@ -129,7 +124,7 @@ do_poly_light(const CullTraverserData *data, const TransformState *node_transfor
|
||||
Gcollect /= num_lights;
|
||||
Bcollect /= num_lights;
|
||||
|
||||
if(!no_lights_closeby) {
|
||||
if (!no_lights_closeby) {
|
||||
//r = 1.0 + ((1.0 - _weight) + Rcollect * _weight);
|
||||
//g = 1.0 + ((1.0 - _weight) + Gcollect * _weight);
|
||||
//b = 1.0 + ((1.0 - _weight) + Bcollect * _weight);
|
||||
@ -163,7 +158,7 @@ compare_to_impl(const RenderEffect *other) const {
|
||||
DCAST_INTO_R(ta, other, 0);
|
||||
|
||||
if (_enabled != ta->_enabled) {
|
||||
return _enabled ? 1 : -1;
|
||||
return _enabled ? 1 : -1;
|
||||
}
|
||||
|
||||
if (_contribution_type != ta->_contribution_type) {
|
||||
@ -171,7 +166,7 @@ compare_to_impl(const RenderEffect *other) const {
|
||||
}
|
||||
|
||||
if (_weight != ta->_weight) {
|
||||
return _weight < ta->_weight ? -1 :1;
|
||||
return _weight < ta->_weight ? -1 :1;
|
||||
}
|
||||
|
||||
if (_lightgroup != ta->_lightgroup) {
|
||||
|
||||
@ -33,10 +33,10 @@
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Class : PolylightEffect
|
||||
// Description : A PolylightEffect can be used on a node to define a
|
||||
// LightGroup for that node. A LightGroup contains
|
||||
// LightGroup for that node. A LightGroup contains
|
||||
// Polylights which are essentially nodes that add
|
||||
// color to the polygons of a model based on distance.
|
||||
// PolylightNode is a cheap way to get lighting effects
|
||||
// color to the polygons of a model based on distance.
|
||||
// PolylightNode is a cheap way to get lighting effects
|
||||
// specially for night scenes
|
||||
////////////////////////////////////////////////////////////////////
|
||||
class EXPCL_PANDA PolylightEffect : public RenderEffect {
|
||||
|
||||
@ -359,7 +359,8 @@ get_step_size() const {
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE void PolylightNode::
|
||||
set_color(Colorf color) {
|
||||
PandaNode::set_attrib(ColorAttrib::make_flat(color));
|
||||
//PandaNode::set_attrib(ColorAttrib::make_flat(color));
|
||||
_color = color;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
@ -369,12 +370,18 @@ set_color(Colorf color) {
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE void PolylightNode::
|
||||
set_color(float r, float g, float b) {
|
||||
/*
|
||||
Colorf color;
|
||||
color[0] = r;
|
||||
color[1] = g;
|
||||
color[2] = b;
|
||||
color[3] = 1.0;
|
||||
PandaNode::set_attrib(ColorAttrib::make_flat(color));
|
||||
*/
|
||||
_color[0] = r;
|
||||
_color[1] = g;
|
||||
_color[2] = b;
|
||||
_color[3] = 1.0;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
@ -384,6 +391,19 @@ set_color(float r, float g, float b) {
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE Colorf PolylightNode::
|
||||
get_color() const {
|
||||
return _color;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: PolylightNode::get_color_scenegraph
|
||||
// Access: Published
|
||||
// Description: This differs from get_color in that when applying
|
||||
// the light color we need to make sure that a color
|
||||
// flattening external to the PolylightNode is not
|
||||
// ignored.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE Colorf PolylightNode::
|
||||
get_color_scenegraph() const {
|
||||
|
||||
const RenderAttrib *attrib =
|
||||
PandaNode::get_attrib(ColorAttrib::get_class_type());
|
||||
@ -394,7 +414,7 @@ get_color() const {
|
||||
}
|
||||
}
|
||||
|
||||
return Colorf(1.0f, 1.0f, 1.0f, 1.0f);
|
||||
return _color;
|
||||
|
||||
}
|
||||
|
||||
|
||||
@ -70,36 +70,34 @@ Colorf PolylightNode::flicker() const {
|
||||
float r,g,b;
|
||||
|
||||
Colorf color;
|
||||
color = get_color();
|
||||
color = get_color_scenegraph();
|
||||
r = color[0];
|
||||
g = color[1];
|
||||
b = color[2];
|
||||
float variation= 0.0;
|
||||
|
||||
if(_flicker_type == FRANDOM) {
|
||||
if (_flicker_type == FRANDOM) {
|
||||
//srand((int)ClockObject::get_global_clock()->get_frame_time());
|
||||
variation = (rand()%100);// * ClockObject::get_global_clock()->get_dt();
|
||||
variation /= 100.0;
|
||||
//printf("Random Variation: %f\n",variation);
|
||||
variation += _offset;
|
||||
variation *= _scale;
|
||||
}
|
||||
else if(_flicker_type == FSIN) {
|
||||
double now = ClockObject::get_global_clock()->get_frame_time();
|
||||
variation /= 100.0;
|
||||
//printf("Random Variation: %f\n",variation);
|
||||
variation += _offset;
|
||||
variation *= _scale;
|
||||
} else if (_flicker_type == FSIN) {
|
||||
double now = ClockObject::get_global_clock()->get_frame_time();
|
||||
variation = sinf(now*_sin_freq);// * ClockObject::get_global_clock()->get_dt();
|
||||
//printf("Variation: %f\n",variation);
|
||||
variation += _offset;
|
||||
variation *= _scale;
|
||||
}
|
||||
else if(_flicker_type == FCUSTOM) {
|
||||
//printf("Variation: %f\n",variation);
|
||||
variation += _offset;
|
||||
variation *= _scale;
|
||||
} else if (_flicker_type == FCUSTOM) {
|
||||
// fixed point list of variation values coming soon...
|
||||
//double index = (ClockObject::get_global_clock()->get_frame_time() % len(fixed_points)) * ClockObject::get_global_clock()->get_dt();
|
||||
//index *= _speed;
|
||||
/*if(!(int)index > len(fixed_points) {
|
||||
variation = _fixed_points[(int)index];
|
||||
variation += _offset;
|
||||
variation *= _scale;
|
||||
}*/
|
||||
//index *= _speed;
|
||||
/*if (!(int)index > len(fixed_points) {
|
||||
variation = _fixed_points[(int)index];
|
||||
variation += _offset;
|
||||
variation *= _scale;
|
||||
}*/
|
||||
}
|
||||
//printf("Variation: %f\n",variation);
|
||||
r+=variation;
|
||||
@ -107,7 +105,7 @@ Colorf PolylightNode::flicker() const {
|
||||
b+=variation;
|
||||
|
||||
/* CLAMPING
|
||||
if(fabs(r - color[0]) > 0.5 || fabs(g - color[1]) > 0.5 || fabs(b - color[2]) > 0.5) {
|
||||
if (fabs(r - color[0]) > 0.5 || fabs(g - color[1]) > 0.5 || fabs(b - color[2]) > 0.5) {
|
||||
r = color[0];
|
||||
g = color[1];
|
||||
b = color[2];
|
||||
@ -126,7 +124,7 @@ Colorf PolylightNode::flicker() const {
|
||||
//
|
||||
// Two PolylightNodes are considered equivalent if they
|
||||
// consist of exactly the same properties
|
||||
// Otherwise, they are different; different
|
||||
// Otherwise, they are different; different
|
||||
// PolylightNodes will be ranked in a consistent but
|
||||
// undefined ordering; the ordering is useful only for
|
||||
// placing the PolylightNodes in a sorted container like an
|
||||
@ -136,62 +134,62 @@ int PolylightNode::
|
||||
compare_to(const PolylightNode &other) const {
|
||||
|
||||
if (_enabled != other._enabled) {
|
||||
return _enabled ? 1 :-1;
|
||||
return _enabled ? 1 :-1;
|
||||
}
|
||||
|
||||
if (_radius != other._radius) {
|
||||
return _radius < other._radius ? -1 :1;
|
||||
return _radius < other._radius ? -1 :1;
|
||||
}
|
||||
LVecBase3f position = get_pos();
|
||||
LVecBase3f other_position = other.get_pos();
|
||||
if (position != other_position) {
|
||||
return position < other_position ? -1 :1;
|
||||
return position < other_position ? -1 :1;
|
||||
}
|
||||
|
||||
Colorf color = get_color();
|
||||
Colorf other_color = other.get_color();
|
||||
if (color != other_color) {
|
||||
return color < other_color ? -1 :1;
|
||||
return color < other_color ? -1 :1;
|
||||
}
|
||||
|
||||
if (_attenuation_type != other._attenuation_type) {
|
||||
return _attenuation_type < other._attenuation_type ? -1 :1;
|
||||
return _attenuation_type < other._attenuation_type ? -1 :1;
|
||||
}
|
||||
|
||||
if (_a0 != other._a0) {
|
||||
return _a0 < other._a0 ? -1 :1;
|
||||
return _a0 < other._a0 ? -1 :1;
|
||||
}
|
||||
|
||||
if (_a1 != other._a1) {
|
||||
return _a1 < other._a1 ? -1 :1;
|
||||
return _a1 < other._a1 ? -1 :1;
|
||||
}
|
||||
|
||||
if (_a2 != other._a2) {
|
||||
return _a2 < other._a2 ? -1 :1;
|
||||
return _a2 < other._a2 ? -1 :1;
|
||||
}
|
||||
|
||||
if (_flickering != other._flickering) {
|
||||
return _flickering ? 1 :-1;
|
||||
return _flickering ? 1 :-1;
|
||||
}
|
||||
|
||||
if (_flicker_type != other._flicker_type) {
|
||||
return _flicker_type < other._flicker_type ? -1 :1;
|
||||
return _flicker_type < other._flicker_type ? -1 :1;
|
||||
}
|
||||
|
||||
if (_offset != other._offset) {
|
||||
return _offset < other._offset ? -1 :1;
|
||||
return _offset < other._offset ? -1 :1;
|
||||
}
|
||||
|
||||
if (_scale != other._scale) {
|
||||
return _scale < other._scale ? -1 :1;
|
||||
return _scale < other._scale ? -1 :1;
|
||||
}
|
||||
|
||||
if (_step_size != other._step_size) {
|
||||
return _step_size < other._step_size ? -1 :1;
|
||||
return _step_size < other._step_size ? -1 :1;
|
||||
}
|
||||
|
||||
if (_sin_freq != other._sin_freq) {
|
||||
return _sin_freq < other._sin_freq ? -1 :1;
|
||||
return _sin_freq < other._sin_freq ? -1 :1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -43,9 +43,9 @@ PUBLISHED:
|
||||
// have a simpler constructor and require the programmer
|
||||
// to use set_* methods.
|
||||
PolylightNode(const string &name, float x = 0.0, float y = 0.0, float z = 0.0,
|
||||
float r = 1.0, float g = 1.0, float b = 1.0,
|
||||
float radius=50.0, string attenuation_type= "linear",
|
||||
bool flickering =false, string flicker_type="random");
|
||||
float r = 1.0, float g = 1.0, float b = 1.0,
|
||||
float radius=50.0, string attenuation_type= "linear",
|
||||
bool flickering =false, string flicker_type="random");
|
||||
*/
|
||||
|
||||
enum Flicker_Type {
|
||||
@ -68,6 +68,7 @@ PUBLISHED:
|
||||
INLINE void set_color(Colorf color);
|
||||
INLINE void set_color(float r, float g, float b);
|
||||
INLINE Colorf get_color() const;
|
||||
INLINE Colorf get_color_scenegraph() const;
|
||||
INLINE void set_radius(float r);
|
||||
INLINE float get_radius() const;
|
||||
INLINE bool set_attenuation(Attenuation_Type type);
|
||||
@ -107,7 +108,7 @@ public:
|
||||
private:
|
||||
bool _enabled;
|
||||
LVecBase3f _position;
|
||||
//Colorf _color;
|
||||
Colorf _color;
|
||||
float _radius;
|
||||
Attenuation_Type _attenuation_type;
|
||||
float _a0;
|
||||
|
||||
@ -1,550 +0,0 @@
|
||||
// Filename: seaPatchNode.I
|
||||
// Created by: sshodhan (18Jun04)
|
||||
//
|
||||
////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// PANDA 3D SOFTWARE
|
||||
// Copyright (c) 2001 - 2004, Disney Enterprises, Inc. All rights reserved
|
||||
//
|
||||
// All use of this software is subject to the terms of the Panda 3d
|
||||
// Software license. You should have received a copy of this license
|
||||
// along with this source code; you will also find a current copy of
|
||||
// the license at http://etc.cmu.edu/panda3d/docs/license/ .
|
||||
//
|
||||
// To contact the maintainers of this program write to
|
||||
// panda3d-general@lists.sourceforge.net .
|
||||
//
|
||||
////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::operator ==
|
||||
// Access: Published
|
||||
// Description: Returns true if the two lights are equivalent
|
||||
// that is, all their properties are same
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE bool SeaPatchNode::
|
||||
operator == (const SeaPatchNode &other) const {
|
||||
return (compare_to(other) == 0);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::operator !=
|
||||
// Access: Published
|
||||
// Description: Returns true if the two lights are not equivalent.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE bool SeaPatchNode::
|
||||
operator != (const SeaPatchNode &other) const {
|
||||
return (compare_to(other) != 0);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::operator <
|
||||
// Access: Published
|
||||
// Description: Returns true if this SeaPatchNode sorts before the other
|
||||
// one, false otherwise. The sorting order of two
|
||||
// nonequivalent SeaPatchNodes is consistent but undefined,
|
||||
// and is useful only for storing SeaPatchNodes in a sorted
|
||||
// container like an STL set.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE bool SeaPatchNode::
|
||||
operator < (const SeaPatchNode &other) const {
|
||||
return (compare_to(other) < 0);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::is_enabled
|
||||
// Access: Published
|
||||
// Description: Is this light is enabled/disabled?
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE bool SeaPatchNode::
|
||||
is_enabled() const {
|
||||
return _enabled;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::enable
|
||||
// Access: Published
|
||||
// Description: Enable this light
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE void SeaPatchNode::
|
||||
enable(){
|
||||
_enabled=true;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::disable
|
||||
// Access: Published
|
||||
// Description: Disable this light
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE void SeaPatchNode::
|
||||
disable(){
|
||||
_enabled=false;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::set_amp
|
||||
// Access: Published
|
||||
// Description: Set Wave Amplitude
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE void SeaPatchNode::
|
||||
set_amp(float amplitude) {
|
||||
_amplitude = amplitude;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::set_freq
|
||||
// Access: Published
|
||||
// Description: Set Wave Frequency
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE void SeaPatchNode::
|
||||
set_freq(float frequency) {
|
||||
_frequency = frequency;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::get_amp
|
||||
// Access: Published
|
||||
// Description: Get Wave amplitude
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE float SeaPatchNode::
|
||||
get_amp() const {
|
||||
return _amplitude;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::get_freq
|
||||
// Access: Published
|
||||
// Description: Get Wave frequency
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE float SeaPatchNode::
|
||||
get_freq() const {
|
||||
return _frequency;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::set_passive_move
|
||||
// Access: Published
|
||||
// Description: This is the U and V speed at which textures will
|
||||
// slide in default mode. This is kind of like an
|
||||
// idle cylce for the ocean water
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE void SeaPatchNode::
|
||||
set_passive_move(LVecBase2f UV) {
|
||||
_passive_move = UV;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::get_passive_move
|
||||
// Access: Published
|
||||
// Description: This is the U and V speed at which textures will
|
||||
// slide in default mode. This is kind of like an
|
||||
// idle cylce for the ocean water
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE LVecBase2f SeaPatchNode::
|
||||
get_passive_move() const {
|
||||
return _passive_move;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::get_center
|
||||
// Access: Published
|
||||
// Description: Center for fade out effect
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE LPoint3f SeaPatchNode::
|
||||
get_center() const {
|
||||
return _center;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::get_radius
|
||||
// Access: Published
|
||||
// Description: Radius for fade out effect
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE float SeaPatchNode::
|
||||
get_radius() const {
|
||||
return _radius;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::get_threshold
|
||||
// Access: Published
|
||||
// Description: Threshold for fade out effect
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE float SeaPatchNode::
|
||||
get_threshold() const {
|
||||
return _threshold;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::set_center
|
||||
// Access: Published
|
||||
// Description: Center for fade out effect
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE void SeaPatchNode::
|
||||
set_center(LPoint3f center) {
|
||||
_center = center;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::set_radius
|
||||
// Access: Published
|
||||
// Description: Radius for fade out effect
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE void SeaPatchNode::
|
||||
set_radius(float r) {
|
||||
_radius = r;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::set_threshold
|
||||
// Access: Published
|
||||
// Description: Radius for fade out effect
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE void SeaPatchNode::
|
||||
set_threshold(float t) {
|
||||
_threshold = t;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::set_noise_amp
|
||||
// Access: Published
|
||||
// Description: Set Noise Amplitude
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE void SeaPatchNode::
|
||||
set_noise_amp(float x) {
|
||||
_noise_amp = x;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::get_noise_amp
|
||||
// Access: Published
|
||||
// Description: Amplitude of noise
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE float SeaPatchNode::
|
||||
get_noise_amp() const {
|
||||
return _noise_amp;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::enable_noise_uv
|
||||
// Access: Published
|
||||
// Description: Apply noise to UVs
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE void SeaPatchNode::
|
||||
enable_noise_uv() {
|
||||
_noise_on_uv = true;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::disable_noise_uv
|
||||
// Access: Published
|
||||
// Description: Disable applying noise to UVs
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE void SeaPatchNode::
|
||||
disable_noise_uv() {
|
||||
_noise_on_uv = false;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::is_noise_on_uv
|
||||
// Access: Published
|
||||
// Description: Check if noise is on
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE bool SeaPatchNode::
|
||||
is_noise_on_uv() const {
|
||||
return _noise_on_uv;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::set_noise_f
|
||||
// Access: Published
|
||||
// Description: Set Noise Frequency
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE void SeaPatchNode::
|
||||
set_noise_f(float f) {
|
||||
_noise_f = f;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::get_noise_f
|
||||
// Access: Published
|
||||
// Description: Get Noise Frequency
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE float SeaPatchNode::
|
||||
get_noise_f() {
|
||||
return _noise_f;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::Weight
|
||||
// Description:
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE float SeaPatchNode::
|
||||
Weight(float t) {
|
||||
return (2.0*fabs(t)-3.0) * t*t + 1.0;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: Mod
|
||||
// Description: An implementation of modulo (%) that is correct for
|
||||
// negative numbers.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE int SeaPatchNode::
|
||||
Mod(int quotient, int divisor) {
|
||||
return (quotient >= 0) ?
|
||||
(quotient % divisor) :
|
||||
(divisor-1 - ((-quotient-1) % divisor));
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: set_xsize
|
||||
// Description: A scale factor for x values to noise function
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE void SeaPatchNode::
|
||||
set_xsize(float xs) {
|
||||
_xsize = xs;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: set_ysize
|
||||
// Description: A scale factor for y values to noise function
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE void SeaPatchNode::
|
||||
set_ysize(float ys) {
|
||||
_ysize = ys;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: get_xsize
|
||||
// Description: A scale factor for x values to noise function
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE float SeaPatchNode::
|
||||
get_xsize() const {
|
||||
return _xsize;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: get_ysize
|
||||
// Description: A scale factor for y values to noise function
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE float SeaPatchNode::
|
||||
get_ysize() const {
|
||||
return _ysize;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: set_u_scale
|
||||
// Description: U coordinate computation scale
|
||||
// We recompute UVs every frame based on world coords
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE void SeaPatchNode::
|
||||
set_u_scale(float us) {
|
||||
_u_scale = us;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: set_v_scale
|
||||
// Description: V coordinate computation scale
|
||||
// We recompute UVs every frame based on world coords
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE void SeaPatchNode::
|
||||
set_v_scale(float vs) {
|
||||
_v_scale = vs;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: get_u_scale
|
||||
// Description: U coordinate computation scale
|
||||
// We recompute UVs every frame based on world coords
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE float SeaPatchNode::
|
||||
get_u_scale() const {
|
||||
return _u_scale;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: get_v_scale
|
||||
// Description: V coordinate computation scale
|
||||
// We recompute UVs every frame based on world coords
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE float SeaPatchNode::
|
||||
get_v_scale() const {
|
||||
return _v_scale;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: get_height
|
||||
// Description: Get the height of any point in the grid
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE float SeaPatchNode::
|
||||
get_height(float x, float y) const {
|
||||
return ((sin(_wave_movement + (x / _wavelength[0]) )
|
||||
+ sin(_wave_movement + (y / _wavelength[1]))) * _amplitude);
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: get_normal
|
||||
// Description: return the normal to any point in the grid
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE LVecBase3f SeaPatchNode::
|
||||
get_normal(float x, float y) const {
|
||||
float h, h1, h2;
|
||||
h = get_height(x,y);
|
||||
h1 = get_height(x - 0.3, y + 0.2);
|
||||
h2 = get_height(x - 0.4, y - 0.1);
|
||||
|
||||
LVecBase3f a,b,N,s,a1, b1;
|
||||
|
||||
a[0] = x - 0.3;
|
||||
a[1] = y + 0.2;
|
||||
a[2] = h1;
|
||||
|
||||
b[0] = x - 0.4;
|
||||
b[1] = y - 0.1;
|
||||
b[2] = h2;
|
||||
|
||||
s[0] = x;
|
||||
s[1] = y;
|
||||
s[2] = h;
|
||||
|
||||
a1 = a - s;
|
||||
b1 = b - s;
|
||||
|
||||
N = cross(a1,b1);
|
||||
|
||||
|
||||
float length = (float)sqrt(N[0]*N[0] + N[1]*N[1] + N[2]*N[2]);
|
||||
|
||||
if(length == 0.0) {
|
||||
length = 1.0;
|
||||
}
|
||||
|
||||
N[0] /= length;
|
||||
N[1] /= length;
|
||||
N[2] /= length;
|
||||
|
||||
return N;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: set_cscale
|
||||
// Description: Color scale for the vertex color... its just an
|
||||
// additive term
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE void SeaPatchNode::
|
||||
set_cscale(float cs) {
|
||||
_color_scale = cs;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: set_ascale
|
||||
// Description: Alpha scale for the vertex color... its just an
|
||||
// additive term
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE void SeaPatchNode::
|
||||
set_ascale(float as) {
|
||||
_alpha_scale = as;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: get_cscale
|
||||
// Description: Color scale for the vertex color... its just an
|
||||
// additive term
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE float SeaPatchNode::
|
||||
get_cscale() const {
|
||||
return _color_scale;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: get_ascale
|
||||
// Description: Alpha scale for the vertex color... its just an
|
||||
// additive term
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE float SeaPatchNode::
|
||||
get_ascale() const {
|
||||
return _alpha_scale;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: set_light_color
|
||||
// Description: Vertex color has an additive light component
|
||||
// Contributes 1/3 of the color
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE void SeaPatchNode::
|
||||
set_light_color(Colorf c) {
|
||||
_light_color = c;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: get_light_color
|
||||
// Description: Vertex color has an additive light component
|
||||
// Contributes 1/3 of the color
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE Colorf SeaPatchNode::
|
||||
get_light_color() const {
|
||||
return _light_color;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: get_u_sin_scale
|
||||
// Description: Pass a sin wave through the UV scaling
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE float SeaPatchNode::
|
||||
get_u_sin_scale() const {
|
||||
return _u_sin_scale;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: get_v_sin_scale
|
||||
// Description: Pass a sin wave through the UV scaling
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE float SeaPatchNode::
|
||||
get_v_sin_scale() const {
|
||||
return _v_sin_scale;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: set_u_sin_scale
|
||||
// Description: Pass a sin wave through the UV scaling
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE void SeaPatchNode::
|
||||
set_u_sin_scale(float s) {
|
||||
_u_sin_scale = s;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: set_u_sin_scale
|
||||
// Description: Pass a sin wave through the UV scaling
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE void SeaPatchNode::
|
||||
set_v_sin_scale(float s) {
|
||||
_v_sin_scale = s;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: get_wavelength
|
||||
// Description: Get the wavelength dividing factor
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE LVecBase2f SeaPatchNode::
|
||||
get_wavelength() const {
|
||||
return _wavelength;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: set_wavelength
|
||||
// Description: Set the wavelength dividing factor
|
||||
////////////////////////////////////////////////////////////////////
|
||||
INLINE void SeaPatchNode::
|
||||
set_wavelength(LVecBase2f w) {
|
||||
_wavelength = w;
|
||||
}
|
||||
|
||||
|
||||
@ -1,472 +0,0 @@
|
||||
// Filename: seaPatchNode.cxx
|
||||
// Created by: sshodhan (18Jun04)
|
||||
//
|
||||
////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// PANDA 3D SOFTWARE
|
||||
// Copyright (c) 2001 - 2004, Disney Enterprises, Inc. All rights reserved
|
||||
//
|
||||
// All use of this software is subject to the terms of the Panda 3d
|
||||
// Software license. You should have received a copy of this license
|
||||
// along with this source code; you will also find a current copy of
|
||||
// the license at http://etc.cmu.edu/panda3d/docs/license/ .
|
||||
//
|
||||
// To contact the maintainers of this program write to
|
||||
// panda3d-general@lists.sourceforge.net .
|
||||
//
|
||||
////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
#include "config_pgraph.h"
|
||||
#include "nodePath.h"
|
||||
#include "clockObject.h"
|
||||
#include "dcast.h"
|
||||
#include "cullTraverserData.h"
|
||||
#include "cullTraverser.h"
|
||||
#include "seaPatchNode.h"
|
||||
#include "geomNode.h"
|
||||
#include "geom.h"
|
||||
|
||||
|
||||
#include <math.h>
|
||||
|
||||
TypeHandle SeaPatchNode::_type_handle;
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::Constructor
|
||||
// Access: Published
|
||||
// Description: Use SeaPatchNode() to construct a new
|
||||
// SeaPatchNode object.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
SeaPatchNode::
|
||||
SeaPatchNode(const string &name) :
|
||||
PandaNode(name)
|
||||
{
|
||||
// center
|
||||
LPoint3f c;
|
||||
c[0] = 0.0;
|
||||
c[1] = 0.0;
|
||||
c[2] = 0.0;
|
||||
_center = c;
|
||||
_enabled = true;
|
||||
// continuously increasing parameter to advance the wave
|
||||
_wave_movement = 0.0;
|
||||
_wavelength = 25.0;
|
||||
_amplitude = 0.05;
|
||||
_frequency = 0.01;
|
||||
// from threshold -> radius the waves will fade out
|
||||
_radius = 100.0;
|
||||
_threshold = 80.0;
|
||||
// sliding of UVs
|
||||
_passive_move[0] = 0.0001;
|
||||
_passive_move[1] = 0.0001;
|
||||
// UV noise
|
||||
_noise_amp = 0.001;
|
||||
_noise_on_uv = true;
|
||||
_noise_f = 10.0;
|
||||
_noise_detail = 4;
|
||||
_xsize = 256.0;
|
||||
_ysize = 256.0;
|
||||
_u_scale = 256.0;
|
||||
_v_scale = 256.0;
|
||||
_u_sin_scale = 1/100.0;
|
||||
_v_sin_scale = 1/100.0;
|
||||
// randomize noise tables
|
||||
noise_init();
|
||||
// shading
|
||||
_alpha_scale = 1.0;
|
||||
_color_scale = 1.0;
|
||||
_light_color = Colorf(0.2, 0.4, 0.6, 1.0);
|
||||
_alpha_mode = ANONE;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::has_cull_callback
|
||||
// Access: Public, Virtual
|
||||
// Description: Should be overridden by derived classes to return
|
||||
// true if cull_callback() has been defined. Otherwise,
|
||||
// returns false to indicate cull_callback() does not
|
||||
// need to be called for this node during the cull
|
||||
// traversal.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
bool SeaPatchNode::
|
||||
has_cull_callback() const {
|
||||
return true;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::cull_callback
|
||||
// Access: Public, Virtual
|
||||
// Description: If has_cull_callback() returns true, this function
|
||||
// will be called during the cull traversal to perform
|
||||
// any additional operations that should be performed at
|
||||
// cull time. This may include additional manipulation
|
||||
// of render state or additional visible/invisible
|
||||
// decisions, or any other arbitrary operation.
|
||||
//
|
||||
// By the time this function is called, the node has
|
||||
// already passed the bounding-volume test for the
|
||||
// viewing frustum, and the node's transform and state
|
||||
// have already been applied to the indicated
|
||||
// CullTraverserData object.
|
||||
//
|
||||
// The return value is true if this node should be
|
||||
// visible, or false if it should be culled.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
bool SeaPatchNode::
|
||||
cull_callback(CullTraverser *trav, CullTraverserData &data) {
|
||||
|
||||
PandaNode *node = data.node(); // Get SeaPatchNode
|
||||
// Get net transoformation matrix
|
||||
LMatrix4f net_trans_mat =
|
||||
data._node_path.get_node_path().get_net_transform()->get_mat();
|
||||
|
||||
if(is_enabled()) {
|
||||
// Go through all the children, find Geom nodes and pass waves
|
||||
recurse_children(node,net_trans_mat);
|
||||
// Advance the wave for all children
|
||||
_wave_movement += _frequency; // Advance the wave
|
||||
}
|
||||
|
||||
// Continue traversal
|
||||
int num_children = node->get_num_children();
|
||||
for(int i = 0; i < num_children; i++) {
|
||||
CullTraverserData child_data(data, node->get_child(i));
|
||||
trav->traverse(child_data);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::recurse_children
|
||||
// Access: Published
|
||||
// Description: Dig out the GeomNodes and do_wave on them
|
||||
////////////////////////////////////////////////////////////////////
|
||||
void SeaPatchNode::
|
||||
recurse_children(PandaNode *node, LMatrix4f net_trans_mat) {
|
||||
|
||||
if (node->is_of_type(GeomNode::get_class_type())) {
|
||||
GeomNode *geom_node = DCAST(GeomNode, node);
|
||||
int num_geoms = geom_node->get_num_geoms();
|
||||
for(int j =0; j < num_geoms; j++) {
|
||||
PT(Geom) geom = geom_node->get_geom(j);
|
||||
do_wave(geom, net_trans_mat);
|
||||
}
|
||||
}
|
||||
PandaNode::Children cr = node->get_children();
|
||||
int num_children = cr.get_num_children();
|
||||
for (int i = 0; i < num_children; i++) {
|
||||
recurse_children(cr.get_child(i), net_trans_mat);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::do_wave
|
||||
// Access: Published
|
||||
// Description: pass sine wave through geometry
|
||||
// add UV noise and movement
|
||||
// apply vertex color based shading
|
||||
////////////////////////////////////////////////////////////////////
|
||||
void SeaPatchNode::
|
||||
do_wave(Geom * geom, LMatrix4f net_trans_mat) {
|
||||
float dist;
|
||||
unsigned int num_vertices = geom->get_num_vertices();
|
||||
PTA_ushort vindex;
|
||||
PTA_ushort tindex;
|
||||
PTA_ushort cindex;
|
||||
PTA_ushort nindex;
|
||||
PTA_Vertexf vert;
|
||||
PTA_TexCoordf texc;
|
||||
PTA_Colorf colors;
|
||||
PTA_Normalf norms;
|
||||
Colorf c;
|
||||
GeomBindType btypet;
|
||||
float u = 0.0, v = 0.0;
|
||||
float unoise,vnoise;
|
||||
float height_change;
|
||||
|
||||
// Get vertices and UVs
|
||||
geom->get_coords(vert, vindex);
|
||||
geom->get_texcoords(texc, btypet, tindex);
|
||||
|
||||
for (unsigned int k = 0; k < num_vertices; k++) { // For all vertices
|
||||
LPoint3f V = vert[k] * net_trans_mat; // multiply with net transform
|
||||
LPoint3f new_center = _center * net_trans_mat;
|
||||
|
||||
height_change = (sin(_wave_movement + (V[0] / _wavelength[0]) )
|
||||
+ sin(_wave_movement + (V[1] / _wavelength[1]))) * _amplitude; // Do the wave
|
||||
|
||||
// need this distance for fading out waves
|
||||
// ** add fading out to getHeight function
|
||||
dist = (float) sqrt( pow(V[0] - new_center[0],2) + pow(V[1] - new_center[1],2));
|
||||
|
||||
if(dist > _threshold) {
|
||||
if(dist >= _radius) {
|
||||
vert[k][2] = 0.0; // completely faded out
|
||||
}
|
||||
else {
|
||||
vert[k][2] = height_change * ((_radius - dist)/ _radius); // linear fade
|
||||
}
|
||||
}
|
||||
else {
|
||||
vert[k][2] = height_change;
|
||||
}
|
||||
|
||||
// Recompute normals based on height
|
||||
norms.push_back(get_normal(V[0],V[1]));
|
||||
nindex.push_back(k);
|
||||
geom->set_normals(norms, G_PER_VERTEX, nindex);
|
||||
|
||||
// Vertex color based shading
|
||||
// ** add shade_mode (high, low , all, none)
|
||||
c[0] = (_color_scale + _light_color[0] + (height_change / (2 * _amplitude)))/3.0;
|
||||
c[1] = (_color_scale + _light_color[1] + (height_change / (2 * _amplitude)))/3.0;
|
||||
c[2] = (_color_scale + _light_color[2] + (height_change / (2 * _amplitude)))/3.0;
|
||||
if(_alpha_mode == AHIGH) {
|
||||
c[3] = (_alpha_scale + _light_color[3] + (1.0 - (height_change / (2 * _amplitude))))/3.0;
|
||||
}
|
||||
else if(_alpha_mode == ALOW) {
|
||||
c[3] = (_alpha_scale + _light_color[3] + (height_change / (2 * _amplitude)))/3.0;
|
||||
}
|
||||
else if(_alpha_mode == ATOTAL) {
|
||||
c[3] = (_alpha_scale + _light_color[3]) /2.0;
|
||||
}
|
||||
else if(_alpha_mode == ANONE) {
|
||||
c[3] = 1.0;
|
||||
}
|
||||
|
||||
colors.push_back(c);
|
||||
cindex.push_back(k);
|
||||
|
||||
// UV COMPUTATION
|
||||
// Divide vertex X and Y coords by some scale
|
||||
// Also, pass sin wave through the scale for UV scaling
|
||||
// ** Need to make this transform independant
|
||||
_u_scale += sin (_wave_movement) * _u_sin_scale;
|
||||
_v_scale += sin (_wave_movement) * _v_sin_scale;
|
||||
|
||||
if(_u_scale == 0) {
|
||||
_u_scale = 1;
|
||||
}
|
||||
if(_v_scale == 0) {
|
||||
_v_scale = 1;
|
||||
}
|
||||
|
||||
u = V[0] / _u_scale;
|
||||
v = V[1] / _v_scale;
|
||||
|
||||
|
||||
// UV Noise (using the DQ Pirates noise function)
|
||||
if(_noise_on_uv) {
|
||||
unoise = do_noise(V[0], V[1], ClockObject::get_global_clock()->get_frame_time(), 0);
|
||||
vnoise = do_noise(V[0], V[1], ClockObject::get_global_clock()->get_frame_time(), 1);
|
||||
u += unoise;
|
||||
v += vnoise;
|
||||
}
|
||||
// Texture sliding
|
||||
texc[k][0] = u + _move_variable[0];
|
||||
texc[k][1] = v + _move_variable[1];
|
||||
}
|
||||
|
||||
// Apply vertex shading
|
||||
geom->set_colors (colors, G_PER_VERTEX , cindex);
|
||||
|
||||
_move_variable[0] += _passive_move[0];
|
||||
_move_variable[1] += _passive_move[1];
|
||||
|
||||
if(_move_variable[0] > 1.0) {
|
||||
_move_variable[0] = 0.0;
|
||||
}
|
||||
if(_move_variable[1] > 1.0) {
|
||||
_move_variable[1] = 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: NoiseWave::Constructor
|
||||
// Access: Public, Scheme
|
||||
// Description: Initialize noise permutation and gradient table
|
||||
// This function is adapted from the old DQ pirates code
|
||||
// Everything is done for both U and V noise
|
||||
////////////////////////////////////////////////////////////////////
|
||||
void SeaPatchNode::
|
||||
noise_init() {
|
||||
|
||||
int i, j, k, t;
|
||||
|
||||
// Randomize the permutation table.
|
||||
// U TABLE
|
||||
for (i = 0; i < noise_table_size; i++) {
|
||||
_perm_tab_u[i] = i;
|
||||
}
|
||||
for (i = 0; i < (noise_table_size / 2); i++) {
|
||||
j = rand() % noise_table_size;
|
||||
k = rand() % noise_table_size;
|
||||
t = _perm_tab_u[j];
|
||||
_perm_tab_u[j] = _perm_tab_u[k];
|
||||
_perm_tab_u[k] = t;
|
||||
}
|
||||
|
||||
|
||||
// Randomize the permutation table.
|
||||
// V TABLE
|
||||
for (i = 0; i < noise_table_size; i++) {
|
||||
_perm_tab_v[i] = i;
|
||||
}
|
||||
for (i = 0; i < (noise_table_size / 2); i++) {
|
||||
j = rand() % noise_table_size;
|
||||
k = rand() % noise_table_size;
|
||||
t = _perm_tab_v[j];
|
||||
_perm_tab_v[j] = _perm_tab_v[k];
|
||||
_perm_tab_v[k] = t;
|
||||
}
|
||||
|
||||
|
||||
// Choose a number of random unit vectors for the gradient table.
|
||||
// U TABLE
|
||||
for (i = 0; i < noise_table_size; i++) {
|
||||
float m_u;
|
||||
do {
|
||||
_grad_tab_u[i][0] = (float)(rand() - (RAND_MAX / 2)) / (RAND_MAX / 2);
|
||||
_grad_tab_u[i][1] = (float)(rand() - (RAND_MAX / 2)) / (RAND_MAX / 2);
|
||||
_grad_tab_u[i][2] = (float)(rand() - (RAND_MAX / 2)) / (RAND_MAX / 2);
|
||||
m_u = _grad_tab_u[i].dot(_grad_tab_u[i]);
|
||||
} while (m_u == 0.0 || m_u > 1.0);
|
||||
|
||||
_grad_tab_u[i] /= sqrt(m_u);
|
||||
}
|
||||
|
||||
// Choose a number of random unit vectors for the gradient table.
|
||||
// V TABLE
|
||||
for (i = 0; i < noise_table_size; i++) {
|
||||
float m_v;
|
||||
do {
|
||||
_grad_tab_v[i][0] = (float)(rand() - (RAND_MAX / 2)) / (RAND_MAX / 2);
|
||||
_grad_tab_v[i][1] = (float)(rand() - (RAND_MAX / 2)) / (RAND_MAX / 2);
|
||||
_grad_tab_v[i][2] = (float)(rand() - (RAND_MAX / 2)) / (RAND_MAX / 2);
|
||||
m_v = _grad_tab_v[i].dot(_grad_tab_v[i]);
|
||||
} while (m_v == 0.0 || m_v > 1.0);
|
||||
|
||||
_grad_tab_v[i] /= sqrt(m_v);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: NoiseWave::PlainNoise
|
||||
// Access: Protected
|
||||
// Description: 3D noise function
|
||||
// Takes x, y position , time, some scale s
|
||||
// uvi determines if its U noise or V noise
|
||||
////////////////////////////////////////////////////////////////////
|
||||
float SeaPatchNode::
|
||||
plain_noise(float x, float y, float z, unsigned int s, int uvi ) {
|
||||
x *= s;
|
||||
y *= s;
|
||||
z *= s;
|
||||
int a = (int)floor(x);
|
||||
int b = (int)floor(y);
|
||||
int c = (int)floor(z);
|
||||
|
||||
float sum = 0.0;
|
||||
int i, j, k;
|
||||
for (i = 0; i < 2; i++) {
|
||||
for (j = 0; j < 2; j++) {
|
||||
for (k = 0; k < 2; k++) {
|
||||
if(uvi ==0 ) {
|
||||
int n_u = _perm_tab_u[Mod(c + k,noise_table_size)];
|
||||
n_u = _perm_tab_u[Mod(b + j + n_u , noise_table_size)];
|
||||
n_u = _perm_tab_u[Mod(a + i + n_u , noise_table_size)];
|
||||
LVecBase3f v_u(x - a - i, y - b - j, z - c - k);
|
||||
sum += Weight(v_u[0]) * Weight(v_u[1]) * Weight(v_u[2]) *
|
||||
(_grad_tab_u[n_u].dot(v_u));
|
||||
}
|
||||
else {
|
||||
int n_v = _perm_tab_v[Mod(c + k , noise_table_size)];
|
||||
n_v = _perm_tab_v[Mod(b + j + n_v , noise_table_size)];
|
||||
n_v = _perm_tab_v[Mod(a + i + n_v , noise_table_size)];
|
||||
LVecBase3f v_v(x - a - i, y - b - j, z - c - k);
|
||||
sum += Weight(v_v[0]) * Weight(v_v[1]) * Weight(v_v[2]) *
|
||||
(_grad_tab_v[n_v].dot(v_v));
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return sum / s;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: NoiseWave::do_noise
|
||||
// Access: Protected
|
||||
// Description: Based on detail additively compute various level
|
||||
// of detail noises
|
||||
////////////////////////////////////////////////////////////////////
|
||||
float SeaPatchNode::
|
||||
do_noise(float x, float y, float t, int uvi) {
|
||||
|
||||
unsigned int s = 1;
|
||||
x /= _xsize;
|
||||
y /= _ysize;
|
||||
t *= _noise_f * 0.1;
|
||||
|
||||
float sum = 0.0;
|
||||
int i;
|
||||
for (i = 0; i <= _noise_detail; i++) {
|
||||
sum += plain_noise(x, y, t, s, uvi);
|
||||
s *= 2;
|
||||
}
|
||||
|
||||
return sum * _noise_amp;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: set_alpha_mode
|
||||
// Description: Alpha Modes are AHIGH, ALOW, ATOTAL, ANONE
|
||||
// high and low are height based affecting high and low
|
||||
// points respectively. total affects all vertices
|
||||
// none is no alpha. you have to manually setTransparency
|
||||
////////////////////////////////////////////////////////////////////
|
||||
void SeaPatchNode::
|
||||
set_alpha_mode(Alpha_Type a) {
|
||||
_alpha_mode = a;
|
||||
}
|
||||
|
||||
// ** IMPLEMENT compare_to properly once API is more finalized
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Function: SeaPatchNode::compare_to
|
||||
// Access: Published
|
||||
// Description: Returns a number less than zero if this SeaPatchNode
|
||||
// sorts before the other one, greater than zero if it
|
||||
// sorts after, or zero if they are equivalent.
|
||||
//
|
||||
// Two SeaPatchNodes are considered equivalent if they
|
||||
// consist of exactly the same properties
|
||||
// Otherwise, they are different; different
|
||||
// SeaPatchNodes will be ranked in a consistent but
|
||||
// undefined ordering; the ordering is useful only for
|
||||
// placing the SeaPatchNodes in a sorted container like an
|
||||
// STL set.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
int SeaPatchNode::
|
||||
compare_to(const SeaPatchNode &other) const {
|
||||
if (_enabled != other._enabled) {
|
||||
return _enabled ? 1 :-1;
|
||||
}
|
||||
if (_wave_movement != other._wave_movement) {
|
||||
return _wave_movement < other._wave_movement ? -1 : 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1,185 +0,0 @@
|
||||
// Filename: seaPatchNode.h
|
||||
// Created by: sshodhan (18Jun04)
|
||||
//
|
||||
////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// PANDA 3D SOFTWARE
|
||||
// Copyright (c) 2001 - 2004, Disney Enterprises, Inc. All rights reserved
|
||||
//
|
||||
// All use of this software is subject to the terms of the Panda 3d
|
||||
// Software license. You should have received a copy of this license
|
||||
// along with this source code; you will also find a current copy of
|
||||
// the license at http://etc.cmu.edu/panda3d/docs/license/ .
|
||||
//
|
||||
// To contact the maintainers of this program write to
|
||||
// panda3d-general@lists.sourceforge.net .
|
||||
//
|
||||
////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef SEAPATCHNODE_H
|
||||
#define SEAPATCHNODE_H
|
||||
#include "pandabase.h"
|
||||
#include "luse.h"
|
||||
#include "nodePath.h"
|
||||
#include "pmap.h"
|
||||
#include "notify.h"
|
||||
#include "pandaNode.h"
|
||||
#include "geom.h"
|
||||
#include "geomNode.h"
|
||||
#include "pmap.h"
|
||||
#include "lvecBase3.h"
|
||||
|
||||
static const int noise_table_size = 64;
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
// Class : SeaPatchNode
|
||||
// Description : A SeaPatchNode
|
||||
// Modeled after the old DQ SeaPatchNode
|
||||
// Any Geometry parented to a SeaPatchNode will have
|
||||
// - waves
|
||||
// - UV noise and transforms
|
||||
// - vertex color and height based shading
|
||||
// Looking to work on:
|
||||
// - multiple sine waves at different resolutions (for base waves
|
||||
// and detail waves)
|
||||
// - independant control over multiple layers parented to the same
|
||||
// SeaPatchNode (or should this just be done through multiple
|
||||
// copies of the SeaPatchNode? Need to make copy constructor and =
|
||||
// - perturbing normals (bump mapping, pixel level stuff?)
|
||||
// - wakes, decals
|
||||
// - damping floating objects
|
||||
// - reflecting things like a flaming ship, torches, sun, moon
|
||||
// - tiling to make ocean
|
||||
// - offload UV manipulation to texture matrix?
|
||||
////////////////////////////////////////////////////////////////////
|
||||
class EXPCL_PANDA SeaPatchNode : public PandaNode{
|
||||
|
||||
PUBLISHED:
|
||||
|
||||
enum Alpha_Type {
|
||||
AHIGH,
|
||||
ALOW,
|
||||
ATOTAL,
|
||||
ANONE,
|
||||
};
|
||||
|
||||
SeaPatchNode(const string &name);
|
||||
|
||||
INLINE void enable();
|
||||
INLINE void disable();
|
||||
INLINE bool is_enabled() const;
|
||||
|
||||
// Comparison methods
|
||||
INLINE bool operator == (const SeaPatchNode &other) const;
|
||||
INLINE bool operator != (const SeaPatchNode &other) const;
|
||||
INLINE bool operator < (const SeaPatchNode &other) const;
|
||||
int compare_to(const SeaPatchNode &other) const;
|
||||
|
||||
INLINE void set_amp(float amplitude);
|
||||
INLINE void set_freq(float frequency);
|
||||
INLINE float get_amp() const;
|
||||
INLINE float get_freq() const;
|
||||
INLINE LVecBase2f get_wavelength() const;
|
||||
INLINE void set_wavelength(LVecBase2f w);
|
||||
INLINE void set_passive_move(LVecBase2f UV);
|
||||
INLINE LVecBase2f get_passive_move() const;
|
||||
INLINE LPoint3f get_center() const;
|
||||
INLINE float get_radius() const;
|
||||
INLINE float get_threshold() const;
|
||||
INLINE void set_center(LPoint3f center);
|
||||
INLINE void set_radius(float r);
|
||||
INLINE void set_threshold(float t);
|
||||
INLINE void set_noise_amp(float x);
|
||||
INLINE float get_noise_amp() const;
|
||||
INLINE void enable_noise_uv();
|
||||
INLINE void disable_noise_uv();
|
||||
INLINE bool is_noise_on_uv() const;
|
||||
INLINE void set_noise_f(float f);
|
||||
INLINE float get_noise_f();
|
||||
INLINE float Weight(float t) ;
|
||||
INLINE int Mod(int quotient, int divisor);
|
||||
INLINE void set_xsize(float xs);
|
||||
INLINE void set_ysize(float ys);
|
||||
INLINE float get_xsize() const;
|
||||
INLINE float get_ysize() const;
|
||||
INLINE void set_u_scale(float us);
|
||||
INLINE void set_v_scale(float vs);
|
||||
INLINE float get_u_scale() const;
|
||||
INLINE float get_v_scale() const;
|
||||
INLINE float get_height(float x, float y) const;
|
||||
INLINE void set_cscale(float cs);
|
||||
INLINE void set_ascale(float as);
|
||||
INLINE float get_cscale() const;
|
||||
INLINE float get_ascale() const;
|
||||
INLINE LVecBase3f get_normal(float x, float y) const;
|
||||
INLINE void set_light_color(Colorf c);
|
||||
INLINE Colorf get_light_color() const;
|
||||
INLINE float get_u_sin_scale() const;
|
||||
INLINE float get_v_sin_scale() const;
|
||||
INLINE void set_u_sin_scale(float s);
|
||||
INLINE void set_v_sin_scale(float s);
|
||||
void set_alpha_mode(Alpha_Type a);
|
||||
|
||||
|
||||
private:
|
||||
bool _enabled;
|
||||
float _wave_movement;
|
||||
float _amplitude;
|
||||
float _frequency;
|
||||
LVecBase2f _wavelength;
|
||||
LVecBase2f _passive_move;
|
||||
LVecBase2f _move_variable;
|
||||
LPoint3f _center;
|
||||
float _radius;
|
||||
float _noise_amp;
|
||||
bool _noise_on_uv;
|
||||
float _noise_f;
|
||||
int _perm_tab_u[noise_table_size];
|
||||
LVecBase3f _grad_tab_u[noise_table_size];
|
||||
int _perm_tab_v[noise_table_size];
|
||||
LVecBase3f _grad_tab_v[noise_table_size];
|
||||
int _noise_detail;
|
||||
float _xsize;
|
||||
float _ysize;
|
||||
float _u_scale;
|
||||
float _v_scale;
|
||||
float _color_scale;
|
||||
float _alpha_scale;
|
||||
Colorf _light_color;
|
||||
float _u_sin_scale;
|
||||
float _v_sin_scale;
|
||||
float _threshold;
|
||||
Alpha_Type _alpha_mode;
|
||||
|
||||
public:
|
||||
virtual bool has_cull_callback() const;
|
||||
virtual bool cull_callback(CullTraverser *trav, CullTraverserData &data);
|
||||
void recurse_children(PandaNode *node, LMatrix4f mat);
|
||||
void do_wave(Geom *geom, LMatrix4f mat);
|
||||
void noise_init();
|
||||
float plain_noise(float x, float y, float z, unsigned int s, int uvi );
|
||||
float do_noise(float x, float y, float t, int uvi);
|
||||
|
||||
public:
|
||||
static TypeHandle get_class_type() {
|
||||
return _type_handle;
|
||||
}
|
||||
static void init_type() {
|
||||
PandaNode::init_type();
|
||||
register_type(_type_handle, "SeaPatchNode",
|
||||
PandaNode::get_class_type());
|
||||
}
|
||||
virtual TypeHandle get_type() const {
|
||||
return get_class_type();
|
||||
}
|
||||
virtual TypeHandle force_init_type() {init_type(); return get_class_type();}
|
||||
|
||||
private:
|
||||
static TypeHandle _type_handle;
|
||||
};
|
||||
|
||||
#include "seaPatchNode.I"
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user