_id stringlengths 2 7 | title stringlengths 3 140 | partition stringclasses 3
values | text stringlengths 73 34.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q5200 | ShellFactory.createSubshell | train | public static Shell createSubshell(String pathElement, Shell parent, String appName, Object mainHandler,
MultiMap<String, Object> auxHandlers) {
List<String> newPath = new ArrayList<String>(parent.getPath());
newPath.add(pathElement);
Shell subshell = new Shell(parent.getSettings().createWithAddedAuxHandlers(auxHandlers),
new CommandTable(parent.getCommandTable().getNamer()), newPath);
subshell.setAppName(appName);
subshell.addMainHandler(subshell, "!");
subshell.addMainHandler(new HelpCommandHandler(), "?");
subshell.addMainHandler(mainHandler, "");
return subshell;
} | java | {
"resource": ""
} |
q5201 | ShellFactory.createSubshell | train | public static Shell createSubshell(String pathElement, Shell parent, String appName, Object mainHandler) {
return createSubshell(pathElement, parent, appName, mainHandler, new EmptyMultiMap<String, Object>());
} | java | {
"resource": ""
} |
q5202 | GVRAnimationChannel.animate | train | public void animate(float animationTime, Matrix4f mat)
{
mRotInterpolator.animate(animationTime, mRotKey);
mPosInterpolator.animate(animationTime, mPosKey);
mSclInterpolator.animate(animationTime, mScaleKey);
mat.translationRotateScale(mPosKey[0], mPosKey[1], mPosKey[2], mRotKey[0], mRotKey[1], mRotKey[2], mRotKey[3], mScaleKey[0], mScaleKey[1], mScaleKey[2]);
} | java | {
"resource": ""
} |
q5203 | GVRPointLight.setAmbientIntensity | train | public void setAmbientIntensity(float r, float g, float b, float a) {
setVec4("ambient_intensity", r, g, b, a);
} | java | {
"resource": ""
} |
q5204 | GVRPointLight.setDiffuseIntensity | train | public void setDiffuseIntensity(float r, float g, float b, float a) {
setVec4("diffuse_intensity", r, g, b, a);
} | java | {
"resource": ""
} |
q5205 | GVRPointLight.setSpecularIntensity | train | public void setSpecularIntensity(float r, float g, float b, float a) {
setVec4("specular_intensity", r, g, b, a);
} | java | {
"resource": ""
} |
q5206 | MonoscopicInternalSensorListener.getQuaternionW | train | private float getQuaternionW(float x, float y, float z) {
return (float) Math.cos(Math.asin(Math.sqrt(x * x + y * y + z * z)));
} | java | {
"resource": ""
} |
q5207 | DebugServer.shutdown | train | public void shutdown() {
debugConnection = null;
shuttingDown = true;
try {
if (serverSocket != null) {
serverSocket.close();
}
} catch (IOException e) {
e.printStackTrace();
}
} | java | {
"resource": ""
} |
q5208 | DebugServer.run | train | @Override
public void run() {
ExecutorService executorService = Executors.newFixedThreadPool(maxClients);
try {
serverSocket = new ServerSocket(port, maxClients);
while (!shuttingDown) {
try {
Socket socket = serverSocket.accept();
debugConnection = new DebugConnection(socket);
executorService.submit(debugConnection);
} catch (SocketException e) {
// closed
debugConnection = null;
}
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
debugConnection = null;
serverSocket.close();
} catch (Exception e) {
}
executorService.shutdownNow();
}
} | java | {
"resource": ""
} |
q5209 | GVRScene.removeAllSceneObjects | train | public synchronized void removeAllSceneObjects() {
final GVRCameraRig rig = getMainCameraRig();
final GVRSceneObject head = rig.getOwnerObject();
rig.removeAllChildren();
NativeScene.removeAllSceneObjects(getNative());
for (final GVRSceneObject child : mSceneRoot.getChildren()) {
child.getParent().removeChildObject(child);
}
if (null != head) {
mSceneRoot.addChildObject(head);
}
final int numControllers = getGVRContext().getInputManager().clear();
if (numControllers > 0)
{
getGVRContext().getInputManager().selectController();
}
getGVRContext().runOnGlThread(new Runnable() {
@Override
public void run() {
NativeScene.deleteLightsAndDepthTextureOnRenderThread(getNative());
}
});
} | java | {
"resource": ""
} |
q5210 | GVRPicker.setPickRay | train | public void setPickRay(float ox, float oy, float oz, float dx, float dy, float dz)
{
synchronized (this)
{
mRayOrigin.x = ox;
mRayOrigin.y = oy;
mRayOrigin.z = oz;
mRayDirection.x = dx;
mRayDirection.y = dy;
mRayDirection.z = dz;
}
} | java | {
"resource": ""
} |
q5211 | GVRPicker.onDrawFrame | train | public void onDrawFrame(float frameTime)
{
if (isEnabled() && (mScene != null) && mPickEventLock.tryLock())
{
// Don't call if we are in the middle of processing another pick
try
{
doPick();
}
finally
{
mPickEventLock.unlock();
}
}
} | java | {
"resource": ""
} |
q5212 | GVRPicker.processPick | train | public void processPick(boolean touched, MotionEvent event)
{
mPickEventLock.lock();
mTouched = touched;
mMotionEvent = event;
doPick();
mPickEventLock.unlock();
} | java | {
"resource": ""
} |
q5213 | GVRPicker.propagateOnNoPick | train | protected void propagateOnNoPick(GVRPicker picker)
{
if (mEventOptions.contains(EventOptions.SEND_PICK_EVENTS))
{
if (mEventOptions.contains(EventOptions.SEND_TO_LISTENERS))
{
getGVRContext().getEventManager().sendEvent(this, IPickEvents.class, "onNoPick", picker);
}
if (mEventOptions.contains(EventOptions.SEND_TO_SCENE) && (mScene != null))
{
getGVRContext().getEventManager().sendEvent(mScene, IPickEvents.class, "onNoPick", picker);
}
}
} | java | {
"resource": ""
} |
q5214 | GVRPicker.propagateOnMotionOutside | train | protected void propagateOnMotionOutside(MotionEvent event)
{
if (mEventOptions.contains(EventOptions.SEND_TOUCH_EVENTS))
{
if (mEventOptions.contains(EventOptions.SEND_TO_LISTENERS))
{
getGVRContext().getEventManager().sendEvent(this, ITouchEvents.class, "onMotionOutside", this, event);
}
if (mEventOptions.contains(EventOptions.SEND_TO_SCENE) && (mScene != null))
{
getGVRContext().getEventManager().sendEvent(mScene, ITouchEvents.class, "onMotionOutside", this, event);
}
}
} | java | {
"resource": ""
} |
q5215 | GVRPicker.propagateOnEnter | train | protected void propagateOnEnter(GVRPickedObject hit)
{
GVRSceneObject hitObject = hit.getHitObject();
GVREventManager eventManager = getGVRContext().getEventManager();
if (mEventOptions.contains(EventOptions.SEND_TOUCH_EVENTS))
{
if (mEventOptions.contains(EventOptions.SEND_TO_LISTENERS))
{
eventManager.sendEvent(this, ITouchEvents.class, "onEnter", hitObject, hit);
}
if (mEventOptions.contains(EventOptions.SEND_TO_HIT_OBJECT))
{
eventManager.sendEvent(hitObject, ITouchEvents.class, "onEnter", hitObject, hit);
}
if (mEventOptions.contains(EventOptions.SEND_TO_SCENE) && (mScene != null))
{
eventManager.sendEvent(mScene, ITouchEvents.class, "onEnter", hitObject, hit);
}
}
if (mEventOptions.contains(EventOptions.SEND_PICK_EVENTS))
{
if (mEventOptions.contains(EventOptions.SEND_TO_LISTENERS))
{
eventManager.sendEvent(this, IPickEvents.class, "onEnter", hitObject, hit);
}
if (mEventOptions.contains(EventOptions.SEND_TO_HIT_OBJECT))
{
eventManager.sendEvent(hitObject, IPickEvents.class, "onEnter", hitObject, hit);
}
if (mEventOptions.contains(EventOptions.SEND_TO_SCENE) && (mScene != null))
{
eventManager.sendEvent(mScene, IPickEvents.class, "onEnter", hitObject, hit);
}
}
} | java | {
"resource": ""
} |
q5216 | GVRPicker.propagateOnTouch | train | protected void propagateOnTouch(GVRPickedObject hit)
{
if (mEventOptions.contains(EventOptions.SEND_TOUCH_EVENTS))
{
GVREventManager eventManager = getGVRContext().getEventManager();
GVRSceneObject hitObject = hit.getHitObject();
if (mEventOptions.contains(EventOptions.SEND_TO_LISTENERS))
{
eventManager.sendEvent(this, ITouchEvents.class, "onTouchStart", hitObject, hit);
}
if (mEventOptions.contains(EventOptions.SEND_TO_HIT_OBJECT))
{
eventManager.sendEvent(hitObject, ITouchEvents.class, "onTouchStart", hitObject, hit);
}
if (mEventOptions.contains(EventOptions.SEND_TO_SCENE) && (mScene != null))
{
eventManager.sendEvent(mScene, ITouchEvents.class, "onTouchStart", hitObject, hit);
}
}
} | java | {
"resource": ""
} |
q5217 | GVRPicker.findCollider | train | protected GVRPickedObject findCollider(GVRPickedObject[] pickList, GVRCollider findme)
{
if (pickList == null)
{
return null;
}
for (GVRPickedObject hit : pickList)
{
if ((hit != null) && (hit.hitCollider == findme))
{
return hit;
}
}
return null;
} | java | {
"resource": ""
} |
q5218 | GVRPicker.pickObjects | train | public static final GVRPickedObject[] pickObjects(GVRScene scene, float ox, float oy, float oz, float dx,
float dy, float dz) {
sFindObjectsLock.lock();
try {
final GVRPickedObject[] result = NativePicker.pickObjects(scene.getNative(), 0L, ox, oy, oz, dx, dy, dz);
return result;
} finally {
sFindObjectsLock.unlock();
}
} | java | {
"resource": ""
} |
q5219 | GVRPicker.makeHitMesh | train | static GVRPickedObject makeHitMesh(long colliderPointer, float distance, float hitx, float hity, float hitz,
int faceIndex, float barycentricx, float barycentricy, float barycentricz,
float texu, float texv, float normalx, float normaly, float normalz)
{
GVRCollider collider = GVRCollider.lookup(colliderPointer);
if (collider == null)
{
Log.d(TAG, "makeHit: cannot find collider for %x", colliderPointer);
return null;
}
return new GVRPicker.GVRPickedObject(collider, new float[] { hitx, hity, hitz }, distance, faceIndex,
new float[] {barycentricx, barycentricy, barycentricz},
new float[]{ texu, texv },
new float[]{normalx, normaly, normalz});
} | java | {
"resource": ""
} |
q5220 | AsyncAtlasInfo.loadAtlasInformation | train | public static List<GVRAtlasInformation> loadAtlasInformation(InputStream ins) {
try {
int size = ins.available();
byte[] buffer = new byte[size];
ins.read(buffer);
return loadAtlasInformation(new JSONArray(new String(buffer, "UTF-8")));
} catch (JSONException je) {
je.printStackTrace();
} catch (IOException ex) {
ex.printStackTrace();
}
return null;
} | java | {
"resource": ""
} |
q5221 | MovieTexture.setSpeed | train | public void setSpeed(float newValue) {
if (newValue < 0) newValue = 0;
this.pitch.setValue( newValue );
this.speed.setValue( newValue );
} | java | {
"resource": ""
} |
q5222 | GVRShaderId.getUniformDescriptor | train | public String getUniformDescriptor(GVRContext ctx)
{
if (mShaderTemplate == null)
{
mShaderTemplate = makeTemplate(ID, ctx);
ctx.getShaderManager().addShaderID(this);
}
return mShaderTemplate.getUniformDescriptor();
} | java | {
"resource": ""
} |
q5223 | GVRShaderId.getTemplate | train | public GVRShader getTemplate(GVRContext ctx)
{
if (mShaderTemplate == null)
{
mShaderTemplate = makeTemplate(ID, ctx);
ctx.getShaderManager().addShaderID(this);
}
return mShaderTemplate;
} | java | {
"resource": ""
} |
q5224 | GVRShaderId.makeTemplate | train | GVRShader makeTemplate(Class<? extends GVRShader> id, GVRContext ctx)
{
try
{
Constructor<? extends GVRShader> maker = id.getDeclaredConstructor(GVRContext.class);
return maker.newInstance(ctx);
}
catch (NoSuchMethodException | IllegalAccessException | InstantiationException | InvocationTargetException ex)
{
try
{
Constructor<? extends GVRShader> maker = id.getDeclaredConstructor();
return maker.newInstance();
}
catch (NoSuchMethodException | IllegalAccessException | InstantiationException | InvocationTargetException ex2)
{
ctx.getEventManager().sendEvent(ctx, IErrorEvents.class, "onError", new Object[] {ex2.getMessage(), this});
return null;
}
}
} | java | {
"resource": ""
} |
q5225 | GVRAccessibilitySpeech.start | train | public void start(GVRAccessibilitySpeechListener speechListener) {
mTts.setSpeechListener(speechListener);
mTts.getSpeechRecognizer().startListening(mTts.getSpeechRecognizerIntent());
} | java | {
"resource": ""
} |
q5226 | GVRMesh.setVertexBuffer | train | public void setVertexBuffer(GVRVertexBuffer vbuf)
{
if (vbuf == null)
{
throw new IllegalArgumentException("Vertex buffer cannot be null");
}
mVertices = vbuf;
NativeMesh.setVertexBuffer(getNative(), vbuf.getNative());
} | java | {
"resource": ""
} |
q5227 | GVRMesh.setIndexBuffer | train | public void setIndexBuffer(GVRIndexBuffer ibuf)
{
mIndices = ibuf;
NativeMesh.setIndexBuffer(getNative(), (ibuf != null) ? ibuf.getNative() : 0L);
} | java | {
"resource": ""
} |
q5228 | Log.rebuild | train | public static void rebuild(final MODE newMode) {
if (mode != newMode) {
mode = newMode;
TYPE type;
switch (mode) {
case DEBUG:
type = TYPE.ANDROID;
Log.startFullLog();
break;
case DEVELOPER:
type = TYPE.PERSISTENT;
Log.stopFullLog();
break;
case USER:
type = TYPE.ANDROID;
break;
default:
type = DEFAULT_TYPE;
Log.stopFullLog();
break;
}
currentLog = getLog(type);
}
} | java | {
"resource": ""
} |
q5229 | Log.e | train | public static int e(ISubsystem subsystem, String tag, String msg) {
return isEnabled(subsystem) ?
currentLog.e(tag, getMsg(subsystem,msg)) : 0;
} | java | {
"resource": ""
} |
q5230 | Log.d | train | public static void d(ISubsystem subsystem, String tag, String pattern, Object... parameters) {
if (!isEnabled(subsystem)) return;
d(subsystem, tag, format(pattern, parameters));
} | java | {
"resource": ""
} |
q5231 | Log.deleteOldAndEmptyFiles | train | private static void deleteOldAndEmptyFiles() {
File dir = LOG_FILE_DIR;
if (dir.exists()) {
File[] files = dir.listFiles();
for (File f : files) {
if (f.length() == 0 ||
f.lastModified() + MAXFILEAGE < System.currentTimeMillis()) {
f.delete();
}
}
}
} | java | {
"resource": ""
} |
q5232 | GVRExternalScene.load | train | public boolean load(GVRScene scene)
{
GVRAssetLoader loader = getGVRContext().getAssetLoader();
if (scene == null)
{
scene = getGVRContext().getMainScene();
}
if (mReplaceScene)
{
loader.loadScene(getOwnerObject(), mVolume, mImportSettings, scene, null);
}
else
{
loader.loadModel(getOwnerObject(), mVolume, mImportSettings, scene);
}
return true;
} | java | {
"resource": ""
} |
q5233 | GVRExternalScene.load | train | public void load(IAssetEvents handler)
{
GVRAssetLoader loader = getGVRContext().getAssetLoader();
if (mReplaceScene)
{
loader.loadScene(getOwnerObject(), mVolume, mImportSettings, getGVRContext().getMainScene(), handler);
}
else
{
loader.loadModel(mVolume, getOwnerObject(), mImportSettings, true, handler);
}
} | java | {
"resource": ""
} |
q5234 | Utility.parseMFString | train | public String[] parseMFString(String mfString) {
Vector<String> strings = new Vector<String>();
StringReader sr = new StringReader(mfString);
StreamTokenizer st = new StreamTokenizer(sr);
st.quoteChar('"');
st.quoteChar('\'');
String[] mfStrings = null;
int tokenType;
try {
while ((tokenType = st.nextToken()) != StreamTokenizer.TT_EOF) {
strings.add(st.sval);
}
} catch (IOException e) {
Log.d(TAG, "String parsing Error: " + e);
e.printStackTrace();
}
mfStrings = new String[strings.size()];
for (int i = 0; i < strings.size(); i++) {
mfStrings[i] = strings.get(i);
}
return mfStrings;
} | java | {
"resource": ""
} |
q5235 | AsyncBitmapTexture.getScreenSize | train | private static Point getScreenSize(Context context, Point p) {
if (p == null) {
p = new Point();
}
WindowManager windowManager = (WindowManager) context
.getSystemService(Context.WINDOW_SERVICE);
Display display = windowManager.getDefaultDisplay();
display.getSize(p);
return p;
} | java | {
"resource": ""
} |
q5236 | AiMatrix4f.get | train | public float get(int row, int col) {
if (row < 0 || row > 3) {
throw new IndexOutOfBoundsException("Index: " + row + ", Size: 4");
}
if (col < 0 || col > 3) {
throw new IndexOutOfBoundsException("Index: " + col + ", Size: 4");
}
return m_data[row * 4 + col];
} | java | {
"resource": ""
} |
q5237 | GVRPeriodicEngine.runAfter | train | public PeriodicEvent runAfter(Runnable task, float delay) {
validateDelay(delay);
return new Event(task, delay);
} | java | {
"resource": ""
} |
q5238 | GVRPeriodicEngine.runEvery | train | public PeriodicEvent runEvery(Runnable task, float delay, float period) {
return runEvery(task, delay, period, null);
} | java | {
"resource": ""
} |
q5239 | GVRPeriodicEngine.runEvery | train | public PeriodicEvent runEvery(Runnable task, float delay, float period,
int repetitions) {
if (repetitions < 1) {
return null;
} else if (repetitions == 1) {
// Better to burn a handful of CPU cycles than to churn memory by
// creating a new callback
return runAfter(task, delay);
} else {
return runEvery(task, delay, period, new RunFor(repetitions));
}
} | java | {
"resource": ""
} |
q5240 | GVRPeriodicEngine.runEvery | train | public PeriodicEvent runEvery(Runnable task, float delay, float period,
KeepRunning callback) {
validateDelay(delay);
validatePeriod(period);
return new Event(task, delay, period, callback);
} | java | {
"resource": ""
} |
q5241 | AiScene.getSceneRoot | train | @SuppressWarnings("unchecked")
public <V3, M4, C, N, Q> N getSceneRoot(AiWrapperProvider<V3, M4, C, N, Q>
wrapperProvider) {
return (N) m_sceneRoot;
} | java | {
"resource": ""
} |
q5242 | Widget.enableClipRegion | train | public void enableClipRegion() {
if (mClippingEnabled) {
Log.w(TAG, "Clipping has been enabled already for %s!", getName());
return;
}
Log.d(Log.SUBSYSTEM.WIDGET, TAG, "enableClipping for %s [%f, %f, %f]",
getName(), getViewPortWidth(), getViewPortHeight(), getViewPortDepth());
mClippingEnabled = true;
GVRTexture texture = WidgetLib.getTextureHelper().getSolidColorTexture(Color.YELLOW);
GVRSceneObject clippingObj = new GVRSceneObject(mContext, getViewPortWidth(), getViewPortHeight(), texture);
clippingObj.setName("clippingObj");
clippingObj.getRenderData()
.setRenderingOrder(GVRRenderData.GVRRenderingOrder.STENCIL)
.setStencilTest(true)
.setStencilFunc(GLES30.GL_ALWAYS, 1, 0xFF)
.setStencilOp(GLES30.GL_KEEP, GLES30.GL_KEEP, GLES30.GL_REPLACE)
.setStencilMask(0xFF);
mSceneObject.addChildObject(clippingObj);
for (Widget child : getChildren()) {
setObjectClipped(child);
}
} | java | {
"resource": ""
} |
q5243 | Widget.getLayoutSize | train | public float getLayoutSize(final Layout.Axis axis) {
float size = 0;
for (Layout layout : mLayouts) {
size = Math.max(size, layout.getSize(axis));
}
Log.d(Log.SUBSYSTEM.LAYOUT, TAG, "getLayoutSize [%s] axis [%s] size [%f]", getName(), axis, size);
return size;
} | java | {
"resource": ""
} |
q5244 | Widget.getBoundsWidth | train | public float getBoundsWidth() {
if (mSceneObject != null) {
GVRSceneObject.BoundingVolume v = mSceneObject.getBoundingVolume();
return v.maxCorner.x - v.minCorner.x;
}
return 0f;
} | java | {
"resource": ""
} |
q5245 | Widget.getBoundsHeight | train | public float getBoundsHeight(){
if (mSceneObject != null) {
GVRSceneObject.BoundingVolume v = mSceneObject.getBoundingVolume();
return v.maxCorner.y - v.minCorner.y;
}
return 0f;
} | java | {
"resource": ""
} |
q5246 | Widget.getBoundsDepth | train | public float getBoundsDepth() {
if (mSceneObject != null) {
GVRSceneObject.BoundingVolume v = mSceneObject.getBoundingVolume();
return v.maxCorner.z - v.minCorner.z;
}
return 0f;
} | java | {
"resource": ""
} |
q5247 | Widget.rotateWithPivot | train | public void rotateWithPivot(float w, float x, float y, float z,
float pivotX, float pivotY, float pivotZ) {
getTransform().rotateWithPivot(w, x, y, z, pivotX, pivotY, pivotZ);
if (mTransformCache.rotateWithPivot(w, x, y, z, pivotX, pivotY, pivotZ)) {
onTransformChanged();
}
} | java | {
"resource": ""
} |
q5248 | Widget.setVisibility | train | public boolean setVisibility(final Visibility visibility) {
if (visibility != mVisibility) {
Log.d(Log.SUBSYSTEM.WIDGET, TAG, "setVisibility(%s) for %s", visibility, getName());
updateVisibility(visibility);
mVisibility = visibility;
return true;
}
return false;
} | java | {
"resource": ""
} |
q5249 | Widget.setViewPortVisibility | train | public boolean setViewPortVisibility(final ViewPortVisibility viewportVisibility) {
boolean visibilityIsChanged = viewportVisibility != mIsVisibleInViewPort;
if (visibilityIsChanged) {
Visibility visibility = mVisibility;
switch(viewportVisibility) {
case FULLY_VISIBLE:
case PARTIALLY_VISIBLE:
break;
case INVISIBLE:
visibility = Visibility.HIDDEN;
break;
}
mIsVisibleInViewPort = viewportVisibility;
updateVisibility(visibility);
}
return visibilityIsChanged;
} | java | {
"resource": ""
} |
q5250 | Widget.findChildByName | train | public Widget findChildByName(final String name) {
final List<Widget> groups = new ArrayList<>();
groups.add(this);
return findChildByNameInAllGroups(name, groups);
} | java | {
"resource": ""
} |
q5251 | Widget.isGLThread | train | protected final boolean isGLThread() {
final Thread glThread = sGLThread.get();
return glThread != null && glThread.equals(Thread.currentThread());
} | java | {
"resource": ""
} |
q5252 | ARCoreAnchor.update | train | protected void update(float scale) {
// Updates only when the plane is in the scene
GVRSceneObject owner = getOwnerObject();
if ((owner != null) && isEnabled() && owner.isEnabled())
{
convertFromARtoVRSpace(scale);
}
} | java | {
"resource": ""
} |
q5253 | GVRDirectLight.setCastShadow | train | public void setCastShadow(boolean enableFlag)
{
GVRSceneObject owner = getOwnerObject();
if (owner != null)
{
GVRShadowMap shadowMap = (GVRShadowMap) getComponent(GVRRenderTarget.getComponentType());
if (enableFlag)
{
if (shadowMap != null)
{
shadowMap.setEnable(true);
}
else
{
GVRCamera shadowCam = GVRShadowMap.makeOrthoShadowCamera(
getGVRContext().getMainScene().getMainCameraRig().getCenterCamera());
shadowMap = new GVRShadowMap(getGVRContext(), shadowCam);
owner.attachComponent(shadowMap);
}
}
else if (shadowMap != null)
{
shadowMap.setEnable(false);
}
}
mCastShadow = enableFlag;
} | java | {
"resource": ""
} |
q5254 | ExternalScriptable.delete | train | public synchronized void delete(String name) {
if (isEmpty(name)) {
indexedProps.remove(name);
} else {
synchronized (context) {
int scope = context.getAttributesScope(name);
if (scope != -1) {
context.removeAttribute(name, scope);
}
}
}
} | java | {
"resource": ""
} |
q5255 | ExternalScriptable.getIds | train | public synchronized Object[] getIds() {
String[] keys = getAllKeys();
int size = keys.length + indexedProps.size();
Object[] res = new Object[size];
System.arraycopy(keys, 0, res, 0, keys.length);
int i = keys.length;
// now add all indexed properties
for (Object index : indexedProps.keySet()) {
res[i++] = index;
}
return res;
} | java | {
"resource": ""
} |
q5256 | ExternalScriptable.hasInstance | train | public boolean hasInstance(Scriptable instance) {
// Default for JS objects (other than Function) is to do prototype
// chasing.
Scriptable proto = instance.getPrototype();
while (proto != null) {
if (proto.equals(this)) return true;
proto = proto.getPrototype();
}
return false;
} | java | {
"resource": ""
} |
q5257 | TimeSensor.setLoop | train | public void setLoop(boolean doLoop, GVRContext gvrContext) {
if (this.loop != doLoop ) {
// a change in the loop
for (GVRNodeAnimation gvrKeyFrameAnimation : gvrKeyFrameAnimations) {
if (doLoop) gvrKeyFrameAnimation.setRepeatMode(GVRRepeatMode.REPEATED);
else gvrKeyFrameAnimation.setRepeatMode(GVRRepeatMode.ONCE);
}
// be sure to start the animations if loop is true
if ( doLoop ) {
for (GVRNodeAnimation gvrKeyFrameAnimation : gvrKeyFrameAnimations) {
gvrKeyFrameAnimation.start(gvrContext.getAnimationEngine() );
}
}
this.loop = doLoop;
}
} | java | {
"resource": ""
} |
q5258 | TimeSensor.setCycleInterval | train | public void setCycleInterval(float newCycleInterval) {
if ( (this.cycleInterval != newCycleInterval) && (newCycleInterval > 0) ) {
for (GVRNodeAnimation gvrKeyFrameAnimation : gvrKeyFrameAnimations) {
//TODO Cannot easily change the GVRAnimation's GVRChannel once set.
}
this.cycleInterval = newCycleInterval;
}
} | java | {
"resource": ""
} |
q5259 | ExecutionChain.setErrorCallback | train | public ExecutionChain setErrorCallback(ErrorCallback callback) {
if (state.get() == State.RUNNING) {
throw new IllegalStateException(
"Invalid while ExecutionChain is running");
}
errorCallback = callback;
return this;
} | java | {
"resource": ""
} |
q5260 | ExecutionChain.execute | train | public void execute() {
State currentState = state.getAndSet(State.RUNNING);
if (currentState == State.RUNNING) {
throw new IllegalStateException(
"ExecutionChain is already running!");
}
executeRunnable = new ExecuteRunnable();
} | java | {
"resource": ""
} |
q5261 | GVRConfigurationManager.isHomeKeyPresent | train | public boolean isHomeKeyPresent() {
final GVRApplication application = mApplication.get();
if (null != application) {
final String model = getHmtModel();
if (null != model && model.contains("R323")) {
return true;
}
}
return false;
} | java | {
"resource": ""
} |
q5262 | Shell.addAuxHandler | train | public void addAuxHandler(Object handler, String prefix) {
if (handler == null) {
throw new NullPointerException();
}
auxHandlers.put(prefix, handler);
allHandlers.add(handler);
addDeclaredMethods(handler, prefix);
inputConverter.addDeclaredConverters(handler);
outputConverter.addDeclaredConverters(handler);
if (handler instanceof ShellDependent) {
((ShellDependent)handler).cliSetShell(this);
}
} | java | {
"resource": ""
} |
q5263 | Shell.commandLoop | train | public void commandLoop() throws IOException {
for (Object handler : allHandlers) {
if (handler instanceof ShellManageable) {
((ShellManageable)handler).cliEnterLoop();
}
}
output.output(appName, outputConverter);
String command = "";
while (true) {
try {
command = input.readCommand(path);
if (command.trim().equals("exit")) {
if (lineProcessor == null)
break;
else {
path = savedPath;
lineProcessor = null;
}
}
processLine(command);
} catch (TokenException te) {
lastException = te;
output.outputException(command, te);
} catch (CLIException clie) {
lastException = clie;
if (!command.trim().equals("exit")) {
output.outputException(clie);
}
}
}
for (Object handler : allHandlers) {
if (handler instanceof ShellManageable) {
((ShellManageable)handler).cliLeaveLoop();
}
}
} | java | {
"resource": ""
} |
q5264 | GVRScriptManager.addVariable | train | @Override
public void addVariable(String varName, Object value) {
synchronized (mGlobalVariables) {
mGlobalVariables.put(varName, value);
}
refreshGlobalBindings();
} | java | {
"resource": ""
} |
q5265 | GVRScriptManager.attachScriptFile | train | @Override
public void attachScriptFile(IScriptable target, IScriptFile scriptFile) {
mScriptMap.put(target, scriptFile);
scriptFile.invokeFunction("onAttach", new Object[] { target });
} | java | {
"resource": ""
} |
q5266 | GVRScriptManager.detachScriptFile | train | @Override
public void detachScriptFile(IScriptable target) {
IScriptFile scriptFile = mScriptMap.remove(target);
if (scriptFile != null) {
scriptFile.invokeFunction("onDetach", new Object[] { target });
}
} | java | {
"resource": ""
} |
q5267 | GVRScriptManager.bindScriptBundleToScene | train | public void bindScriptBundleToScene(GVRScriptBundle scriptBundle, GVRScene scene) throws IOException, GVRScriptException {
for (GVRSceneObject sceneObject : scene.getSceneObjects()) {
bindBundleToSceneObject(scriptBundle, sceneObject);
}
} | java | {
"resource": ""
} |
q5268 | GVRScriptManager.bindBundleToSceneObject | train | public void bindBundleToSceneObject(GVRScriptBundle scriptBundle, GVRSceneObject rootSceneObject)
throws IOException, GVRScriptException
{
bindHelper(scriptBundle, rootSceneObject, BIND_MASK_SCENE_OBJECTS);
} | java | {
"resource": ""
} |
q5269 | GVRScriptManager.bindHelper | train | protected void bindHelper(GVRScriptBundle scriptBundle, GVRSceneObject rootSceneObject, int bindMask)
throws IOException, GVRScriptException
{
for (GVRScriptBindingEntry entry : scriptBundle.file.binding) {
GVRAndroidResource rc;
if (entry.volumeType == null || entry.volumeType.isEmpty()) {
rc = scriptBundle.volume.openResource(entry.script);
} else {
GVRResourceVolume.VolumeType volumeType = GVRResourceVolume.VolumeType.fromString(entry.volumeType);
if (volumeType == null) {
throw new GVRScriptException(String.format("Volume type %s is not recognized, script=%s",
entry.volumeType, entry.script));
}
rc = new GVRResourceVolume(mGvrContext, volumeType).openResource(entry.script);
}
GVRScriptFile scriptFile = (GVRScriptFile)loadScript(rc, entry.language);
String targetName = entry.target;
if (targetName.startsWith(TARGET_PREFIX)) {
TargetResolver resolver = sBuiltinTargetMap.get(targetName);
IScriptable target = resolver.getTarget(mGvrContext, targetName);
// Apply mask
boolean toBind = false;
if ((bindMask & BIND_MASK_GVRSCRIPT) != 0 && targetName.equalsIgnoreCase(TARGET_GVRMAIN)) {
toBind = true;
}
if ((bindMask & BIND_MASK_GVRACTIVITY) != 0 && targetName.equalsIgnoreCase(TARGET_GVRAPPLICATION)) {
toBind = true;
}
if (toBind) {
attachScriptFile(target, scriptFile);
}
} else {
if ((bindMask & BIND_MASK_SCENE_OBJECTS) != 0) {
if (targetName.equals(rootSceneObject.getName())) {
attachScriptFile(rootSceneObject, scriptFile);
}
// Search in children
GVRSceneObject[] sceneObjects = rootSceneObject.getSceneObjectsByName(targetName);
if (sceneObjects != null) {
for (GVRSceneObject sceneObject : sceneObjects) {
GVRScriptBehavior b = new GVRScriptBehavior(sceneObject.getGVRContext());
b.setScriptFile(scriptFile);
sceneObject.attachComponent(b);
}
}
}
}
}
} | java | {
"resource": ""
} |
q5270 | GVRViewManager.doMemoryManagementAndPerFrameCallbacks | train | private long doMemoryManagementAndPerFrameCallbacks() {
long currentTime = GVRTime.getCurrentTime();
mFrameTime = (currentTime - mPreviousTimeNanos) / 1e9f;
mPreviousTimeNanos = currentTime;
/*
* Without the sensor data, can't draw a scene properly.
*/
if (!(mSensoredScene == null || !mMainScene.equals(mSensoredScene))) {
Runnable runnable;
while ((runnable = mRunnables.poll()) != null) {
try {
runnable.run();
} catch (final Exception exc) {
Log.e(TAG, "Runnable-on-GL %s threw %s", runnable, exc.toString());
exc.printStackTrace();
}
}
final List<GVRDrawFrameListener> frameListeners = mFrameListeners;
for (GVRDrawFrameListener listener : frameListeners) {
try {
listener.onDrawFrame(mFrameTime);
} catch (final Exception exc) {
Log.e(TAG, "DrawFrameListener %s threw %s", listener, exc.toString());
exc.printStackTrace();
}
}
}
return currentTime;
} | java | {
"resource": ""
} |
q5271 | GVRViewManager.capture3DScreenShot | train | protected void capture3DScreenShot(GVRRenderTarget renderTarget, boolean isMultiview) {
if (mScreenshot3DCallback == null) {
return;
}
final Bitmap[] bitmaps = new Bitmap[6];
renderSixCamerasAndReadback(mMainScene.getMainCameraRig(), bitmaps, renderTarget, isMultiview);
returnScreenshot3DToCaller(mScreenshot3DCallback, bitmaps, mReadbackBufferWidth, mReadbackBufferHeight);
mScreenshot3DCallback = null;
} | java | {
"resource": ""
} |
q5272 | GVRViewManager.captureEye | train | private void captureEye(GVRScreenshotCallback callback, GVRRenderTarget renderTarget, GVRViewManager.EYE eye, boolean useMultiview) {
if (null == callback) {
return;
}
readRenderResult(renderTarget,eye,useMultiview);
returnScreenshotToCaller(callback, mReadbackBufferWidth, mReadbackBufferHeight);
} | java | {
"resource": ""
} |
q5273 | GVRViewManager.captureCenterEye | train | protected void captureCenterEye(GVRRenderTarget renderTarget, boolean isMultiview) {
if (mScreenshotCenterCallback == null) {
return;
}
// TODO: when we will use multithreading, create new camera using centercamera as we are adding posteffects into it
final GVRCamera centerCamera = mMainScene.getMainCameraRig().getCenterCamera();
final GVRMaterial postEffect = new GVRMaterial(this, GVRMaterial.GVRShaderType.VerticalFlip.ID);
centerCamera.addPostEffect(postEffect);
GVRRenderTexture posteffectRenderTextureB = null;
GVRRenderTexture posteffectRenderTextureA = null;
if(isMultiview) {
posteffectRenderTextureA = mRenderBundle.getEyeCapturePostEffectRenderTextureA();
posteffectRenderTextureB = mRenderBundle.getEyeCapturePostEffectRenderTextureB();
renderTarget = mRenderBundle.getEyeCaptureRenderTarget();
renderTarget.cullFromCamera(mMainScene, centerCamera ,mRenderBundle.getShaderManager());
renderTarget.beginRendering(centerCamera);
}
else {
posteffectRenderTextureA = mRenderBundle.getPostEffectRenderTextureA();
posteffectRenderTextureB = mRenderBundle.getPostEffectRenderTextureB();
}
renderTarget.render(mMainScene,centerCamera, mRenderBundle.getShaderManager(), posteffectRenderTextureA, posteffectRenderTextureB);
centerCamera.removePostEffect(postEffect);
readRenderResult(renderTarget, EYE.MULTIVIEW, false);
if(isMultiview)
renderTarget.endRendering();
final Bitmap bitmap = Bitmap.createBitmap(mReadbackBufferWidth, mReadbackBufferHeight, Bitmap.Config.ARGB_8888);
mReadbackBuffer.rewind();
bitmap.copyPixelsFromBuffer(mReadbackBuffer);
final GVRScreenshotCallback callback = mScreenshotCenterCallback;
Threads.spawn(new Runnable() {
public void run() {
callback.onScreenCaptured(bitmap);
}
});
mScreenshotCenterCallback = null;
} | java | {
"resource": ""
} |
q5274 | MainThread.runOnMainThreadNext | train | public boolean runOnMainThreadNext(Runnable r) {
assert handler != null;
if (!sanityCheck("runOnMainThreadNext " + r)) {
return false;
}
return handler.post(r);
} | java | {
"resource": ""
} |
q5275 | CursorManager.showSettingsMenu | train | private void showSettingsMenu(final Cursor cursor) {
Log.d(TAG, "showSettingsMenu");
enableSettingsCursor(cursor);
context.runOnGlThread(new Runnable() {
@Override
public void run() {
new SettingsView(context, scene, CursorManager.this,
settingsCursor.getIoDevice().getCursorControllerId(), cursor, new
SettingsChangeListener() {
@Override
public void onBack(boolean cascading) {
disableSettingsCursor();
}
@Override
public int onDeviceChanged(IoDevice device) {
// we are changing the io device on the settings cursor
removeCursorFromScene(settingsCursor);
IoDevice clickedDevice = getAvailableIoDevice(device);
settingsCursor.setIoDevice(clickedDevice);
addCursorToScene(settingsCursor);
return device.getCursorControllerId();
}
});
}
});
} | java | {
"resource": ""
} |
q5276 | CursorManager.updateCursorsInScene | train | private void updateCursorsInScene(GVRScene scene, boolean add) {
synchronized (mCursors) {
for (Cursor cursor : mCursors) {
if (cursor.isActive()) {
if (add) {
addCursorToScene(cursor);
} else {
removeCursorFromScene(cursor);
}
}
}
}
} | java | {
"resource": ""
} |
q5277 | ListWidget.getAllViews | train | public List<Widget> getAllViews() {
List<Widget> views = new ArrayList<>();
for (Widget child: mContent.getChildren()) {
Widget item = ((ListItemHostWidget) child).getGuest();
if (item != null) {
views.add(item);
}
}
return views;
} | java | {
"resource": ""
} |
q5278 | ListWidget.clearSelection | train | public boolean clearSelection(boolean requestLayout) {
Log.d(Log.SUBSYSTEM.LAYOUT, TAG, "clearSelection [%d]", mSelectedItemsList.size());
boolean updateLayout = false;
List<ListItemHostWidget> views = getAllHosts();
for (ListItemHostWidget host: views) {
if (host.isSelected()) {
host.setSelected(false);
updateLayout = true;
if (requestLayout) {
host.requestLayout();
}
}
}
clearSelectedItemsList();
return updateLayout;
} | java | {
"resource": ""
} |
q5279 | ListWidget.updateSelectedItemsList | train | public boolean updateSelectedItemsList(int dataIndex, boolean select) {
boolean done = false;
boolean contains = isSelected(dataIndex);
if (select) {
if (!contains) {
if (!mMultiSelectionSupported) {
clearSelection(false);
}
Log.d(Log.SUBSYSTEM.LAYOUT, TAG, "updateSelectedItemsList add index = %d", dataIndex);
mSelectedItemsList.add(dataIndex);
done = true;
}
} else {
if (contains) {
Log.d(Log.SUBSYSTEM.LAYOUT, TAG, "updateSelectedItemsList remove index = %d", dataIndex);
mSelectedItemsList.remove(dataIndex);
done = true;
}
}
return done;
} | java | {
"resource": ""
} |
q5280 | ListWidget.onScrollImpl | train | private void onScrollImpl(final Vector3Axis offset, final LayoutScroller.OnScrollListener listener) {
if (!isScrolling()) {
mScroller = new ScrollingProcessor(offset, listener);
mScroller.scroll();
}
} | java | {
"resource": ""
} |
q5281 | ListWidget.recycleChildren | train | protected void recycleChildren() {
for (ListItemHostWidget host: getAllHosts()) {
recycle(host);
}
mContent.onTransformChanged();
mContent.requestLayout();
} | java | {
"resource": ""
} |
q5282 | ListWidget.onChangedImpl | train | private void onChangedImpl(final int preferableCenterPosition) {
for (ListOnChangedListener listener: mOnChangedListeners) {
listener.onChangedStart(this);
}
Log.d(Log.SUBSYSTEM.LAYOUT, TAG, "onChangedImpl(%s): items [%d] views [%d] mLayouts.size() = %d " +
"preferableCenterPosition = %d",
getName(), getDataCount(), getViewCount(), mContent.mLayouts.size(), preferableCenterPosition);
// TODO: selectively recycle data based on the changes in the data set
mPreferableCenterPosition = preferableCenterPosition;
recycleChildren();
} | java | {
"resource": ""
} |
q5283 | GVRConsoleFactory.createTerminalConsoleShell | train | static Shell createTerminalConsoleShell(String prompt, String appName,
ShellCommandHandler mainHandler, InputStream input, OutputStream output) {
try {
PrintStream out = new PrintStream(output);
// Build jline terminal
jline.Terminal term = TerminalFactory.get();
final ConsoleReader console = new ConsoleReader(input, output, term);
console.setBellEnabled(true);
console.setHistoryEnabled(true);
// Build console
BufferedReader in = new BufferedReader(new InputStreamReader(
new ConsoleReaderInputStream(console)));
ConsoleIO.PromptListener promptListener = new ConsoleIO.PromptListener() {
@Override
public boolean onPrompt(String prompt) {
console.setPrompt(prompt);
return true; // suppress normal prompt
}
};
return createConsoleShell(prompt, appName, mainHandler, in, out, out, promptListener);
} catch (Exception e) {
// Failover: use default shell
BufferedReader in = new BufferedReader(new InputStreamReader(input));
PrintStream out = new PrintStream(output);
return createConsoleShell(prompt, appName, mainHandler, in, out, out, null);
}
} | java | {
"resource": ""
} |
q5284 | GVRConsoleFactory.createTelnetConsoleShell | train | static Shell createTelnetConsoleShell(String prompt, String appName,
ShellCommandHandler mainHandler, InputStream input, OutputStream output) {
try {
// Set up nvt4j; ignore the initial clear & reposition
final nvt4j.impl.Terminal nvt4jTerminal = new nvt4j.impl.Terminal(input, output) {
private boolean cleared;
private boolean moved;
@Override
public void clear() throws IOException {
if (this.cleared)
super.clear();
this.cleared = true;
}
@Override
public void move(int row, int col) throws IOException {
if (this.moved)
super.move(row, col);
this.moved = true;
}
};
nvt4jTerminal.put(nvt4j.impl.Terminal.AUTO_WRAP_ON);
nvt4jTerminal.setCursor(true);
// Have JLine do input & output through telnet terminal
final InputStream jlineInput = new InputStream() {
@Override
public int read() throws IOException {
return nvt4jTerminal.get();
}
};
final OutputStream jlineOutput = new OutputStream() {
@Override
public void write(int value) throws IOException {
nvt4jTerminal.put(value);
}
};
return createTerminalConsoleShell(prompt, appName, mainHandler, jlineInput, jlineOutput);
} catch (Exception e) {
// Failover: use default shell
BufferedReader in = new BufferedReader(new InputStreamReader(input));
PrintStream out = new PrintStream(output);
return createConsoleShell(prompt, appName, mainHandler, in, out, out, null);
}
} | java | {
"resource": ""
} |
q5285 | LODmanager.AddLODSceneObject | train | protected void AddLODSceneObject(GVRSceneObject currentSceneObject) {
if (this.transformLODSceneObject != null) {
GVRSceneObject levelOfDetailSceneObject = null;
if ( currentSceneObject.getParent() == this.transformLODSceneObject) {
levelOfDetailSceneObject = currentSceneObject;
}
else {
GVRSceneObject lodSceneObj = root.getSceneObjectByName((currentSceneObject.getName() + TRANSFORM_TRANSLATION_));
if ( lodSceneObj != null ) {
if (lodSceneObj.getParent() == this.transformLODSceneObject) {
levelOfDetailSceneObject = lodSceneObj;
}
}
if (levelOfDetailSceneObject == null) {
lodSceneObj = root.getSceneObjectByName((currentSceneObject.getName() + TRANSFORM_ROTATION_));
if ( lodSceneObj != null ) {
if (lodSceneObj.getParent() == this.transformLODSceneObject) {
levelOfDetailSceneObject = lodSceneObj;
}
}
}
if (levelOfDetailSceneObject == null) {
lodSceneObj = root.getSceneObjectByName((currentSceneObject.getName() + TRANSFORM_SCALE_));
if ( lodSceneObj != null ) {
if (lodSceneObj.getParent() == this.transformLODSceneObject) {
levelOfDetailSceneObject = lodSceneObj;
}
}
}
}
if ( levelOfDetailSceneObject != null) {
final GVRLODGroup lodGroup = (GVRLODGroup) this.transformLODSceneObject.getComponent(GVRLODGroup.getComponentType());
lodGroup.addRange(this.getMinRange(), levelOfDetailSceneObject);
this.increment();
}
}
} | java | {
"resource": ""
} |
q5286 | MultiPageWidget.applyLayout | train | @Override
public boolean applyLayout(Layout itemLayout) {
boolean applied = false;
if (itemLayout != null && mItemLayouts.add(itemLayout)) {
// apply the layout to all visible pages
List<Widget> views = getAllViews();
for (Widget view: views) {
view.applyLayout(itemLayout.clone());
}
applied = true;
}
return applied;
} | java | {
"resource": ""
} |
q5287 | MultiPageWidget.getPageScrollable | train | public LayoutScroller.ScrollableList getPageScrollable() {
return new LayoutScroller.ScrollableList() {
@Override
public int getScrollingItemsCount() {
return MultiPageWidget.super.getScrollingItemsCount();
}
@Override
public float getViewPortWidth() {
return MultiPageWidget.super.getViewPortWidth();
}
@Override
public float getViewPortHeight() {
return MultiPageWidget.super.getViewPortHeight();
}
@Override
public float getViewPortDepth() {
return MultiPageWidget.super.getViewPortDepth();
}
@Override
public boolean scrollToPosition(int pos, final LayoutScroller.OnScrollListener listener) {
return MultiPageWidget.super.scrollToPosition(pos, listener);
}
@Override
public boolean scrollByOffset(float xOffset, float yOffset, float zOffset,
final LayoutScroller.OnScrollListener listener) {
return MultiPageWidget.super.scrollByOffset(xOffset, yOffset, zOffset, listener);
}
@Override
public void registerDataSetObserver(DataSetObserver observer) {
MultiPageWidget.super.registerDataSetObserver(observer);
}
@Override
public void unregisterDataSetObserver(DataSetObserver observer) {
MultiPageWidget.super.unregisterDataSetObserver(observer);
}
@Override
public int getCurrentPosition() {
return MultiPageWidget.super.getCurrentPosition();
}
};
} | java | {
"resource": ""
} |
q5288 | ViewpointAnimation.startAnimation | train | public void startAnimation()
{
Date time = new Date();
this.beginAnimation = time.getTime();
this.endAnimation = beginAnimation + (long) (animationTime * 1000);
this.animate = true;
} | java | {
"resource": ""
} |
q5289 | ViewpointAnimation.updateAnimation | train | public void updateAnimation()
{
Date time = new Date();
long currentTime = time.getTime() - this.beginAnimation;
if (currentTime > animationTime)
{
this.currentQuaternion.set(endQuaternion);
for (int i = 0; i < 3; i++)
{
this.currentPos[i] = this.endPos[i];
}
this.animate = false;
}
else
{
float t = (float) currentTime / animationTime;
this.currentQuaternion = this.beginQuaternion.slerp(this.endQuaternion,
t);
for (int i = 0; i < 3; i++)
{
this.currentPos[i] = this.beginPos[i] + totalTranslation[i] * t;
}
}
} | java | {
"resource": ""
} |
q5290 | GVRTextureParameters.getDefalutValuesArray | train | public int[] getDefalutValuesArray() {
int[] defaultValues = new int[5];
defaultValues[0] = GLES20.GL_LINEAR_MIPMAP_NEAREST; // MIN FILTER
defaultValues[1] = GLES20.GL_LINEAR; // MAG FILTER
defaultValues[2] = 1; // ANISO FILTER
defaultValues[3] = GLES20.GL_CLAMP_TO_EDGE; // WRAP S
defaultValues[4] = GLES20.GL_CLAMP_TO_EDGE; // WRAP T
return defaultValues;
} | java | {
"resource": ""
} |
q5291 | GVRTextureParameters.getCurrentValuesArray | train | public int[] getCurrentValuesArray() {
int[] currentValues = new int[5];
currentValues[0] = getMinFilterType().getFilterValue(); // MIN FILTER
currentValues[1] = getMagFilterType().getFilterValue(); // MAG FILTER
currentValues[2] = getAnisotropicValue(); // ANISO FILTER
currentValues[3] = getWrapSType().getWrapValue(); // WRAP S
currentValues[4] = getWrapTType().getWrapValue(); // WRAP T
return currentValues;
} | java | {
"resource": ""
} |
q5292 | AiMaterial.hasProperties | train | public boolean hasProperties(Set<PropertyKey> keys) {
for (PropertyKey key : keys) {
if (null == getProperty(key.m_key)) {
return false;
}
}
return true;
} | java | {
"resource": ""
} |
q5293 | AiMaterial.getTextureMagFilter | train | public Integer getTextureMagFilter(AiTextureType type, int index) {
checkTexRange(type, index);
Property p = getProperty(PropertyKey.TEX_MAG_FILTER.m_key);
if (null == p || null == p.getData()) {
return (Integer) m_defaults.get(PropertyKey.TEX_MAG_FILTER);
}
Object rawValue = p.getData();
if (rawValue instanceof java.nio.ByteBuffer)
{
java.nio.IntBuffer ibuf = ((java.nio.ByteBuffer) rawValue).asIntBuffer();
return ibuf.get();
}
else
{
return (Integer) rawValue;
}
} | java | {
"resource": ""
} |
q5294 | AiMaterial.getMetallic | train | public float getMetallic()
{
Property p = getProperty(PropertyKey.METALLIC.m_key);
if (null == p || null == p.getData())
{
throw new IllegalArgumentException("Metallic property not found");
}
Object rawValue = p.getData();
if (rawValue instanceof java.nio.ByteBuffer)
{
java.nio.FloatBuffer fbuf = ((java.nio.ByteBuffer) rawValue).asFloatBuffer();
return fbuf.get();
}
else
{
return (Float) rawValue;
}
} | java | {
"resource": ""
} |
q5295 | AiMaterial.getTextureInfo | train | public AiTextureInfo getTextureInfo(AiTextureType type, int index) {
return new AiTextureInfo(type, index, getTextureFile(type, index),
getTextureUVIndex(type, index), getBlendFactor(type, index),
getTextureOp(type, index), getTextureMapModeW(type, index),
getTextureMapModeW(type, index),
getTextureMapModeW(type, index));
} | java | {
"resource": ""
} |
q5296 | AiMaterial.checkTexRange | train | private void checkTexRange(AiTextureType type, int index) {
if (index < 0 || index > m_numTextures.get(type)) {
throw new IndexOutOfBoundsException("Index: " + index + ", Size: " +
m_numTextures.get(type));
}
} | java | {
"resource": ""
} |
q5297 | AiMaterial.setTextureNumber | train | @SuppressWarnings("unused")
private void setTextureNumber(int type, int number) {
m_numTextures.put(AiTextureType.fromRawValue(type), number);
} | java | {
"resource": ""
} |
q5298 | GVRFrustumPicker.setFrustum | train | public void setFrustum(float[] frustum)
{
Matrix4f projMatrix = new Matrix4f();
projMatrix.setFrustum(frustum[0], frustum[3], frustum[1], frustum[4], frustum[2], frustum[5]);
setFrustum(projMatrix);
} | java | {
"resource": ""
} |
q5299 | GVRFrustumPicker.setFrustum | train | public void setFrustum(float fovy, float aspect, float znear, float zfar)
{
Matrix4f projMatrix = new Matrix4f();
projMatrix.perspective((float) Math.toRadians(fovy), aspect, znear, zfar);
setFrustum(projMatrix);
} | java | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.