This repository was archived by the owner on Oct 26, 2026. It is now read-only.
Repository navigation
Expand file tree
/
Copy pathDirectionalLight.java
More file actions
220 lines (196 loc) · 7.83 KB
/
Copy pathDirectionalLight.java
File metadata and controls
220 lines (196 loc) · 7.83 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
/*
* Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code 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
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
*/
package org.scijava.java3d;
import org.scijava.vecmath.Color3f;
import org.scijava.vecmath.Vector3f;
/**
* A DirectionalLight node defines an oriented light with an origin at
* infinity. It has the same attributes as a Light node, with the
* addition of a directional vector to specify the direction in which the
* light shines. A directional light has parallel light rays that travel
* in one direction along the specified vector. Directional light contributes
* to diffuse and specular reflections, which in turn depend on the
* orientation of an object's surface but not its position. A directional
* light does not contribute to ambient reflections.
*/
public class DirectionalLight extends Light {
/**
* Specifies that the Node allows access to its object's direction
* information.
*/
public static final int
ALLOW_DIRECTION_READ = CapabilityBits.DIRECTIONAL_LIGHT_ALLOW_DIRECTION_READ;
/**
* Specifies that the Node allows writing to its object's direction
* information.
*/
public static final int
ALLOW_DIRECTION_WRITE = CapabilityBits.DIRECTIONAL_LIGHT_ALLOW_DIRECTION_WRITE;
// Array for setting default read capabilities
private static final int[] readCapabilities = {
ALLOW_DIRECTION_READ
};
/**
* Constructs a DirectionalLight node with default parameters.
* The default values are as follows:
* <ul>
* direction : (0,0,-1)<br>
* </ul>
*/
public DirectionalLight() {
// set default read capabilities
setDefaultReadCapabilities(readCapabilities);
}
/**
* Constructs and initializes a directional light.
* @param color the color of the light source
* @param direction the direction vector pointing from the light
* to the object
*/
public DirectionalLight(Color3f color, Vector3f direction) {
super(color);
// set default read capabilities
setDefaultReadCapabilities(readCapabilities);
((DirectionalLightRetained)this.retained).initDirection(direction);
}
/**
* Constructs and initializes a directional light.
* @param lightOn flag indicating whether this light is on or off
* @param color the color of the light source
* @param direction the direction vector pointing from the light
* to the object
*/
public DirectionalLight(boolean lightOn, Color3f color, Vector3f direction) {
super(lightOn, color);
// set default read capabilities
setDefaultReadCapabilities(readCapabilities);
((DirectionalLightRetained)this.retained).initDirection(direction);
}
/**
* Creates the retained mode DirectionalLightRetained object that this
* DirectionalLight component object will point to.
*/
@Override
void createRetained() {
this.retained = new DirectionalLightRetained();
this.retained.setSource(this);
}
/**
* Set light direction.
* @param direction the new direction
* @exception CapabilityNotSetException if appropriate capability is
* not set and this object is part of live or compiled scene graph
*/
public void setDirection(Vector3f direction) {
if (isLiveOrCompiled())
if(!this.getCapability(ALLOW_DIRECTION_WRITE))
throw new CapabilityNotSetException(
J3dI18N.getString("DirectionalLight0"));
if (isLive())
((DirectionalLightRetained)this.retained).setDirection(direction);
else
((DirectionalLightRetained)this.retained).initDirection(direction);
}
/**
* Set light direction.
* @param x the new X direction
* @param y the new Y direction
* @param z the new Z direction
* @exception CapabilityNotSetException if appropriate capability is
* not set and this object is part of live or compiled scene graph
*/
public void setDirection(float x, float y, float z) {
if (isLiveOrCompiled())
if(!this.getCapability(ALLOW_DIRECTION_WRITE))
throw new CapabilityNotSetException(
J3dI18N.getString("DirectionalLight1"));
if (isLive())
((DirectionalLightRetained)this.retained).setDirection(x,y,z);
else
((DirectionalLightRetained)this.retained).initDirection(x,y,z);
}
/**
* Gets this Light's current direction and places it in the parameter specified.
* @param direction the vector that will receive this node's direction
* @exception CapabilityNotSetException if appropriate capability is
* not set and this object is part of live or compiled scene graph
*/
public void getDirection(Vector3f direction) {
if (isLiveOrCompiled())
if(!this.getCapability(ALLOW_DIRECTION_READ))
throw new CapabilityNotSetException(
J3dI18N.getString("DirectionalLight2"));
((DirectionalLightRetained)this.retained).getDirection(direction);
}
/**
* Used to create a new instance of the node. This routine is called
* by <code>cloneTree</code> to duplicate the current node.
* @param forceDuplicate when set to <code>true</code>, causes the
* <code>duplicateOnCloneTree</code> flag to be ignored. When
* <code>false</code>, the value of each node's
* <code>duplicateOnCloneTree</code> variable determines whether
* NodeComponent data is duplicated or copied.
*
* @see Node#cloneTree
* @see Node#cloneNode
* @see Node#duplicateNode
* @see NodeComponent#setDuplicateOnCloneTree
*/
@Override
public Node cloneNode(boolean forceDuplicate) {
DirectionalLight d = new DirectionalLight();
d.duplicateNode(this, forceDuplicate);
return d;
}
/**
* Copies all DirectionalLight information from
* <code>originalNode</code> into
* the current node. This method is called from the
* <code>cloneNode</code> method which is, in turn, called by the
* <code>cloneTree</code> method.<P>
*
* @param originalNode the original node to duplicate.
* @param forceDuplicate when set to <code>true</code>, causes the
* <code>duplicateOnCloneTree</code> flag to be ignored. When
* <code>false</code>, the value of each node's
* <code>duplicateOnCloneTree</code> variable determines whether
* NodeComponent data is duplicated or copied.
*
* @exception RestrictedAccessException if this object is part of a live
* or compiled scenegraph.
*
* @see Node#duplicateNode
* @see Node#cloneTree
* @see NodeComponent#setDuplicateOnCloneTree
*/
@Override
void duplicateAttributes(Node originalNode, boolean forceDuplicate) {
super.duplicateAttributes(originalNode, forceDuplicate);
Vector3f v = new Vector3f();
((DirectionalLightRetained) originalNode.retained).getDirection(v);
((DirectionalLightRetained) retained).initDirection(v);
}
}