code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
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 |
@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 |
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 |
public void startAnimation()
{
Date time = new Date();
this.beginAnimation = time.getTime();
this.endAnimation = beginAnimation + (long) (animationTime * 1000);
this.animate = true;
} | java |
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 |
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 |
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 |
public boolean hasProperties(Set<PropertyKey> keys) {
for (PropertyKey key : keys) {
if (null == getProperty(key.m_key)) {
return false;
}
}
return true;
} | java |
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 |
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 |
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 |
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 |
@SuppressWarnings("unused")
private void setTextureNumber(int type, int number) {
m_numTextures.put(AiTextureType.fromRawValue(type), number);
} | java |
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 |
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 |
public void setFrustum(Matrix4f projMatrix)
{
if (projMatrix != null)
{
if (mProjMatrix == null)
{
mProjMatrix = new float[16];
}
mProjMatrix = projMatrix.get(mProjMatrix, 0);
mScene.setPickVisible(false);
if (mCuller != null)
{
mCuller.set(projMatrix);
}
else
{
mCuller = new FrustumIntersection(projMatrix);
}
}
mProjection = projMatrix;
} | java |
public static final GVRPickedObject[] pickVisible(GVRScene scene) {
sFindObjectsLock.lock();
try {
final GVRPickedObject[] result = NativePicker.pickVisible(scene.getNative());
return result;
} finally {
sFindObjectsLock.unlock();
}
} | java |
public void setShortVec(char[] data)
{
if (data == null)
{
throw new IllegalArgumentException("Input data for indices cannot be null");
}
if (getIndexSize() != 2)
{
throw new UnsupportedOperationException("Cannot update integer indices with char array");
}
if (!NativeIndexBuffer.setShortArray(getNative(), data))
{
throw new UnsupportedOperationException("Input array is wrong size");
}
} | java |
public void setShortVec(CharBuffer data)
{
if (data == null)
{
throw new IllegalArgumentException("Input data for indices cannot be null");
}
if (getIndexSize() != 2)
{
throw new UnsupportedOperationException("Cannot update integer indices with char array");
}
if (data.isDirect())
{
if (!NativeIndexBuffer.setShortVec(getNative(), data))
{
throw new UnsupportedOperationException("Input buffer is wrong size");
}
}
else if (data.hasArray())
{
if (!NativeIndexBuffer.setShortArray(getNative(), data.array()))
{
throw new UnsupportedOperationException("Input buffer is wrong size");
}
}
else
{
throw new UnsupportedOperationException(
"CharBuffer type not supported. Must be direct or have backing array");
}
} | java |
public void setIntVec(int[] data)
{
if (data == null)
{
throw new IllegalArgumentException("Input data for indices cannot be null");
}
if (getIndexSize() != 4)
{
throw new UnsupportedOperationException("Cannot update short indices with int array");
}
if (!NativeIndexBuffer.setIntArray(getNative(), data))
{
throw new UnsupportedOperationException("Input array is wrong size");
}
} | java |
public void setIntVec(IntBuffer data)
{
if (data == null)
{
throw new IllegalArgumentException("Input buffer for indices cannot be null");
}
if (getIndexSize() != 4)
{
throw new UnsupportedOperationException("Cannot update integer indices with short array");
}
if (data.isDirect())
{
if (!NativeIndexBuffer.setIntVec(getNative(), data))
{
throw new UnsupportedOperationException("Input array is wrong size");
}
}
else if (data.hasArray())
{
if (!NativeIndexBuffer.setIntArray(getNative(), data.array()))
{
throw new IllegalArgumentException("Data array incompatible with index buffer");
}
}
else
{
throw new UnsupportedOperationException("IntBuffer type not supported. Must be direct or have backing array");
}
} | java |
protected void emitWithBurstCheck(float[] particlePositions, float[] particleVelocities,
float[] particleTimeStamps)
{
if ( burstMode )
{
if ( executeOnce )
{
emit(particlePositions, particleVelocities, particleTimeStamps);
executeOnce = false;
}
}
else
{
emit(particlePositions, particleVelocities, particleTimeStamps);
}
} | java |
private void emit(float[] particlePositions, float[] particleVelocities,
float[] particleTimeStamps)
{
float[] allParticlePositions = new float[particlePositions.length + particleBoundingVolume.length];
System.arraycopy(particlePositions, 0, allParticlePositions, 0, particlePositions.length);
System.arraycopy(particleBoundingVolume, 0, allParticlePositions,
particlePositions.length, particleBoundingVolume.length);
float[] allSpawnTimes = new float[particleTimeStamps.length + BVSpawnTimes.length];
System.arraycopy(particleTimeStamps, 0, allSpawnTimes, 0, particleTimeStamps.length);
System.arraycopy(BVSpawnTimes, 0, allSpawnTimes, particleTimeStamps.length, BVSpawnTimes.length);
float[] allParticleVelocities = new float[particleVelocities.length + BVVelocities.length];
System.arraycopy(particleVelocities, 0, allParticleVelocities, 0, particleVelocities.length);
System.arraycopy(BVVelocities, 0, allParticleVelocities, particleVelocities.length, BVVelocities.length);
Particles particleMesh = new Particles(mGVRContext, mMaxAge,
mParticleSize, mEnvironmentAcceleration, mParticleSizeRate, mFadeWithAge,
mParticleTexture, mColor, mNoiseFactor);
GVRSceneObject particleObject = particleMesh.makeParticleMesh(allParticlePositions,
allParticleVelocities, allSpawnTimes);
this.addChildObject(particleObject);
meshInfo.add(Pair.create(particleObject, currTime));
} | java |
public void setVelocityRange( final Vector3f minV, final Vector3f maxV )
{
if (null != mGVRContext) {
mGVRContext.runOnGlThread(new Runnable() {
@Override
public void run() {
minVelocity = minV;
maxVelocity = maxV;
}
});
}
} | java |
public static void logLong(String TAG, String longString) {
InputStream is = new ByteArrayInputStream( longString.getBytes() );
@SuppressWarnings("resource")
Scanner scan = new Scanner(is);
while (scan.hasNextLine()) {
Log.v(TAG, scan.nextLine());
}
} | java |
public static String readTextFile(Context context, String asset) {
try {
InputStream inputStream = context.getAssets().open(asset);
return org.gearvrf.utility.TextFile.readTextFile(inputStream);
} catch (FileNotFoundException f) {
Log.w(TAG, "readTextFile(): asset file '%s' doesn't exist", asset);
} catch (IOException e) {
e.printStackTrace();
Log.e(TAG, e, "readTextFile()");
}
return null;
} | java |
public static boolean equal(Vector3f v1, Vector3f v2) {
return equal(v1.x, v2.x) && equal(v1.y, v2.y) && equal(v1.z, v2.z);
} | java |
public static int getId(Context context, String id) {
final String defType;
if (id.startsWith("R.")) {
int dot = id.indexOf('.', 2);
defType = id.substring(2, dot);
} else {
defType = "drawable";
}
Log.d(TAG, "getId(): id: %s, extracted type: %s", id, defType);
return getId(context, id, defType);
} | java |
public static int getId(Context context, String id, String defType) {
String type = "R." + defType + ".";
if (id.startsWith(type)) {
id = id.substring(type.length());
}
Resources r = context.getResources();
int resId = r.getIdentifier(id, defType,
context.getPackageName());
if (resId > 0) {
return resId;
} else {
throw new RuntimeAssertion("Specified resource '%s' could not be found", id);
}
} | java |
public String generateSignature(HashMap<String, Integer> defined, GVRLight[] lightlist)
{
return getClass().getSimpleName();
} | java |
public int bindShader(GVRContext context, IRenderable rdata, GVRScene scene, boolean isMultiview)
{
String signature = getClass().getSimpleName();
GVRShaderManager shaderManager = context.getShaderManager();
GVRMaterial mtl = rdata.getMaterial();
synchronized (shaderManager)
{
int nativeShader = shaderManager.getShader(signature);
if (nativeShader == 0)
{
nativeShader = addShader(shaderManager, signature, mtl);
}
if (nativeShader > 0)
{
rdata.setShader(nativeShader, isMultiview);
}
return nativeShader;
}
} | java |
public int bindShader(GVRContext context, GVRShaderData material, String vertexDesc)
{
String signature = getClass().getSimpleName();
GVRShaderManager shaderManager = context.getShaderManager();
synchronized (shaderManager)
{
int nativeShader = shaderManager.getShader(signature);
if (nativeShader == 0)
{
nativeShader = addShader(shaderManager, signature, material);
}
return nativeShader;
}
} | java |
public GVRSceneObject startDrag(GVRSceneObject dragMe, float relX, float relY, float relZ) {
synchronized (mLock) {
if (mCursorController == null) {
Log.w(TAG, "Physics drag failed: Cursor controller not found!");
return null;
}
if (mDragMe != null) {
Log.w(TAG, "Physics drag failed: Previous drag wasn't finished!");
return null;
}
if (mPivotObject == null) {
mPivotObject = onCreatePivotObject(mContext);
}
mDragMe = dragMe;
GVRTransform t = dragMe.getTransform();
/* It is not possible to drag a rigid body directly, we need a pivot object.
We are using the pivot object's position as pivot of the dragging's physics constraint.
*/
mPivotObject.getTransform().setPosition(t.getPositionX() + relX,
t.getPositionY() + relY, t.getPositionZ() + relZ);
mCursorController.startDrag(mPivotObject);
}
return mPivotObject;
} | java |
public void setTexCoord(String texName, String texCoordAttr, String shaderVarName)
{
synchronized (textures)
{
GVRTexture tex = textures.get(texName);
if (tex != null)
{
tex.setTexCoord(texCoordAttr, shaderVarName);
}
else
{
throw new UnsupportedOperationException("Texture must be set before updating texture coordinate information");
}
}
} | java |
public String getTexCoordAttr(String texName)
{
GVRTexture tex = textures.get(texName);
if (tex != null)
{
return tex.getTexCoordAttr();
}
return null;
} | java |
public String getTexCoordShaderVar(String texName)
{
GVRTexture tex = textures.get(texName);
if (tex != null)
{
return tex.getTexCoordShaderVar();
}
return null;
} | java |
public String getProperty(String key, String defaultValue) {
return mProperties.getProperty(key, defaultValue);
} | java |
public synchronized void hide() {
if (focusedQuad != null) {
mDefocusAnimationFactory.create(focusedQuad)
.setRequestLayoutOnTargetChange(false)
.start().finish();
focusedQuad = null;
}
Log.d(Log.SUBSYSTEM.WIDGET, TAG, "hide Picker!");
} | java |
public void set1Value(int index, String newValue) {
try {
value.set( index, newValue );
}
catch (IndexOutOfBoundsException e) {
Log.e(TAG, "X3D MFString set1Value(int index, ...) out of bounds." + e);
}
catch (Exception e) {
Log.e(TAG, "X3D MFString set1Value(int index, ...) exception " + e);
}
} | java |
public void setValue(int numStrings, String[] newValues) {
value.clear();
if (numStrings == newValues.length) {
for (int i = 0; i < newValues.length; i++) {
value.add(newValues[i]);
}
}
else {
Log.e(TAG, "X3D MFString setValue() numStrings not equal total newValues");
}
} | java |
public void update(int width, int height, byte[] grayscaleData)
{
NativeBitmapImage.updateFromMemory(getNative(), width, height, grayscaleData);
} | java |
public static void start(final GVRContext context, final String appId, final ResultListener listener) {
if (null == listener) {
throw new IllegalArgumentException("listener cannot be null");
}
final Activity activity = context.getActivity();
final long result = create(activity, appId);
if (0 != result) {
throw new IllegalStateException("Could not initialize the platform sdk; error code: " + result);
}
context.registerDrawFrameListener(new GVRDrawFrameListener() {
@Override
public void onDrawFrame(float frameTime) {
final int result = processEntitlementCheckResponse();
if (0 != result) {
context.unregisterDrawFrameListener(this);
final Runnable runnable;
if (-1 == result) {
runnable = new Runnable() {
@Override
public void run() {
listener.onFailure();
}
};
} else {
runnable = new Runnable() {
@Override
public void run() {
listener.onSuccess();
}
};
}
activity.runOnUiThread(runnable);
}
}
});
} | java |
public synchronized void tick() {
long currentTime = GVRTime.getMilliTime();
long cutoffTime = currentTime - BUFFER_SECONDS * 1000;
ListIterator<Long> it = mTimestamps.listIterator();
while (it.hasNext()) {
Long timestamp = it.next();
if (timestamp < cutoffTime) {
it.remove();
} else {
break;
}
}
mTimestamps.add(currentTime);
mStatColumn.addValue(((float)mTimestamps.size()) / BUFFER_SECONDS);
} | java |
public void addControllerType(GVRControllerType controllerType)
{
if (cursorControllerTypes == null)
{
cursorControllerTypes = new ArrayList<GVRControllerType>();
}
else if (cursorControllerTypes.contains(controllerType))
{
return;
}
cursorControllerTypes.add(controllerType);
} | java |
public static void checkStringNotNullOrEmpty(String parameterName,
String value) {
if (TextUtils.isEmpty(value)) {
throw Exceptions.IllegalArgument("Current input string %s is %s.",
parameterName, value == null ? "null" : "empty");
}
} | java |
public static void checkArrayLength(String parameterName, int actualLength,
int expectedLength) {
if (actualLength != expectedLength) {
throw Exceptions.IllegalArgument(
"Array %s should have %d elements, not %d", parameterName,
expectedLength, actualLength);
}
} | java |
public static void checkMinimumArrayLength(String parameterName,
int actualLength, int minimumLength) {
if (actualLength < minimumLength) {
throw Exceptions
.IllegalArgument(
"Array %s should have at least %d elements, but it only has %d",
parameterName, minimumLength, actualLength);
}
} | java |
public static void checkFloatNotNaNOrInfinity(String parameterName,
float data) {
if (Float.isNaN(data) || Float.isInfinite(data)) {
throw Exceptions.IllegalArgument(
"%s should never be NaN or Infinite.", parameterName);
}
} | java |
public void transformPose(Matrix4f trans)
{
Bone bone = mBones[0];
bone.LocalMatrix.set(trans);
bone.WorldMatrix.set(trans);
bone.Changed = WORLD_POS | WORLD_ROT;
mNeedSync = true;
sync();
} | java |
public void inverse(GVRPose src)
{
if (getSkeleton() != src.getSkeleton())
throw new IllegalArgumentException("GVRPose.copy: input pose is incompatible with this pose");
src.sync();
int numbones = getNumBones();
Bone srcBone = src.mBones[0];
Bone dstBone = mBones[0];
mNeedSync = true;
srcBone.WorldMatrix.invertAffine(dstBone.WorldMatrix);
srcBone.LocalMatrix.set(dstBone.WorldMatrix);
if (sDebug)
{
Log.d("BONE", "invert: %s %s", mSkeleton.getBoneName(0), dstBone.toString());
}
for (int i = 1; i < numbones; ++i)
{
srcBone = src.mBones[i];
dstBone = mBones[i];
srcBone.WorldMatrix.invertAffine(dstBone.WorldMatrix);
dstBone.Changed = WORLD_ROT | WORLD_POS;
if (sDebug)
{
Log.d("BONE", "invert: %s %s", mSkeleton.getBoneName(i), dstBone.toString());
}
}
sync();
} | java |
protected void calcWorld(Bone bone, int parentId)
{
getWorldMatrix(parentId, mTempMtxB); // WorldMatrix (parent) TempMtxB
mTempMtxB.mul(bone.LocalMatrix); // WorldMatrix = WorldMatrix(parent) * LocalMatrix
bone.WorldMatrix.set(mTempMtxB);
} | java |
protected void calcLocal(Bone bone, int parentId)
{
if (parentId < 0)
{
bone.LocalMatrix.set(bone.WorldMatrix);
return;
}
/*
* WorldMatrix = WorldMatrix(parent) * LocalMatrix
* LocalMatrix = INVERSE[ WorldMatrix(parent) ] * WorldMatrix
*/
getWorldMatrix(parentId, mTempMtxA); // WorldMatrix(par)
mTempMtxA.invert(); // INVERSE[ WorldMatrix(parent) ]
mTempMtxA.mul(bone.WorldMatrix, bone.LocalMatrix); // LocalMatrix = INVERSE[ WorldMatrix(parent) ] * WorldMatrix
} | java |
public void setVec3(String key, float x, float y, float z)
{
checkKeyIsUniform(key);
NativeLight.setVec3(getNative(), key, x, y, z);
} | java |
public void setVec4(String key, float x, float y, float z, float w)
{
checkKeyIsUniform(key);
NativeLight.setVec4(getNative(), key, x, y, z, w);
} | java |
public void setMat4(String key, float x1, float y1, float z1, float w1,
float x2, float y2, float z2, float w2, float x3, float y3,
float z3, float w3, float x4, float y4, float z4, float w4)
{
checkKeyIsUniform(key);
NativeLight.setMat4(getNative(), key, x1, y1, z1, w1, x2, y2,
z2, w2, x3, y3, z3, w3, x4, y4, z4, w4);
} | java |
public void onDrawFrame(float frameTime)
{
if (!isEnabled() || (owner == null) || (getFloat("enabled") <= 0.0f))
{
return;
}
float[] odir = getVec3("world_direction");
float[] opos = getVec3("world_position");
GVRSceneObject parent = owner;
Matrix4f worldmtx = parent.getTransform().getModelMatrix4f();
mOldDir.x = odir[0];
mOldDir.y = odir[1];
mOldDir.z = odir[2];
mOldPos.x = opos[0];
mOldPos.y = opos[1];
mOldPos.z = opos[2];
mNewDir.x = 0.0f;
mNewDir.y = 0.0f;
mNewDir.z = -1.0f;
worldmtx.getTranslation(mNewPos);
worldmtx.mul(mLightRot);
worldmtx.transformDirection(mNewDir);
if ((mOldDir.x != mNewDir.x) || (mOldDir.y != mNewDir.y) || (mOldDir.z != mNewDir.z))
{
setVec4("world_direction", mNewDir.x, mNewDir.y, mNewDir.z, 0);
}
if ((mOldPos.x != mNewPos.x) || (mOldPos.y != mNewPos.y) || (mOldPos.z != mNewPos.z))
{
setPosition(mNewPos.x, mNewPos.y, mNewPos.z);
}
} | java |
public void setProjectionMatrix(float x1, float y1, float z1, float w1,
float x2, float y2, float z2, float w2, float x3, float y3,
float z3, float w3, float x4, float y4, float z4, float w4) {
NativeCustomCamera.setProjectionMatrix(getNative(), x1, y1, z1, w1, x2,
y2, z2, w2, x3, y3, z3, w3, x4, y4, z4, w4);
} | java |
private void loadCadidateString() {
volumeUp = mGvrContext.getActivity().getResources().getString(R.string.volume_up);
volumeDown = mGvrContext.getActivity().getResources().getString(R.string.volume_down);
zoomIn = mGvrContext.getActivity().getResources().getString(R.string.zoom_in);
zoomOut = mGvrContext.getActivity().getResources().getString(R.string.zoom_out);
invertedColors = mGvrContext.getActivity().getResources().getString(R.string.inverted_colors);
talkBack = mGvrContext.getActivity().getResources().getString(R.string.talk_back);
disableTalkBack = mGvrContext.getActivity().getResources().getString(R.string.disable_talk_back);
} | java |
public void findMatch(ArrayList<String> speechResult) {
loadCadidateString();
for (String matchCandidate : speechResult) {
Locale localeDefault = mGvrContext.getActivity().getResources().getConfiguration().locale;
if (volumeUp.equals(matchCandidate)) {
startVolumeUp();
break;
} else if (volumeDown.toLowerCase(localeDefault).equals(matchCandidate.toLowerCase(localeDefault))) {
startVolumeDown();
break;
} else if (zoomIn.toLowerCase(localeDefault).equals(matchCandidate.toLowerCase(localeDefault))) {
startZoomIn();
break;
} else if (zoomOut.toLowerCase(localeDefault).equals(matchCandidate.toLowerCase(localeDefault))) {
startZoomOut();
break;
} else if (invertedColors.toLowerCase(localeDefault).equals(matchCandidate.toLowerCase(localeDefault))) {
startInvertedColors();
break;
} else if (talkBack.toLowerCase(localeDefault).equals(matchCandidate.toLowerCase(localeDefault))) {
enableTalkBack();
} else if (disableTalkBack.toLowerCase(localeDefault).equals(matchCandidate.toLowerCase(localeDefault))) {
disableTalkBack();
}
}
} | java |
private void enableTalkBack() {
GVRSceneObject[] sceneObjects = mGvrContext.getMainScene().getWholeSceneObjects();
for (GVRSceneObject sceneObject : sceneObjects) {
if (sceneObject instanceof GVRAccessiblityObject)
if (((GVRAccessiblityObject) sceneObject).getTalkBack() != null)
((GVRAccessiblityObject) sceneObject).getTalkBack().setActive(true);
}
} | java |
private void disableTalkBack() {
GVRSceneObject[] sceneObjects = mGvrContext.getMainScene().getWholeSceneObjects();
for (GVRSceneObject sceneObject : sceneObjects) {
if (sceneObject instanceof GVRAccessiblityObject)
if (((GVRAccessiblityObject) sceneObject).getTalkBack() != null)
((GVRAccessiblityObject) sceneObject).getTalkBack().setActive(false);
}
} | java |
private void startInvertedColors() {
if (managerFeatures.getInvertedColors().isInverted()) {
managerFeatures.getInvertedColors().turnOff(mGvrContext.getMainScene());
} else {
managerFeatures.getInvertedColors().turnOn(mGvrContext.getMainScene());
}
} | java |
public static void dumpTexCoords(AiMesh mesh, int coords) {
if (!mesh.hasTexCoords(coords)) {
System.out.println("mesh has no texture coordinate set " + coords);
return;
}
for (int i = 0; i < mesh.getNumVertices(); i++) {
int numComponents = mesh.getNumUVComponents(coords);
System.out.print("[" + mesh.getTexCoordU(i, coords));
if (numComponents > 1) {
System.out.print(", " + mesh.getTexCoordV(i, coords));
}
if (numComponents > 2) {
System.out.print(", " + mesh.getTexCoordW(i, coords));
}
System.out.println("]");
}
} | java |
public static void dumpMaterialProperty(AiMaterial.Property property) {
System.out.print(property.getKey() + " " + property.getSemantic() +
" " + property.getIndex() + ": ");
Object data = property.getData();
if (data instanceof ByteBuffer) {
ByteBuffer buf = (ByteBuffer) data;
for (int i = 0; i < buf.capacity(); i++) {
System.out.print(Integer.toHexString(buf.get(i) & 0xFF) + " ");
}
System.out.println();
}
else {
System.out.println(data.toString());
}
} | java |
public static void dumpMaterial(AiMaterial material) {
for (AiMaterial.Property prop : material.getProperties()) {
dumpMaterialProperty(prop);
}
} | java |
public static void dumpNodeAnim(AiNodeAnim nodeAnim) {
for (int i = 0; i < nodeAnim.getNumPosKeys(); i++) {
System.out.println(i + ": " + nodeAnim.getPosKeyTime(i) +
" ticks, " + nodeAnim.getPosKeyVector(i, Jassimp.BUILTIN));
}
} | java |
public static String joinStrings(List<String> strings, boolean fixCase, char withChar) {
if (strings == null || strings.size() == 0) {
return "";
}
StringBuilder result = null;
for (String s : strings) {
if (fixCase) {
s = fixCase(s);
}
if (result == null) {
result = new StringBuilder(s);
} else {
result.append(withChar);
result.append(s);
}
}
return result.toString();
} | java |
public int addCollidable(GVRSceneObject sceneObj)
{
synchronized (mCollidables)
{
int index = mCollidables.indexOf(sceneObj);
if (index >= 0)
{
return index;
}
mCollidables.add(sceneObj);
return mCollidables.size() - 1;
}
} | java |
public static GVRCameraRig makeInstance(GVRContext gvrContext) {
final GVRCameraRig result = gvrContext.getApplication().getDelegate().makeCameraRig(gvrContext);
result.init(gvrContext);
return result;
} | java |
public void removeAllChildren() {
for (final GVRSceneObject so : headTransformObject.getChildren()) {
final boolean notCamera = (so != leftCameraObject && so != rightCameraObject && so != centerCameraObject);
if (notCamera) {
headTransformObject.removeChildObject(so);
}
}
} | java |
public void setNearClippingDistance(float near) {
if(leftCamera instanceof GVRCameraClippingDistanceInterface &&
centerCamera instanceof GVRCameraClippingDistanceInterface &&
rightCamera instanceof GVRCameraClippingDistanceInterface) {
((GVRCameraClippingDistanceInterface)leftCamera).setNearClippingDistance(near);
centerCamera.setNearClippingDistance(near);
((GVRCameraClippingDistanceInterface)rightCamera).setNearClippingDistance(near);
}
} | java |
public void setFarClippingDistance(float far) {
if(leftCamera instanceof GVRCameraClippingDistanceInterface &&
centerCamera instanceof GVRCameraClippingDistanceInterface &&
rightCamera instanceof GVRCameraClippingDistanceInterface) {
((GVRCameraClippingDistanceInterface)leftCamera).setFarClippingDistance(far);
centerCamera.setFarClippingDistance(far);
((GVRCameraClippingDistanceInterface)rightCamera).setFarClippingDistance(far);
}
} | java |
public static String readTextFile(File file) {
try {
return readTextFile(new FileReader(file));
} catch (FileNotFoundException e) {
e.printStackTrace();
return null;
}
} | java |
public static String readTextFile(Context context, int resourceId) {
InputStream inputStream = context.getResources().openRawResource(
resourceId);
return readTextFile(inputStream);
} | java |
public static String readTextFile(InputStream inputStream) {
InputStreamReader streamReader = new InputStreamReader(inputStream);
return readTextFile(streamReader);
} | java |
private static Future<?> spawn(final int priority, final Runnable threadProc) {
return threadPool.submit(new Runnable() {
@Override
public void run() {
Thread current = Thread.currentThread();
int defaultPriority = current.getPriority();
try {
current.setPriority(priority);
/*
* We yield to give the foreground process a chance to run.
* This also means that the new priority takes effect RIGHT
* AWAY, not after the next blocking call or quantum
* timeout.
*/
Thread.yield();
try {
threadProc.run();
} catch (Exception e) {
logException(TAG, e);
}
} finally {
current.setPriority(defaultPriority);
}
}
});
} | java |
public static void assertUnlocked(Object object, String name) {
if (RUNTIME_ASSERTIONS) {
if (Thread.holdsLock(object)) {
throw new RuntimeAssertion("Recursive lock of %s", name);
}
}
} | java |
public void enableUniformSize(final boolean enable) {
if (mUniformSize != enable) {
mUniformSize = enable;
if (mContainer != null) {
mContainer.onLayoutChanged(this);
}
}
} | java |
public void setDividerPadding(float padding, final Axis axis) {
if (axis == getOrientationAxis()) {
super.setDividerPadding(padding, axis);
} else {
Log.w(TAG, "Cannot apply divider padding for wrong axis [%s], orientation = %s",
axis, getOrientation());
}
} | java |
protected boolean isValidLayout(Gravity gravity, Orientation orientation) {
boolean isValid = true;
switch (gravity) {
case TOP:
case BOTTOM:
isValid = (!isUnlimitedSize() && orientation == Orientation.VERTICAL);
break;
case LEFT:
case RIGHT:
isValid = (!isUnlimitedSize() && orientation == Orientation.HORIZONTAL);
break;
case FRONT:
case BACK:
isValid = (!isUnlimitedSize() && orientation == Orientation.STACK);
break;
case FILL:
isValid = !isUnlimitedSize();
break;
case CENTER:
break;
default:
isValid = false;
break;
}
if (!isValid) {
Log.w(TAG, "Cannot set the gravity %s and orientation %s - " +
"due to unlimited bounds or incompatibility", gravity, orientation);
}
return isValid;
} | java |
protected float getLayoutOffset() {
//final int offsetSign = getOffsetSign();
final float axisSize = getViewPortSize(getOrientationAxis());
float layoutOffset = - axisSize / 2;
Log.d(LAYOUT, TAG, "getLayoutOffset(): dimension: %5.2f, layoutOffset: %5.2f",
axisSize, layoutOffset);
return layoutOffset;
} | java |
protected float getStartingOffset(final float totalSize) {
final float axisSize = getViewPortSize(getOrientationAxis());
float startingOffset = 0;
switch (getGravityInternal()) {
case LEFT:
case FILL:
case TOP:
case FRONT:
startingOffset = -axisSize / 2;
break;
case RIGHT:
case BOTTOM:
case BACK:
startingOffset = (axisSize / 2 - totalSize);
break;
case CENTER:
startingOffset = -totalSize / 2;
break;
default:
Log.w(TAG, "Cannot calculate starting offset: " +
"gravity %s is not supported!", mGravity);
break;
}
Log.d(LAYOUT, TAG, "getStartingOffset(): totalSize: %5.4f, dimension: %5.4f, startingOffset: %5.4f",
totalSize, axisSize, startingOffset);
return startingOffset;
} | java |
@Override
protected boolean changeDirection(int currentIndex, int centerIndex, boolean inBounds) {
boolean changed = false;
if (getGravityInternal() == Gravity.CENTER &&
currentIndex <= centerIndex &&
currentIndex == 0 || !inBounds) {
changed = true;
}
return changed;
} | java |
protected int getCenterChild(CacheDataSet cache) {
if (cache.count() == 0)
return -1;
int id = cache.getId(0);
switch (getGravityInternal()) {
case TOP:
case LEFT:
case FRONT:
case FILL:
break;
case BOTTOM:
case RIGHT:
case BACK:
id = cache.getId(cache.count() - 1);
break;
case CENTER:
int i = cache.count() / 2;
while (i < cache.count() && i >= 0) {
id = cache.getId(i);
if (cache.getStartDataOffset(id) <= 0) {
if (cache.getEndDataOffset(id) >= 0) {
break;
} else {
i++;
}
} else {
i--;
}
}
break;
default:
break;
}
Log.d(LAYOUT, TAG, "getCenterChild = %d ", id);
return id;
} | java |
protected boolean computeOffset(final int dataIndex, CacheDataSet cache) {
float layoutOffset = getLayoutOffset();
int pos = cache.getPos(dataIndex);
float startDataOffset = Float.NaN;
float endDataOffset = Float.NaN;
if (pos > 0) {
int id = cache.getId(pos - 1);
if (id != -1) {
startDataOffset = cache.getEndDataOffset(id);
if (!Float.isNaN(startDataOffset)) {
endDataOffset = cache.setDataAfter(dataIndex, startDataOffset);
}
}
} else if (pos == 0) {
int id = cache.getId(pos + 1);
if (id != -1) {
endDataOffset = cache.getStartDataOffset(id);
if (!Float.isNaN(endDataOffset)) {
startDataOffset = cache.setDataBefore(dataIndex, endDataOffset);
}
} else {
startDataOffset = getStartingOffset((cache.getTotalSizeWithPadding()));
endDataOffset = cache.setDataAfter(dataIndex, startDataOffset);
}
}
Log.d(LAYOUT, TAG, "computeOffset [%d, %d]: startDataOffset = %f endDataOffset = %f",
dataIndex, pos, startDataOffset, endDataOffset);
boolean inBounds = !Float.isNaN(cache.getDataOffset(dataIndex)) &&
endDataOffset > layoutOffset &&
startDataOffset < -layoutOffset;
return inBounds;
} | java |
protected boolean computeOffset(CacheDataSet cache) {
// offset computation: update offset for all items in the cache
float startDataOffset = getStartingOffset((cache.getTotalSizeWithPadding()));
float layoutOffset = getLayoutOffset();
boolean inBounds = startDataOffset < -layoutOffset;
for (int pos = 0; pos < cache.count(); ++pos) {
int id = cache.getId(pos);
if (id != -1) {
float endDataOffset = cache.setDataAfter(id, startDataOffset);
inBounds = inBounds &&
endDataOffset > layoutOffset &&
startDataOffset < -layoutOffset;
startDataOffset = endDataOffset;
Log.d(LAYOUT, TAG, "computeOffset [%d] = %f" , id, cache.getDataOffset(id));
}
}
return inBounds;
} | java |
protected float computeUniformPadding(final CacheDataSet cache) {
float axisSize = getViewPortSize(getOrientationAxis());
float totalPadding = axisSize - cache.getTotalSize();
float uniformPadding = totalPadding > 0 && cache.count() > 1 ?
totalPadding / (cache.count() - 1) : 0;
return uniformPadding;
} | java |
public String[] getString() {
String[] valueDestination = new String[ string.size() ];
this.string.getValue(valueDestination);
return valueDestination;
} | java |
public void setString(String[] newValue) {
if ( newValue != null ) {
this.string.setValue(newValue.length, newValue);
}
} | java |
public int findAnimation(GVRAnimation findme)
{
int index = 0;
for (GVRAnimation anim : mAnimations)
{
if (anim == findme)
{
return index;
}
++index;
}
return -1;
} | java |
public void setDuration(float start, float end)
{
for (GVRAnimation anim : mAnimations)
{
anim.setDuration(start,end);
}
} | java |
public static void init(Context cx, Scriptable scope, boolean sealed)
throws RhinoException {
JSAdapter obj = new JSAdapter(cx.newObject(scope));
obj.setParentScope(scope);
obj.setPrototype(getFunctionPrototype(scope));
obj.isPrototype = true;
ScriptableObject.defineProperty(scope, "JSAdapter", obj,
ScriptableObject.DONTENUM);
} | java |
private Object mapToId(Object tmp) {
if (tmp instanceof Double) {
return new Integer(((Double)tmp).intValue());
} else {
return Context.toString(tmp);
}
} | java |
public void setList(List<T> list) {
if (list != mList) {
mList = list;
if (mList == null) {
notifyInvalidated();
} else {
notifyChanged();
}
}
} | java |
public void register() {
synchronized (loaders) {
loaders.add(this);
maximumHeaderLength = 0;
for (GVRCompressedTextureLoader loader : loaders) {
int headerLength = loader.headerLength();
if (headerLength > maximumHeaderLength) {
maximumHeaderLength = headerLength;
}
}
}
} | java |
public static GVRSceneObject loadModel(final GVRContext gvrContext,
final String modelFile) throws IOException {
return loadModel(gvrContext, modelFile, new HashMap<String, Integer>());
} | java |
public int getFaceNumIndices(int face) {
if (null == m_faceOffsets) {
if (face >= m_numFaces || face < 0) {
throw new IndexOutOfBoundsException("Index: " + face +
", Size: " + m_numFaces);
}
return 3;
}
else {
/*
* no need to perform bound checks here as the array access will
* throw IndexOutOfBoundsExceptions if the index is invalid
*/
if (face == m_numFaces - 1) {
return m_faces.capacity() / 4 - m_faceOffsets.getInt(face * 4);
}
return m_faceOffsets.getInt((face + 1) * 4) -
m_faceOffsets.getInt(face * 4);
}
} | java |
public float getPositionX(int vertex) {
if (!hasPositions()) {
throw new IllegalStateException("mesh has no positions");
}
checkVertexIndexBounds(vertex);
return m_vertices.getFloat(vertex * 3 * SIZEOF_FLOAT);
} | java |
public float getPositionY(int vertex) {
if (!hasPositions()) {
throw new IllegalStateException("mesh has no positions");
}
checkVertexIndexBounds(vertex);
return m_vertices.getFloat((vertex * 3 + 1) * SIZEOF_FLOAT);
} | java |
public float getPositionZ(int vertex) {
if (!hasPositions()) {
throw new IllegalStateException("mesh has no positions");
}
checkVertexIndexBounds(vertex);
return m_vertices.getFloat((vertex * 3 + 2) * SIZEOF_FLOAT);
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.